neuroagent 1.3.0

package/neuroagent/memory/vector_memory.py

@@ -0,0 +1,57 @@
+from typing import List, Dict, Any, Optional
+from datetime import datetime
+import numpy as np
+
+
+class VectorMemory:
+    def __init__(self, embedding_dim: int = 1536):
+        self.embedding_dim = embedding_dim
+        self._embeddings: List[np.ndarray] = []
+        self._memory: List[Dict[str, Any]] = []
+    
+    def _create_embedding(self, text: str) -> np.ndarray:
+        hash_val = hash(text)
+        np.random.seed(hash_val % (2**32))
+        return np.random.randn(self.embedding_dim)
+    
+    def _cosine_similarity(self, a: np.ndarray, b: np.ndarray) -> float:
+        dot_product = np.dot(a, b)
+        norm_a = np.linalg.norm(a)
+        norm_b = np.linalg.norm(b)
+        if norm_a == 0 or norm_b == 0:
+            return 0.0
+        return float(dot_product / (norm_a * norm_b))
+    
+    def save(self, content: str, metadata: Optional[Dict[str, Any]] = None):
+        embedding = self._create_embedding(content)
+        entry = {
+            "content": content,
+            "timestamp": datetime.now().isoformat(),
+            "metadata": metadata or {}
+        }
+        self._embeddings.append(embedding)
+        self._memory.append(entry)
+    
+    def search(self, query: str, top_k: int = 5) -> List[Dict[str, Any]]:
+        if not self._memory:
+            return []
+        
+        query_embedding = self._create_embedding(query)
+        similarities = [
+            self._cosine_similarity(query_embedding, emb)
+            for emb in self._embeddings
+        ]
+        
+        top_indices = np.argsort(similarities)[-top_k:][::-1]
+        
+        return [self._memory[i] for i in top_indices if similarities[i] > 0.1]
+    
+    def get_all(self) -> List[Dict[str, Any]]:
+        return self._memory
+    
+    def clear(self):
+        self._embeddings = []
+        self._memory = []
+    
+    def to_messages(self) -> List[Dict[str, str]]:
+        return [{"role": "system", "content": e["content"]} for e in self._memory[-5:]]

package/neuroagent/planner/__init__.py

@@ -0,0 +1,3 @@
+from neuroagent.planner.planner import Planner, Plan, Task
+
+__all__ = ["Planner", "Plan", "Task"]

package/neuroagent/planner/planner.py

@@ -0,0 +1,90 @@
+from typing import List, Dict, Any, Optional
+from pydantic import BaseModel
+
+
+class Task(BaseModel):
+    id: str
+    description: str
+    status: str = "pending"
+    result: Optional[Any] = None
+    subtasks: List["Task"] = []
+
+
+class Plan(BaseModel):
+    goal: str
+    tasks: List[Task]
+    current_task_index: int = 0
+
+
+class Planner:
+    def __init__(self, llm_provider=None):
+        self.llm_provider = llm_provider
+    
+    async def create_plan(self, goal: str, context: Optional[str] = None) -> Plan:
+        if self.llm_provider:
+            return await self._create_llm_plan(goal, context)
+        else:
+            return self._create_simple_plan(goal)
+    
+    async def _create_llm_plan(self, goal: str, context: Optional[str] = None) -> Plan:
+        prompt = f"""Create a detailed plan to accomplish the following goal:
+        
+Goal: {goal}
+
+{"Context: " + context if context else ""}
+
+Provide a list of tasks in this format:
+1. [Task description]
+2. [Task description]
+3. [Task description]
+"""
+
+        from neuroagent.llm.base import Message
+        response = await self.llm_provider.complete(
+            prompt=prompt,
+            max_tokens=500
+        )
+        
+        tasks = self._parse_tasks(response.content, goal)
+        return Plan(goal=goal, tasks=tasks)
+    
+    def _create_simple_plan(self, goal: str) -> Plan:
+        tasks = [
+            Task(id="1", description=f"Analyze goal: {goal}"),
+            Task(id="2", description="Break down into subtasks"),
+            Task(id="3", description="Execute subtasks"),
+            Task(id="4", description="Review and finalize results")
+        ]
+        return Plan(goal=goal, tasks=tasks)
+    
+    def _parse_tasks(self, response: str, goal: str) -> List[Task]:
+        lines = response.strip().split("\n")
+        tasks = []
+        
+        for i, line in enumerate(lines):
+            line = line.strip()
+            if line and (line[0].isdigit() or line.startswith("-")):
+                task_desc = line.lstrip("0123456789.-) ").strip()
+                if task_desc:
+                    tasks.append(Task(id=str(i + 1), description=task_desc))
+        
+        if not tasks:
+            tasks = [Task(id="1", description=goal)]
+        
+        return tasks
+    
+    def get_next_task(self, plan: Plan) -> Optional[Task]:
+        if plan.current_task_index < len(plan.tasks):
+            return plan.tasks[plan.current_task_index]
+        return None
+    
+    def complete_task(self, plan: Plan, task_id: str, result: Any) -> None:
+        for task in plan.tasks:
+            if task.id == task_id:
+                task.status = "completed"
+                task.result = result
+        
+        plan.current_task_index += 1
+    
+    def is_complete(self, plan: Plan) -> bool:
+        return all(task.status == "completed" for task in plan.tasks)

