Update app.py

app.py

@@ -1,262 +1,441 @@
 import os
-import json
+import subprocess
+from huggingface_hub import InferenceClient
+import gradio as gr
+import random
 import time
-from typing import Dict, List, Tuple
+from typing import List, Dict
 
-import gradio as gr
-import streamlit as st
-from huggingface_hub import InferenceClient
-from transformers import AutoModelForCausalLM, AutoTokenizer
-from rich import print as rprint
-from rich.panel import Panel
-from rich.progress import track
-from rich.table import Table
-
-# --- Constants ---
-MODEL_NAME = "bigscience/bloom-1b7"  # Choose a suitable model
-MAX_NEW_TOKENS = 1024
-TEMPERATURE = 0.7
-TOP_P = 0.95
-REPETITION_PENALTY = 1.2
-
-# --- Model & Tokenizer ---
-model = AutoModelForCausalLM.from_pretrained(MODEL_NAME)
-tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-
-# --- Agents ---
-agents = {
-    "WEB_DEV": {
-        "description": "Expert in web development technologies and frameworks.",
-        "skills": ["HTML", "CSS", "JavaScript", "React", "Vue.js", "Flask", "Django", "Node.js", "Express.js"],
-        "system_prompt": "You are a web development expert. Your goal is to assist the user in building and deploying web applications. Provide code snippets, explanations, and guidance on best practices.",
-    },
-    "AI_SYSTEM_PROMPT": {
-        "description": "Expert in designing and implementing AI systems.",
-        "skills": ["Machine Learning", "Deep Learning", "Natural Language Processing", "Computer Vision", "Reinforcement Learning"],
-        "system_prompt": "You are an AI system expert. Your goal is to assist the user in designing and implementing AI systems. Provide code snippets, explanations, and guidance on best practices.",
-    },
-    "PYTHON_CODE_DEV": {
-        "description": "Expert in Python programming and development.",
-        "skills": ["Python", "Data Structures", "Algorithms", "Object-Oriented Programming", "Functional Programming"],
-        "system_prompt": "You are a Python code development expert. Your goal is to assist the user in writing and debugging Python code. Provide code snippets, explanations, and guidance on best practices.",
-    },
-    "CODE_REVIEW_ASSISTANT": {
-        "description": "Expert in code review and quality assurance.",
-        "skills": ["Code Style", "Best Practices", "Security", "Performance", "Maintainability"],
-        "system_prompt": "You are a code review assistant. Your goal is to assist the user in reviewing code for quality and efficiency. Provide feedback on code style, best practices, security, performance, and maintainability.",
-    },
-    "CONTENT_WRITER_EDITOR": {
-        "description": "Expert in content writing and editing.",
-        "skills": ["Grammar", "Style", "Clarity", "Conciseness", "SEO"],
-        "system_prompt": "You are a content writer and editor. Your goal is to assist the user in creating high-quality content. Provide suggestions on grammar, style, clarity, conciseness, and SEO.",
-    },
-    "QUESTION_GENERATOR": {
-        "description": "Expert in generating questions for learning and assessment.",
-        "skills": ["Question Types", "Cognitive Levels", "Assessment Design"],
-        "system_prompt": "You are a question generator. Your goal is to assist the user in generating questions for learning and assessment. Provide questions that are relevant to the topic and aligned with the cognitive levels.",
-    },
-    "HUGGINGFACE_FILE_DEV": {
-        "description": "Expert in developing Hugging Face files for machine learning models.",
-        "skills": ["Transformers", "Datasets", "Model Training", "Model Deployment"],
-        "system_prompt": "You are a Hugging Face file development expert. Your goal is to assist the user in creating and deploying Hugging Face files for machine learning models. Provide code snippets, explanations, and guidance on best practices.",
-    },
-}
-
-# --- Session State ---
-if "workspace_projects" not in st.session_state:
-    st.session_state.workspace_projects = {}
-if "chat_history" not in st.session_state:
-    st.session_state.chat_history = []
-if "active_agent" not in st.session_state:
-    st.session_state.active_agent = None
-if "selected_agents" not in st.session_state:
-    st.session_state.selected_agents = []
-
-# --- Functions ---
-def format_prompt(message: str, history: List[Tuple[str, str]], agent_prompt: str) -> str:
-    """Formats the prompt for the language model."""
-    prompt = "<s>"
-    for user_prompt, bot_response in history:
-        prompt += f"[INST] {user_prompt} [/INST]"
-        prompt += f" {bot_response}</s> "
-    prompt += f"[INST] {agent_prompt}, {message} [/INST]"
-    return prompt
-
-def generate_response(prompt: str, agent_name: str) -> str:
-    """Generates a response from the language model."""
-    agent = agents[agent_name]
-    system_prompt = agent["system_prompt"]
-    generate_kwargs = dict(
-        temperature=TEMPERATURE,
-        max_new_tokens=MAX_NEW_TOKENS,
-        top_p=TOP_P,
-        repetition_penalty=REPETITION_PENALTY,
-        do_sample=True,
-    )
-    input_ids = tokenizer.encode(prompt, return_tensors="pt")
-    output = model.generate(input_ids, **generate_kwargs)
-    response = tokenizer.decode(output[0], skip_special_tokens=True)
-    return response
-
-def chat_interface(chat_input: str, agent_names: List[str]) -> str:
-    """Handles chat interactions with the selected agents."""
-    if agent_names:
-        responses = []
-        for agent_name in agent_names:
-            prompt = format_prompt(chat_input, st.session_state.chat_history, agents[agent_name]["system_prompt"])
-            response = generate_response(prompt, agent_name)
-            responses.append(f"{agent_name}: {response}")
-        return "\n".join(responses)
-    else:
-        return "Please select at least one agent."
-
-def terminal_interface(command: str, project_name: str) -> str:
-    """Executes a command within the specified project directory."""
-    try:
-        result = subprocess.run(command, shell=True, capture_output=True, text=True, cwd=project_name)
-        return result.stdout if result.returncode == 0 else result.stderr
-    except Exception as e:
-        return str(e)
-
-def add_code_to_workspace(project_name: str, code: str, file_name: str) -> str:
-    """Adds code to a workspace project."""
-    project_path = os.path.join(os.getcwd(), project_name)
-    if not os.path.exists(project_path):
-        os.makedirs(project_path)
-    file_path = os.path.join(project_path, file_name)
-    with open(file_path, 'w') as file:
-        file.write(code)
-    if project_name not in st.session_state.workspace_projects:
-        st.session_state.workspace_projects[project_name] = {'files': []}
-    st.session_state.workspace_projects[project_name]['files'].append(file_name)
-    return f"Added {file_name} to {project_name}"
-
-def display_workspace_projects():
-    """Displays a table of workspace projects."""
-    table = Table(title="Workspace Projects")
-    table.add_column("Project Name", style="cyan", no_wrap=True)
-    table.add_column("Files", style="magenta")
-    for project_name, details in st.session_state.workspace_projects.items():
-        table.add_row(project_name, ", ".join(details['files']))
-    rprint(Panel(table, title="[bold blue]Workspace Projects[/bold blue]"))
-
-def display_chat_history():
-    """Displays the chat history in a formatted way."""
-    table = Table(title="Chat History")
-    table.add_column("User", style="cyan", no_wrap=True)
-    table.add_column("Agent", style="magenta")
-    for user_prompt, bot_response in st.session_state.chat_history:
-        table.add_row(user_prompt, bot_response)
-    rprint(Panel(table, title="[bold blue]Chat History[/bold blue]"))
-
-def display_agent_info(agent_name: str):
-    """Displays information about the selected agent."""
-    agent = agents[agent_name]
-    table = Table(title=f"{agent_name} - Agent Information")
-    table.add_column("Description", style="cyan", no_wrap=True)
-    table.add_column("Skills", style="magenta")
-    table.add_row(agent["description"], ", ".join(agent["skills"]))
-    rprint(Panel(table, title=f"[bold blue]{agent_name} - Agent Information[/bold blue]"))
-
-def run_autonomous_build(agent_names: List[str], project_name: str):
-    """Runs the autonomous build process."""
-    for agent_name in agent_names:
-        agent = agents[agent_name]
-        chat_history = st.session_state.chat_history
-        workspace_projects = st.session_state.workspace_projects
-        summary, next_step = agent.autonomous_build(chat_history, workspace_projects)
-        rprint(Panel(summary, title="[bold blue]Current State[/bold blue]"))
-        rprint(Panel(next_step, title="[bold blue]Next Step[/bold blue]"))
-        # Implement logic for autonomous build based on the current state
-        # ...
-
-# --- Streamlit UI ---
-st.title("DevToolKit: AI-Powered Development Environment")
-
-# --- Project Management ---
-st.header("Project Management")
-project_name = st.text_input("Enter project name:")
-if st.button("Create Project"):
-    if project_name not in st.session_state.workspace_projects:
-        st.session_state.workspace_projects[project_name] = {'files': []}
-        st.success(f"Created project: {project_name}")
-    else:
-        st.warning(f"Project {project_name} already exists")
-
-# --- Code Addition ---
-st.subheader("Add Code to Workspace")
-code_to_add = st.text_area("Enter code to add to workspace:")
-file_name = st.text_input("Enter file name (e.g. 'app.py'):")
-if st.button("Add Code"):
-    add_code_status = add_code_to_workspace(project_name, code_to_add, file_name)
-    st.success(add_code_status)
-
-# --- Terminal Interface ---
-st.subheader("Terminal (Workspace Context)")
-terminal_input = st.text_input("Enter a command within the workspace:")
-if st.button("Run Command"):
-    terminal_output = terminal_interface(terminal_input, project_name)
-    st.code(terminal_output, language="bash")
-
-# --- Chat Interface ---
-st.subheader("Chat with AI Agents")
-selected_agents = st.multiselect("Select AI agents", list(agents.keys()), key="agent_select")
-st.session_state.selected_agents = selected_agents
-agent_chat_input = st.text_area("Enter your message for the agents:", key="agent_input")
-if st.button("Send to Agents", key="agent_send"):
-    agent_chat_response = chat_interface(agent_chat_input, selected_agents)
-    st.write(agent_chat_response)
-
-# --- Agent Control ---
-st.subheader("Agent Control")
-for agent_name in agents:
-    agent = agents[agent_name]
-    with st.expander(f"{agent_name} ({agent['description']})"):
-        if st.button(f"Activate {agent_name}", key=f"activate_{agent_name}"):
-            st.session_state.active_agent = agent_name
-            st.success(f"{agent_name} activated.")
-        if st.button(f"Deactivate {agent_name}", key=f"deactivate_{agent_name}"):
-            st.session_state.active_agent = None
-            st.success(f"{agent_name} deactivated.")
-
-# --- Automate Build Process ---
-st.subheader("Automate Build Process")
-if st.button("Automate"):
-    if st.session_state.selected_agents:
-        run_autonomous_build(st.session_state.selected_agents, project_name)
-    else:
-        st.warning("Please select at least one agent.")
-
-# --- Display Information ---
-st.sidebar.subheader("Current State")
-st.sidebar.json(st.session_state.current_state)
-if st.session_state.active_agent:
-    display_agent_info(st.session_state.active_agent)
-display_workspace_projects()
-display_chat_history()
-
-# --- Gradio Interface ---
-additional_inputs = [
-    gr.Dropdown(label="Agents", choices=[s for s in agents.keys()], value=list(agents.keys())[0], interactive=True),
-    gr.Textbox(label="System Prompt", max_lines=1, interactive=True),
-    gr.Slider(label="Temperature", value=TEMPERATURE, minimum=0.0, maximum=1.0, step=0.05, interactive=True, info="Higher values produce more diverse outputs"),
-    gr.Slider(label="Max new tokens", value=MAX_NEW_TOKENS, minimum=0, maximum=1000*10, step=64, interactive=True, info="The maximum numbers of new tokens"),
-    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"),
-    gr.Slider(label="Repetition penalty", value=REPETITION_PENALTY, minimum=1.0, maximum=2.0, step=0.05, interactive=True, info="Penalize repeated tokens"),
+# Simulated agent and tool libraries
+AGENT_TYPES = [
+    "Task Executor",
+    "Information Retriever",
+    "Decision Maker",
+    "Data Analyzer",
 ]
-
-examples = [
-    ["Create a simple web application using Flask", "WEB_DEV"],
-    ["Generate a Python script to perform a linear regression analysis", "PYTHON_CODE_DEV"],
-    ["Create a Dockerfile for a Node.js application", "AI_SYSTEM_PROMPT"],
-    # Add more examples as needed
+TOOL_TYPES = [
+    "Web Scraper",
+    "Database Connector",
+    "API Caller",
+    "File Handler",
+    "Text Processor",
 ]
 
-gr.ChatInterface(
-    fn=chat_interface,
-    chatbot=gr.Chatbot(show_label=False, show_share_button=False, show_copy_button=True, likeable=True, layout="panel"),
-    additional_inputs=additional_inputs,
-    title="DevToolKit AI Assistant",
-    examples=examples,
-    concurrency_limit=20,
-).launch(show_api=True)
+# Initialize Hugging Face client
+client = InferenceClient("mistralai/Mixtral-8x7B-Instruct-v0.1")
+
+VERBOSE = False
+MAX_HISTORY = 100
+MODEL = "mistralai/Mixtral-8x7B-Instruct-v0.1"
+
+# Import necessary prompts and functions from the existing code
+from .prompts import (
+    ACTION_PROMPT,
+    ADD_PROMPT,
+    COMPRESS_HISTORY_PROMPT,
+    LOG_PROMPT,
+    LOG_RESPONSE,
+    MODIFY_PROMPT,
+    PREFIX,
+    READ_PROMPT,
+    TASK_PROMPT,
+    UNDERSTAND_TEST_RESULTS_PROMPT,
+)
+from .utils import parse_action, parse_file_content, read_python_module_structure
+from flask import Flask, request, jsonify
+
+
+class Agent:
+    def __init__(self, name: str, agent_type: str, complexity: int):
+        self.name = name
+        self.type = agent_type
+        self.complexity = complexity
+        self.tools = []
+
+    def add_tool(self, tool):
+        self.tools.append(tool)
+
+    def __str__(self):
+        return f"{self.name} ({self.type}) - Complexity: {self.complexity}"
+
+
+class Tool:
+    def __init__(self, name: str, tool_type: str):
+        self.name = name
+        self.type = tool_type
+
+    def __str__(self):
+        return f"{self.name} ({self.type})"
+
+
+class Pypelyne:
+    def __init__(self):
+        self.agents: List[Agent] = []
+        self.tools: List[Tool] = []
+        self.history = ""
+        self.task = None
+        self.purpose = None
+        self.directory = None
+
+    def add_agent(self, agent: Agent):
+        self.agents.append(agent)
+
+    def add_tool(self, tool: Tool):
+        self.tools.append(tool)
+
+    def generate_chat_app(self):
+        time.sleep(2)  # Simulate processing time
+        return f"Chat app generated with {len(self.agents)} agents and {len(self.tools)} tools."
+
+    def run_gpt(self, prompt_template, stop_tokens, max_tokens, **prompt_kwargs):
+        content = PREFIX.format(
+            module_summary=read_python_module_structure(self.directory)[0],
+            purpose=self.purpose,
+        ) + prompt_template.format(**prompt_kwargs)
+
+        if VERBOSE:
+            print(LOG_PROMPT.format(content))
+
+        stream = client.text_generation(
+            prompt=content,
+            max_new_tokens=max_tokens,
+            stop_sequences=stop_tokens if stop_tokens else None,
+            do_sample=True,
+            temperature=0.7,
+        )
+
+        resp = "".join(token for token in stream)
+
+        if VERBOSE:
+            print(LOG_RESPONSE.format(resp))
+        return resp
+
+    def compress_history(self):
+        resp = self.run_gpt(
+            COMPRESS_HISTORY_PROMPT,
+            stop_tokens=["observation:", "task:", "action:", "thought:"],
+            max_tokens=512,
+            task=self.task,
+            history=self.history,
+        )
+        self.history = f"observation: {resp}\n"
+
+    def run_action(self, action_name, action_input):
+        if action_name == "COMPLETE":
+            return "Task completed."
+
+        if len(self.history.split("\n")) > MAX_HISTORY:
+            if VERBOSE:
+                print("COMPRESSING HISTORY")
+            self.compress_history()
+
+        action_funcs = {
+            "MAIN": self.call_main,
+            "UPDATE-TASK": self.call_set_task,
+            "MODIFY-FILE": self.call_modify,
+            "READ-FILE": self.call_read,
+            "ADD-FILE": self.call_add,
+            "TEST": self.call_test,
+        }
+
+        if action_name not in action_funcs:
+            return f"Unknown action: {action_name}"
+
+        print(f"RUN: {action_name} {action_input}")
+        return action_funcs[action_name](action_input)
+
+    def call_main(self, action_input):
+        resp = self.run_gpt(
+            ACTION_PROMPT,
+            stop_tokens=["observation:", "task:"],
+            max_tokens=256,
+            task=self.task,
+            history=self.history,
+        )
+        lines = resp.strip().strip("\n").split("\n")
+        for line in lines:
+            if line == "":
+                continue
+            if line.startswith("thought: "):
+                self.history += f"{line}\n"
+            elif line.startswith("action: "):
+                action_name, action_input = parse_action(line)
+                self.history += f"{line}\n"
+                return self.run_action(action_name, action_input)
+        return "No valid action found."
+
+    def call_set_task(self, action_input):
+        self.task = self.run_gpt(
+            TASK_PROMPT,
+            stop_tokens=[],
+            max_tokens=64,
+            task=self.task,
+            history=self.history,
+        ).strip("\n")
+        self.history += f"observation: task has been updated to: {self.task}\n"
+        return f"Task updated: {self.task}"
+
+    def call_modify(self, action_input):
+        if not os.path.exists(action_input):
+            self.history += "observation: file does not exist\n"
+            return "File does not exist."
+
+        content = read_python_module_structure(self.directory)[1]
+        f_content = (
+            content[action_input] if content[action_input] else "< document is empty >"
+        )
+
+        resp = self.run_gpt(
+            MODIFY_PROMPT,
+            stop_tokens=["action:", "thought:", "observation:"],
+            max_tokens=2048,
+            task=self.task,
+            history=self.history,
+            file_path=action_input,
+            file_contents=f_content,
+        )
+        new_contents, description = parse_file_content(resp)
+        if new_contents is None:
+            self.history += "observation: failed to modify file\n"
+            return "Failed to modify file."
+
+        with open(action_input, "w") as f:
+            f.write(new_contents)
+
+        self.history += f"observation: file successfully modified\n"
+        self.history += f"observation: {description}\n"
+        return f"File modified: {action_input}"
+
+    def call_read(self, action_input):
+        if not os.path.exists(action_input):
+            self.history += "observation: file does not exist\n"
+            return "File does not exist."
+
+        content = read_python_module_structure(self.directory)[1]
+        f_content = (
+            content[action_input] if content[action_input] else "< document is empty >"
+        )
+
+        resp = self.run_gpt(
+            READ_PROMPT,
+            stop_tokens=[],
+            max_tokens=256,
+            task=self.task,
+            history=self.history,
+            file_path=action_input,
+            file_contents=f_content,
+        ).strip("\n")
+        self.history += f"observation: {resp}\n"
+        return f"File read: {action_input}"
+
+    def call_add(self, action_input):
+        d = os.path.dirname(action_input)
+        if not d.startswith(self.directory):
+            self.history += (
+                f"observation: files must be under directory {self.directory}\n"
+            )
+            return f"Invalid directory: {d}"
+        elif not action_input.endswith(".py"):
+            self.history += "observation: can only write .py files\n"
+            return "Only .py files are allowed."
+        else:
+            if d and not os.path.exists(d):
+                os.makedirs(d)
+            if not os.path.exists(action_input):
+                resp = self.run_gpt(
+                    ADD_PROMPT,
+                    stop_tokens=["action:", "thought:", "observation:"],
+                    max_tokens=2048,
+                    task=self.task,
+                    history=self.history,
+                    file_path=action_input,
+                )
+                new_contents, description = parse_file_content(resp)
+                if new_contents is None:
+                    self.history += "observation: failed to write file\n"
+                    return "Failed to write file."
+
+                with open(action_input, "w") as f:
+                    f.write(new_contents)
+
+                self.history += "observation: file successfully written\n"
+                self.history += f"observation: {description}\n"
+                return f"File added: {action_input}"
+            else:
+                self.history += "observation: file already exists\n"
+                return "File already exists."
+
+    def call_test(self, action_input):
+        result = subprocess.run(
+            ["python", "-m", "pytest", "--collect-only", self.directory],
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode != 0:
+            self.history += f"observation: there are no tests! Test should be written in a test folder under {self.directory}\n"
+            return "No tests found."
+        result = subprocess.run(
+            ["python", "-m", "pytest", self.directory], capture_output=True, text=True
+        )
+        if result.returncode == 0:
+            self.history += "observation: tests pass\n"
+            return "All tests passed."
+
+        resp = self.run_gpt(
+            UNDERSTAND_TEST_RESULTS_PROMPT,
+            stop_tokens=[],
+            max_tokens=256,
+            task=self.task,
+            history=self.history,
+            stdout=result.stdout[:5000],
+            stderr=result.stderr[:5000],
+        )
+        self.history += f"observation: tests failed: {resp}\n"
+        return f"Tests failed: {resp}"
+
+
+pypelyne = Pypelyne()
+
+
+def create_agent(name: str, agent_type: str, complexity: int) -> str:
+    agent = Agent(name, agent_type, complexity)
+    pypelyne.add_agent(agent)
+    return f"Agent created: {agent}"
+
+
+def create_tool(name: str, tool_type: str) -> str:
+    tool = Tool(name, tool_type)
+    pypelyne.add_tool(tool)
+    return f"Tool created: {tool}"
+
+
+def assign_tool(agent_name: str, tool_name: str) -> str:
+    agent = next((a for a in pypelyne.agents if a.name == agent_name), None)
+    tool = next((t for t in pypelyne.tools if t.name == tool_name), None)
+
+    if agent and tool:
+        agent.add_tool(tool)
+        return f"Tool '{tool.name}' assigned to agent '{agent.name}'"
+    else:
+        return "Agent or tool not found."
+
+
+def generate_chat_app() -> str:
+    return pypelyne.generate_chat_app()
+
+
+def list_agents() -> str:
+    return (
+        "\n".join(str(agent) for agent in pypelyne.agents) or "No agents created yet."
+    )
+
+
+def list_tools() -> str:
+    return "\n".join(str(tool) for tool in pypelyne.tools) or "No tools created yet."
+
+
+def chat_with_pypelyne(message: str) -> str:
+    return pypelyne.run_action("MAIN", message)
+
+
+def set_purpose_and_directory(purpose: str, directory: str) -> str:
+    pypelyne.purpose = purpose
+    pypelyne.directory = directory
+    return f"Purpose set to: {purpose}\nWorking directory set to: {directory}"
+
+
+with gr.Blocks() as app:
+    gr.Markdown("# Welcome to Pypelyne")
+    gr.Markdown("Create your custom pipeline with agents and tools, then chat with it!")
+
+    with gr.Tab("Setup"):
+        purpose_input = gr.Textbox(label="Set Purpose")
+        directory_input = gr.Textbox(label="Set Working Directory")
+        setup_btn = gr.Button("Set Purpose and Directory")
+        setup_output = gr.Textbox(label="Setup Output")
+        setup_btn.click(
+            set_purpose_and_directory,
+            inputs=[purpose_input, directory_input],
+            outputs=setup_output,
+        )
+
+    with gr.Tab("Create Agents"):
+        agent_name = gr.Textbox(label="Agent Name")
+        agent_type = gr.Dropdown(choices=AGENT_TYPES, label="Agent Type")
+        agent_complexity = gr.Slider(
+            minimum=1, maximum=10, step=1, label="Agent Complexity"
+        )
+        create_agent_btn = gr.Button("Create Agent")
+        agent_output = gr.Textbox(label="Output")
+        create_agent_btn.click(
+            create_agent,
+            inputs=[agent_name, agent_type, agent_complexity],
+            outputs=agent_output,
+        )
+
+    with gr.Tab("Create Tools"):
+        tool_name = gr.Textbox(label="Tool Name")
+        tool_type = gr.Dropdown(choices=TOOL_TYPES, label="Tool Type")
+        create_tool_btn = gr.Button("Create Tool")
+        tool_output = gr.Textbox(label="Output")
+        create_tool_btn.click(
+            create_tool, inputs=[tool_name, tool_type], outputs=tool_output
+        )
+
+    with gr.Tab("Assign Tools"):
+        agent_select = gr.Dropdown(choices=[], label="Select Agent")
+        tool_select = gr.Dropdown(choices=[], label="Select Tool")
+        assign_tool_btn = gr.Button("Assign Tool")
+        assign_output = gr.Textbox(label="Output")
+        assign_tool_btn.click(
+            assign_tool, inputs=[agent_select, tool_select], outputs=assign_output
+        )
+
+    with gr.Tab("Generate Chat App"):
+        generate_btn = gr.Button("Generate Chat App")
+        generate_output = gr.Textbox(label="Output")
+        generate_btn.click(generate_chat_app, outputs=generate_output)
+
+    with gr.Tab("Chat with Pypelyne"):
+        chat_input = gr.Textbox(label="Your Message")
+        chat_output = gr.Textbox(label="Pypelyne's Response")
+        chat_btn = gr.Button("Send")
+        chat_btn.click(chat_with_pypelyne, inputs=chat_input, outputs=chat_output)
+
+    with gr.Tab("View Pypelyne"):
+        view_agents_btn = gr.Button("View Agents")
+        view_tools_btn = gr.Button("View Tools")
+        view_output = gr.Textbox(label="Pypelyne Components")
+        view_agents_btn.click(list_agents, outputs=view_output)
+        view_tools_btn.click(list_tools, outputs=view_output)
+
+    def update_dropdowns():
+        return gr.Dropdown.update(
+            choices=[agent.name for agent in pypelyne.agents]
+        ), gr.Dropdown.update(choices=[tool.name for tool in pypelyne.tools])
+
+    create_agent_btn.click(update_dropdowns, outputs=[agent_select, tool_select])
+    create_tool_btn.click(update_dropdowns, outputs=[agent_select, tool_select])
+
+if __name__ == "__main__":
+    app.launch()
+    app = Flask(__name__)
+
+    @app.route("/chat", methods=["POST"])
+    def chat():
+        message = request.json["message"]
+        response = chat_with_pypelyne(message)
+        return jsonify({"response": response})
+
+    @app.route("/agents", methods=["GET"])
+    def get_agents():
+        agents = list_agents()
+        return jsonify({"agents": agents})
+
+    @app.route("/tools", methods=["GET"])
+    def get_tools():
+        tools = list_tools()
+        return jsonify({"tools": tools})
+
+    if __name__ == "__main__":
+        app.run()