neuroagent 1.3.0

package/neuroagent/agents/agent.py

@@ -0,0 +1,253 @@
+from typing import List, Dict, Any, Optional, Callable
+import asyncio
+
+from neuroagent.llm.base import LLMProvider, Message
+from neuroagent.llm.openai_provider import OpenAIProvider
+from neuroagent.memory.short_memory import ShortMemory
+from neuroagent.memory.long_memory import LongMemory
+from neuroagent.memory.vector_memory import VectorMemory
+from neuroagent.planner.planner import Planner, Plan
+from neuroagent.tools.base import Tool, FunctionTool
+
+
+class Agent:
+    def __init__(
+        self,
+        name: str,
+        goal: str,
+        llm_provider: Optional[LLMProvider] = None,
+        model: str = "gpt-4",
+        api_key: Optional[str] = None,
+        temperature: float = 0.7,
+        max_tokens: Optional[int] = None,
+        enable_planning: bool = True,
+        enable_short_memory: bool = True,
+        enable_long_memory: bool = False,
+        enable_vector_memory: bool = False,
+        tools: Optional[List[Tool]] = None
+    ):
+        self.name = name
+        self.goal = goal
+        self.temperature = temperature
+        self.max_tokens = max_tokens
+        self.enable_planning = enable_planning
+        
+        self.llm_provider = llm_provider or OpenAIProvider(api_key=api_key, model=model)
+        
+        self.short_memory = ShortMemory() if enable_short_memory else None
+        self.long_memory = LongMemory() if enable_long_memory else None
+        self.vector_memory = VectorMemory() if enable_vector_memory else None
+        
+        self.planner = Planner(llm_provider=self.llm_provider) if enable_planning else None
+        self.current_plan: Optional[Plan] = None
+        
+        self._tools: Dict[str, Tool] = {}
+        if tools:
+            for tool in tools:
+                self._tools[tool.name] = tool
+    
+    def add_tool(self, tool_name: str) -> None:
+        tool_map = {
+            "web_search": "neuroagent.tools.web_search.WebSearchTool",
+            "code_executor": "neuroagent.tools.code_executor.CodeExecutorTool",
+            "file_manager": "neuroagent.tools.file_manager.FileManagerTool",
+            "http_client": "neuroagent.tools.http_client.HTTPClientTool",
+        }
+        
+        if tool_name in tool_map:
+            module_path = tool_map[tool_name]
+            parts = module_path.rsplit(".", 1)
+            import importlib
+            module = importlib.import_module(parts[0])
+            tool_class = getattr(module, parts[1])
+            self._tools[tool_name] = tool_class()
+        else:
+            raise ValueError(f"Unknown built-in tool: {tool_name}")
+    
+    def register_tool(self, tool: Tool) -> None:
+        self._tools[tool.name] = tool
+    
+    def tool(self, name: Optional[str] = None, description: str = ""):
+        def decorator(func: Callable) -> Callable:
+            tool_obj = FunctionTool(
+                name=name or func.__name__,
+                description=description or func.__doc__ or "",
+                func=func
+            )
+            self._tools[tool_obj.name] = tool_obj
+            return func
+        return decorator
+    
+    def _build_system_prompt(self) -> str:
+        prompt = f"""You are {self.name}, an AI agent.
+
+Your goal is: {self.goal}
+
+You have access to the following tools:
+"""
+        for tool_name, tool in self._tools.items():
+            prompt += f"- {tool_name}: {tool.description}\n"
+        
+        if self.current_plan:
+            prompt += f"\nCurrent plan:\n"
+            for i, task in enumerate(self.current_plan.tasks):
+                status = "✓" if task.status == "completed" else "○"
+                prompt += f"{status} {task.id}. {task.description}\n"
+        
+        return prompt
+    
+    def _get_memory_context(self) -> List[Message]:
+        messages = []
+        
+        if self.vector_memory:
+            messages.extend(self.vector_memory.to_messages())
+        
+        if self.long_memory:
+            messages.extend(self.long_memory.to_messages())
+        
+        if self.short_memory:
+            for entry in self.short_memory.get_recent(10):
+                messages.append(Message(role="user", content=entry["content"]))
+        
+        return messages
+    
+    async def _execute_tool(self, tool_name: str, args: str) -> str:
+        if tool_name not in self._tools:
+            return f"Error: Tool '{tool_name}' not found"
+        
+        tool = self._tools[tool_name]
+        
+        try:
+            result = await tool.execute(query=args)
+            return str(result)
+        except Exception as e:
+            return f"Error executing tool: {str(e)}"
+    
+    async def _decide_tool_use(self, prompt: str) -> Optional[tuple[str, str]]:
+        if not self._tools:
+            return None
+        
+        tool_descriptions = "\n".join([
+            f"{name}: {tool.description}" 
+            for name, tool in self._tools.items()
+        ])
+        
+        decision_prompt = f"""Should you use a tool to answer this user request?
+
+User request: {prompt}
+
+Available tools:
+{tool_descriptions}
+
+Respond in this format only:
+TOOL: <tool_name>
+ARGS: <arguments>
+
+If no tool is needed, respond:
+TOOL: none
+ARGS: none
+"""
+
+        from neuroagent.llm.base import Message
+        response = await self.llm_provider.complete(
+            prompt=decision_prompt,
+            max_tokens=100
+        )
+        
+        lines = response.content.strip().split("\n")
+        tool_name = ""
+        tool_args = ""
+        
+        for line in lines:
+            if line.startswith("TOOL:"):
+                tool_name = line.replace("TOOL:", "").strip()
+            elif line.startswith("ARGS:"):
+                tool_args = line.replace("ARGS:", "").strip()
+        
+        if tool_name and tool_name.lower() != "none":
+            return tool_name, tool_args
+        
+        return None
+    
+    async def run(self, prompt: str, max_iterations: int = 10) -> str:
+        self.short_memory.save(prompt, {"role": "user"})
+        
+        if self.enable_planning and self.planner:
+            self.current_plan = await self.planner.create_plan(prompt)
+        
+        iteration = 0
+        final_response = ""
+        
+        while iteration < max_iterations:
+            iteration += 1
+            
+            if self.current_plan and not self.planner.is_complete(self.current_plan):
+                task = self.planner.get_next_task(self.current_plan)
+                if task:
+                    task_prompt = f"{prompt}\n\nCurrent task: {task.description}"
+                    response = await self._process_input(task_prompt)
+                    self.planner.complete_task(self.current_plan, task.id, response)
+            else:
+                response = await self._process_input(prompt)
+                final_response = response
+                break
+        
+        self.short_memory.save(final_response, {"role": "assistant"})
+        
+        if self.long_memory:
+            self.long_memory.save(f"User: {prompt}\nAssistant: {final_response}")
+        
+        if self.vector_memory:
+            self.vector_memory.save(f"User: {prompt}\nAssistant: {final_response}")
+        
+        return final_response
+    
+    async def _process_input(self, prompt: str) -> str:
+        tool_use = await self._decide_tool_use(prompt)
+        
+        if tool_use:
+            tool_name, tool_args = tool_use
+            tool_result = await self._execute_tool(tool_name, tool_args)
+            
+            context_prompt = f"""User request: {prompt}
+
+Tool '{tool_name}' result: {tool_result}
+
+Based on the tool result, provide a helpful response to the user.
+"""
+            
+            memory_context = self._get_memory_context()
+            messages = [Message(role="system", content=self._build_system_prompt())]
+            messages.extend(memory_context)
+            messages.append(Message(role="user", content=context_prompt))
+            
+            response = await self.llm_provider.chat(messages, temperature=self.temperature, max_tokens=self.max_tokens)
+            return response.content
+        
+        messages = [Message(role="system", content=self._build_system_prompt())]
+        messages.extend(self._get_memory_context())
+        messages.append(Message(role="user", content=prompt))
+        
+        response = await self.llm_provider.chat(messages, temperature=self.temperature, max_tokens=self.max_tokens)
+        return response.content
+    
+    def memory(self, type: str = "short") -> Any:
+        if type == "short":
+            return self.short_memory
+        elif type == "long":
+            return self.long_memory
+        elif type == "vector":
+            return self.vector_memory
+        else:
+            raise ValueError(f"Unknown memory type: {type}")
+    
+    def save_memory(self, content: str, memory_type: str = "short") -> None:
+        if memory_type == "short" and self.short_memory:
+            self.short_memory.save(content)
+        elif memory_type == "long" and self.long_memory:
+            self.long_memory.save(content)
+        elif memory_type == "vector" and self.vector_memory:
+            self.vector_memory.save(content)
+    
+    async def chat(self, message: str) -> str:
+        return await self.run(message, max_iterations=1)

