Update app.py

app.py

@@ -1,579 +1,121 @@
 import streamlit as st
-from huggingface_hub import InferenceClient
-import os
-import pickle
-from langchain.memory import ConversationBufferMemory
-from langchain_community.tools import Tool
-from langchain_community.agents import initialize_agent, AgentType
-from langchain_community.chains import LLMChain
-from langchain_community.prompts import PromptTemplate
-from langchain_community.chains.question_answering import load_qa_chain
-from langchain_community.document_loaders import TextLoader
-from langchain_community.text_splitter import CharacterTextSplitter
-from langchain_community.embeddings import HuggingFaceEmbeddings  # Use Hugging Face Embeddings
-from langchain_community.vectorstores import FAISS
-from langchain_community.chains import RetrievalQA
-from langchain_community.chains.conversational_retrieval_qa import ConversationalRetrievalQAChain
-from langchain_community.chains.summarization import load_summarization_chain
+from langchain.agents import create_react_agent, AgentExecutor
+from langchain.prompts import PromptTemplate
 from langchain_community.llms import HuggingFaceHub
+from langchain.tools import Tool
+from langchain.chains import LLMChain
 from typing import List, Dict, Any, Optional
 
-st.title("Triagi - Dev-Centric Agent Clusters ☄")
+# Base Tool and specific tools (CodeGenerationTool, DataRetrievalTool, TextGenerationTool) remain the same as in the previous version
 
