Update app.py

app.py

@@ -1,36 +1,24 @@
 from fastapi import FastAPI
 import gradio as gr
-from orchestrator import run_agents
-from memory import init_memory
-
-app = FastAPI()
-memory = init_memory()
-
-def agent_interface(goal):
-    return run_agents(goal, memory)
-
-gr_interface = gr.Interface(
-    fn=agent_interface,
-    inputs=gr.Textbox(lines=2, placeholder="Describe your task...", label="Your Task"),
-    outputs=gr.Textbox(lines=20, label="Multi-Agent Output"),
-    title="🧠 Multi-Agent Autonomous AI System",
-    description="Planner → Executor → Critic | Contextual Memory | Logs | Expandable AI System"
-)
-
-gr.mount_gradio_app(app, gr_interface, path="/gradio")
-
-@app.get("/")
-def root():
-    return {"message": "Multi-Agent AI system with logging and memory."}
-''',
-
 from src.core.cognitive_engine import CognitiveEngine
 from src.utils.hf_packager import HFSpacePackager
-import gradio as gr
-import time
+from agents.planner import plan_task
+from agents.executor import execute_step
+from agents.critic import review_result
+from memory import init_memory, add_to_memory, search_memory
+import uuid
+from datetime import datetime
 import os
 import psutil
 import json
+import time
+import subprocess
+from sentence_transformers import SentenceTransformer
+import numpy as np
+import faiss
+
+app = FastAPI()
+memory = init_memory()
 
 # Initialize components
 cognitive_engine = CognitiveEngine()
@@ -78,6 +66,40 @@ def run_cycle(task_description):
             ""
         )
 
+# Multi-agent system
+def run_agents(goal, memory, session_id=None):
+    session_id = session_id or str(uuid.uuid4())[:8]
+    timestamp = datetime.now().isoformat(timespec="seconds")
+
+    log = f"[{timestamp}] Session {session_id}: Goal: {goal}\n"
+    history = search_memory(goal, memory)
+    context = "\n".join(history[:3]) if history else "No relevant memory found."
+
+    plan = plan_task(goal, memory)
+    add_to_memory(f"[{session_id}] 🧠 Context: {context}", memory)
+    add_to_memory(f"[{session_id}] 🗂 Plan: {plan}", memory)
+
+    outputs = []
+    for step in plan:
+        result = execute_step(step)
+        add_to_memory(f"[{session_id}] 🔧 Executor ran: {step} -> {result}", memory)
+
+        review = review_result(step, result)
+        add_to_memory(f"[{session_id}] 🔍 Critic: {review}", memory)
+
+        step_log = f"🔹 Step: {step}\n🛠 Result: {result}\n🧠 Review: {review}\n"
+        log += step_log + "\n"
+        outputs.append(step_log)
+
+    with open("log.txt", "a") as f:
+        f.write(log + "\n")
+
+    return "\n".join(outputs)
+
+# Agent interface
+def agent_interface(goal):
+    return run_agents(goal, memory)
+
 # Get system resources
 def get_resource_usage():
     return {
@@ -101,12 +123,40 @@ def submit_manual_code(code):
     except Exception as e:
         return f"⚠️ Error: {str(e)}", code
 
+# Create Gradio interface
 with gr.Blocks(css="static/style.css", theme=gr.themes.Soft()) as demo:
     knowledge = load_knowledge()
     
-    gr.Markdown("# 🤖 Interactive Autonomous AI System")
+    gr.Markdown("# 🤖 Multi-Agent Autonomous AI System")
+    
+    with gr.Tab("Multi-Agent Task"):
+        goal_input = gr.Textbox(
+            label="Describe your task", 
+            placeholder="What do you want to accomplish?",
+            lines=3
+        )
+        agent_output = gr.Textbox(
+            label="Multi-Agent Process", 
+            lines=10,
+            interactive=False
+        )
+        run_agents_btn = gr.Button("🚀 Run Agents", variant="primary")
+        
+        run_agents_btn.click(
+            agent_interface,
+            inputs=[goal_input],
+            outputs=[agent_output]
+        )
+        
+        gr.Markdown("### Agent Architecture")
+        gr.Markdown("""
+        - **🧠 Planner**: Creates task execution plan
+        - **🛠 Executor**: Carries out each step
+        - **🔍 Critic**: Reviews results and provides feedback
+        - **💾 Memory**: Maintains context-aware knowledge
+        """)
     
-    with gr.Tab("Task-Based Improvement"):
+    with gr.Tab("Cognitive Engine"):
         with gr.Row():
             with gr.Column():
                 task_input = gr.Textbox(
@@ -129,7 +179,7 @@ with gr.Blocks(css="static/style.css", theme=gr.themes.Soft()) as demo:
                     interactive=True
                 )
     
-    with gr.Tab("Manual Code Submission"):
+    with gr.Tab("Manual Code"):
         with gr.Row():
             with gr.Column():
                 manual_code = gr.Code(
@@ -155,10 +205,11 @@ with gr.Blocks(css="static/style.css", theme=gr.themes.Soft()) as demo:
             value=get_task_history(),
             interactive=False
         )
-        gr.Markdown("### Improvement Database")
-        knowledge_display = gr.JSON(
-            value={k: v for k, v in knowledge.items() if k != "solutions"},
-            label="System Knowledge"
+        gr.Markdown("### Memory Log")
+        memory_display = gr.Textbox(
+            label="Agent Memory",
+            value="\n".join(memory["texts"][-5:]),
+            interactive=False
         )
         refresh_knowledge = gr.Button("🔁 Refresh Knowledge")
     
@@ -186,152 +237,16 @@ with gr.Blocks(css="static/style.css", theme=gr.themes.Soft()) as demo:
     refresh_knowledge.click(
         lambda: load_knowledge(),
         inputs=[],
-        outputs=knowledge_display
+        outputs=task_history
     )
 
-if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        show_api=True
-    )
+# Mount Gradio app to FastAPI
+gr.mount_gradio_app(app, demo, path="/")
 
-    "orchestrator.py": '''
-from agents.planner import plan_task
-from agents.executor import execute_step
-from agents.critic import review_result
-from memory import add_to_memory, search_memory
-import uuid
-from datetime import datetime
+@app.get("/status")
+def status():
+    return {"status": "active", "agents": ["planner", "executor", "critic"]}
 