package/neuroagent/cli/__init__.py

@@ -0,0 +1,3 @@
+from neuroagent.cli.neuroagent_cli import cli, main
+
+__all__ = ["cli", "main"]

package/neuroagent/cli/neuroagent_cli.py

@@ -0,0 +1,182 @@
+import click
+import os
+import sys
+import asyncio
+import json
+from pathlib import Path
+
+
+@click.group()
+@click.version_option(version="0.1.0")
+def cli():
+    """NeuroAgent - AI Agent Framework"""
+    pass
+
+
+@cli.command()
+@click.argument("project_name")
+def init(project_name):
+    """Initialize a new NeuroAgent project"""
+    project_path = Path(project_name)
+    
+    if project_path.exists() and any(project_path.iterdir()):
+        click.echo(f"Error: Directory '{project_name}' is not empty", err=True)
+        sys.exit(1)
+    
+    project_path.mkdir(parents=True, exist_ok=True)
+    
+    files = {
+        "main.py": '''"""NeuroAgent Project"""
+from neuroagent import Agent
+
+agent = Agent(
+    name="MyAgent",
+    goal="Your agent goal here"
+)
+
+if __name__ == "__main__":
+    result = asyncio.run(agent.run("Hello, world!"))
+    print(result)
+''',
+        "agents.py": '''"""Define your agents here"""
+from neuroagent import Agent
+
+def create_support_agent():
+    return Agent(
+        name="SupportAgent",
+        goal="Help users with their questions"
+    )
+
+def create_coder_agent():
+    return Agent(
+        name="CoderAgent", 
+        goal="Write code and help with programming"
+    )
+''',
+        "tools.py": '''"""Custom tools for your agents"""
+from neuroagent.tools import tool
+
+@tool(name="my_custom_tool", description="Description of what this tool does")
+def my_custom_tool(param: str):
+    """Your custom tool implementation"""
+    return f"Result: {param}"
+''',
+        ".env": '''# Environment variables
+OPENAI_API_KEY=your-api-key-here
+''',
+        "requirements.txt": """neuroagent>=0.1.0
+python-dotenv>=1.0.0
+""",
+        "README.md": f"""# {project_name}
+
+NeuroAgent project
+
+## Setup
+
+1. Install dependencies:
+   pip install -r requirements.txt
+
+2. Configure environment variables in .env
+
+3. Run:
+   python main.py
+"""
+    }
+    
+    for filename, content in files.items():
+        file_path = project_path / filename
+        with open(file_path, "w") as f:
+            f.write(content)
+    
+    click.echo(f"Project '{project_name}' created successfully!")
+    click.echo(f"\nNext steps:")
+    click.echo(f"  cd {project_name}")
+    click.echo(f"  pip install -r requirements.txt")
+    click.echo(f"  python main.py")
+
+
+@cli.command()
+@click.argument("agent_name")
+@click.option("--goal", "-g", default="", help="Agent goal")
+@click.option("--model", "-m", default="gpt-4", help="Model to use")
+def create_agent(agent_name, goal, model):
+    """Create a new agent configuration"""
+    if not goal:
+        goal = click.prompt("Enter agent goal: ")
+    
+    agent_config = {
+        "name": agent_name,
+        "goal": goal,
+        "model": model
+    }
+    
+    config_path = Path("agents") / f"{agent_name}.json"
+    config_path.parent.mkdir(exist_ok=True)
+    
+    with open(config_path, "w") as f:
+        json.dump(agent_config, f, indent=2)
+    
+    click.echo(f"Agent '{agent_name}' created!")
+
+
+@cli.command()
+@click.argument("agent_name")
+@click.option("--message", "-m", default="Hello", help="Message to send")
+def run(agent_name, message):
+    """Run an agent"""
+    click.echo(f"Running agent '{agent_name}' with message: {message}")
+    click.echo("(This requires the agent to be registered in the server)")
+
+
+@cli.command()
+@click.option("--host", "-h", default="0.0.0.0", help="Host to bind to")
+@click.option("--port", "-p", default=8000, help="Port to bind to")
+@click.option("--reload", "-r", is_flag=True, help="Enable auto-reload")
+def start_server(host, port, reload):
+    """Start the NeuroAgent API server"""
+    import uvicorn
+    from neuroagent.server.api_server import app
+    
+    click.echo(f"Starting NeuroAgent server on {host}:{port}")
+    
+    uvicorn.run(
+        "neuroagent.server.api_server:app",
+        host=host,
+        port=port,
+        reload=reload
+    )
+
+
+@cli.command()
+@click.option("--host", "-h", default="0.0.0.0", help="Host to bind to")
+@click.option("--port", "-p", default=8001, help="Port to bind to")
+def start_websocket(host, port):
+    """Start the NeuroAgent WebSocket server"""
+    import uvicorn
+    from neuroagent.server import websocket_server
+    
+    click.echo(f"Starting WebSocket server on {host}:{port}")
+    
+    async def ws_app():
+        while True:
+            await asyncio.sleep(1)
+    
+    uvicorn.run(ws_app, host=host, port=port)
+
+
+@cli.command()
+def list_agents():
+    """List all available agents"""
+    click.echo("Available built-in tools:")
+    click.echo("  - web_search")
+    click.echo("  - code_executor")
+    click.echo("  - file_manager")
+    click.echo("  - http_client")
+
+
+def main():
+    cli()
+
+
+if __name__ == "__main__":
+    main()

