Streamlit tab app works.

app/meta_prompt_utils.py

@@ -0,0 +1,382 @@
+# meta_prompt_utils.py
+
+import json
+import logging
+import io
+from typing import Any, Dict, List, Optional, Union
+from langchain_core.language_models import BaseLanguageModel
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_openai import ChatOpenAI
+from meta_prompt import *
+from meta_prompt.sample_generator import TaskDescriptionGenerator
+from pythonjsonlogger import jsonlogger
+from app.config import MetaPromptConfig, RoleMessage
+from confz import BaseConfig, CLArgSource, EnvSource, FileSource
+
+def prompt_templates_confz2langchain(
+    prompt_templates: Dict[str, Dict[str, List[RoleMessage]]]
+) -> Dict[str, ChatPromptTemplate]:
+    return {
+        node: ChatPromptTemplate.from_messages(
+            [
+                (role_message.role, role_message.message)
+                for role_message in role_messages
+            ]
+        )
+        for node, role_messages in prompt_templates.items()
+    }
+
+class LLMModelFactory:
+    _instance = None
+
+    def __new__(cls):
+        if not cls._instance:
+            cls._instance = super(LLMModelFactory, cls).__new__(cls)
+        return cls._instance
+
+    def create(self, model_type: str, **kwargs) -> BaseLanguageModel:
+        model_class = globals()[model_type]
+        return model_class(**kwargs)
+
+def chat_log_2_chatbot_list(chat_log: str) -> List[List[str]]:
+    chatbot_list = []
+    if chat_log is None or chat_log == '':
+        return chatbot_list
+    for line in chat_log.splitlines():
+        try:
+            json_line = json.loads(line)
+            if 'action' in json_line:
+                if json_line['action'] == 'invoke':
+                    chatbot_list.append([json_line['message'], None])
+                if json_line['action'] == 'response':
+                    chatbot_list.append([None, json_line['message']])
+        except json.decoder.JSONDecodeError as e:
+            print(f"Error decoding JSON log output: {e}")
+            print(line)
+        except KeyError as e:
+            print(f"Error accessing key in JSON log output: {e}")
+            print(line)
+    return chatbot_list
+
+def get_current_model(simple_model_name: str,
+                      advanced_model_name: str,
+                      expert_model_name: str,
+                      expert_model_config: Optional[Dict[str, Any]] = None,
+                      config: MetaPromptConfig = None,
+                      active_model_tab: str = "Simple") -> BaseLanguageModel:
+    model_mapping = {
+        "Simple": simple_model_name,
+        "Advanced": advanced_model_name,
+        "Expert": expert_model_name
+    }
+    
+    try:
+        model_name = model_mapping.get(active_model_tab, simple_model_name)
+        model = config.llms[model_name]
+        model_type = model.type
+        model_config = model.model_dump(exclude={'type'})
+    
+        if active_model_tab == "Expert" and expert_model_config:
+            model_config.update(expert_model_config)
+    
+        return LLMModelFactory().create(model_type, **model_config)
+    
+    except KeyError as e:
+        logging.error(f"Configuration key error: {e}")
+        raise ValueError(f"Invalid model name or configuration: {e}")
+    
+    except Exception as e:
+        logging.error(f"An unexpected error occurred: {e}")
+        raise RuntimeError(f"Failed to retrieve the model: {e}")
+
+def evaluate_system_message(system_message, user_message, simple_model,
+                            advanced_executor_model, expert_executor_model,
+                            expert_executor_model_temperature=0.1,
+                            config: MetaPromptConfig = None,
+                            active_model_tab: str = "Simple"):
+    llm = get_current_model(simple_model, advanced_executor_model,
+                            expert_executor_model,
+                            {"temperature": expert_executor_model_temperature},
+                            config, active_model_tab)
+    template = ChatPromptTemplate.from_messages([
+        ("system", "{system_message}"),
+        ("human", "{user_message}")
+    ])
+    try:
+        output = llm.invoke(template.format(
+            system_message=system_message, user_message=user_message))
+        return output.content if hasattr(output, 'content') else ""
+    except Exception as e:
+        raise Exception(f"Error: {e}")
+
+def generate_acceptance_criteria(user_message, expected_output,
+                                 simple_model, advanced_executor_model,
+                                 expert_prompt_acceptance_criteria_model,
+                                 expert_prompt_acceptance_criteria_temperature=0.1,
+                                 prompt_template_group: Optional[str] = None,
+                                 config: MetaPromptConfig = None,
+                                 active_model_tab: str = "Simple"):
+    log_stream = io.StringIO()
+    logger = logging.getLogger(MetaPromptGraph.__name__) if config.verbose else None
+    log_handler = logging.StreamHandler(log_stream) if logger else None
+
+    if log_handler:
+        log_handler.setFormatter(
+            jsonlogger.JsonFormatter('%(asctime)s %(name)s %(levelname)s %(message)s')
+        )
+        logger.addHandler(log_handler)
+
+    llm = get_current_model(simple_model, advanced_executor_model,
+                            expert_prompt_acceptance_criteria_model,
+                            {"temperature": expert_prompt_acceptance_criteria_temperature},
+                            config, active_model_tab)
+    if prompt_template_group is None:
+        prompt_template_group = 'default'
+    prompt_templates = prompt_templates_confz2langchain(
+        config.prompt_templates[prompt_template_group]
+    )
+    acceptance_criteria_graph = MetaPromptGraph(llms={
+        NODE_ACCEPTANCE_CRITERIA_DEVELOPER: llm
+    }, prompts=prompt_templates,
+    verbose=config.verbose, logger=logger)
+    state = AgentState(
+        user_message=user_message,
+        expected_output=expected_output
+    )
+    output_state = acceptance_criteria_graph.run_acceptance_criteria_graph(state)
+
+    if log_handler:
+        log_handler.close()
+        log_output = log_stream.getvalue()
+    else:
+        log_output = None
+    return output_state.get('acceptance_criteria', ""), chat_log_2_chatbot_list(log_output)
+
+def generate_initial_system_message(
+    user_message: str,
+    expected_output: str,
+    simple_model: str,
+    advanced_executor_model: str,
+    expert_prompt_initial_developer_model: str,
+    expert_prompt_initial_developer_temperature: float = 0.1,
+    prompt_template_group: Optional[str] = None,
+    config: MetaPromptConfig = None,
+    active_model_tab: str = "Simple"
+) -> tuple:
+    log_stream = io.StringIO()
+    logger = logging.getLogger(MetaPromptGraph.__name__) if config.verbose else None
+    log_handler = logging.StreamHandler(log_stream) if logger else None
+
+    if log_handler:
+        log_handler.setFormatter(
+            jsonlogger.JsonFormatter('%(asctime)s %(name)s %(levelname)s %(message)s')
+        )
+        logger.addHandler(log_handler)
+
+    llm = get_current_model(
+        simple_model,
+        advanced_executor_model,
+        expert_prompt_initial_developer_model,
+        {"temperature": expert_prompt_initial_developer_temperature},
+        config,
+        active_model_tab
+    )
+
+    if prompt_template_group is None:
+        prompt_template_group = 'default'
+    prompt_templates = prompt_templates_confz2langchain(
+        config.prompt_templates[prompt_template_group]
+    )
+
+    initial_system_message_graph = MetaPromptGraph(
+        llms={NODE_PROMPT_INITIAL_DEVELOPER: llm},
+        prompts=prompt_templates,
+        verbose=config.verbose,
+        logger=logger
+    )
+
+    state = AgentState(
+        user_message=user_message,
+        expected_output=expected_output
+    )
+
+    output_state = initial_system_message_graph.run_prompt_initial_developer_graph(state)
+
+    if log_handler:
+        log_handler.close()
+        log_output = log_stream.getvalue()
+    else:
+        log_output = None
+
+    system_message = output_state.get('system_message', "")
+    return system_message, chat_log_2_chatbot_list(log_output)
+
+def process_message(
+    user_message: str, expected_output: str, acceptance_criteria: str,
+    initial_system_message: str, recursion_limit: int, max_output_age: int,
+    llms: Union[BaseLanguageModel, Dict[str, BaseLanguageModel]],
+    prompt_template_group: Optional[str] = None,
+    aggressive_exploration: bool = False,
+    config: MetaPromptConfig = None
+) -> tuple:
+    input_state = AgentState(
+        user_message=user_message,
+        expected_output=expected_output,
+        acceptance_criteria=acceptance_criteria,
+        system_message=initial_system_message,
+        max_output_age=max_output_age
+    )
+
+    log_stream = io.StringIO()
+    logger = logging.getLogger(MetaPromptGraph.__name__) if config.verbose else None
+    log_handler = logging.StreamHandler(log_stream) if logger else None
+    if log_handler:
+        log_handler.setFormatter(jsonlogger.JsonFormatter(
+            '%(asctime)s %(name)s %(levelname)s %(message)s'))
+        logger.addHandler(log_handler)
+
+    if prompt_template_group is None:
+        prompt_template_group = 'default'
+    prompt_templates = prompt_templates_confz2langchain(config.prompt_templates[prompt_template_group])
+    meta_prompt_graph = MetaPromptGraph(llms=llms, prompts=prompt_templates,
+                                        aggressive_exploration=aggressive_exploration,
+                                        verbose=config.verbose, logger=logger)
+    try:
+        output_state = meta_prompt_graph(input_state, recursion_limit=recursion_limit)
+    except Exception as e:
+        raise Exception(f"Error: {e}")           
+
+    if log_handler:
+        log_handler.close()
+        log_output = log_stream.getvalue()
+    else:
+        log_output = None
+
+    system_message = output_state.get(
+        'best_system_message', "Error: The output state does not contain a valid 'best_system_message'")
+    output = output_state.get(
+        'best_output', "Error: The output state does not contain a valid 'best_output'")
+    analysis = output_state.get(
+        'analysis', "Error: The output state does not contain a valid 'analysis'")
+    acceptance_criteria = output_state.get(
+        'acceptance_criteria', "Error: The output state does not contain a valid 'acceptance_criteria'")
+
+    return (system_message, output, analysis, acceptance_criteria, chat_log_2_chatbot_list(log_output))
+
+def initialize_llm(model_name: str, model_config: Optional[Dict[str, Any]] = None, config: MetaPromptConfig = None) -> Any:
+    try:
+        llm_config = config.llms[model_name]
+        model_type = llm_config.type
+        dumped_config = llm_config.model_dump(exclude={'type'})
+
+        if model_config:
+            dumped_config.update(model_config)
+
+        return LLMModelFactory().create(model_type, **dumped_config)
+    except KeyError:
+        raise KeyError(f"No configuration exists for the model name: {model_name}")
+    except NotImplementedError:
+        raise NotImplementedError(
+            f"Unrecognized type configured for the language model: {model_type}"
+        )
+
+# Sample generator functions
+
+def process_json(input_json, model_name, generating_batch_size, temperature, config: MetaPromptConfig = None):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        result = generator.process(input_json, generating_batch_size)
+        description = result["description"]
+        suggestions = result["suggestions"]
+        examples_directly = [[example["input"], example["output"]]
+                             for example in result["examples_directly"]["examples"]]
+        input_analysis = result["examples_from_briefs"]["input_analysis"]
+        new_example_briefs = result["examples_from_briefs"]["new_example_briefs"]
+        examples_from_briefs = [[example["input"], example["output"]]
+                                for example in result["examples_from_briefs"]["examples"]]
+        examples = [[example["input"], example["output"]]
+                    for example in result["additional_examples"]]
+        return description, suggestions, examples_directly, input_analysis, new_example_briefs, examples_from_briefs, examples
+    except Exception as e:
+        raise Exception(f"An error occurred: {str(e)}. Returning default values.")
+
+def generate_description_only(input_json, model_name, temperature, config: MetaPromptConfig = None):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        result = generator.generate_description(input_json)
+        description = result["description"]
+        suggestions = result["suggestions"]
+        return description, suggestions
+    except Exception as e:
+        raise Exception(f"An error occurred: {str(e)}")
+
+def analyze_input(description, model_name, temperature, config: MetaPromptConfig = None):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        input_analysis = generator.analyze_input(description)
+        return input_analysis
+    except Exception as e:
+        raise Exception(f"An error occurred: {str(e)}")
+
+def generate_briefs(description, input_analysis, generating_batch_size, model_name, temperature, config: MetaPromptConfig = None):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        briefs = generator.generate_briefs(
+            description, input_analysis, generating_batch_size)
+        return briefs
+    except Exception as e:
+        raise Exception(f"An error occurred: {str(e)}")
+
+def generate_examples_from_briefs(description, new_example_briefs, input_str, generating_batch_size, model_name, temperature, config: MetaPromptConfig = None):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        result = generator.generate_examples_from_briefs(
+            description, new_example_briefs, input_str, generating_batch_size)
+        examples = [[example["input"], example["output"]]
+                    for example in result["examples"]]
+        return examples
+    except Exception as e:
+        raise Exception(f"An error occurred: {str(e)}")
+
+def generate_examples_directly(description, raw_example, generating_batch_size, model_name, temperature, config: MetaPromptConfig = None):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        result = generator.generate_examples_directly(
+            description, raw_example, generating_batch_size)
+        examples = [[example["input"], example["output"]]
+                    for example in result["examples"]]
+        return examples
+    except Exception as e:
+        raise Exception(f"An error occurred: {str(e)}")
+
+class FileConfig(BaseConfig):
+    config_file: str = 'config.yml'  # default path
+
+def load_config():
+    pre_config_sources = [
+        EnvSource(prefix='METAPROMPT_', allow_all=True),
+        CLArgSource()
+    ]
+    pre_config = FileConfig(config_sources=pre_config_sources)
+
+    config_sources = [
+        FileSource(file=pre_config.config_file, optional=True),
+        EnvSource(prefix='METAPROMPT_', allow_all=True),
+        CLArgSource()
+    ]
+
+    return MetaPromptConfig(config_sources=config_sources)
+
+# Add any additional utility functions here if needed

