Upload 10 files

README.md

@@ -1,39 +1,3 @@
-# Autonomous AI System
+# Autonomous AI App
 
-This is a self-improving AI system that can:
-- Search the web for information
-- Learn from new information
-- Generate and execute its own code
-- Diagnose and repair itself
-- Continuously improve its capabilities
-
-## Features
-
-1. **Goal-Oriented Processing**  
-   Enter any goal and the AI will create a plan to achieve it
-
-2. **Web Search Integration**  
-   Uses DuckDuckGo to research topics and gather information
-
-3. **Self-Coding Capability**  
-   Generates Python code to solve problems and executes it safely
-
-4. **Self-Diagnostic System**  
-   Regularly checks its own performance and identifies improvements
-
-5. **Continuous Learning**  
-   Maintains memory of all sessions for context-aware operations
-
-6. **Self-Repair Mechanism**  
-   Automatically fixes identified issues in its own systems
-
-7. **Snapshot System**  
-   Creates recoverable snapshots of system state
-
-## Setup Instructions
-
-1. Install Python 3.8 or higher
-
-2. Install requirements:
-```bash
-pip install -r requirements.txt
+This app includes a FastAPI backend, Gradio frontend, and a multi-agent LLM system with learning capabilities.

app.py

@@ -1,140 +1,83 @@
+from fastapi import FastAPI, Request, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel, constr
+from memory import add_to_memory, get_memory, get_summary
+from ctransformers import AutoModelForCausalLM
+from src.core.cognitive_engine import CognitiveEngine
+from src.agents.planner import plan_task
+from src.agents.executor import execute_step
+from src.agents.critic import review_result
+import uuid, time, logging
 import gradio as gr
-import uuid
-import json
-import logging
 import os
-from memory import MemoryManager
-from planner import Planner
-from executor import Executor
-from critic import Critic
-from cognitive_engine import CognitiveEngine
-from web_searcher import WebSearcher
-from hf_packager import HFSpacePackager
 
-# Initialize components
-memory = MemoryManager()
-planner = Planner()
-executor = Executor()
-critic = Critic()
-cog_engine = CognitiveEngine()
-web_searcher = WebSearcher()
-packager = HFSpacePackager()
+app = FastAPI()
+logging.basicConfig(filename="log.txt", level=logging.INFO)
 
-# Set up logging
-logging.basicConfig(filename='log.txt', level=logging.INFO,
-                    format='%(asctime)s - %(levelname)s - %(message)s')
+llm_model = AutoModelForCausalLM.from_pretrained(
+    "TheBloke/zephyr-7B-alpha-GGUF",
+    model_file="zephyr-7b-alpha.Q4_K_M.gguf",
+    model_type="llama",
+    max_new_tokens=256,
+    temperature=0.7
+)
+cognitive_engine = CognitiveEngine(llm_model)
 
-class AutonomousAgent:
-    def __init__(self):
-        self.state_file = "state.json"
-        self.load_state()
-        
-    def load_state(self):
-        try:
-            with open(self.state_file, 'r') as f:
-                self.state = json.load(f)
-        except (FileNotFoundError, json.JSONDecodeError):
-            self.state = {"sessions": {}}
-            self.save_state()
-    
-    def save_state(self):
-        with open(self.state_file, 'w') as f:
-            json.dump(self.state, f, indent=2)
-    
-    def process_goal(self, goal, session_id=None):
-        try:
-            if not session_id:
-                session_id = str(uuid.uuid4())
-                self.state["sessions"][session_id] = {"goal": goal, "status": "processing"}
-                memory.init_session(session_id)
-                self.save_state()
-            
-            # Add to memory
-            memory.add(session_id, "user_goal", goal)
-            
-            # Plan the task
-            plan = planner.plan_task(goal, memory.get(session_id))
-            memory.add(session_id, "plan", plan)
-            
-            # Execute plan
-            results = []
-            for step in plan:
-                if "research" in step.lower() or "search" in step.lower():
-                    # Perform web search
-                    search_query = step.split(":")[1].strip() if ":" in step else goal
-                    search_results = web_searcher.search(search_query)
-                    memory.add(session_id, f"search:{search_query}", search_results)
-                    results.append(f"🔍 Search results for '{search_query}':\n{search_results[:500]}...")
-                
-                elif "develop" in step.lower() or "code" in step.lower():
-                    # Generate and execute code
-                    code = cog_engine.generate_code(step, memory.get(session_id))
-                    execution_result = executor.execute_code(code)
-                    memory.add(session_id, "generated_code", code)
-                    memory.add(session_id, "execution_result", execution_result)
-                    
-                    # Review and improve
-                    review = critic.review(step, execution_result)
-                    memory.add(session_id, "review", review)
-                    
-                    if "error" in review.lower() or "improve" in review.lower():
-                        enhanced_code = cog_engine.improve_code(code, review)
-                        memory.add(session_id, "enhanced_code", enhanced_code)
-                        execution_result = executor.execute_code(enhanced_code)
-                        results.append(f"🛠️ Enhanced code execution:\n{execution_result}")
-                    else:
-                        results.append(f"✅ Code executed successfully:\n{execution_result}")
-                
-                elif "diagnose" in step.lower() or "check" in step.lower():
-                    # Self-diagnostic
-                    issues = cog_engine.identify_improvements(step)
-                    memory.add(session_id, "diagnosis", issues)
-                    
-                    if issues:
-                        fixes = cog_engine.generate_enhancements(issues)
-                        cog_engine.apply_enhancements(fixes)
-                        results.append(f"⚙️ System repaired: {', '.join(issues)}")
-                    else:
-                        results.append("✅ System health check passed")
-            
-            self.state["sessions"][session_id]["status"] = "completed"
-            self.save_state()
-            snapshot_url = packager.create_snapshot({
-                "session_id": session_id,
-                "memory": memory.get(session_id),
-                "results": results
-            })
-            return "\n\n".join(results), session_id, snapshot_url
-        
-        except Exception as e:
-            logging.error(f"Error processing goal: {str(e)}", exc_info=True)
-            # Attempt self-repair
-            issues = [f"Runtime error: {str(e)}"]
-            fixes = cog_engine.generate_enhancements(issues)
-            cog_engine.apply_enhancements(fixes)
-            return f"⚠️ Error occurred. Self-repair initiated: {str(e)}", session_id, ""
+class GenerateRequest(BaseModel):
+    prompt: constr(min_length=5, max_length=1000)
+    session_id: constr(min_length=3, max_length=50)
 
-# Gradio interface
-agent = AutonomousAgent()
+@app.get("/status")
+def status():
+    return {
+        "message": "✅ Autonomous AI API is live",
+        "routes": ["/status", "/generate?prompt=...", "/generate [POST]", "/memory/{session_id}", "/summary/{session_id}"]
+    }
 
-with gr.Blocks(css="style.css", title="Autonomous AI") as demo:
-    session_id = gr.State()
-    gr.Markdown("# 🤖 Autonomous AI System")
-    gr.Markdown("Enter a goal and the AI will research, plan, code, and self-improve to accomplish it.")
-    
-    with gr.Row():
-        goal_input = gr.Textbox(label="Your Goal", placeholder="Enter what you want to achieve...")
-        submit_btn = gr.Button("Execute Goal", variant="primary")
-    
-    output = gr.Textbox(label="Execution Results", interactive=False)
-    session_display = gr.Textbox(label="Session ID", interactive=False)
-    snapshot = gr.Textbox(label="Snapshot URL", interactive=False)
-    
-    submit_btn.click(
-        fn=agent.process_goal,
-        inputs=[goal_input, session_id],
-        outputs=[output, session_display, snapshot]
-    )
+@app.get("/generate")
+def generate(prompt: str):
+    return {"response": llm_model(prompt)}
+
+@app.post("/generate")
+def generate_post(data: GenerateRequest):
+    start = time.time()
+    try:
+        response = llm_model(data.prompt)
+        latency = round(time.time() - start, 2)
+        add_to_memory(data.session_id, data.prompt, response)
+        logging.info(f"[{data.session_id}] Prompt processed in {latency}s")
+        return {"session_id": data.session_id, "response": response, "latency": latency}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/memory/{session_id}")
+def session_memory(session_id: str):
+    return {"session_id": session_id, "history": get_memory(session_id)}
+
+@app.get("/summary/{session_id}")
+def memory_summary(session_id: str):
+    return {"session_id": session_id, "summary": get_summary(session_id)}
+
+def agent_interface(goal):
+    session_id = str(uuid.uuid4())[:8]
+    context = get_summary(session_id)
+    plan = plan_task(goal, context)
+    output = []
+    for step in plan:
+        result = execute_step(step)
+        review = review_result(step, result)
+        output.append(f"Step: {step}\nResult: {result}\nReview: {review}\n")
+    return "\n".join(output)
+
+with gr.Blocks() as demo:
+    with gr.Tab("Multi-Agent"):
+        inp = gr.Textbox(label="Task", placeholder="Describe your goal")
+        out = gr.Textbox(label="Agent Output")
+        btn = gr.Button("Run")
+        btn.click(agent_interface, inputs=[inp], outputs=[out])
+
+gr.mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":
-    demo.launch()
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

memory/__init__.py

@@ -0,0 +1,3 @@
+def add_to_memory(sid, prompt, response): pass
+def get_memory(sid): return []
+def get_summary(sid): return 'Summary not implemented.'

requirements.txt

@@ -1,10 +1,5 @@
 fastapi
 uvicorn
-ctransformers
 gradio
-psutil
-sentence-transformers
-faiss-cpu
-duckduckgo-search
-requests
-python-dotenv
+pydantic
+ctransformers

src/agents/critic.py

@@ -1,2 +1 @@
-def review_result(step, result):
-    return f"Review passed for step: {step}"
+def review_result(step, result): return f"Review OK for {step}"

src/agents/executor.py

@@ -1,2 +1 @@
-def execute_step(step):
-    return f"Executed: {step} (simulated)"
+def execute_step(step): return f"Executed {step}"

src/agents/planner.py

@@ -1,2 +1 @@
-def plan_task(goal, memory):
-    return [f"Analyze: {goal}", "Generate code", "Review & validate"]
+def plan_task(goal, context): return [f"Plan for {goal}"]

src/core/cognitive_engine.py

@@ -1,4 +1,3 @@
 class CognitiveEngine:
-    def identify_improvements(self, task): return ['Fix bug']
-    def generate_enhancements(self, targets): return 'def fix(): pass'
-    def apply_enhancements(self, code): return True
+    def __init__(self, model=None): self.model = model
+    def learn(self, *args): return 'Learning completed.'