Updated layout.

app/gradio_meta_prompt.py

@@ -31,136 +31,138 @@ with gr.Blocks(title='Meta Prompt') as demo:
 <p style="text-align:left">A tool for generating and analyzing natural language prompts using multiple language models.</p>
 <a href="https://github.com/yaleh/meta-prompt"><img src="https://img.shields.io/badge/GitHub-blue?logo=github" alt="GitHub"></a>""")
 
-    input_dataframe = gr.DataFrame(
-        label="Input Examples",
-        headers=["Input", "Output"],
-        datatype=["str", "str"],
-        column_widths=["50%", "50%"],
-        row_count=(1, "dynamic"),
-        col_count=(2, "fixed"),
-        interactive=False,
-        wrap=True
-    )
-
     with gr.Row():
-        selected_example_input = gr.Textbox(
-            label="Selected Example Input",
-            lines=2,
-            show_copy_button=True,
-            value="",
-        )
-        selected_example_output = gr.Textbox(
-            label="Selected Example Output",
-            lines=2,
-            show_copy_button=True,
-            value="",
-        )
-
-    selected_group_mode = gr.State(None)  # None, "update", "append"
-    selected_group_index = gr.State(None)  # None, int
-    selected_group_input = gr.State("")
-    selected_group_output = gr.State("")
+        with gr.Column(scale=3):
+            input_dataframe = gr.DataFrame(
+                label="Input Examples",
+                headers=["Input", "Output"],
+                datatype=["str", "str"],
+                column_widths=["50%", "50%"],
+                row_count=(1, "dynamic"),
+                col_count=(2, "fixed"),
+                interactive=False,
+                wrap=True
+            )
 
-    selected_group_input.change(
-        fn=lambda x: x,
-        inputs=[selected_group_input],
-        outputs=[selected_example_input],
-    )
-    selected_group_output.change(
-        fn=lambda x: x,
-        inputs=[selected_group_output],
-        outputs=[selected_example_output],
-    )
+            selected_example_input = gr.Textbox(
+                label="Selected Example Input",
+                lines=2,
+                show_copy_button=True,
+                value="",
+            )
+            selected_example_output = gr.Textbox(
+                label="Selected Example Output",
+                lines=2,
+                show_copy_button=True,
+                value="",
+            )
 
-    @gr.render(
-        inputs=[
-            selected_group_mode,
-            selected_group_index,
-            selected_group_input,
-            selected_group_output,
-        ],
-        triggers=[selected_group_mode.change],
-    )
-    def selected_group(mode, index, input, output):
-        if mode is None:
-            return
-        with gr.Group():
-            if mode == "update":
-                with gr.Row():
-                    selected_row_index = gr.Number(
-                        label="Selected Row Index", value=index, precision=0, interactive=False
-                    )
-                    delete_row_button = gr.Button(
-                        "Delete Selected Row", variant="secondary"
-                    )
-                with gr.Row():
-                    update_row_button = gr.Button(
-                        "Update Selected Row", variant="secondary"
-                    )
-                    close_button = gr.Button("Close", variant="secondary")
-
-                delete_row_button.click(
-                    fn=delete_selected_dataframe_row,
-                    inputs=[selected_row_index, input_dataframe],
-                    outputs=[
-                        input_dataframe,
-                        selected_group_mode,
-                        selected_group_index,
-                        selected_group_input,
-                        selected_group_output,
-                    ],
+        with gr.Column(scale=1):
+            with gr.Accordion("Import/Export JSON", open=False):
+                json_file_object = gr.File(
+                    label="Import/Export JSON", file_types=[".json"], type="filepath"
                 )
+                export_button = gr.Button("Export to JSON")
 
-                update_row_button.click(
-                    fn=update_selected_dataframe_row,
-                    inputs=[
-                        selected_example_input,
-                        selected_example_output,
-                        selected_row_index,
-                        input_dataframe,
-                    ],
-                    outputs=[
-                        input_dataframe,
-                        selected_group_mode,
-                        selected_group_index,
-                        selected_group_input,
-                        selected_group_output,
-                    ],
-                )
-            elif mode == "append":
-                with gr.Row():
-                    append_example_button = gr.Button(
-                        "Append to Input Examples", variant="secondary"
-                    )
-                    close_button = gr.Button("Close", variant="secondary")
-
-                append_example_button.click(
-                    fn=append_example_to_input_dataframe,
-                    inputs=[
-                        selected_example_input,
-                        selected_example_output,
-                        input_dataframe,
-                    ],
-                    outputs=[
-                        input_dataframe,
-                        selected_group_mode,
-                        selected_group_index,
-                        selected_group_input,
-                        selected_group_output,
-                    ],
-                )
+            selected_group_mode = gr.State(None)  # None, "update", "append"
+            selected_group_index = gr.State(None)  # None, int
+            selected_group_input = gr.State("")
+            selected_group_output = gr.State("")
 
-            close_button.click(
-                fn=lambda: None,
-                inputs=[],
-                outputs=[selected_group_mode],
+            selected_group_input.change(
+                fn=lambda x: x,
+                inputs=[selected_group_input],
+                outputs=[selected_example_input],
+            )
+            selected_group_output.change(
+                fn=lambda x: x,
+                inputs=[selected_group_output],
+                outputs=[selected_example_output],
             )
 
-    with gr.Accordion("Import/Export JSON", open=False):
-        json_file_object = gr.File(
-            label="Import/Export JSON", file_types=[".json"], type="filepath"
-        )
-        export_button = gr.Button("Export to JSON")
+            @gr.render(
+                inputs=[
+                    selected_group_mode,
+                    selected_group_index,
+                    selected_group_input,
+                    selected_group_output,
+                ],
+                triggers=[selected_group_mode.change],
+            )
+            def selected_group(mode, index, input, output):
+                if mode is None:
+                    return
+                with gr.Group():
+                    if mode == "update":
+                        with gr.Row():
+                            selected_row_index = gr.Number(
+                                label="Selected Row Index", value=index, precision=0, interactive=False
+                            )
+                            delete_row_button = gr.Button(
+                                "Delete Selected Row", variant="secondary"
+                            )
+                        with gr.Row():
+                            update_row_button = gr.Button(
+                                "Update Selected Row", variant="secondary"
+                            )
+                            close_button = gr.Button("Close", variant="secondary")
+
+                        delete_row_button.click(
+                            fn=delete_selected_dataframe_row,
+                            inputs=[selected_row_index, input_dataframe],
+                            outputs=[
+                                input_dataframe,
+                                selected_group_mode,
+                                selected_group_index,
+                                selected_group_input,
+                                selected_group_output,
+                            ],
+                        )
+
+                        update_row_button.click(
+                            fn=update_selected_dataframe_row,
+                            inputs=[
+                                selected_example_input,
+                                selected_example_output,
+                                selected_row_index,
+                                input_dataframe,
+                            ],
+                            outputs=[
+                                input_dataframe,
+                                selected_group_mode,
+                                selected_group_index,
+                                selected_group_input,
+                                selected_group_output,
+                            ],
+                        )
+                    elif mode == "append":
+                        with gr.Row():
+                            append_example_button = gr.Button(
+                                "Append to Input Examples", variant="secondary"
+                            )
+                            close_button = gr.Button("Close", variant="secondary")
+
+                        append_example_button.click(
+                            fn=append_example_to_input_dataframe,
+                            inputs=[
+                                selected_example_input,
+                                selected_example_output,
+                                input_dataframe,
+                            ],
+                            outputs=[
+                                input_dataframe,
+                                selected_group_mode,
+                                selected_group_index,
+                                selected_group_input,
+                                selected_group_output,
+                            ],
+                        )
+
+                    close_button.click(
+                        fn=lambda: None,
+                        inputs=[],
+                        outputs=[selected_group_mode],
+                    )
 
     with gr.Tabs() as tabs:
 
@@ -187,16 +189,10 @@ with gr.Blocks(title='Meta Prompt') as demo:
             )
 
             with gr.Accordion("Model Settings", open=False):
-                model_name = gr.Dropdown(
+                scope_model_name = gr.Dropdown(
                     label="Model Name",
-                    choices=[
-                        "llama3-70b-8192",
-                        "llama3-8b-8192",
-                        "llama-3.1-70b-versatile",
-                        "llama-3.1-8b-instant",
-                        "gemma2-9b-it",
-                    ],
-                    value="llama3-70b-8192",
+                    choices=config.llms.keys(),
+                    value=list(config.llms.keys())[0],
                 )
                 temperature = gr.Slider(
                     label="Temperature", value=1.0, minimum=0.0, maximum=1.0, step=0.1
@@ -285,7 +281,7 @@ with gr.Blocks(title='Meta Prompt') as demo:
         with gr.Tab("Prompt"):
 
             with gr.Row():
-                prompt_submit_button = gr.Button(value="Submit", variant="primary")
+                prompt_submit_button = gr.Button(value="Submit", variant="primary", interactive=False)
                 prompt_clear_button = gr.ClearButton(value='Clear All')
 
             with gr.Row():
@@ -473,7 +469,8 @@ with gr.Blocks(title='Meta Prompt') as demo:
                 simple_model_name_input
             ])
 
-            model_states = {
+            prompt_model_tab_state = gr.State(value='Simple')
+            model_name_states = {
                 # None | str
                 "initial_developer": gr.State(value=simple_model_name_input.value),
                 # None | str
@@ -489,9 +486,20 @@ with gr.Blocks(title='Meta Prompt') as demo:
                 # None | str
                 "suggester": gr.State(value=simple_model_name_input.value)
             }
+            model_temperature_states = {
+                "initial_developer": gr.State(value=config.default_llm_temperature),
+                "acceptance_criteria": gr.State(value=config.default_llm_temperature),
+                "developer": gr.State(value=config.default_llm_temperature),
+                "executor": gr.State(value=config.default_llm_temperature),
+                "history_analyzer": gr.State(value=config.default_llm_temperature),
+                "analyzer": gr.State(value=config.default_llm_temperature),
+                "suggester": gr.State(value=config.default_llm_temperature)
+            }
 
             config_state = gr.State(value=config)
 
+            prompt_inputs_ready_state = gr.State(value=False)
+
     # set up event handlers for the scope tab
 
     json_file_object.change(
@@ -509,8 +517,9 @@ with gr.Blocks(title='Meta Prompt') as demo:
     submit_button.click(
         fn=process_json_data,
         inputs=[
+            config_state,
             input_dataframe,
-            model_name,
+            scope_model_name,
             generating_batch_size,
             temperature,
         ],
@@ -527,17 +536,23 @@ with gr.Blocks(title='Meta Prompt') as demo:
 
     generate_description_button.click(
         fn=generate_description,
-        inputs=[input_dataframe, model_name, temperature],
+        inputs=[
+            config_state,
+            input_dataframe,
+            scope_model_name,
+            temperature
+        ],
         outputs=[description_output, suggestions_output],
     )
 
     generate_examples_directly_button.click(
         fn=generate_examples_from_description,
         inputs=[
+            config_state,
             description_output,
             input_dataframe,
             generating_batch_size,
-            model_name,
+            scope_model_name,
             temperature,
         ],
         outputs=[examples_directly_output_dataframe],
@@ -545,17 +560,18 @@ with gr.Blocks(title='Meta Prompt') as demo:
 
     analyze_input_button.click(
         fn=analyze_input_data,
-        inputs=[description_output, model_name, temperature],
+        inputs=[config_state, description_output, scope_model_name, temperature],
         outputs=[input_analysis_output],
     )
 
     generate_briefs_button.click(
         fn=generate_example_briefs,
         inputs=[
+            config_state,
             description_output,
             input_analysis_output,
             generating_batch_size,
-            model_name,
+            scope_model_name,
             temperature,
         ],
         outputs=[example_briefs_output],
@@ -564,11 +580,12 @@ with gr.Blocks(title='Meta Prompt') as demo:
     generate_examples_from_briefs_button.click(
         fn=generate_examples_using_briefs,
         inputs=[
+            config_state,
             description_output,
             example_briefs_output,
             input_dataframe,
             generating_batch_size,
-            model_name,
+            scope_model_name,
             temperature,
         ],
         outputs=[examples_from_briefs_output_dataframe],
@@ -637,102 +654,130 @@ with gr.Blocks(title='Meta Prompt') as demo:
 
     generate_suggestions_button.click(
         fn=generate_suggestions,
-        inputs=[description_output, input_dataframe, model_name, temperature],
+        inputs=[config_state, description_output, input_dataframe, scope_model_name, temperature],
         outputs=[suggestions_output],
     )
 
     apply_suggestions_button.click(
         fn=apply_suggestions,
-        inputs=[description_output, suggestions_output,
-                input_dataframe, model_name, temperature],
+        inputs=[config_state, description_output, suggestions_output,
+                input_dataframe, scope_model_name, temperature],
         outputs=[description_output],
     )
 
     # set up event handlers for the prompt tab
+    for item in [selected_example_input, selected_example_output]:
+        item.change(
+            fn=lambda x, y: all(v is not None and v != '' for v in [x, y]),
+            inputs=[selected_example_input, selected_example_output],
+            outputs=[prompt_inputs_ready_state],
+        )
+
+    prompt_inputs_ready_state.change(
+        fn=lambda x: gr.update(interactive=x),
+        inputs=[prompt_inputs_ready_state],
+        outputs=[prompt_submit_button],
+    )
+
     simple_llm_tab.select(
         on_model_tab_select,
         [
-            simple_model_name_input,
-            advanced_optimizer_model_name_input,
-            advanced_executor_model_name_input,
-            expert_prompt_initial_developer_model_name_input,
-            expert_prompt_acceptance_criteria_model_name_input,
-            expert_prompt_developer_model_name_input,
-            expert_prompt_executor_model_name_input,
-            expert_output_history_analyzer_model_name_input,
-            expert_prompt_analyzer_model_name_input,
-            expert_prompt_suggester_model_name_input
         ],
         [
-            model_states["initial_developer"],
-            model_states["acceptance_criteria"],
-            model_states["developer"],
-            model_states["executor"],
-            model_states["history_analyzer"],
-            model_states["analyzer"],
-            model_states["suggester"]
+            prompt_model_tab_state
         ]
     )
     advanced_llm_tab.select(
         on_model_tab_select,
         [
-            simple_model_name_input,
-            advanced_optimizer_model_name_input,
-            advanced_executor_model_name_input,
-            expert_prompt_initial_developer_model_name_input,
-            expert_prompt_acceptance_criteria_model_name_input,
-            expert_prompt_developer_model_name_input,
-            expert_prompt_executor_model_name_input,
-            expert_output_history_analyzer_model_name_input,
-            expert_prompt_analyzer_model_name_input,
-            expert_prompt_suggester_model_name_input
         ],
         [
-            model_states["initial_developer"],
-            model_states["acceptance_criteria"],
-            model_states["developer"],
-            model_states["executor"],
-            model_states["history_analyzer"],
-            model_states["analyzer"],
-            model_states["suggester"]
+            prompt_model_tab_state
         ]
     )
     expert_llm_tab.select(
         on_model_tab_select,
         [
-            simple_model_name_input,
-            advanced_optimizer_model_name_input,
-            advanced_executor_model_name_input,
-            expert_prompt_initial_developer_model_name_input,
-            expert_prompt_acceptance_criteria_model_name_input,
-            expert_prompt_developer_model_name_input,
-            expert_prompt_executor_model_name_input,
-            expert_output_history_analyzer_model_name_input,
-            expert_prompt_analyzer_model_name_input,
-            expert_prompt_suggester_model_name_input
         ],
         [
-            model_states["initial_developer"],
-            model_states["acceptance_criteria"],
-            model_states["developer"],
-            model_states["executor"],
-            model_states["history_analyzer"],
-            model_states["analyzer"],
-            model_states["suggester"]
+            prompt_model_tab_state
         ]
     )
 
+    for item in [
+        prompt_model_tab_state,
+        simple_model_name_input,
+        advanced_optimizer_model_name_input,
+        advanced_executor_model_name_input,
+        expert_prompt_initial_developer_model_name_input,
+        expert_prompt_initial_developer_temperature_input,
+        expert_prompt_acceptance_criteria_model_name_input,
+        expert_prompt_acceptance_criteria_temperature_input,
+        expert_prompt_developer_model_name_input,
+        expert_prompt_developer_temperature_input,
+        expert_prompt_executor_model_name_input,
+        expert_prompt_executor_temperature_input,
+        expert_output_history_analyzer_model_name_input,
+        expert_output_history_analyzer_temperature_input,
+        expert_prompt_analyzer_model_name_input,
+        expert_prompt_analyzer_temperature_input,
+        expert_prompt_suggester_model_name_input,
+        expert_prompt_suggester_temperature_input,
+    ]:
+        item.change(
+            on_prompt_model_tab_state_change,
+            [
+                config_state,
+                prompt_model_tab_state,
+                simple_model_name_input,
+                advanced_optimizer_model_name_input,
+                advanced_executor_model_name_input,
+                expert_prompt_initial_developer_model_name_input,
+                expert_prompt_initial_developer_temperature_input,
+                expert_prompt_acceptance_criteria_model_name_input,
+                expert_prompt_acceptance_criteria_temperature_input,
+                expert_prompt_developer_model_name_input,
+                expert_prompt_developer_temperature_input,
+                expert_prompt_executor_model_name_input,
+                expert_prompt_executor_temperature_input,
+                expert_output_history_analyzer_model_name_input,
+                expert_output_history_analyzer_temperature_input,
+                expert_prompt_analyzer_model_name_input,
+                expert_prompt_analyzer_temperature_input,
+                expert_prompt_suggester_model_name_input,
+                expert_prompt_suggester_temperature_input
+            ],
+            [
+                model_name_states["initial_developer"],
+                model_temperature_states["initial_developer"],
+                model_name_states["acceptance_criteria"],
+                model_temperature_states["acceptance_criteria"],
+                model_name_states["developer"],
+                model_temperature_states["developer"],
+                model_name_states["executor"],
+                model_temperature_states["executor"],
+                model_name_states["history_analyzer"],
+                model_temperature_states["history_analyzer"],
+                model_name_states["analyzer"],
+                model_temperature_states["analyzer"],
+                model_name_states["suggester"],
+                model_temperature_states["suggester"]
+            ],
+        )
+
     generate_acceptance_criteria_button.click(
         generate_acceptance_criteria,
         inputs=[config_state, selected_example_input, selected_example_output,
-                model_states["acceptance_criteria"],
+                model_name_states["acceptance_criteria"],
+                model_temperature_states["acceptance_criteria"],
                 prompt_template_group],
         outputs=[acceptance_criteria_input, logs_chatbot]
     )
     generate_initial_system_message_button.click(
         generate_initial_system_message,
         inputs=[config_state, selected_example_input, selected_example_output,
-                model_states["initial_developer"],
+                model_name_states["initial_developer"],
+                model_temperature_states["initial_developer"],
                 prompt_template_group],
         outputs=[initial_system_message_input, logs_chatbot]
     )
@@ -743,7 +788,8 @@ with gr.Blocks(title='Meta Prompt') as demo:
             config_state,
             initial_system_message_input,
             selected_example_input,
-            model_states["executor"]
+            model_name_states["executor"],
+            model_temperature_states["executor"]
         ],
         outputs=[output_output]
     )
@@ -753,7 +799,8 @@ with gr.Blocks(title='Meta Prompt') as demo:
             config_state,
             system_message_output,
             selected_example_input,
-            model_states["executor"]
+            model_name_states["executor"],
+            model_temperature_states["executor"]
         ],
         outputs=[output_output]
     )
@@ -778,13 +825,20 @@ with gr.Blocks(title='Meta Prompt') as demo:
             initial_system_message_input,
             recursion_limit_input,
             max_output_age,
-            model_states["initial_developer"],
-            model_states["acceptance_criteria"],
-            model_states["developer"],
-            model_states["executor"],
-            model_states["history_analyzer"],
-            model_states["analyzer"],
-            model_states["suggester"],
+            model_name_states["initial_developer"],
+            model_temperature_states["initial_developer"],
+            model_name_states["acceptance_criteria"],
+            model_temperature_states["acceptance_criteria"],
+            model_name_states["developer"],
+            model_temperature_states["developer"],
+            model_name_states["executor"],
+            model_temperature_states["executor"],
+            model_name_states["history_analyzer"],
+            model_temperature_states["history_analyzer"],
+            model_name_states["analyzer"],
+            model_temperature_states["analyzer"],
+            model_name_states["suggester"],
+            model_temperature_states["suggester"],
             prompt_template_group,
             aggressive_exploration
         ],

app/gradio_meta_prompt_utils.py

@@ -171,44 +171,72 @@ def chat_log_2_chatbot_list(chat_log: str) -> List[List[str]]:
             print(line)
     return chatbot_list
 
-def on_model_tab_select(simple_model_name, 
-                        advanced_optimizer_model_name, advanced_executor_model_name,
-                        expert_prompt_initial_developer_model_name,
-                        expert_prompt_acceptance_criteria_developer_model_name,
-                        expert_prompt_developer_model_name,
-                        expert_prompt_executor_model_name,
-                        expert_prompt_history_analyzer_model_name,
-                        expert_prompt_analyzer_model_name,
-                        expert_prompt_suggester_model_name,
-                        event: gr.SelectData):
-    if event.value == 'Simple':
+def on_prompt_model_tab_state_change(config, model_tab_select_state,
+                              simple_model_name, advanced_optimizer_model_name, advanced_executor_model_name,
+                              expert_prompt_initial_developer_model_name,
+                              expert_prompt_initial_developer_temperature,
+                              expert_prompt_acceptance_criteria_developer_model_name,
+                              expert_prompt_acceptance_criteria_temperature,
+                              expert_prompt_developer_model_name,
+                              expert_prompt_developer_temperature,
+                              expert_prompt_executor_model_name,
+                              expert_prompt_executor_temperature,
+                              expert_prompt_history_analyzer_model_name,
+                              expert_prompt_history_analyzer_temperature,
+                              expert_prompt_analyzer_model_name,
+                              expert_prompt_analyzer_temperature,
+                              expert_prompt_suggester_model_name,
+                              expert_prompt_suggester_temperature):
+    if model_tab_select_state == 'Simple':
         return simple_model_name, \
+            config.default_llm_temperature, \
             simple_model_name, \
+            config.default_llm_temperature, \
             simple_model_name, \
+            config.default_llm_temperature, \
             simple_model_name, \
+            config.default_llm_temperature, \
             simple_model_name, \
+            config.default_llm_temperature, \
             simple_model_name, \
-            simple_model_name
-    elif event.value == 'Advanced':
+            config.default_llm_temperature, \
+            simple_model_name, \
+            config.default_llm_temperature
+    elif model_tab_select_state == 'Advanced':
         return advanced_optimizer_model_name, \
+            config.default_llm_temperature, \
             advanced_optimizer_model_name, \
+            config.default_llm_temperature, \
             advanced_optimizer_model_name, \
+            config.default_llm_temperature, \
             advanced_executor_model_name, \
+            config.default_llm_temperature, \
             advanced_optimizer_model_name, \
+            config.default_llm_temperature, \
             advanced_optimizer_model_name, \
-            advanced_optimizer_model_name
-    elif event.value == 'Expert':
+            config.default_llm_temperature
+    elif model_tab_select_state == 'Expert':
         return expert_prompt_initial_developer_model_name, \
+            expert_prompt_initial_developer_temperature, \
             expert_prompt_acceptance_criteria_developer_model_name, \
+            expert_prompt_acceptance_criteria_temperature, \
             expert_prompt_developer_model_name, \
+            expert_prompt_developer_temperature, \
             expert_prompt_executor_model_name, \
+            expert_prompt_executor_temperature, \
             expert_prompt_history_analyzer_model_name, \
+            expert_prompt_history_analyzer_temperature, \
             expert_prompt_analyzer_model_name, \
-            expert_prompt_suggester_model_name
+            expert_prompt_analyzer_temperature, \
+            expert_prompt_suggester_model_name, \
+            expert_prompt_suggester_temperature
     else:
-        raise ValueError(f"Invalid model tab selected: {event.value}")
-    
-def evaluate_system_message(config, system_message, user_message, executor_model_name):
+        raise ValueError(f"Invalid model tab selected: {model_tab_select_state}")
+
+def on_model_tab_select(event: gr.SelectData):
+    return event.value
+
+def evaluate_system_message(config, system_message, user_message, executor_model_name, executor_temperature):
     """
     Evaluate a system message by using it to generate a response from an
     executor model based on the current active tab and provided user message.