-# --- Model Definitions ---
-class Model:
-    def __init__(self, name, description, model_link):
-        self.name = name
-        self.description = description
-        self.model_link = model_link
-        self.inference_client = InferenceClient(model=model_link)
-
-    def generate_text(self, prompt, temperature=0.5, max_new_tokens=4096):
-        try:
-            output = self.inference_client.text_generation(
-                prompt,
-                temperature=temperature,
-                max_new_tokens=max_new_tokens,
-                stream=True
-            )
-            response = "".join(output)
-        except ValueError as e:
-            if "Input validation error" in str(e):
-                return "Error: The input prompt is too long. Please try a shorter prompt."
-            else:
-                return f"An error occurred: {e}"
-        return response
-
-# --- Model Examples ---
-class FrontendForgeModel(Model):
-    def __init__(self):
-        super().__init__("FrontendForge🚀", "The FrontendForge model is a Large Language Model (LLM) that's able to handle frontend development tasks such as UI design and user interaction logic.", "mistralai/Mistral-7B-Instruct-v0.2")
-
-class BackendBuilderModel(Model):
-    def __init__(self):
-        super().__init__("BackendBuilder⭐", "The BackendBuilder model is a Large Language Model (LLM) that's specialized in backend development tasks including API creation, database management, and server-side logic.", "mistralai/Mixtral-8x7B-Instruct-v0.1")
-
-class IntegratorModel(Model):
-    def __init__(self):
-        super().__init__("Integrator🔄", "The Integrator model is a Large Language Model (LLM) that's best suited for integrating frontend and backend components, handling business logic, and ensuring seamless communication between different parts of the application.", "microsoft/Phi-3-mini-4k-instruct")
-
-# --- Streamlit Interface ---
-model_links = {
-    "FrontendForge🚀": "mistralai/Mistral-7B-Instruct-v0.2",
-    "BackendBuilder⭐": "mistralai/Mixtral-8x7B-Instruct-v0.1",
-    "Integrator🔄": "microsoft/Phi-3-mini-4k-instruct"
-}
-
-model_info = {
-    "FrontendForge🚀": {
-        'description': "The FrontendForge model is a Large Language Model (LLM) that's able to handle frontend development tasks such as UI design and user interaction logic.",
-        'logo': './11.jpg'
-    },
-    "BackendBuilder⭐": {
-        'description': "The BackendBuilder model is a Large Language Model (LLM) that's specialized in backend development tasks including API creation, database management, and server-side logic.",
-        'logo': './2.jpg'
-    },
-    "Integrator🔄": {
-        'description': "The Integrator model is a Large Language Model (LLM) that's best suited for integrating frontend and backend components, handling business logic, and ensuring seamless communication between different parts of the application.",
-        'logo': './3.jpg'
-    },
-}
-
-def format_prompt(message, conversation_history, custom_instructions=None):
-    prompt = ""
-    if custom_instructions:
-        prompt += "[INST] {} [/INST]\n".format(custom_instructions)
-    
-    # Add conversation history to the prompt
-    prompt += "[CONV_HISTORY]\n"
-    for role, content in conversation_history:
-        prompt += "{}: {}\n".format(role.upper(), content)
-    prompt += "[/CONV_HISTORY]\n"
-    
-    # Add the current message
-    prompt += "[INST] {} [/INST]\n".format(message)
-    
-    # Add the response format
-    prompt += "[RESPONSE]\n"
-    
-    return prompt
-
-def reset_conversation():
-    '''
-    Resets Conversation
-    '''
-    st.session_state.conversation = []
-    st.session_state.messages = []
-    st.session_state.chat_state = "reset"
-
-def load_conversation_history():
-    history_file = "conversation_history.pickle"
-    if os.path.exists(history_file):
-        with open(history_file, "rb") as f:
-            conversation_history = pickle.load(f)
-    else:
-        conversation_history = []
-    return conversation_history
-
-def save_conversation_history(conversation_history):
-    history_file = "conversation_history.pickle"
-    with open(history_file, "wb") as f:
-        pickle.dump(conversation_history, f)
-
-models = [key for key in model_links.keys()]
-selected_model = st.sidebar.selectbox("Select Model", models)
-temp_values = st.sidebar.slider('Select a temperature value', 0.0, 1.0, (0.5))
-st.sidebar.button('Reset Chat', on_click=reset_conversation)  # Reset button
-
-st.sidebar.write(f"You're now chatting with **{selected_model}**")
-st.sidebar.markdown(model_info[selected_model]['description'])
-st.sidebar.image(model_info[selected_model]['logo'])
-
-st.sidebar.markdown("*Generating the code might go slow if you are using low power resources*")
-
-if "prev_option" not in st.session_state:
-    st.session_state.prev_option = selected_model
-
-if st.session_state.prev_option != selected_model:
-    st.session_state.messages = []
-    st.session_state.prev_option = selected_model
-
-if "chat_state" not in st.session_state:
-    st.session_state.chat_state = "normal"
-
-# Load the conversation history from the file
-if "messages" not in st.session_state:
-    st.session_state.messages = load_conversation_history()
-
-repo_id = model_links[selected_model]
-st.subheader(f'{selected_model}')
-
-if st.session_state.chat_state == "normal":
-    for message in st.session_state.messages:
-        with st.chat_message(message["role"]):
-            st.markdown(message["content"])
-
-    if prompt := st.chat_input(f"Hi I'm {selected_model}, How can I help you today?"):
-        custom_instruction = "Act like a Human in conversation"
-        with st.chat_message("user"):
-            st.markdown(prompt)
-        
-        st.session_state.messages.append({"role": "user", "content": prompt})
-        conversation_history = [(message["role"], message["content"]) for message in st.session_state.messages]
-        
-        formated_text = format_prompt(prompt, conversation_history, custom_instruction)
-        
-        with st.chat_message("assistant"):
-            # Select the appropriate model based on the user's choice
-            if selected_model == "FrontendForge🚀":
-                model = FrontendForgeModel()
-            elif selected_model == "BackendBuilder⭐":
-                model = BackendBuilderModel()
-            elif selected_model == "Integrator🔄":
-                model = IntegratorModel()
-            else:
-                st.error("Invalid model selection.")
-                st.stop()  # Stop the Streamlit app execution
-
-            response = model.generate_text(formated_text, temperature=temp_values)
-            st.markdown(response)
-            st.session_state.messages.append({"role": "assistant", "content": response})
-            save_conversation_history(st.session_state.messages)
-
-elif st.session_state.chat_state == "reset":
-    st.session_state.chat_state = "normal"
-    st.experimental_rerun()
-
-# --- Agent Definitions ---
-class Agent:
+# --- Specialized Agent Definitions ---
+class SpecializedAgent(Agent):
     def __init__(self, name, role, tools, knowledge_base=None):