package/neuroagent/server/__init__.py

@@ -0,0 +1,16 @@
+from neuroagent.server.api_server import app, create_app
+from neuroagent.server.websocket_server import (
+    manager,
+    handle_websocket,
+    register_agent,
+    get_registered_agents
+)
+
+__all__ = [
+    "app",
+    "create_app",
+    "manager",
+    "handle_websocket",
+    "register_agent",
+    "get_registered_agents"
+]

package/neuroagent/server/api_server.py

@@ -0,0 +1,191 @@
+from typing import Dict, Any, Optional
+from pydantic import BaseModel
+from fastapi import FastAPI, HTTPException, WebSocket, WebSocketDisconnect
+from fastapi.middleware.cors import CORSMiddleware
+import asyncio
+
+from neuroagent.agents.agent import Agent
+from neuroagent.team.team import Team
+from neuroagent.llm.openai_provider import OpenAIProvider
+
+
+app = FastAPI(title="NeuroAgent API", version="0.1.0")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+_agents: Dict[str, Agent] = {}
+_teams: Dict[str, Team] = {}
+
+
+class AgentRequest(BaseModel):
+    agent: str
+    message: str
+    model: Optional[str] = "gpt-4"
+    temperature: Optional[float] = 0.7
+    max_tokens: Optional[int] = None
+
+
+class AgentCreateRequest(BaseModel):
+    name: str
+    goal: str
+    model: Optional[str] = "gpt-4"
+    api_key: Optional[str] = None
+    enable_planning: Optional[bool] = True
+    tools: Optional[list[str]] = None
+
+
+class TeamCreateRequest(BaseModel):
+    name: str
+    goal: str
+    model: Optional[str] = "gpt-4"
+    api_key: Optional[str] = None
+
+
+class TeamAddAgentRequest(BaseModel):
+    team: str
+    agent: str
+
+
+@app.get("/")
+async def root():
+    return {"message": "NeuroAgent API", "version": "0.1.0"}
+
+
+@app.get("/agents")
+async def list_agents():
+    return {"agents": list(_agents.keys())}
+
+
+@app.post("/agents")
+async def create_agent(request: AgentCreateRequest):
+    if request.name in _agents:
+        raise HTTPException(status_code=400, detail="Agent already exists")
+    
+    agent = Agent(
+        name=request.name,
+        goal=request.goal,
+        model=request.model,
+        api_key=request.api_key,
+        enable_planning=request.enable_planning
+    )
+    
+    if request.tools:
+        for tool in request.tools:
+            try:
+                agent.add_tool(tool)
+            except ValueError as e:
+                raise HTTPException(status_code=400, detail=str(e))
+    
+    _agents[request.name] = agent
+    
+    return {"message": f"Agent '{request.name}' created", "agent": request.name}
+
+
+@app.post("/agent/run")
+async def run_agent(request: AgentRequest):
+    if request.agent not in _agents:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    
+    agent = _agents[request.agent]
+    
+    if request.model:
+        agent.llm_provider.model = request.model
+    if request.temperature:
+        agent.temperature = request.temperature
+    if request.max_tokens:
+        agent.max_tokens = request.max_tokens
+    
+    result = await agent.run(request.message)
+    
+    return {"response": result, "agent": request.agent}
+
+
+@app.post("/agent/chat")
+async def chat_agent(request: AgentRequest):
+    if request.agent not in _agents:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    
+    agent = _agents[request.agent]
+    result = await agent.chat(request.message)
+    
+    return {"response": result, "agent": request.agent}
+
+
+@app.delete("/agents/{agent_name}")
+async def delete_agent(agent_name: str):
+    if agent_name not in _agents:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    
+    del _agents[agent_name]
+    return {"message": f"Agent '{agent_name}' deleted"}
+
+
+@app.get("/teams")
+async def list_teams():
+    return {"teams": list(_teams.keys())}
+
+
+@app.post("/teams")
+async def create_team(request: TeamCreateRequest):
+    if request.name in _teams:
+        raise HTTPException(status_code=400, detail="Team already exists")
+    
+    team = Team(
+        name=request.name,
+        goal=request.goal,
+        model=request.model,
+        api_key=request.api_key
+    )
+    
+    _teams[request.name] = team
+    
+    return {"message": f"Team '{request.name}' created", "team": request.name}
+
+
+@app.post("/teams/add-agent")
+async def add_agent_to_team(request: TeamAddAgentRequest):
+    if request.team not in _teams:
+        raise HTTPException(status_code=404, detail="Team not found")
+    if request.agent not in _agents:
+        raise HTTPException(status_code=404, detail="Agent not found")
+    
+    team = _teams[request.team]
+    agent = _agents[request.agent]
+    team.add_agent(agent)
+    
+    return {"message": f"Agent '{request.agent}' added to team '{request.team}'"}
+
+
+@app.post("/team/run")
+async def run_team(request: AgentRequest):
+    if request.agent not in _teams:
+        raise HTTPException(status_code=404, detail="Team not found")
+    
+    team = _teams[request.agent]
+    result = await team.run(request.message)
+    
+    return {"response": result, "team": request.agent}
+
+
+@app.delete("/teams/{team_name}")
+async def delete_team(team_name: str):
+    if team_name not in _teams:
+        raise HTTPException(status_code=404, detail="Team not found")
+    
+    del _teams[team_name]
+    return {"message": f"Team '{team_name}' deleted"}
+
+
+@app.get("/health")
+async def health_check():
+    return {"status": "healthy"}
+
+
+def create_app() -> FastAPI:
+    return app