@@ -236,7 +264,7 @@ def evaluate_system_message(config, system_message, user_message, executor_model
         Exception: For any other unexpected errors that occur during the
             execution of this function.
     """
-    llm = initialize_llm(config, executor_model_name)
+    llm = initialize_llm(config, executor_model_name, {'temperature': executor_temperature})
     template = ChatPromptTemplate.from_messages([
         ("system", "{system_message}"),
         ("human", "{user_message}")
@@ -251,7 +279,7 @@ def evaluate_system_message(config, system_message, user_message, executor_model
         raise gr.Error(f"Error: {e}")
 
 
-def generate_acceptance_criteria(config, user_message, expected_output, acceptance_criteria_model_name, prompt_template_group):
+def generate_acceptance_criteria(config, user_message, expected_output, acceptance_criteria_model_name, acceptance_criteria_temperature, prompt_template_group):
     """
     Generate acceptance criteria based on the user message and expected output.
 
@@ -280,7 +308,7 @@ def generate_acceptance_criteria(config, user_message, expected_output, acceptan
         )
         logger.addHandler(log_handler)
 
-    llm = initialize_llm(config, acceptance_criteria_model_name)
+    llm = initialize_llm(config, acceptance_criteria_model_name, {'temperature': acceptance_criteria_temperature})
     if prompt_template_group is None:
         prompt_template_group = 'default'
     prompt_templates = prompt_templates_confz2langchain(
@@ -309,6 +337,7 @@ def generate_initial_system_message(
     user_message: str,
     expected_output: str,
     initial_developer_model_name: str,
+    initial_developer_temperature: float,
     prompt_template_group: Optional[str] = None
 ) -> tuple:
     """
@@ -335,7 +364,7 @@ def generate_initial_system_message(
         )
         logger.addHandler(log_handler)
 
-    llm = initialize_llm(config, initial_developer_model_name)
+    llm = initialize_llm(config, initial_developer_model_name, {'temperature': initial_developer_temperature})
 
     if prompt_template_group is None:
         prompt_template_group = 'default'
@@ -371,9 +400,13 @@ def process_message_with_models(
     config,
     user_message: str, expected_output: str, acceptance_criteria: str,
     initial_system_message: str, recursion_limit: int, max_output_age: int,
-    initial_developer_model_name: str, acceptance_criteria_model_name: str,
-    developer_model_name: str, executor_model_name: str, history_analyzer_model_name: str,
-    analyzer_model_name: str, suggester_model_name: str,
+    initial_developer_model_name: str, initial_developer_temperature: float,
+    acceptance_criteria_model_name: str, acceptance_criteria_temperature: float,
+    developer_model_name: str, developer_temperature: float,
+    executor_model_name: str, executor_temperature: float,
+    history_analyzer_model_name: str, history_analyzer_temperature: float,
+    analyzer_model_name: str, analyzer_temperature: float,
+    suggester_model_name: str, suggester_temperature: float,
     prompt_template_group: Optional[str] = None,
     aggressive_exploration: bool = False
 ) -> tuple:
@@ -423,13 +456,13 @@ def process_message_with_models(
         prompt_template_group = 'default'
     prompt_templates = prompt_templates_confz2langchain(config.prompt_templates[prompt_template_group])
     llms = {
-        NODE_PROMPT_INITIAL_DEVELOPER: initialize_llm(config, initial_developer_model_name),
-        NODE_ACCEPTANCE_CRITERIA_DEVELOPER: initialize_llm(config, acceptance_criteria_model_name),
-        NODE_PROMPT_DEVELOPER: initialize_llm(config, developer_model_name),
-        NODE_PROMPT_EXECUTOR: initialize_llm(config, executor_model_name),
-        NODE_OUTPUT_HISTORY_ANALYZER: initialize_llm(config, history_analyzer_model_name),
-        NODE_PROMPT_ANALYZER: initialize_llm(config, analyzer_model_name),
-        NODE_PROMPT_SUGGESTER: initialize_llm(config, suggester_model_name)
+        NODE_PROMPT_INITIAL_DEVELOPER: initialize_llm(config, initial_developer_model_name, {'temperature': initial_developer_temperature}),
+        NODE_ACCEPTANCE_CRITERIA_DEVELOPER: initialize_llm(config, acceptance_criteria_model_name, {'temperature': acceptance_criteria_temperature}),
+        NODE_PROMPT_DEVELOPER: initialize_llm(config, developer_model_name, {'temperature': developer_temperature}),
+        NODE_PROMPT_EXECUTOR: initialize_llm(config, executor_model_name, {'temperature': executor_temperature}),
+        NODE_OUTPUT_HISTORY_ANALYZER: initialize_llm(config, history_analyzer_model_name, {'temperature': history_analyzer_temperature}),
+        NODE_PROMPT_ANALYZER: initialize_llm(config, analyzer_model_name, {'temperature': analyzer_temperature}),
+        NODE_PROMPT_SUGGESTER: initialize_llm(config, suggester_model_name, {'temperature': suggester_temperature})
     }
     meta_prompt_graph = MetaPromptGraph(llms=llms, prompts=prompt_templates,
                                         aggressive_exploration=aggressive_exploration,
@@ -513,15 +546,14 @@ def convert_examples_to_json(examples):
     return pd_examples.to_json(orient="records")
 
 def process_json_data(
+    config,
     examples, model_name, generating_batch_size, temperature
 ):
     try:
         # Convert the gradio dataframe into a JSON array
         input_json = convert_examples_to_json(examples)
 
-        model = ChatOpenAI(
-            model=model_name, temperature=temperature, max_retries=3
-        )
+        model = initialize_llm(config, model_name, {'temperature': temperature, 'max_retries': 3})
         generator = TaskDescriptionGenerator(model)
         result = generator.process(input_json, generating_batch_size)
 
@@ -553,11 +585,11 @@ def process_json_data(
     except Exception as e:
         raise gr.Error(f"An error occurred: {str(e)}")
     
-def generate_description(examples, model_name, temperature):
+def generate_description(config, examples, model_name, temperature):
     try:
         input_json = convert_examples_to_json(examples)
 
-        model = ChatOpenAI(model=model_name, temperature=temperature, max_retries=3)
+        model = initialize_llm(config, model_name, {'temperature': temperature, 'max_retries': 3})
         generator = TaskDescriptionGenerator(model)
         result = generator.generate_description(input_json)
         description = result["description"]
@@ -566,9 +598,9 @@ def generate_description(examples, model_name, temperature):
     except Exception as e:
         raise gr.Error(f"An error occurred: {str(e)}")
 
-def analyze_input_data(description, model_name, temperature):
+def analyze_input_data(config, description, model_name, temperature):
     try:
-        model = ChatOpenAI(model=model_name, temperature=temperature, max_retries=3)
+        model = initialize_llm(config, model_name, {'temperature': temperature, 'max_retries': 3})
         generator = TaskDescriptionGenerator(model)
         input_analysis = generator.analyze_input(description)
         return input_analysis
@@ -576,12 +608,10 @@ def analyze_input_data(description, model_name, temperature):
         raise gr.Error(f"An error occurred: {str(e)}")
     
 def generate_example_briefs(
-    description, input_analysis, generating_batch_size, model_name, temperature
+    config, description, input_analysis, generating_batch_size, model_name, temperature
 ):
     try:
-        model = ChatOpenAI(
-            model=model_name, temperature=temperature, max_retries=3
-        )
+        model = initialize_llm(config, model_name, {'temperature': temperature, 'max_retries': 3})
         generator = TaskDescriptionGenerator(model)
         briefs = generator.generate_briefs(
             description, input_analysis, generating_batch_size
@@ -592,13 +622,11 @@ def generate_example_briefs(
 
 
 def generate_examples_using_briefs(
-    description, new_example_briefs, examples, generating_batch_size, model_name, temperature
+    config, description, new_example_briefs, examples, generating_batch_size, model_name, temperature
 ):
     try:
         input_json = convert_examples_to_json(examples)
-        model = ChatOpenAI(
-            model=model_name, temperature=temperature, max_retries=3
-        )
+        model = initialize_llm(config, model_name, {'temperature': temperature, 'max_retries': 3})
         generator = TaskDescriptionGenerator(model)
         result = generator.generate_examples_from_briefs(
             description, new_example_briefs, input_json, generating_batch_size
@@ -613,11 +641,11 @@ def generate_examples_using_briefs(
 
 
 def generate_examples_from_description(
-    description, raw_example, generating_batch_size, model_name, temperature
+    config, description, raw_example, generating_batch_size, model_name, temperature
 ):
     try:
         input_json = convert_examples_to_json(raw_example)
-        model = ChatOpenAI(model=model_name, temperature=temperature, max_retries=3)
+        model = initialize_llm(config, model_name, {'temperature': temperature, 'max_retries': 3})
         generator = TaskDescriptionGenerator(model)
         result = generator.generate_examples_directly(
             description, input_json, generating_batch_size
@@ -717,20 +745,20 @@ def input_dataframe_change(
         selected_group_output,
     )
 
-def generate_suggestions(description, examples, model_name, temperature):
+def generate_suggestions(config, description, examples, model_name, temperature):
     try:
         input_json = convert_examples_to_json(examples)
-        model = ChatOpenAI(model=model_name, temperature=temperature, max_retries=3)
+        model = initialize_llm(config, model_name, {'temperature': temperature, 'max_retries': 3})
         generator = TaskDescriptionGenerator(model)
         result = generator.generate_suggestions(input_json, description)
         return gr.update(choices=result["suggestions"])
     except Exception as e:
         raise gr.Error(f"An error occurred: {str(e)}")
 
-def apply_suggestions(description, suggestions, examples, model_name, temperature):
+def apply_suggestions(config, description, suggestions, examples, model_name, temperature):
     try:
         input_json = convert_examples_to_json(examples)
-        model = ChatOpenAI(model=model_name, temperature=temperature, max_retries=3)
+        model = initialize_llm(config, model_name, {'temperature': temperature, 'max_retries': 3})
         generator = TaskDescriptionGenerator(model)
         result = generator.update_description(input_json, description, suggestions)
         return result["description"]