-        self.name = name
-        self.role = role
-        self.tools = tools
-        self.knowledge_base = knowledge_base
-        self.memory = []
-        self.llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 0.5})  # Use a language model for action selection
-        self.agent = ToolAgent(
-            llm=self.llm,
-            tools=self.tools,
-            agent_type=AgentType.ZERO_SHOT_REACT_DESCRIPTION,
-            verbose=True
+        super().__init__(name, role, tools, knowledge_base)
+        self.prompt = PromptTemplate.from_template(
+            "You are a specialized AI assistant named {name} with the role of {role}. "
+            "Use the following tools to complete your task: {tools}\n\n"
+            "Task: {input}\n"
+            "Thought: Let's approach this step-by-step:\n"
+            "{agent_scratchpad}"
         )
-
-    def act(self, prompt, context):
-        self.memory.append((prompt, context))
-        action = self.agent.run(prompt, context)
-        return action
-
-    def observe(self, observation):
-        # Process observation based on the agent's capabilities and the nature of the observation
-        self.memory.append(observation)
-
-    def learn(self, data):
-        # Implement learning logic based on the agent's capabilities and the type of data
-        pass
-
-    def __str__(self):
-        return f"Agent: {self.name} (Role: {self.role})"
-
-# --- Tool Definitions ---
-class Tool:
-    def __init__(self, name, description):
-        self.name = name
-        self.description = description
-
-    def run(self, arguments):
-        # Implement tool execution logic based on the specific tool's functionality and the provided arguments
-        return {"output": "Tool Output"}
-
-# --- Tool Examples ---
-class CodeGenerationTool(Tool):
-    def __init__(self):
-        super().__init__("Code Generation", "Generates code snippets in various languages.")
-        self.llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 0.5})
-        self.prompt_template = PromptTemplate(
-            input_variables=["language", "code_description"],
-            template="Generate {language} code for: {code_description}"
+        self.react_agent = create_react_agent(self.llm, self.tools, self.prompt)
+        self.agent_executor = AgentExecutor(
+            agent=self.react_agent, 
+            tools=self.tools, 
+            verbose=True,
+            max_iterations=5
         )
-        self.chain = LLMChain(llm=self.llm, prompt=self.prompt_template)
-
-    def run(self, arguments):
-        language = arguments.get("language", "python")
-        code_description = arguments.get("code_description", "print('Hello, World!')")
-        code = self.chain.run(language=language, code_description=code_description)
-        return {"output": code}
 
-class DataRetrievalTool(Tool):
+class RequirementsAgent(SpecializedAgent):
     def __init__(self):
-        super().__init__("Data Retrieval", "Accesses data from APIs, databases, or files.")
-        self.llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 0.5})
-        self.prompt_template = PromptTemplate(
-            input_variables=["data_source", "data_query"],
-            template="Retrieve data from {data_source} based on: {data_query}"
-        )
-        self.chain = LLMChain(llm=self.llm, prompt=self.prompt_template)
-
-    def run(self, arguments):
-        data_source = arguments.get("data_source", "https://example.com/data")
-        data_query = arguments.get("data_query", "some information")
-        data = self.chain.run(data_source=data_source, data_query=data_query)
-        return {"output": data}
+        super().__init__("RequirementsAnalyst", "Analyzing and refining project requirements", [TextGenerationTool()])
 
-class TextGenerationTool(Tool):
+class ArchitectureAgent(SpecializedAgent):
     def __init__(self):
-        super().__init__("Text Generation", "Generates human-like text based on a given prompt.")
-        self.llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 0.5})
-        self.prompt_template = PromptTemplate(
-            input_variables=["text_prompt"],
-            template="Generate text based on: {text_prompt}"
-        )
-        self.chain = LLMChain(llm=self.llm, prompt=self.prompt_template)
-
-    def run(self, arguments):
-        text_prompt = arguments.get("text_prompt", "Write a short story about a cat.")
-        text = self.chain.run(text_prompt=text_prompt)
-        return {"output": text}
+        super().__init__("SystemArchitect", "Designing system architecture", [TextGenerationTool()])
 
-class CodeExecutionTool(Tool):
+class FrontendAgent(SpecializedAgent):
     def __init__(self):
-        super().__init__("Code Execution", "Runs code snippets in various languages.")
+        super().__init__("FrontendDeveloper", "Developing the frontend", [CodeGenerationTool()])
 
-    def run(self, arguments):
-        code = arguments.get("code", "print('Hello, World!')")
-        try:
-            exec(code)
-            return {"output": f"Code executed: {code}"}
-        except Exception as e:
-            return {"output": f"Error executing code: {e}"}
-
-class CodeDebuggingTool(Tool):
+class BackendAgent(SpecializedAgent):
     def __init__(self):