package/neuroagent/server/websocket_server.py

@@ -0,0 +1,108 @@
+from typing import Dict, Set
+import asyncio
+import json
+from fastapi import WebSocket, WebSocketDisconnect
+
+from neuroagent.agents.agent import Agent
+
+
+class ConnectionManager:
+    def __init__(self):
+        self.active_connections: Dict[str, Set[WebSocket]] = {}
+    
+    async def connect(self, websocket: WebSocket, agent_name: str):
+        await websocket.accept()
+        if agent_name not in self.active_connections:
+            self.active_connections[agent_name] = set()
+        self.active_connections[agent_name].add(websocket)
+    
+    def disconnect(self, websocket: WebSocket, agent_name: str):
+        if agent_name in self.active_connections:
+            self.active_connections[agent_name].discard(websocket)
+    
+    async def send_message(self, message: str, agent_name: str):
+        if agent_name in self.active_connections:
+            for connection in self.active_connections[agent_name]:
+                try:
+                    await connection.send_text(message)
+                except:
+                    pass
+    
+    async def broadcast(self, message: str):
+        for agent_name, connections in self.active_connections.items():
+            for connection in connections:
+                try:
+                    await connection.send_text(message)
+                except:
+                    pass
+
+
+manager = ConnectionManager()
+
+_agents: Dict[str, Agent] = {}
+
+
+async def handle_websocket(websocket: WebSocket, agent_name: str):
+    await manager.connect(websocket, agent_name)
+    
+    if agent_name not in _agents:
+        await websocket.send_json({
+            "type": "error",
+            "message": f"Agent '{agent_name}' not found"
+        })
+        await websocket.close()
+        return
+    
+    agent = _agents[agent_name]
+    
+    try:
+        await websocket.send_json({
+            "type": "connected",
+            "message": f"Connected to agent {agent_name}",
+            "agent": agent_name,
+            "goal": agent.goal
+        })
+        
+        while True:
+            data = await websocket.receive_text()
+            
+            try:
+                message_data = json.loads(data)
+                message = message_data.get("message", "")
+                
+                if not message:
+                    await websocket.send_json({
+                        "type": "error",
+                        "message": "No message provided"
+                    })
+                    continue
+                
+                await websocket.send_json({
+                    "type": "thinking",
+                    "message": "Agent is thinking..."
+                })
+                
+                response = await agent.run(message)
+                
+                await websocket.send_json({
+                    "type": "response",
+                    "message": response,
+                    "agent": agent_name
+                })
+                
+            except json.JSONDecodeError:
+                await websocket.send_json({
+                    "type": "error",
+                    "message": "Invalid JSON"
+                })
+    
+    except WebSocketDisconnect:
+        manager.disconnect(websocket, agent_name)
+
+
+def register_agent(agent_name: str, agent: Agent):
+    _agents[agent_name] = agent
+
+
+def get_registered_agents() -> Dict[str, Agent]:
+    return _agents