-def run_agents(goal, memory, session_id=None):
-    session_id = session_id or str(uuid.uuid4())[:8]
-    timestamp = datetime.now().isoformat(timespec="seconds")
-
-    log = f"[{timestamp}] Session {session_id}: Goal: {goal}\\n"
-    history = search_memory(goal, memory)
-    context = "\\n".join(history[:3]) if history else "No relevant memory found."
-
-    plan = plan_task(goal, memory)
-    add_to_memory(f"[{session_id}] 🧠 Context: {context}", memory)
-    add_to_memory(f"[{session_id}] 🗂 Plan: {plan}", memory)
-
-    outputs = []
-    for step in plan:
-        result = execute_step(step)
-        add_to_memory(f"[{session_id}] 🔧 Executor ran: {step} -> {result}", memory)
-
-        review = review_result(step, result)
-        add_to_memory(f"[{session_id}] 🔍 Critic: {review}", memory)
-
-        step_log = f"🔹 Step: {step}\\n🛠 Result: {result}\\n🧠 Review: {review}\\n"
-        log += step_log + "\\n"
-        outputs.append(step_log)
-
-    with open("log.txt", "a") as f:
-        f.write(log + "\\n")
-
-    return "\\n".join(outputs)
-''',
-
-    "memory.py": '''
-from sentence_transformers import SentenceTransformer
-import numpy as np
-import faiss
-import json
-import os
-
-model = SentenceTransformer("all-MiniLM-L6-v2")
-MEMORY_LOG = "memory_log.json"
-
-def init_memory():
-    dim = 384
-    index = faiss.IndexFlatL2(dim)
-    memory = {"index": index, "texts": []}
-    if os.path.exists(MEMORY_LOG):
-        with open(MEMORY_LOG, "r") as f:
-            memory["texts"] = json.load(f)
-        vectors = np.array([model.encode([text])[0] for text in memory["texts"]])
-        if len(vectors) > 0:
-            memory["index"].add(vectors)
-    return memory
-
-def add_to_memory(text, memory):
-    vec = model.encode([text])[0]
-    memory["index"].add(np.array([vec]))
-    memory["texts"].append(text)
-    with open(MEMORY_LOG, "w") as f:
-        json.dump(memory["texts"], f)
-
-def search_memory(query, memory, k=5):
-    vec = model.encode([query])[0]
-    D, I = memory["index"].search(np.array([vec]), k)
-    return [memory["texts"][i] for i in I[0] if i < len(memory["texts"])]
-''',
-
-    "agents/planner.py": '''
-def plan_task(goal, memory):
-    plan = []
-    if "website" in goal:
-        plan.extend([
-            "Create basic HTML structure",
-            "Add styling with CSS",
-            "Add interactivity with JavaScript",
-            "Review and test website"
-        ])
-    else:
-        plan.extend([
-            f"Understand the goal: {goal}",
-            "Find the best method to solve it",
-            "Execute and gather result"
-        ])
-    return plan
-''',
-
-    "agents/executor.py": '''
-import subprocess
-
-def execute_step(step):
-    step_lower = step.lower()
-    if "html" in step_lower:
-        return "<html><body>Hello Multi-Agent World!</body></html>"
-    elif "calculate" in step_lower:
-        try:
-            expression = step_lower.replace("calculate", "").strip()
-            return str(eval(expression))
-        except:
-            return "Calculation error."
-    elif "python" in step_lower or "code" in step_lower:
-        try:
-            code = step.split("```python")[1].split("```")[0] if "```python" in step else step
-            result = subprocess.check_output(["python3", "-c", code], stderr=subprocess.STDOUT, timeout=5)
-            return result.decode()
-        except Exception as e:
-            return f"Error running Python code: {e}"
-    else:
-        return f"No defined execution path for: {step}"
-''',
-
-    "agents/critic.py": '''
-def review_result(step, result):
-    if not result or "error" in result.lower():
-        return f"❌ Step failed or incomplete: {step}. Result: {result[:80]}"
-    if len(result) < 10:
-        return f"⚠️ Result seems too short for step: {step}."
-    return f"✅ Step successful. Result preview: {result[:80]}"
-''',
-
-    "requirements.txt": '''
-fastapi
-uvicorn
-gradio
-faiss-cpu
-sentence-transformers
-numpy
-''',
-
-    ".huggingface.yaml": '''
-sdk: gradio
-sdk_version: 3.50.2
-app_file: app.py
-''',
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)