-        super().__init__("Code Debugging", "Identifies and resolves errors in code snippets.")
-        self.llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 0.5})
-        self.prompt_template = PromptTemplate(
-            input_variables=["code", "error_message"],
-            template="Debug the following code:\n{code}\n\nError message: {error_message}"
-        )
-        self.chain = LLMChain(llm=self.llm, prompt=self.prompt_template)
-
-    def run(self, arguments):
-        code = arguments.get("code", "print('Hello, World!')")
-        try:
-            exec(code)
-            return {"output": f"Code debugged: {code}"}
-        except Exception as e:
-            error_message = str(e)
-            debugged_code = self.chain.run(code=code, error_message=error_message)
-            return {"output": f"Debugged code:\n{debugged_code}"}
+        super().__init__("BackendDeveloper", "Developing the backend", [CodeGenerationTool(), DataRetrievalTool()])
 
-class CodeSummarizationTool(Tool):
+class DatabaseAgent(SpecializedAgent):
     def __init__(self):
-        super().__init__("Code Summarization", "Provides a concise overview of the functionality of a code snippet.")
-        self.llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 0.5})
-        self.prompt_template = PromptTemplate(
-            input_variables=["code"],
-            template="Summarize the functionality of the following code:\n{code}"
-        )
-        self.chain = LLMChain(llm=self.llm, prompt=self.prompt_template)
-
-    def run(self, arguments):
-        code = arguments.get("code", "print('Hello, World!')")
-        summary = self.chain.run(code=code)
-        return {"output": f"Code summary: {summary}"}
+        super().__init__("DatabaseEngineer", "Designing and implementing the database", [CodeGenerationTool(), DataRetrievalTool()])
 
-class CodeTranslationTool(Tool):
+class TestingAgent(SpecializedAgent):
     def __init__(self):
-        super().__init__("Code Translation", "Translates code snippets between different programming languages.")
-        self.llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 0.5})
-        self.prompt_template = PromptTemplate(
-            input_variables=["code", "target_language"],
-            template="Translate the following code to {target_language}:\n{code}"
-        )
-        self.chain = LLMChain(llm=self.llm, prompt=self.prompt_template)
+        super().__init__("QAEngineer", "Creating and executing test plans", [CodeGenerationTool(), TextGenerationTool()])
 
-    def run(self, arguments):
-        code = arguments.get("code", "print('Hello, World!')")
-        target_language = arguments.get("target_language", "javascript")
-        translated_code = self.chain.run(code=code, target_language=target_language)
-        return {"output": f"Translated code:\n{translated_code}"}
-
-class CodeOptimizationTool(Tool):
+class DeploymentAgent(SpecializedAgent):
     def __init__(self):
-        super().__init__("Code Optimization", "Optimizes code for performance and efficiency.")
-        self.llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 0.5})
-        self.prompt_template = PromptTemplate(
-            input_variables=["code"],
-            template="Optimize the following code for performance and efficiency:\n{code}"
-        )
-        self.chain = LLMChain(llm=self.llm, prompt=self.prompt_template)
-
-    def run(self, arguments):
-        code = arguments.get("code", "print('Hello, World!')")
-        optimized_code = self.chain.run(code=code)
-        return {"output": f"Optimized code:\n{optimized_code}"}
+        super().__init__("DevOpsEngineer", "Handling deployment and infrastructure", [CodeGenerationTool(), TextGenerationTool()])
 
-class CodeDocumentationTool(Tool):
+# --- Application Building Sequence ---
+class ApplicationBuilder:
     def __init__(self):