package/neuroagent/team/__init__.py

@@ -0,0 +1,3 @@
+from neuroagent.team.team import Team
+
+__all__ = ["Team"]

package/neuroagent/team/team.py

@@ -0,0 +1,134 @@
+from typing import List, Dict, Any, Optional
+import asyncio
+
+from neuroagent.agents.agent import Agent
+from neuroagent.llm.base import LLMProvider, Message
+from neuroagent.llm.openai_provider import OpenAIProvider
+
+
+class Team:
+    def __init__(
+        self,
+        name: str = "Team",
+        goal: str = "Work together to accomplish complex tasks",
+        llm_provider: Optional[LLMProvider] = None,
+        model: str = "gpt-4",
+        api_key: Optional[str] = None,
+        coordination_enabled: bool = True
+    ):
+        self.name = name
+        self.goal = goal
+        self.coordination_enabled = coordination_enabled
+        self.llm_provider = llm_provider or OpenAIProvider(api_key=api_key, model=model)
+        
+        self._agents: Dict[str, Agent] = {}
+        self._agent_order: List[str] = []
+    
+    def add_agent(
+        self,
+        agent: Agent,
+        role: Optional[str] = None
+    ) -> None:
+        self._agents[agent.name] = agent
+        self._agent_order.append(agent.name)
+    
+    def get_agent(self, name: str) -> Optional[Agent]:
+        return self._agents.get(name)
+    
+    def remove_agent(self, name: str) -> None:
+        if name in self._agents:
+            del self._agents[name]
+            self._agent_order.remove(name)
+    
+    def list_agents(self) -> List[str]:
+        return list(self._agent_order)
+    
+    async def run(
+        self,
+        task: str,
+        max_rounds: int = 5,
+        parallel: bool = False
+    ) -> str:
+        if not self._agents:
+            return "Error: No agents in team"
+        
+        if parallel:
+            return await self._run_parallel(task, max_rounds)
+        else:
+            return await self._run_sequential(task, max_rounds)
+    
+    async def _run_sequential(self, task: str, max_rounds: int) -> str:
+        context = f"Original task: {task}\n\n"
+        
+        for round_num in range(max_rounds):
+            round_results = []
+            
+            for agent_name in self._agent_order:
+                agent = self._agents[agent_name]
+                agent_context = f"{context}\n\nOther agents' work:\n{round_results[-3:]}\n\nYour task: {task}"
+                
+                result = await agent.run(agent_context, max_iterations=2)
+                round_results.append(f"{agent.name}: {result}")
+            
+            context += f"\nRound {round_num + 1}:\n" + "\n".join(round_results)
+            
+            if await self._check_completion(task, context):
+                break
+        
+        return await self._summarize_results(task, context)
+    
+    async def _run_parallel(self, task: str, max_rounds: int) -> str:
+        async def run_agent(agent: Agent):
+            return agent.name, await agent.run(task, max_iterations=2)
+        
+        results = await asyncio.gather(*[
+            run_agent(self._agents[name]) 
+            for name in self._agent_order
+        ])
+        
+        combined_results = "\n".join([f"{name}: {result}" for name, result in results])
+        
+        return await self._summarize_results(task, combined_results)
+    
+    async def _check_completion(self, task: str, context: str) -> bool:
+        if not self.llm_provider:
+            return True
+        
+        prompt = f"""Based on the following work, determine if the task is complete.
+
+Task: {task}
+
+Work done:
+{context}
+
+Is the task complete? Respond with just "YES" or "NO"."""
+
+        response = await self.llm_provider.complete(prompt, max_tokens=10)
+        return response.content.strip().upper() == "YES"
+    
+    async def _summarize_results(self, task: str, context: str) -> str:
+        if not self.llm_provider:
+            return context
+        
+        prompt = f"""Summarize the work done by the team to accomplish this task:
+
+Task: {task}
+
+Work completed:
+{context}
+
+Provide a clear summary of what was accomplished:"""
+
+        response = await self.llm_provider.complete(prompt, max_tokens=500)
+        return response.content
+    
+    async def broadcast(self, message: str) -> Dict[str, str]:
+        async def send_message(agent: Agent):
+            return agent.name, await agent.chat(message)
+        
+        results = await asyncio.gather(*[
+            send_message(self._agents[name]) 
+            for name in self._agent_order
+        ])
+        
+        return dict(results)

