Update app.py

app.py

@@ -7,31 +7,43 @@ from datetime import datetime
 import logging
 
 import gradio as gr
-from transformers import AutoModelForCausalLM, AutoTokenizer, pipeline
-from huggingface_hub import InferenceClient, cached_download, Repository, HfApi
-from IPython.display import display, HTML
+from huggingface_hub import InferenceClient, cached_download
+from safe_search import safe_search
+from i_search import google, i_search as i_s
 
 # --- Configuration ---
-VERBOSE = True
-MAX_HISTORY = 5
-MAX_TOKENS = 2048
-TEMPERATURE = 0.7
-TOP_P = 0.8
-REPETITION_PENALTY = 1.5
-DEFAULT_PROJECT_PATH = "./my-hf-project"  # Default project directory
+VERBOSE = True  # Enable verbose logging
+MAX_HISTORY = 5  # Maximum history turns to keep
+MAX_TOKENS = 2048  # Maximum tokens for LLM responses
+TEMPERATURE = 0.7  # Temperature for LLM responses
+TOP_P = 0.8  # Top-p (nucleus sampling) for LLM responses
+REPETITION_PENALTY = 1.5  # Repetition penalty for LLM responses
+MODEL_NAME = "mistralai/Mixtral-8x7B-Instruct-v0.1"  # Name of the LLM model
+
+import os
+API_KEY = os.getenv("HUGGINGFACE_API_KEY")  # Ensure you set the HUGGINGFACE_API_KEY environment variable
 
 # --- Logging Setup ---
 logging.basicConfig(
-    filename="app.log",
-    level=logging.INFO,
+    filename="app.log",  # Name of the log file
+    level=logging.INFO,  # Set the logging level (INFO, DEBUG, etc.)
     format="%(asctime)s - %(levelname)s - %(message)s",
 )
 