-        super().__init__("Code Documentation", "Generates documentation for code snippets.")
-        self.llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 0.5})
-        self.prompt_template = PromptTemplate(
-            input_variables=["code"],
-            template="Generate documentation for the following code:\n{code}"
-        )
-        self.chain = LLMChain(llm=self.llm, prompt=self.prompt_template)
-
-    def run(self, arguments):
-        code = arguments.get("code", "print('Hello, World!')")
-        documentation = self.chain.run(code=code)
-        return {"output": f"Code documentation:\n{documentation}"}
-
-class ImageGenerationTool(Tool):
-    def __init__(self):
-        super().__init__("Image Generation", "Generates images based on text descriptions.")
-        self.llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 0.5})
-        self.prompt_template = PromptTemplate(
-            input_variables=["description"],
-            template="Generate an image based on the description: {description}"
-        )
-        self.chain = LLMChain(llm=self.llm, prompt=self.prompt_template)
-
-    def run(self, arguments):
-        description = arguments.get("description", "A cat sitting on a couch")
-        image_url = self.chain.run(description=description)
-        return {"output": f"Generated image: {image_url}"}
-
-class ImageEditingTool(Tool):
-    def __init__(self):
-        super().__init__("Image Editing", "Modifying existing images.")
-        self.llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 0.5})
-        self.prompt_template = PromptTemplate(
-            input_variables=["image_url", "editing_instructions"],
-            template="Edit the image at {image_url} according to the instructions: {editing_instructions}"
-        )
-        self.chain = LLMChain(llm=self.llm, prompt=self.prompt_template)
-
-    def run(self, arguments):
-        image_url = arguments.get("image_url", "https://example.com/image.jpg")
-        editing_instructions = arguments.get("editing_instructions", "Make the cat smile")
-        edited_image_url = self.chain.run(image_url=image_url, editing_instructions=editing_instructions)
-        return {"output": f"Edited image: {edited_image_url}"}
-
-class ImageAnalysisTool(Tool):
-    def __init__(self):
-        super().__init__("Image Analysis", "Extracting information from images, such as objects, scenes, and emotions.")
-        self.llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 0.5})
-        self.prompt_template = PromptTemplate(
-            input_variables=["image_url"],
-            template="Analyze the image at {image_url} and provide information about objects, scenes, and emotions."
-        )
-        self.chain = LLMChain(llm=self.llm, prompt=self.prompt_template)
+        self.agents = [
+            RequirementsAgent(),
+            ArchitectureAgent(),
+            FrontendAgent(),
+            BackendAgent(),
+            DatabaseAgent(),
+            TestingAgent(),
+            DeploymentAgent()
+        ]
+        self.project_state = {}
 
-    def run(self, arguments):
-        image_url = arguments.get("image_url", "https://example.com/image.jpg")
-        analysis_results = self.chain.run(image_url=image_url)
-        return {"output": f"Image analysis results:\n{analysis_results}"}
-
-class QuestionAnsweringTool(Tool):
-    def __init__(self):
-        super().__init__("Question Answering", "Answers questions based on provided context.")
-        self.llm = HuggingFaceHub(repo_id="google/flan-t5-xl", model_kwargs={"temperature": 0.5})
-        self.qa_chain = load_qa_chain(self.llm)  # Use a question answering chain
-
-    def run(self, arguments):
-        question = arguments.get("question", "What is the capital of France?")
-        context = arguments.get("context", "France is a country in Western Europe. Its capital is Paris.")
-        answer = self.qa_chain.run(question=question, context=context)
-        return {"output": answer}
-
-# --- Agent Pool ---
-agent_pool = {
-    "IdeaIntake": Agent("IdeaIntake", "Idea Intake", [DataRetrievalTool(), CodeGenerationTool(), TextGenerationTool(), QuestionAnsweringTool()], knowledge_base=""),
-    "CodeBuilder": Agent("CodeBuilder", "Code Builder", [CodeGenerationTool(), CodeDebuggingTool(), CodeOptimizationTool(), CodeExecutionTool(), CodeSummarizationTool(), CodeTranslationTool(), CodeDocumentationTool()], knowledge_base=""),
-    "ImageCreator": Agent("ImageCreator", "Image Creator", [ImageGenerationTool(), ImageEditingTool(), ImageAnalysisTool()], knowledge_base=""),
-}
-
-# --- Workflow Definitions ---
-class Workflow:
-    def __init__(self, name, agents, task, description):
-        self.name = name
-        self.agents = agents
-        self.task = task
-        self.description = description
-
-    def run(self, prompt, context):
+    def build_application(self, project_description):
+        st.write("Starting application building process...")
         for agent in self.agents:
