Spaces:

Leonydis137
/

Autonomous-AI

Runtime error

Leonydis137 commited on Jun 26

Commit

f1e84da

verified ·

1 Parent(s): f277a38

Upload 9 files

Files changed (8) hide show

.huggingface.yaml ADDED Viewed

+sdk: gradio
+sdk_version: 3.50.2
+app_file: app.py

README.md CHANGED Viewed

@@ -1,21 +1,13 @@
----
-license: mit
-sdk: gradio
-sdk_version: 4.44.1
----
-# Multi-Agent Autonomous AI
-This is a multi-agent AI system designed to self-plan, execute, and reflect on tasks. It uses:
-- **Planner**: Breaks goals into subtasks.
-- **Executor**: Performs tasks.
-- **Critic**: Reviews and reflects.
-- **Memory**: FAISS vector storage.
-### Run on Hugging Face Spaces
-Ensure the following structure and that your Space is set to use `app.py`:
-To deploy:
-1. Upload the entire folder to a new Hugging Face Space (set to FastAPI + Gradio).
-2. That's it!!

+# 🧠 Multi-Agent Autonomous AI (Advanced)
+## Features
+- Planner, Executor, Critic agents
+- Contextual vector memory (FAISS)
+- JSON + log file memory
+- Timestamped, session-aware logging
+- Ready for Hugging Face Spaces
+## How to Use
+1. Create a Hugging Face Space (Gradio SDK)
+2. Upload this ZIP folder
+3. Done — `app.py` runs automatically

agents/critic.py CHANGED Viewed

@@ -1,6 +1,6 @@
 def review_result(step, result):
-    if "failed" in str(result).lower():
-        return f"Step '{step}' failed. Suggest retry or alternative."
-    elif result is None or result == "":
-        return f"Step '{step}' produced no output."
-    return f"Step '{step}' succeeded with output: {str(result)[:60]}"

 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]}"

agents/executor.py CHANGED Viewed

@@ -1,19 +1,21 @@
 import subprocess
 def execute_step(step):
-    if "create html" in step.lower():
-        return "<html><body>Hello World</body></html>"
-    elif "calculate" in step.lower():
         try:
-            expression = step.lower().replace("calculate", "").strip()
-            return eval(expression)
         except:
-            return "Calculation failed."
-    elif "python" in step.lower():
         try:
-            code = step.split("```python")[1].split("```")[0]
-            return subprocess.check_output(["python3", "-c", code], timeout=5).decode()
         except Exception as e:
-            return f"Python execution failed: {e}"
     else:
-        return "Unrecognized task."

 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/planner.py CHANGED Viewed

@@ -1,8 +1,16 @@
 def plan_task(goal, memory):
     if "website" in goal:
-        return [
-            "Create HTML structure",
-            "Add CSS styling",
-            "Test with sample data"
-        ]
-    return [f"Perform goal: {goal}"]

 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

memory.py CHANGED Viewed

@@ -1,17 +1,30 @@
 from sentence_transformers import SentenceTransformer
 import numpy as np
 import faiss
 model = SentenceTransformer("all-MiniLM-L6-v2")
 def init_memory():
     dim = 384
-    return {"index": faiss.IndexFlatL2(dim), "texts": []}
 def add_to_memory(text, memory):
     vec = model.encode([text])[0]
     memory["index"].add(np.array([vec]))
     memory["texts"].append(text)
 def search_memory(query, memory, k=5):
     vec = model.encode([query])[0]

 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]

orchestrator.py CHANGED Viewed

@@ -1,19 +1,35 @@
 from agents.planner import plan_task
 from agents.executor import execute_step
 from agents.critic import review_result
-from memory import add_to_memory
-def run_agents(goal, memory):
     plan = plan_task(goal, memory)
-    add_to_memory(f"Planner: {plan}", memory)
     outputs = []
     for step in plan:
         result = execute_step(step)
-        add_to_memory(f"Executor: {step} -> {result}", memory)
         review = review_result(step, result)
-        add_to_memory(f"Critic: {review}", memory)
-        outputs.append((step, result, review))
-    return outputs

 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
+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)

requirements.txt CHANGED Viewed

@@ -1,9 +1,6 @@
 fastapi
 uvicorn
-gradio==4.44.1
 faiss-cpu
 sentence-transformers
-numpy
-transformers
-torch
-accelerate

 fastapi
 uvicorn
+gradio
 faiss-cpu
 sentence-transformers
+numpy