app/streamlit_tab_app.py

@@ -0,0 +1,730 @@
+import pandas as pd
+import streamlit as st
+import json
+from app.meta_prompt_utils import *
+from meta_prompt.sample_generator import TaskDescriptionGenerator
+
+# Initialize session state
+def init_session_state():
+    if 'shared_input_data' not in st.session_state:
+        st.session_state.shared_input_data = pd.DataFrame(columns=["Input", "Output"])
+    if 'initial_system_message' not in st.session_state:
+        st.session_state.initial_system_message = ""
+    if 'initial_acceptance_criteria' not in st.session_state:
+        st.session_state.initial_acceptance_criteria = ""
+    if 'system_message_output' not in st.session_state:
+        st.session_state.system_message_output = ""
+    if 'output' not in st.session_state:
+        st.session_state.output = ""
+    if 'analysis' not in st.session_state:
+        st.session_state.analysis = ""
+    if 'acceptance_criteria_output' not in st.session_state:
+        st.session_state.acceptance_criteria_output = ""
+    if 'chat_log' not in st.session_state:
+        st.session_state.chat_log = []
+    if 'description_output_text' not in st.session_state:
+        st.session_state.description_output_text = ''
+    if 'suggestions' not in st.session_state:
+        st.session_state.suggestions = []
+    if 'input_analysis_output_text' not in st.session_state:
+        st.session_state.input_analysis_output_text = ''
+    if 'example_briefs_output_text' not in st.session_state:
+        st.session_state.example_briefs_output_text = ''
+    if 'examples_from_briefs_dataframe' not in st.session_state:
+        st.session_state.examples_from_briefs_dataframe = pd.DataFrame(columns=["Input", "Output"])
+    if 'examples_directly_dataframe' not in st.session_state:
+        st.session_state.examples_directly_dataframe = pd.DataFrame(columns=["Input", "Output"])
+    if 'examples_dataframe' not in st.session_state:
+        st.session_state.examples_dataframe = pd.DataFrame(columns=["Input", "Output"])
+    if 'selected_example' not in st.session_state:
+        st.session_state.selected_example = None
+
+# UI helper functions
+def clear_session_state():
+    for key in list(st.session_state.keys()):
+        del st.session_state[key]
+    init_session_state()
+
+def sync_input_data():
+    st.session_state.shared_input_data = st.session_state.data_editor_data.copy()
+
+# Sample Generator Functions
+
+def process_json(input_json, model_name, generating_batch_size, temperature):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        result = generator.process(input_json, generating_batch_size)
+        description = result["description"]
+        suggestions = result["suggestions"]
+        examples_directly = [[example["input"], example["output"]]
+                             for example in result["examples_directly"]["examples"]]
+        input_analysis = result["examples_from_briefs"]["input_analysis"]
+        new_example_briefs = result["examples_from_briefs"]["new_example_briefs"]
+        examples_from_briefs = [[example["input"], example["output"]]
+                                for example in result["examples_from_briefs"]["examples"]]
+        examples = [[example["input"], example["output"]]
+                    for example in result["additional_examples"]]
+        return description, suggestions, examples_directly, input_analysis, new_example_briefs, examples_from_briefs, examples
+    except Exception as e:
+        st.warning(f"An error occurred: {str(e)}. Returning default values.")
+        return "", [], [], "", [], [], []
+
+
+def generate_description_only(input_json, model_name, temperature):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        result = generator.generate_description(input_json)
+        description = result["description"]
+        suggestions = result["suggestions"]
+        return description, suggestions
+    except Exception as e:
+        st.warning(f"An error occurred: {str(e)}")
+        return "", []
+
+
+def analyze_input(description, model_name, temperature):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        input_analysis = generator.analyze_input(description)
+        return input_analysis
+    except Exception as e:
+        st.warning(f"An error occurred: {str(e)}")
+        return ""
+
+
+def generate_briefs(description, input_analysis, generating_batch_size, model_name, temperature):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        briefs = generator.generate_briefs(
+            description, input_analysis, generating_batch_size)
+        return briefs
+    except Exception as e:
+        st.warning(f"An error occurred: {str(e)}")
+        return ""
+
+
+def generate_examples_from_briefs(description, new_example_briefs, input_str, generating_batch_size, model_name, temperature):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        result = generator.generate_examples_from_briefs(
+            description, new_example_briefs, input_str, generating_batch_size)
+        examples = [[example["input"], example["output"]]
+                    for example in result["examples"]]
+        return examples
+    except Exception as e:
+        st.warning(f"An error occurred: {str(e)}")
+        return []
+
+
+def generate_examples_directly(description, raw_example, generating_batch_size, model_name, temperature):
+    try:
+        model = ChatOpenAI(
+            model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        result = generator.generate_examples_directly(
+            description, raw_example, generating_batch_size)
+        examples = [[example["input"], example["output"]]
+                    for example in result["examples"]]
+        return examples
+    except Exception as e:
+        st.warning(f"An error occurred: {str(e)}")
+        return []
+
+
+def example_directly_selected():
+    if 'selected_example_directly_id' in st.session_state:
+        try:
+            selected_example_ids = st.session_state.selected_example_directly_id[
+                'selection']['rows']
+            # set selected examples to the selected rows if there are any
+            if selected_example_ids:
+                selected_examples = st.session_state.examples_directly_dataframe.iloc[selected_example_ids].to_dict(
+                    'records')
+                st.session_state.selected_example = pd.DataFrame(selected_examples)  # Convert to DataFrame
+            else:
+                st.session_state.selected_example = None
+        except Exception as e:
+            st.session_state.selected_example = None
+
+
+def example_from_briefs_selected():
+    if 'selected_example_from_briefs_id' in st.session_state:
+        try:
+            selected_example_ids = st.session_state.selected_example_from_briefs_id[
+                'selection']['rows']
+            # set selected examples to the selected rows if there are any
+            if selected_example_ids:
+                selected_examples = st.session_state.examples_from_briefs_dataframe.iloc[selected_example_ids].to_dict(
+                    'records')
+                st.session_state.selected_example = pd.DataFrame(selected_examples)  # Convert to DataFrame
+            else:
+                st.session_state.selected_example = None
+        except Exception as e:
+            st.session_state.selected_example = None
+
+
+def example_selected():
+    if 'selected_example_id' in st.session_state:
+        try:
+            selected_example_ids = st.session_state.selected_example_id['selection']['rows']
+            # set selected examples to the selected rows if there are any
+            if selected_example_ids:
+                selected_examples = st.session_state.examples_dataframe.iloc[selected_example_ids].to_dict(
+                    'records')
+                st.session_state.selected_example = pd.DataFrame(selected_examples)  # Convert to DataFrame
+            else:
+                st.session_state.selected_example = None
+        except Exception as e:
+            st.session_state.selected_example = None
+
+def update_description_output_text():
+    input_json = package_input_data()
+    result = generate_description_only(input_json, model_name, temperature)
+    st.session_state.description_output_text = result[0]
+    st.session_state.suggestions = result[1]
+
+
+def update_input_analysis_output_text():
+    st.session_state.input_analysis_output_text = analyze_input(
+        description_output, model_name, temperature)
+
+
+def update_example_briefs_output_text():
+    st.session_state.example_briefs_output_text = generate_briefs(
+        description_output, input_analysis_output, generating_batch_size, model_name, temperature)
+
+
+def update_examples_from_briefs_dataframe():
+    input_json = package_input_data()
+    examples = generate_examples_from_briefs(
+        description_output, example_briefs_output, input_json, generating_batch_size, model_name, temperature)
+    st.session_state.examples_from_briefs_dataframe = pd.DataFrame(
+        examples, columns=["Input", "Output"])
+
+
+def update_examples_directly_dataframe():
+    input_json = package_input_data()
+    examples = generate_examples_directly(
+        description_output, input_json, generating_batch_size, model_name, temperature)
+    st.session_state.examples_directly_dataframe = pd.DataFrame(
+        examples, columns=["Input", "Output"])
+
+
+def generate_examples_dataframe():
+    input_json = package_input_data()
+    result = process_json(input_json, model_name,
+                          generating_batch_size, temperature)
+    description, suggestions, examples_directly, input_analysis, new_example_briefs, examples_from_briefs, examples = result
+    st.session_state.description_output_text = description
+    st.session_state.suggestions = suggestions  # Ensure suggestions are stored in session state
+    st.session_state.examples_directly_dataframe = pd.DataFrame(
+        examples_directly, columns=["Input", "Output"])
+    st.session_state.input_analysis_output_text = input_analysis
+    st.session_state.example_briefs_output_text = new_example_briefs
+    st.session_state.examples_from_briefs_dataframe = pd.DataFrame(
+        examples_from_briefs, columns=["Input", "Output"])
+    st.session_state.examples_dataframe = pd.DataFrame(
+        examples, columns=["Input", "Output"])
+    st.session_state.selected_example = None
+
+def package_input_data():
+    data = data_editor_data.to_dict(orient='records')
+    lowered_data = [{k.lower(): v for k, v in d.items()} for d in data]
+    return json.dumps(lowered_data, ensure_ascii=False)
+
+def export_input_data_to_json():
+    input_data_json = package_input_data()
+    st.download_button(
+        label="Download input data as JSON",
+        data=input_data_json,
+        file_name="input_data.json",
+        mime="application/json"
+    )
+
+def import_input_data_from_json():
+    try:
+        if 'input_file' in st.session_state and st.session_state.input_file is not None:
+            data = st.session_state.input_file.getvalue()
+            data = json.loads(data)
+            data = [{k.capitalize(): v for k, v in d.items()} for d in data]
+            st.session_state.shared_input_data = pd.DataFrame(data)
+    except Exception as e:
+        st.warning(f"Failed to import JSON: {str(e)}")
+
+def apply_suggestions():
+    try:
+        result = TaskDescriptionGenerator(
+            ChatOpenAI(model=model_name, temperature=temperature, max_retries=3)).update_description(
+            package_input_data(), st.session_state.description_output_text, st.session_state.selected_suggestions)
+        st.session_state.description_output_text = result["description"]
+        st.session_state.suggestions = result["suggestions"]
+    except Exception as e:
+        st.warning(f"Failed to update description: {str(e)}")
+
+def generate_suggestions():
+    try:
+        description = st.session_state.description_output_text
+        input_json = package_input_data()
+
+        model = ChatOpenAI(model=model_name, temperature=temperature, max_retries=3)
+        generator = TaskDescriptionGenerator(model)
+        result = generator.generate_suggestions(input_json, description)
+        st.session_state.suggestions = result["suggestions"]
+    except Exception as e:
+        st.warning(f"Failed to generate suggestions: {str(e)}")
+
+# Function to add new suggestion to the list and select it
+def add_new_suggestion():
+    if st.session_state.new_suggestion:
+        st.session_state.suggestions.append(st.session_state.new_suggestion)
+        st.session_state.new_suggestion = ""  # Clear the input field
+
+def append_selected_to_input_data():
+    if st.session_state.selected_example is not None:
+        st.session_state.shared_input_data = pd.concat(
+            [data_editor_data, st.session_state.selected_example], ignore_index=True)
+        st.session_state.selected_example = None
+
+def show_scoping_sidebar():
+    if st.session_state.selected_example is not None:
+        with st.sidebar:
+            st.dataframe(st.session_state.selected_example, hide_index=False)
+            st.button("Append to Input Data", on_click=append_selected_to_input_data)
+
+# Meta Prompt Functions
+def process_message_with_single_llm(
+    user_message: str, expected_output: str, acceptance_criteria: str,
+    initial_system_message: str, recursion_limit: int, max_output_age: int,
+    model_name: str, prompt_template_group: Optional[str] = None,
+    aggressive_exploration: bool = False, config: MetaPromptConfig = None
+) -> tuple:
+    llm = initialize_llm(model_name, config=config)
+    return process_message(
+        user_message, expected_output, acceptance_criteria, initial_system_message,
+        recursion_limit, max_output_age, llm, prompt_template_group, aggressive_exploration,
+        config
+    )
+
+def process_message_with_2_llms(
+    user_message: str, expected_output: str, acceptance_criteria: str,
+    initial_system_message: str, recursion_limit: int, max_output_age: int,
+    optimizer_model_name: str, executor_model_name: str,
+    prompt_template_group: Optional[str] = None,
+    aggressive_exploration: bool = False, config: MetaPromptConfig = None
+) -> tuple:
+    optimizer_model = initialize_llm(optimizer_model_name, config=config)
+    executor_model = initialize_llm(executor_model_name, config=config)
+    llms = {
+        NODE_ACCEPTANCE_CRITERIA_DEVELOPER: optimizer_model,
+        NODE_PROMPT_INITIAL_DEVELOPER: optimizer_model,
+        NODE_PROMPT_DEVELOPER: optimizer_model,
+        NODE_PROMPT_EXECUTOR: executor_model,
+        NODE_OUTPUT_HISTORY_ANALYZER: optimizer_model,
+        NODE_PROMPT_ANALYZER: optimizer_model,
+        NODE_PROMPT_SUGGESTER: optimizer_model
+    }
+    return process_message(
+        user_message, expected_output, acceptance_criteria,
+        initial_system_message, recursion_limit, max_output_age, llms,
+        prompt_template_group, aggressive_exploration, config
+    )
+
+def process_message_with_expert_llms(
+    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, 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,
+    output_history_analyzer_model_name: str, output_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,
+    config: MetaPromptConfig = None
+) -> tuple:
+    llms = {
+        NODE_PROMPT_INITIAL_DEVELOPER: initialize_llm(
+            initial_developer_model_name, {"temperature": initial_developer_temperature}, config
+        ),
+        NODE_ACCEPTANCE_CRITERIA_DEVELOPER: initialize_llm(
+            acceptance_criteria_model_name, {"temperature": acceptance_criteria_temperature}, config
+        ),
+        NODE_PROMPT_DEVELOPER: initialize_llm(
+            developer_model_name, {"temperature": developer_temperature}, config
+        ),
+        NODE_PROMPT_EXECUTOR: initialize_llm(
+            executor_model_name, {"temperature": executor_temperature}, config
+        ),
+        NODE_OUTPUT_HISTORY_ANALYZER: initialize_llm(
+            output_history_analyzer_model_name,
+            {"temperature": output_history_analyzer_temperature},
+            config
+        ),
+        NODE_PROMPT_ANALYZER: initialize_llm(
+            analyzer_model_name, {"temperature": analyzer_temperature}, config
+        ),
+        NODE_PROMPT_SUGGESTER: initialize_llm(
+            suggester_model_name, {"temperature": suggester_temperature}, config
+        )
+    }
+    return process_message(
+        user_message,
+        expected_output,
+        acceptance_criteria,
+        initial_system_message,
+        recursion_limit,
+        max_output_age,
+        llms,
+        prompt_template_group,
+        aggressive_exploration,
+        config
+    )
+
+def copy_system_message():
+    st.session_state.initial_system_message = system_message_output
+
+def copy_acceptance_criteria():
+    st.session_state.initial_acceptance_criteria = acceptance_criteria_output
+
+def clear_session_state():
+    st.session_state.shared_input_data = pd.DataFrame(columns=["Input", "Output"])
+    st.session_state.initial_system_message = ""
+    st.session_state.initial_acceptance_criteria = ""
+    st.session_state.system_message_output = ""
+    st.session_state.output = ""
+    st.session_state.analysis = ""
+    st.session_state.acceptance_criteria_output = ""
+    st.session_state.chat_log = []
+
+def pull_sample_description():
+    st.session_state.initial_system_message = description_output
+
+def generate_callback():
+    try:
+        first_input_key = data_editor_data["Input"].first_valid_index()
+        first_output_key = data_editor_data["Output"].first_valid_index()
+        user_message = data_editor_data["Input"][first_input_key].strip()
+        expected_output = data_editor_data["Output"][first_output_key].strip()
+
+        input_acceptance_criteria = initial_acceptance_criteria.strip() if 'initial_acceptance_criteria' in st.session_state else ""
+        input_system_message = initial_system_message.strip() if 'initial_system_message' in st.session_state else ""
+
+        if model_tab == "Simple":
+            system_message, output, analysis, acceptance_criteria, chat_log = process_message_with_single_llm(
+                user_message,
+                expected_output,
+                input_acceptance_criteria,
+                input_system_message,
+                recursion_limit_input,
+                max_output_age_input,
+                simple_model_name_input,
+                prompt_template_group_input,
+                aggressive_exploration_input,
+                config=config
+            )
+        elif model_tab == "Advanced":
+            system_message, output, analysis, acceptance_criteria, chat_log = process_message_with_2_llms(
+                user_message,
+                expected_output,
+                input_acceptance_criteria,
+                input_system_message,
+                recursion_limit_input,
+                max_output_age_input,
+                advanced_optimizer_model_name_input,
+                advanced_executor_model_name_input,
+                prompt_template_group_input,
+                aggressive_exploration_input,
+                config=config
+            )
+        else:  # Expert
+            system_message, output, analysis, acceptance_criteria, chat_log = process_message_with_expert_llms(
+                user_message,
+                expected_output,
+                input_acceptance_criteria,
+                input_system_message,
+                recursion_limit_input,
+                max_output_age_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_prompt_output_history_analyzer_model_name_input,
+                expert_prompt_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,
+                prompt_template_group_input,
+                aggressive_exploration_input,
+                config=config
+            )
+        
+        st.session_state.system_message_output = system_message
+        st.session_state.output = output
+        st.session_state.analysis = analysis
+        st.session_state.acceptance_criteria_output = acceptance_criteria
+        st.session_state.chat_log = chat_log
+
+    except Exception as e:
+        st.error(f"Error: {e}")
+
+# Meta Prompt Config
+
+pre_config_sources = [
+    EnvSource(prefix='METAPROMPT_', allow_all=True),
+    CLArgSource()
+]
+pre_config = FileConfig(config_sources=pre_config_sources)
+
+# Load configuration
+config = MetaPromptConfig(config_sources=[
+    FileSource(file=pre_config.config_file, optional=True),
+    EnvSource(prefix='METAPROMPT_', allow_all=True),
+    CLArgSource()
+])
+
+# Initialize session state
+init_session_state()
+
+# Streamlit UI
+
+st.title("Meta Prompt")
+st.markdown("Enter input-output pairs as the examples for the prompt.")
+data_editor_data = st.data_editor(
+    st.session_state.shared_input_data,
+    # key="meta_prompt_input_data",
+    num_rows="dynamic",
+    column_config={
+        "Input": st.column_config.TextColumn("Input", width="large"),
+        "Output": st.column_config.TextColumn("Output", width="large"),
+    },
+    hide_index=False,
+    use_container_width=True,
+)
+
+with st.expander("Data Management"):
+    # col1, col2 = st.columns(2)
+    # with col1:
+    input_file = st.file_uploader(
+        label="Import Input Data from JSON",
+        type="json",
+        key="input_file",
+        on_change=import_input_data_from_json
+    )
+    # with col2:
+    export_button = st.button(  # Add the export button
+        "Export Input Data to JSON", on_click=export_input_data_to_json
+    )
+
+tab_scoping, tab_prompting = st.tabs(["Scope", "Prompt"])
+
+with tab_scoping:
+    # Streamlit UI
+    st.markdown("Define the task scope using the above input-output pairs.")
+
+    submit_button = st.button(
+        "Go", type="primary", on_click=generate_examples_dataframe,
+        use_container_width=True)
+
+    with st.expander("Model Settings"):
+        model_name = st.selectbox(
+            "Model Name",
+            ["llama3-70b-8192", "llama3-8b-8192", "llama-3.1-70b-versatile",
+                "llama-3.1-8b-instant", "gemma2-9b-it"],
+            index=0
+        )
+        temperature = st.slider("Temperature", 0.0, 1.0, 1.0, 0.1)
+        generating_batch_size = st.slider("Generating Batch Size", 1, 10, 3, 1)
+
+    with st.expander("Description and Analysis"):
+        generate_description_button = st.button(
+            "Generate Description", on_click=update_description_output_text)
+        
+        description_output = st.text_area(
+            "Description", value=st.session_state.description_output_text, height=100)
+
+        col3, col4, col5 = st.columns(3)
+        with col3:
+            generate_suggestions_button = st.button("Generate Suggestions", on_click=generate_suggestions)
+        with col4:
+            generate_examples_directly_button = st.button(
+                "Generate Examples Directly", on_click=update_examples_directly_dataframe)
+        with col5:
+            analyze_input_button = st.button(
+                "Analyze Input", on_click=update_input_analysis_output_text)
+
+        # Add multiselect for suggestions
+        selected_suggestions = st.multiselect(
+            "Suggestions", options=st.session_state.suggestions, key="selected_suggestions")
+
+        # Add button to apply suggestions
+        apply_suggestions_button = st.button("Apply Suggestions", on_click=apply_suggestions)
+
+        # Add text input for adding new suggestions
+        new_suggestion = st.text_input("Add New Suggestion", key="new_suggestion", on_change=add_new_suggestion)
+
+        examples_directly_output = st.dataframe(st.session_state.examples_directly_dataframe, use_container_width=True,
+                                                selection_mode="multi-row", key="selected_example_directly_id",
+                                                on_select=example_directly_selected, hide_index=False)
+        input_analysis_output = st.text_area(
+            "Input Analysis", value=st.session_state.input_analysis_output_text, height=100)
+        generate_briefs_button = st.button(
+            "Generate Briefs", on_click=update_example_briefs_output_text)
+        example_briefs_output = st.text_area(
+            "Example Briefs", value=st.session_state.example_briefs_output_text, height=100)
+        generate_examples_from_briefs_button = st.button(
+            "Generate Examples from Briefs", on_click=update_examples_from_briefs_dataframe)
+        examples_from_briefs_output = st.dataframe(st.session_state.examples_from_briefs_dataframe, use_container_width=True,
+                                                selection_mode="multi-row", key="selected_example_from_briefs_id",
+                                                on_select=example_from_briefs_selected, hide_index=False)
+
+    examples_output = st.dataframe(st.session_state.examples_dataframe, use_container_width=True,
+                                selection_mode="multi-row", key="selected_example_id", on_select=example_selected, hide_index=True)
+
+    show_scoping_sidebar()
+
+with tab_prompting:
+    # Prompting UI
+    st.markdown("Generate the prompt with the above input-output pairs.")
+
+    generate_button_clicked = st.button("Generate", key="generate_button",
+                                        on_click=generate_callback,
+                                        type="primary", use_container_width=True)
+
+    col1, col2 = st.columns(2)
+
+    with col1:
+        with st.expander("Advanced Inputs"):
+            initial_system_message = st.text_area(
+                "Initial System Message",
+                key="initial_system_message"
+            )
+
+            col1_1, col1_2 = st.columns(2)
+            with col1_1:
+                pull_sample_description_button = st.button("Pull Sample Description", key="pull_sample_description",
+                                                        on_click=pull_sample_description)
+            with col1_2:
+                st.button("Pull Output", key="copy_system_message",
+                        on_click=copy_system_message)
+            initial_acceptance_criteria = st.text_area(
+                "Acceptance Criteria",
+                key="initial_acceptance_criteria"
+            )
+            st.button("Pull Output", key="copy_acceptance_criteria",
+                    on_click=copy_acceptance_criteria)
+
+        # New expander for model settings
+        with st.expander("Model Settings"):
+            model_tab = st.selectbox("Select Model Type", ["Simple", "Advanced", "Expert"], key="model_tab")
+
+            if model_tab == "Simple":
+                simple_model_name_input = st.selectbox(
+                    "Model Name",
+                    config.llms.keys(),
+                    index=0,
+                )
+            elif model_tab == "Advanced":
+                advanced_optimizer_model_name_input = st.selectbox(
+                    "Optimizer Model Name",
+                    config.llms.keys(),
+                    index=0,
+                )
+                advanced_executor_model_name_input = st.selectbox(
+                    "Executor Model Name",
+                    config.llms.keys(),
+                    index=1,
+                )
+            else:  # Expert
+                expert_prompt_initial_developer_model_name_input = st.selectbox(
+                    "Initial Developer Model Name",
+                    config.llms.keys(),
+                    index=0,
+                )
+                expert_prompt_initial_developer_temperature_input = st.slider(
+                    "Initial Developer Temperature", 0.0, 1.0, 0.1, 0.1
+                )
+
+                expert_prompt_acceptance_criteria_model_name_input = st.selectbox(
+                    "Acceptance Criteria Model Name",
+                    config.llms.keys(),
+                    index=0,
+                )
+                expert_prompt_acceptance_criteria_temperature_input = st.slider(
+                    "Acceptance Criteria Temperature", 0.0, 1.0, 0.1, 0.1
+                )
+
+                expert_prompt_developer_model_name_input = st.selectbox(
+                    "Developer Model Name", config.llms.keys(), index=0
+                )
+                expert_prompt_developer_temperature_input = st.slider(
+                    "Developer Temperature", 0.0, 1.0, 0.1, 0.1
+                )
+
+                expert_prompt_executor_model_name_input = st.selectbox(
+                    "Executor Model Name", config.llms.keys(), index=1
+                )
+                expert_prompt_executor_temperature_input = st.slider(
+                    "Executor Temperature", 0.0, 1.0, 0.1, 0.1
+                )
+
+                expert_prompt_output_history_analyzer_model_name_input = st.selectbox(
+                    "Output History Analyzer Model Name",
+                    config.llms.keys(),
+                    index=0,
+                )
+                expert_prompt_output_history_analyzer_temperature_input = st.slider(
+                    "Output History Analyzer Temperature", 0.0, 1.0, 0.1, 0.1
+                )
+
+                expert_prompt_analyzer_model_name_input = st.selectbox(
+                    "Analyzer Model Name", config.llms.keys(), index=0
+                )
+                expert_prompt_analyzer_temperature_input = st.slider(
+                    "Analyzer Temperature", 0.0, 1.0, 0.1, 0.1
+                )
+
+                expert_prompt_suggester_model_name_input = st.selectbox(
+                    "Suggester Model Name", config.llms.keys(), index=0
+                )
+                expert_prompt_suggester_temperature_input = st.slider(
+                    "Suggester Temperature", 0.0, 1.0, 0.1, 0.1
+                )
+
+            # st.header("Prompt Template Settings")
+            prompt_template_group_input = st.selectbox(
+                "Prompt Template Group", config.prompt_templates.keys(), index=0
+            )
+
+            # st.header("Advanced Settings")
+            recursion_limit_input = st.number_input("Recursion Limit", 1, 100, 16, 1)
+            max_output_age_input = st.number_input("Max Output Age", 1, 10, 2, 1)
+            aggressive_exploration_input = st.checkbox("Aggressive Exploration", False)
+
+    with col2:
+        system_message_output = st.text_area("System Message",
+                                            key="system_message_output",
+                                            height=100)
+
+        acceptance_criteria_output = st.text_area(
+            "Acceptance Criteria",
+            key="acceptance_criteria_output",
+            height=100)
+        st.text_area("Output", st.session_state.output, height=100)
+        st.text_area("Analysis", st.session_state.analysis, height=100)
+
+        st.json(st.session_state.chat_log, expanded=False)