-            action = agent.act(prompt, context)
-            if action.get("tool"):
-                tool = next((t for t in agent.tools if t.name == action["tool"]), None)
-                if tool:
-                    output = tool.run(action["arguments"])
-                    context.update(output)
-                    agent.observe(output)
-        return context
-
-# --- Workflow Examples ---
-class AppBuildWorkflow(Workflow):
-    def __init__(self):
-        super().__init__("App Build", [agent_pool["IdeaIntake"], agent_pool["CodeBuilder"]], "Build a mobile application", "A workflow for building a mobile application.")
-
-class WebsiteBuildWorkflow(Workflow):
-    def __init__(self):
-        super().__init__("Website Build", [agent_pool["IdeaIntake"], agent_pool["CodeBuilder"]], "Build a website", "A workflow for building a website.")
-
-class GameBuildWorkflow(Workflow):
-    def __init__(self):
-        super().__init__("Game Build", [agent_pool["IdeaIntake"], agent_pool["CodeBuilder"]], "Build a game", "A workflow for building a game.")
-
-class PluginBuildWorkflow(Workflow):
-    def __init__(self):
-        super().__init__("Plugin Build", [agent_pool["IdeaIntake"], agent_pool["CodeBuilder"]], "Build a plugin", "A workflow for building a plugin.")
-
-class DevSandboxWorkflow(Workflow):
-    def __init__(self):
-        super().__init__("Dev Sandbox", [agent_pool["IdeaIntake"], agent_pool["CodeBuilder"]], "Experiment with code", "A workflow for experimenting with code.")
-
-# --- Agent-Based Workflow Execution ---
-def execute_workflow(workflow, prompt, context):
-    # Execute the workflow
-    context = workflow.run(prompt, context)
-    # Display the output
-    for agent in workflow.agents:
-        st.write(f"{agent}: {agent.memory}")
-        for action in agent.memory:
-            st.write(f"  Action: {action}")
-    return context
-
-# --- Example Usage ---
-if st.button("Build an App"):
-    app_build_workflow = AppBuildWorkflow()
-    context = {"task": "Build a mobile application"}
-    context = execute_workflow(app_build_workflow, "Build a mobile app for ordering food.", context)
-    st.write(f"Workflow Output: {context}")
-
-if st.button("Build a Website"):
-    website_build_workflow = WebsiteBuildWorkflow()
-    context = {"task": "Build a website"}
-    context = execute_workflow(website_build_workflow, "Build a website for a restaurant.", context)
-    st.write(f"Workflow Output: {context}")
-
-if st.button("Build a Game"):
-    game_build_workflow = GameBuildWorkflow()
-    context = {"task": "Build a game"}
-    context = execute_workflow(game_build_workflow, "Build a simple 2D platformer game.", context)
-    st.write(f"Workflow Output: {context}")
-
-if st.button("Build a Plugin"):
-    plugin_build_workflow = PluginBuildWorkflow()
-    context = {"task": "Build a plugin"}
-    context = execute_workflow(plugin_build_workflow, "Build a plugin for a text editor that adds a new syntax highlighting theme.", context)
-    st.write(f"Workflow Output: {context}")
-
-if st.button("Dev Sandbox"):
-    dev_sandbox_workflow = DevSandboxWorkflow()
-    context = {"task": "Experiment with code"}
-    context = execute_workflow(dev_sandbox_workflow, "Write a Python function to reverse a string.", context)
-    st.write(f"Workflow Output: {context}")
-
-# --- Displaying Agent and Tool Information ---
-st.subheader("Agent Pool")
-for agent_name, agent in agent_pool.items():
-    st.write(f"**{agent_name}**")
-    st.write(f"  Role: {agent.role}")
-    st.write(f"  Tools: {', '.join([tool.name for tool in agent.tools])}")
-
-st.subheader("Workflows")
-st.write("**App Build**")
-st.write(f"""  Description: {AppBuildWorkflow().description}""")
-st.write("**Website Build**")
-st.write(f"""  Description: {WebsiteBuildWorkflow().description}""")
-st.write("**Game Build**")
-st.write(f"""  Description: {GameBuildWorkflow().description}""")
-st.write("**Plugin Build**")
-st.write(f"""  Description: {PluginBuildWorkflow().description}""")
-st.write("**Dev Sandbox**")
-st.write(f"""  Description: {DevSandboxWorkflow().description}""")
-
-# --- Displaying Tool Definitions ---
-st.subheader("Tool Definitions")
-for tool_class in [CodeGenerationTool, DataRetrievalTool, CodeExecutionTool, CodeDebuggingTool, CodeSummarizationTool, CodeTranslationTool, CodeOptimizationTool, CodeDocumentationTool, ImageGenerationTool, ImageEditingTool, ImageAnalysisTool, TextGenerationTool, QuestionAnsweringTool]:
-    tool = tool_class()
-    st.write(f"**{tool.name}**")
-    st.write(f"  Description: {tool.description}")
-
-# --- Displaying Example Output ---
-st.subheader("Example Output")
-code_generation_tool = CodeGenerationTool()
-st.write(f"""Code Generation Tool Output: {code_generation_tool.run({'language': 'python', 'code_description': "print('Hello, World!')"})}""")
-
-data_retrieval_tool = DataRetrievalTool()
-st.write(f"""Data Retrieval Tool Output: {data_retrieval_tool.run({'data_source': 'https://example.com/data', 'data_query': 'some information'})}""")
-
-code_execution_tool = CodeExecutionTool()
-st.write(f"""Code Execution Tool Output: {code_execution_tool.run({'code': "print('Hello, World!')"})}""")
-
-code_debugging_tool = CodeDebuggingTool()
-st.write(f"""Code Debugging Tool Output: {code_debugging_tool.run({'code': "print('Hello, World!')"})}""")
-
-code_summarization_tool = CodeSummarizationTool()
-st.write(f"""Code Summarization Tool Output: {code_summarization_tool.run({'code': "print('Hello, World!')"})}""")
-
-code_translation_tool = CodeTranslationTool()
-st.write(f"""Code Translation Tool Output: {code_translation_tool.run({'code': "print('Hello, World!')", 'target_language': 'javascript'})}""")
-
-code_optimization_tool = CodeOptimizationTool()
-st.write(f"""Code Optimization Tool Output: {code_optimization_tool.run({'code': "print('Hello, World!')"})}""")
-
-code_documentation_tool = CodeDocumentationTool()
-st.write(f"""Code Documentation Tool Output: {code_documentation_tool.run({'code': "print('Hello, World!')"})}""")
-
-image_generation_tool = ImageGenerationTool()
-st.write(f"""Image Generation Tool Output: {image_generation_tool.run({'description': 'A cat sitting on a couch'})}""")
+            st.write(f"\n--- {agent.name}'s Turn ---")
+            task = self.get_task_for_agent(agent, project_description)
+            response = agent.act(task, self.project_state)
+            self.project_state[agent.role] = response
+            st.write(f"{agent.name}'s output:")
+            st.write(response)
+        st.write("\nApplication building process completed!")
+
+    def get_task_for_agent(self, agent, project_description):
+        tasks = (
+            (RequirementsAgent, f"Analyze and refine the requirements for this project: {project_description}"),
+            (ArchitectureAgent, f"Design the system architecture based on these requirements: {self.project_state.get('Analyzing and refining project requirements', '')}"),
+            (FrontendAgent, f"Develop the frontend based on this architecture: {self.project_state.get('Designing system architecture', '')}"),
+            (BackendAgent, f"Develop the backend based on this architecture: {self.project_state.get('Designing system architecture', '')}"),
+            (DatabaseAgent, f"Design and implement the database based on this architecture: {self.project_state.get('Designing system architecture', '')}"),
+            (TestingAgent, f"Create a test plan for this application: {project_description}"),
+            (DeploymentAgent, f"Create a deployment plan for this application: {project_description}")
+        )
+        
+        for agent_class, task in tasks:
+            if isinstance(agent, agent_class):
+                return task
+        
+        return f"Contribute to the project: {project_description}"
 