package/neuroagent/tools/__init__.py

@@ -0,0 +1,19 @@
+from neuroagent.tools.base import tool, Tool, FunctionTool
+from neuroagent.tools.web_search import WebSearchTool, web_search
+from neuroagent.tools.code_executor import CodeExecutorTool, code_executor
+from neuroagent.tools.file_manager import FileManagerTool, file_manager
+from neuroagent.tools.http_client import HTTPClientTool, http_client
+
+__all__ = [
+    "tool",
+    "Tool",
+    "FunctionTool",
+    "WebSearchTool",
+    "web_search",
+    "CodeExecutorTool",
+    "code_executor",
+    "FileManagerTool",
+    "file_manager",
+    "HTTPClientTool",
+    "http_client",
+]

package/neuroagent/tools/base.py

@@ -0,0 +1,45 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Optional, Callable
+from functools import wraps
+
+
+class Tool(ABC):
+    def __init__(self, name: str, description: str, func: Optional[Callable] = None):
+        self.name = name
+        self.description = description
+        self.func = func
+    
+    @abstractmethod
+    async def execute(self, *args, **kwargs) -> Any:
+        pass
+    
+    def __call__(self, *args, **kwargs):
+        return self.execute(*args, **kwargs)
+
+
+class FunctionTool(Tool):
+    def __init__(self, name: str, description: str, func: Callable):
+        super().__init__(name, description, func)
+        self._func = func
+    
+    async def execute(self, *args, **kwargs) -> Any:
+        if asyncio.iscoroutinefunction(self._func):
+            return await self._func(*args, **kwargs)
+        return self._func(*args, **kwargs)
+
+
+def tool(name: Optional[str] = None, description: str = ""):
+    def decorator(func: Callable) -> FunctionTool:
+        tool_name = name or func.__name__
+        tool_description = description or func.__doc__ or ""
+        
+        @wraps(func)
+        def sync_wrapper(*args, **kwargs):
+            return func(*args, **kwargs)
+        
+        return FunctionTool(tool_name, tool_description, sync_wrapper)
+    
+    return decorator
+
+
+import asyncio