package/neuroagent/examples/__init__.py

@@ -0,0 +1 @@
+# Examples module

package/neuroagent/examples/dev_agent.py

@@ -0,0 +1,31 @@
+"""Developer Agent Example"""
+import asyncio
+from neuroagent import Agent
+
+
+async def main():
+    coder = Agent(
+        name="CoderAI",
+        goal="Create applications, write code, and help with programming tasks",
+        model="gpt-4"
+    )
+    
+    coder.add_tool("code_executor")
+    coder.add_tool("file_manager")
+    coder.add_tool("web_search")
+    
+    print("CoderAI - Ready to help with coding tasks!\n")
+    
+    tasks = [
+        "Write a Python function to calculate fibonacci numbers",
+        "What is the best way to learn React?",
+    ]
+    
+    for task in tasks:
+        print(f"\nTask: {task}")
+        result = await coder.run(task)
+        print(f"Result:\n{result}\n")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/neuroagent/examples/multi_agent_team.py

@@ -0,0 +1,45 @@
+"""Multi-Agent Team Example"""
+import asyncio
+from neuroagent import Agent, Team
+
+
+async def main():
+    research_agent = Agent(
+        name="ResearchAgent",
+        goal="Research topics and gather information"
+    )
+    research_agent.add_tool("web_search")
+    
+    dev_agent = Agent(
+        name="DevAgent",
+        goal="Write code and create applications"
+    )
+    dev_agent.add_tool("code_executor")
+    dev_agent.add_tool("file_manager")
+    
+    deploy_agent = Agent(
+        name="DeployAgent",
+        goal="Deploy applications and manage infrastructure"
+    )
+    deploy_agent.add_tool("http_client")
+    
+    team = Team(
+        name="SaaSTeam",
+        goal="Create and deploy complete SaaS applications"
+    )
+    
+    team.add_agent(research_agent, role="research")
+    team.add_agent(dev_agent, role="development")
+    team.add_agent(deploy_agent, role="deployment")
+    
+    print("SaaS Team assembled!\n")
+    
+    task = "Create a simple task management app"
+    print(f"Task: {task}\n")
+    
+    result = await team.run(task, max_rounds=3)
+    print(f"Final Result:\n{result}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/neuroagent/examples/website_agent.py

@@ -0,0 +1,27 @@
+"""Website Assistant Example"""
+import asyncio
+from neuroagent import Agent
+
+
+async def main():
+    assistant = Agent(
+        name="WebsiteAssistant",
+        goal="Help users of the website with their questions and provide information"
+    )
+    
+    assistant.add_tool("web_search")
+    
+    questions = [
+        "What is NeuroAgent?",
+        "How do I install it?",
+        "Can you help me create an agent?"
+    ]
+    
+    for question in questions:
+        print(f"\nUser: {question}")
+        response = await assistant.chat(question)
+        print(f"Assistant: {response}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

package/neuroagent/frontend/__init__.py

@@ -0,0 +1 @@
+# Frontend module