+# --- Agents ---
+agents = [
+    "WEB_DEV",
+    "AI_SYSTEM_PROMPT",
+    "PYTHON_CODE_DEV",
+    "DATA_SCIENCE",
+    "UI_UX_DESIGN",
+]
+
 # --- Prompts ---
 PREFIX = """
 {date_time_str}
 Purpose: {purpose}
-Agent: {agent_name}
+Safe Search: {safe_search}
 """
 
 LOG_PROMPT = """
@@ -42,254 +54,338 @@ LOG_RESPONSE = """
 RESPONSE: {resp}
 """
 
-# --- Global Variables ---
-current_model = None  # Store the currently loaded model
-repo = None  # Store the Hugging Face Repository object
-model_descriptions = {}  # Store model descriptions
+COMPRESS_HISTORY_PROMPT = """
+You are a helpful AI assistant. Your task is to compress the following history into a summary that is no longer than 512 tokens.
+History:
+{history}
+"""
+
+ACTION_PROMPT = """
+You are a helpful AI assistant. You are working on the task: {task}
+Your current history is:
+{history}
+What is your next thought?
+thought: 
+What is your next action?
+action: 
+"""
+
+TASK_PROMPT = """
+You are a helpful AI assistant. Your current history is:
+{history}
+What is the next task?
+task: 
+"""
+
+UNDERSTAND_TEST_RESULTS_PROMPT = """
+You are a helpful AI assistant. The test results are:
+{test_results}
+What do you want to know about the test results?
+thought: 
+"""
 
 # --- Functions ---
 def format_prompt(message: str, history: List[Tuple[str, str]], max_history_turns: int = 2) -> str:
-    prompt = ""
+    """Formats the prompt for the LLM, including the message and relevant history."""
+    prompt = " "
+    # Keep only the last 'max_history_turns' turns
     for user_prompt, bot_response in history[-max_history_turns:]:
-        prompt += f"Human: {user_prompt}\nAssistant: {bot_response}\n"
-    prompt += f"Human: {message}\nAssistant:"
+        prompt += f"[INST] {user_prompt} [/  "
+        prompt += f" {bot_response}"
+    prompt += f"[INST] {message} [/  "
     return prompt
 
-def generate_response(
+def run_llm(
+    prompt_template: str,
+    stop_tokens: List[str],
+    purpose: str,
+    **prompt_kwargs: Dict
+) -> str:
+    """Runs the LLM with the given prompt and parameters."""
+    seed = random.randint(1, 1111111111111111)
+    logging.info(f"Seed: {seed}")  # Log the seed
+
+    content = PREFIX.format(
+        date_time_str=date_time_str,
+        purpose=purpose,
+        safe_search=safe_search,
+    ) + prompt_template.format(**prompt_kwargs)
+    if VERBOSE:
+        logging.info(LOG_PROMPT.format(content))  # Log the prompt
+
+    resp = client.text_generation(content, max_new_tokens=MAX_TOKENS, stop_sequences=stop_tokens, temperature=TEMPERATURE, top_p=TOP_P, repetition_penalty=REPETITION_PENALTY)
+    if VERBOSE:
+        logging.info(LOG_RESPONSE.format(resp))  # Log the response
+    return resp
+
+def generate(
     prompt: str,
     history: List[Tuple[str, str]],
-    agent_name: str = "Generic Agent",
+    agent_name: str = agents[0],
     sys_prompt: str = "",
     temperature: float = TEMPERATURE,
     max_new_tokens: int = MAX_TOKENS,
     top_p: float = TOP_P,
     repetition_penalty: float = REPETITION_PENALTY,
 ) -> str:
-    global current_model
-    if current_model is None:
-        return "Error: Please load a model first."
-
-    date_time_str = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-    full_prompt = PREFIX.format(
+    """Generates text using the LLM."""
+    content = PREFIX.format(
         date_time_str=date_time_str,
-        purpose=sys_prompt,
-        agent_name=agent_name
-    ) + format_prompt(prompt, history)
-
+        purpose=purpose,
+        safe_search=safe_search,
+    ) + prompt_template.format(**prompt_kwargs)
     if VERBOSE:
-        logging.info(LOG_PROMPT.format(content=full_prompt))
-
-    response = current_model(
-        full_prompt,
-        max_new_tokens=max_new_tokens,
-        temperature=temperature,
-        top_p=top_p,
-        repetition_penalty=repetition_penalty,
-        do_sample=True
-    )[0]['generated_text']
+        logging.info(LOG_PROMPT.format(content))  # Log the prompt
 
-    assistant_response = response.split("Assistant:")[-1].strip()
+    stream = client.text_generation(content, stream=True, details=True, return_full_text=False, temperature=temperature, top_p=top_p, repetition_penalty=repetition_penalty, max_new_tokens=max_new_tokens)
+    resp = ""
+    for response in stream:
+        resp += response.token.text
 
     if VERBOSE:
-        logging.info(LOG_RESPONSE.format(resp=assistant_response))
-
-    return assistant_response
-
-def load_hf_model(model_name: str):
-    """Loads a language model and fetches its description."""
-    global current_model, model_descriptions
-    try:
-        tokenizer = AutoTokenizer.from_pretrained(model_name)
-        current_model = pipeline(
-            "text-generation",
-            model=model_name,
-            tokenizer=tokenizer,
-            model_kwargs={"load_in_8bit": True}
-        )
-
-        # Fetch and store the model description
-        api = HfApi()
-        model_info = api.model_info(model_name)
-        model_descriptions[model_name] = model_info.pipeline_tag
-        return f"Successfully loaded model: {model_name}"
-    except Exception as e:
-        return f"Error loading model: {str(e)}"
-
-def execute_command(command: str, project_path: str = None) -> str:
-    """Executes a shell command and returns the output."""
+        logging.info(LOG_RESPONSE.format(resp))  # Log the response
+    return resp
+
+def compress_history(purpose: str, task: str, history: List[Tuple[str, str]], directory: str) -> str:
+    """Compresses the history into a shorter summary."""
+    resp = run_llm(
+        COMPRESS_HISTORY_PROMPT,
+        stop_tokens=["observation:", "task:", "action:", "thought:"],
+        purpose=purpose,
+        task=task,
+        history="\n".join(f"[INST] {user_prompt} [/] {bot_response}" for user_prompt, bot_response in history),
+    )
+    history = "observation: {}\n".format(resp)
+    return history
+
+def call_search(purpose: str, task: str, history: List[Tuple[str, str]], directory: str, action_input: str) -> Tuple[str, str, List[Tuple[str, str]], str]:
+    """Performs a search based on the action input."""
+    logging.info(f"CALLING SEARCH: {action_input}")
     try:
-        if project_path:
-            process = subprocess.Popen(command, shell=True, cwd=project_path, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        if "http" in action_input:
+            if "<" in action_input:
+                action_input = action_input.strip("<")
+            if ">" in action_input:
+                action_input = action_input.strip(">")
+            
+            response = i_s(action_input)
+            logging.info(f"Search Result: {response}")
+            history.append(("observation: search result is: {}".format(response), ""))
         else:
-            process = subprocess.Popen(command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        output, error = process.communicate()
-        if error:
-            return f"Error: {error.decode('utf-8')}"
-        return output.decode("utf-8")
+            history.append(("observation: I need to provide a valid URL to 'action: SEARCH action_input=https://URL'\n", ""))
     except Exception as e:
-        return f"Error executing command: {str(e)}"
-
-def create_hf_project(project_name: str, project_path: str = DEFAULT_PROJECT_PATH):
-    """Creates a new Hugging Face project."""
-    global repo
+        history.append(("observation: {}\n".format(e), ""))
+    return "MAIN", None, history, task
+
+def call_main(purpose: str, task: str, history: List[Tuple[str, str]], directory: str, action_input: str) -> Tuple[str, str, List[Tuple[str, str]], str]:
+    """Handles the main agent interaction loop."""
+    logging.info(f"CALLING MAIN: {action_input}")
+    resp = run_llm(
+        ACTION_PROMPT,
+        stop_tokens=["observation:", "task:", "action:", "thought:"],
+        purpose=purpose,
+        task=task,
+        history="\n".join(f"[INST] {user_prompt} [/] {bot_response}" for user_prompt, bot_response in history),
+    )
+    lines = resp.strip().strip("\n").split("\n")
+    for line in lines:
+        if line == "":
+            continue
+        if line.startswith("thought: "):
+            history.append((line, ""))
+            logging.info(f"Thought: {line}")
+        elif line.startswith("action: "):
+            action_name, action_input = parse_action(line)
+            logging.info(f"Action: {action_name} - {action_input}")
+            history.append((line, ""))
+            if "COMPLETE" in action_name or "COMPLETE" in action_input:
+                task = "END"
+                return action_name, action_input, history, task
+            else:
+                return action_name, action_input, history, task
+        else:
+            history.append((line, ""))
+            logging.info(f"Other Output: {line}")
+    return "MAIN", None, history, task
+
+def call_set_task(purpose: str, task: str, history: List[Tuple[str, str]], directory: str, action_input: str) -> Tuple[str, str, List[Tuple[str, str]], str]:
+    """Sets a new task for the agent."""
+    logging.info(f"CALLING SET_TASK: {action_input}")
+    task = run_llm(
+        TASK_PROMPT,
+        stop_tokens=[],
+        purpose=purpose,
+        task=task,
+        history="\n".join(f"[INST] {user_prompt} [/] {bot_response}" for user_prompt, bot_response in history),
+    ).strip("\n")
+    history.append(("observation: task has been updated to: {}".format(task), ""))
+    return "MAIN", None, history, task
+
+def end_fn(purpose: str, task: str, history: List[Tuple[str, str]], directory: str, action_input: str) -> Tuple[str, str, List[Tuple[str, str]], str]:
+    """Ends the agent interaction."""
+    logging.info(f"CALLING END_FN: {action_input}")
+    task = "END"
+    return "COMPLETE", "COMPLETE", history, task
+
+NAME_TO_FUNC: Dict[str, callable] = {
+    "MAIN": call_main,
+    "UPDATE-TASK": call_set_task,
+    "SEARCH": call_search,
+    "COMPLETE": end_fn,
+}
+
+def run_action(purpose: str, task: str, history: List[Tuple[str, str]], directory: str, action_name: str, action_input: str) -> Tuple[str, str, List[Tuple[str, str]], str]:
+    """Executes the specified action."""
+    logging.info(f"RUNNING ACTION: {action_name} - {action_input}")
     try:
-        if os.path.exists(project_path):
-            return f"Error: Directory '{project_path}' already exists!"
-        # Create the repository
-        repo = Repository(local_dir=project_path, clone_from=None)
-        repo.git_init()
-
-        # Add basic files (optional, you can customize this)
-        with open(os.path.join(project_path, "README.md"), "w") as f:
-            f.write(f"# {project_name}\n\nA new Hugging Face project.")
-
-        # Stage all changes
-        repo.git_add(pattern="*")
-        repo.git_commit(commit_message="Initial commit")
-
-        return f"Hugging Face project '{project_name}' created successfully at '{project_path}'"
+        if "RESPONSE" in action_name or "COMPLETE" in action_name:
+            action_name = "COMPLETE"
+            task = "END"
+            return action_name, "COMPLETE", history, task
+    
+        # compress the history when it is long
+        if len(history) > MAX_HISTORY:
+            logging.info("COMPRESSING HISTORY")
+            history = compress_history(purpose, task, history, directory)
+        if not action_name in NAME_TO_FUNC:
+            action_name = "MAIN"
+        if action_name == "" or action_name is None:
+            action_name = "MAIN"
+        assert action_name in NAME_TO_FUNC
+    
+        logging.info(f"RUN: {action_name} - {action_input}")
+        return NAME_TO_FUNC[action_name](purpose, task, history, directory, action_input)
     except Exception as e:
-        return f"Error creating Hugging Face project: {str(e)}"
+        history.append(("observation: the previous command did not produce any useful output, I need to check the commands syntax, or use a different command\n", ""))
+        logging.error(f"Error in run_action: {e}")
+        return "MAIN", None, history, task
+
+def run(purpose: str, history: List[Tuple[str, str]]) -> List[Tuple[str, str]]:
+    """Main agent interaction loop."""
+    task = None
+    directory = "./"
+    if history:
+        history = str(history).strip("[]")
+    if not history:
+        history = []
+    
+    action_name = "UPDATE-TASK" if task is None else "MAIN"
+    action_input = None
+    while True:
+        logging.info(f"---")
+        logging.info(f"Purpose: {purpose}")
+        logging.info(f"Task: {task}")
+        logging.info(f"---")
+        logging.info(f"History: {history}")
+        logging.info(f"---")
+
+        action_name, action_input, history, task = run_action(
+            purpose,
+            task,
+            history,
+            directory,
+            action_name,
+            action_input,
+        )
+        yield (history)
+        if task == "END":
+            return (history)
 
-def list_project_files(project_path: str = DEFAULT_PROJECT_PATH) -> str:
-    """Lists files in the project directory."""
-    try:
-        files = os.listdir(project_path)
-        if not files:
-            return "Project directory is empty."
-        return "\n".join(files)
-    except Exception as e:
-        return f"Error listing project files: {str(e)}"
+################################################
 
-def read_file_content(file_path: str, project_path: str = DEFAULT_PROJECT_PATH) -> str:
-    """Reads and returns the content of a file in the project."""
-    try:
-        full_path = os.path.join(project_path, file_path)
-        with open(full_path, "r") as f:
-            content = f.read()
-        return content
-    except Exception as e:
-        return f"Error reading file: {str(e)}"
+def format_prompt(message: str, history: List[Tuple[str, str]], max_history_turns: int = 5) -> str:
+    """Formats the prompt for the LLM, including the message and relevant history."""
+    prompt = " "
+    # Keep only the last 'max_history_turns' turns
+    for user_prompt, bot_response in history[-max_history_turns:]:
+        prompt += f"[INST] {user_prompt} [/  "
+        prompt += f" {bot_response}"
+    prompt += f"[INST] {message} [/  "
+    return prompt
 
-def write_to_file(file_path: str, content: str, project_path: str = DEFAULT_PROJECT_PATH) -> str:
-    """Writes content to a file in the project."""
-    try:
-        full_path = os.path.join(project_path, file_path)
-        with open(full_path, "w") as f:
-            f.write(content)
-        return f"Successfully wrote to '{file_path}'"
-    except Exception as e:
-        return f"Error writing to file: {str(e)}"
+def parse_action(line: str) -> Tuple[str, str]:
+    """Parses the action line to get the action name and input."""
+    parts = line.split(":", 1)
+    if len(parts) == 2:
+        action_name = parts[0].replace("action", "").strip()
+        action_input = parts[1].strip()
+    else:
+        action_name = parts[0].replace("action", "").strip()
+        action_input = ""
+    return action_name, action_input
 
-def preview_project(project_path: str = DEFAULT_PROJECT_PATH):
-    """Provides a preview of the project, if applicable."""
-    # Assuming a simple HTML preview for now
+def main():
+    """Main function to run the Gradio interface."""
+    global client
+    # Initialize the LLM client with your API key
     try:
-        index_html_path = os.path.join(project_path, "index.html")
-        if os.path.exists(index_html_path):
-            with open(index_html_path, "r") as f:
-                html_content = f.read()
-            display(HTML(html_content))
-            return "Previewing 'index.html'"
-        else:
-            return "No 'index.html' found for preview."
+        client = InferenceClient(
+            MODEL_NAME,
+            token=API_KEY  # Replace with your actual API key
+        )
     except Exception as e:
-        return f"Error previewing project: {str(e)}"
+        logging.error(f"Error initializing LLM client: {e}")
+        print("Error initializing LLM client. Please check your API key.")
+        return
 
-def main():
     with gr.Blocks() as demo:
-        gr.Markdown("## FragMixt: Your Hugging Face No-Code App Builder")
-
-        # --- Model Selection ---
-        with gr.Tab("Model"):
-            # --- Model Dropdown with Categories ---
-            model_categories = gr.Dropdown(
-                choices=["Text Generation", "Text Summarization", "Code Generation", "Translation", "Question Answering"],
-                label="Model Category",
-                value="Text Generation"
-            )
-            model_name = gr.Dropdown(
-                choices=[],  # Initially empty, will be populated based on category
-                label="Hugging Face Model Name",
-            )
-            load_button = gr.Button("Load Model")
-            load_output = gr.Textbox(label="Output")
-            model_description = gr.Markdown(label="Model Description")
-
-            # --- Function to populate model names based on category ---
-            def update_model_dropdown(category):
-                models = []
-                api = HfApi()
-                for model in api.list_models():
-                    if model.pipeline_tag == category:
-                        models.append(model.modelId)
-                return gr.Dropdown.update(choices=models)
-
-            # --- Event handler for category dropdown ---
-            model_categories.change(
-                fn=update_model_dropdown,
-                inputs=model_categories,
-                outputs=model_name,
-            )
-
-            # --- Event handler to display model description ---
-            def display_model_description(model_name):
-                global model_descriptions
-                if model_name in model_descriptions:
-                    return model_descriptions[model_name]
-                else:
-                    return "Model description not available."
-
-            model_name.change(
-                fn=display_model_description,
-                inputs=model_name,
-                outputs=model_description,
-            )
-
-            load_button.click(load_hf_model, inputs=model_name, outputs=load_output)
-
-        # --- Chat Interface ---
-        with gr.Tab("Chat"):
-            chatbot = gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True, likeable=True)
-            message = gr.Textbox(label="Enter your message", placeholder="Ask me anything!")
-            purpose = gr.Textbox(label="Purpose", placeholder="What is the purpose of this interaction?")
-            agent_name = gr.Dropdown(label="Agents", choices=["Generic Agent"], value="Generic Agent", interactive=True)
-            sys_prompt = gr.Textbox(label="System Prompt", max_lines=1, interactive=True)
-            temperature = gr.Slider(label="Temperature", value=TEMPERATURE, minimum=0.0, maximum=1.0, step=0.05, interactive=True, info="Higher values produce more diverse outputs")
-            max_new_tokens = gr.Slider(label="Max new tokens", value=MAX_TOKENS, minimum=0, maximum=1048 * 10, step=64, interactive=True, info="The maximum numbers of new tokens")
-            top_p = gr.Slider(label="Top-p (nucleus sampling)", value=TOP_P, minimum=0.0, maximum=1, step=0.05, interactive=True, info="Higher values sample more low-probability tokens")
-            repetition_penalty = gr.Slider(label="Repetition penalty", value=REPETITION_PENALTY, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Penalize repeated tokens")
-            submit_button = gr.Button(value="Send")
+        gr.Markdown("## FragMixt: The No-Code Development Powerhouse")
+        gr.Markdown("###  Your AI-Powered Development Companion")
+
+        # Chat Interface
+        chatbot = gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True, likeable=True, layout="panel")
+        
+        # Input Components
+        message = gr.Textbox(label="Enter your message", placeholder="Ask me anything!")
+        purpose = gr.Textbox(label="Purpose", placeholder="What is the purpose of this interaction?")
+        agent_name = gr.Dropdown(label="Agents", choices=[s for s in agents], value=agents[0], interactive=True)
+        sys_prompt = gr.Textbox(label="System Prompt", max_lines=1, interactive=True)
+        temperature = gr.Slider(label="Temperature", value=TEMPERATURE, minimum=0.0, maximum=1.0, step=0.05, interactive=True, info="Higher values produce more diverse outputs")
+        max_new_tokens = gr.Slider(label="Max new tokens", value=MAX_TOKENS, minimum=0, maximum=1048*10, step=64, interactive=True, info="The maximum numbers of new tokens")
+        top_p = gr.Slider(label="Top-p (nucleus sampling)", value=TOP_P, minimum=0.0, maximum=1, step=0.05, interactive=True, info="Higher values sample more low-probability tokens")
+        repetition_penalty = gr.Slider(label="Repetition penalty", value=REPETITION_PENALTY, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Penalize repeated tokens")
+
+        # Button to submit the message
+        submit_button = gr.Button(value="Send")
+
+        # Project Explorer Tab
+        with gr.Tab("Project Explorer"):
+            project_path = gr.Textbox(label="Project Path", placeholder="/home/user/app/current_project")
+            explore_button = gr.Button(value="Explore")
+            project_output = gr.Textbox(label="File Tree", lines=20)
+
+        # Chat App Logic Tab
+        with gr.Tab("Chat App"):
             history = gr.State([])
-
-            def run_chat(purpose: str, message: str, agent_name: str, sys_prompt: str, temperature: float, max_new_tokens: int, top_p: float, repetition_penalty: float, history: List[Tuple[str, str]]) -> Tuple[List[Tuple[str, str]], List[Tuple[str, str]]]:
-                response = generate_response(message, history, agent_name, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty)
-                history.append((message, response))
-                return history, history
-
-            submit_button.click(run_chat, inputs=[purpose, message, agent_name, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty, history], outputs=[chatbot, history])
-
-        # --- Project Management ---
-        with gr.Tab("Project"):
-            project_name = gr.Textbox(label="Project Name", placeholder="MyHuggingFaceApp")
-            create_project_button = gr.Button("Create Hugging Face Project")
-            project_output = gr.Textbox(label="Output", lines=5)
-            file_content = gr.Code(label="File Content", language="python", lines=20)
-            file_path = gr.Textbox(label="File Path (relative to project)", placeholder="src/main.py")
-            read_button = gr.Button("Read File")
-            write_button = gr.Button("Write to File")
-            command_input = gr.Textbox(label="Terminal Command", placeholder="pip install -r requirements.txt")
-            command_output = gr.Textbox(label="Command Output", lines=5)
-            run_command_button = gr.Button("Run Command")
-            preview_button = gr.Button("Preview Project")
-
-            create_project_button.click(create_hf_project, inputs=[project_name], outputs=project_output)
-            read_button.click(read_file_content, inputs=file_path, outputs=file_content)
-            write_button.click(write_to_file, inputs=[file_path, file_content], outputs=project_output)
-            run_command_button.click(execute_command, inputs=command_input, outputs=command_output)
-            preview_button.click(preview_project, outputs=project_output)
+            examples = [
+                ["What is the purpose of this AI agent?", "I am designed to assist with no-code development tasks."],
+                ["Can you help me generate a Python function to calculate the factorial of a number?", "Sure! Here is a Python function to calculate the factorial of a number:"],
+                ["Generate a simple HTML page with a heading and a paragraph.", "```html\n<!DOCTYPE html>\n<html>\n<head>\n<title>My Simple Page</title>\n</head>\n<body>\n<h1>Welcome to my page!</h1>\n<p>This is a simple paragraph.</p>\n</body>\n</html>\n```"],
+                ["Create a basic SQL query to select all data from a table named 'users'.", "```sql\nSELECT * FROM users;\n```"],
+                ["Design a user interface for a mobile app that allows users to track their daily expenses.", "Here's a basic UI design for a mobile expense tracker app:\n\n**Screen 1: Home**\n- Top: App Name and Balance Display\n- Middle: List of Recent Transactions (Date, Description, Amount)\n- Bottom: Buttons for Add Expense, Add Income, View Categories\n\n**Screen 2: Add Expense**\n- Input fields for Date, Category, Description, Amount\n- Buttons for Save, Cancel\n\n**Screen 3: Expense Categories**\n- List of expense categories (e.g., Food, Transportation, Entertainment)\n- Option to add/edit categories\n\n**Screen 4: Reports**\n- Charts and graphs to visualize spending by category, date range, etc.\n- Filters to customize the reports"],
+            ]
+
+        def chat(purpose: str, message: str, agent_name: str, sys_prompt: str, temperature: float, max_new_tokens: int, top_p: float, repetition_penalty: float, history: List[Tuple[str, str]]) -> Tuple[List[Tuple[str, str]], List[Tuple[str, str]]]:
+            """Handles the chat interaction."""
+            prompt = format_prompt(message, history)
+            response = generate(prompt, history, agent_name, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty)
+            history.append((message, response))
+            return history, history
+
+        submit_button.click(chat, inputs=[purpose, message, agent_name, sys_prompt, temperature, max_new_tokens, top_p, repetition_penalty, history], outputs=[chatbot, history])
+
+        # Project Explorer Logic
+        def explore_project(project_path: str) -> str:
+            """Explores the project directory and returns a file tree."""
+            try:
+                tree = subprocess.check_output(["tree", project_path]).decode("utf-8")
+                return tree
+            except Exception as e:
+                return f"Error exploring project: {e}"
+
+        explore_button.click(explore_project, inputs=[project_path], outputs=[project_output])
 
     demo.launch()
 
 if __name__ == "__main__":
-    main()
+    main()