-image_editing_tool = ImageEditingTool()
-st.write(f"""Image Editing Tool Output: {image_editing_tool.run({'image_url': 'https://example.com/image.jpg', 'editing_instructions': 'Make the cat smile'})}""")
+# --- Streamlit App ---
+st.title("CODEFUSSION ☄ - Full-Stack Application Builder")
 
-image_analysis_tool = ImageAnalysisTool()
-st.write(f"""Image Analysis Tool Output: {image_analysis_tool.run({'image_url': 'https://example.com/image.jpg'})}""")
+project_description = st.text_area("Enter your project description:")
 
-question_answering_tool = QuestionAnsweringTool()
-st.write(f"""Question Answering Tool Output: {question_answering_tool.run({'question': 'What is the capital of France?', 'context': 'France is a country in Western Europe. Its capital is Paris.'})}""")
+if st.button("Build Application"):
+    if project_description:
+        app_builder = ApplicationBuilder()
+        app_builder.build_application(project_description)
+    else:
+        st.write("Please enter a project description.")
+
+# Display information about the agents
+st.sidebar.title("Agent Information")
+app_builder = ApplicationBuilder()
+for agent in app_builder.agents:
+    st.sidebar.write(f"--- {agent.name} ---")
+    st.sidebar.write(f"Role: {agent.role}")
+    st.sidebar.write("Tools:")
+    for tool in agent.tools:
+        st.sidebar.write(f"- {tool.name}")
+    st.sidebar.write("")