updated agent

README.md

@@ -12,16 +12,124 @@ hf_oauth: true
 hf_oauth_expiration_minutes: 480
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# LangGraph Multi-Agent System with Langfuse v3 Observability
 
-To generate a `requirements.txt` file compatible with **Python 3.10** for deployment on a Hugging Face Space, run the following command:
+A sophisticated multi-agent system built with LangGraph that follows best practices for state management, tracing, and iterative workflows. Features comprehensive Langfuse v3 observability with OpenTelemetry integration.
+
+## Architecture Overview
+
+The system implements an iterative research/code loop with specialized agents:
+
+```
+User Query → Lead Agent → Research Agent → Code Agent → Lead Agent (loop) → Answer Formatter → Final Answer
+```
+
+## Key Features
+
+- **🤖 Multi-Agent Workflow**: Specialized agents for research, computation, and formatting
+- **📊 Langfuse v3 Observability**: Complete tracing with OTEL integration and predictable span naming
+- **🔄 Iterative Processing**: Intelligent routing between research and computational tasks
+- **🎯 GAIA Compliance**: Exact-match answer formatting for benchmark evaluation
+- **💾 Memory System**: Vector store integration for learning and caching
+- **🛠️ Tool Integration**: Web search, Wikipedia, ArXiv, calculations, and code execution
+
+## Quick Start
+
+### Environment Setup
+
+Create an `env.local` file with required API keys:
+
+```bash
+# LLM API
+GROQ_API_KEY=your_groq_api_key
+
+# Search Tools
+TAVILY_API_KEY=your_tavily_api_key
+
+# Observability (Langfuse v3)
+LANGFUSE_PUBLIC_KEY=your_langfuse_public_key
+LANGFUSE_SECRET_KEY=your_langfuse_secret_key
+LANGFUSE_HOST=https://cloud.langfuse.com
+
+# Memory (Optional)
+SUPABASE_URL=your_supabase_url
+SUPABASE_SERVICE_KEY=your_supabase_service_key
+```
+
+### Running the System
+
+**Important**: Use `uv run` for proper dependency management:
+
+```bash
+# Run the multi-agent system test
+uv run python test_new_multi_agent_system.py
+
+# Test Langfuse v3 observability
+uv run python test_observability.py
+
+# Run the main application
+uv run python app.py
+```
+
+### Basic Usage
+
+```python
+import asyncio
+from langgraph_agent_system import run_agent_system
+
+async def main():
+    result = await run_agent_system(
+        query="What is the capital of Maharashtra?",
+        user_id="user_123",
+        session_id="session_456"
+    )
+    print(f"Answer: {result}")
+
+asyncio.run(main())
+```
+
+## Observability Dashboard
+
+After running queries, check your traces at: **https://cloud.langfuse.com**
+
+The system provides:
+- 🎯 **Predictable Span Naming**: `agent/<role>`, `tool/<name>`, `llm/<model>`
+- 🔗 **Session Tracking**: User and session continuity across conversations  
+- 📈 **Cost & Latency Metrics**: Automatic aggregation by span type
+- 🌐 **OTEL Integration**: Automatic trace correlation across services
+
+## Deployment
+
+### For Hugging Face Spaces
+
+To generate a `requirements.txt` file compatible with **Python 3.10** for deployment:
 
 ```bash
 uv pip compile pyproject.toml --python 3.10 -o requirements.txt
 
+# Remove Windows-specific packages
 # Linux / macOS (bash)
 sed -i '/^pywin32==/d' requirements.txt
 
 # Windows (PowerShell)
 (Get-Content requirements.txt) -notmatch '^pywin32==' | Set-Content requirements.txt
-```
+```
+
+### Environment Variables for Production
+
+Set these in your deployment environment:
+- `GROQ_API_KEY` - Required for LLM inference
+- `TAVILY_API_KEY` - Required for web search
+- `LANGFUSE_PUBLIC_KEY` - Required for observability
+- `LANGFUSE_SECRET_KEY` - Required for observability
+- `LANGFUSE_HOST` - Langfuse endpoint (default: https://cloud.langfuse.com)
+
+## Documentation
+
+For detailed architecture, configuration, and usage instructions, see:
+- **[Multi-Agent System Guide](README_MULTI_AGENT_SYSTEM.md)** - Complete system documentation
+- **[Supabase Setup](README_SUPABASE.md)** - Memory system configuration
+
+## Configuration Reference
+
+Check out the Hugging Face Spaces configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

README_MULTI_AGENT_SYSTEM.md

@@ -0,0 +1,244 @@
+# LangGraph Multi-Agent System
+
+A sophisticated multi-agent system built with LangGraph that follows best practices for state management, tracing, and iterative workflows.
+
+## Architecture Overview
+
+The system implements an iterative research/code loop with specialized agents:
+
+```
+User Query → Lead Agent → Research Agent → Code Agent → Lead Agent (loop) → Answer Formatter → Final Answer
+```
+
+### Key Components
+
+1. **Lead Agent** (`agents/lead_agent.py`)
+   - Orchestrates the entire workflow
+   - Makes routing decisions between research and code agents
+   - Manages the iterative loop with a maximum of 3 iterations
+   - Synthesizes information from specialists into draft answers
+
+2. **Research Agent** (`agents/research_agent.py`)
+   - Handles information gathering from multiple sources
+   - Uses web search (Tavily), Wikipedia, and ArXiv tools
+   - Provides structured research results with citations
+
+3. **Code Agent** (`agents/code_agent.py`)
+   - Performs mathematical calculations and code execution
+   - Uses calculator tools for basic operations
+   - Executes Python code in a sandboxed environment
+   - Handles Hugging Face Hub statistics
+
+4. **Answer Formatter** (`agents/answer_formatter.py`)
+   - Ensures GAIA benchmark compliance
+   - Extracts final answers according to exact-match rules
+   - Handles different answer types (numbers, strings, lists)
+
+5. **Memory System** (`memory_system.py`)
+   - Vector store integration for long-term learning
+   - Session-based caching for performance
+   - Similar question retrieval for context
+
+## Core Features
+
+### State Management
+- **Immutable State**: Uses LangGraph's Command pattern for pure functions
+- **Typed Schema**: AgentState TypedDict ensures type safety
+- **Accumulation**: Research notes and code outputs accumulate across iterations
+
+### Observability (Langfuse v3)
+- **OTEL-Native Integration**: Uses Langfuse v3 with OpenTelemetry for automatic trace correlation
+- **Single Callback Handler**: One global handler passes traces seamlessly through LangGraph 
+- **Predictable Span Naming**: `agent/<role>`, `tool/<name>`, `llm/<model>` patterns for cost/latency dashboards
+- **Session Stitching**: User and session tracking for conversation continuity
+- **Background Flushing**: Non-blocking trace export for optimal performance
+
+### Tools Integration
+- **Web Search**: Tavily API for current information
+- **Knowledge Bases**: Wikipedia and ArXiv for encyclopedic/academic content
+- **Computation**: Calculator tools and Python execution
+- **Hub Statistics**: Hugging Face model information
+
+## Setup
+
+### Environment Variables
+Create an `env.local` file with:
+
+```bash
+# LLM API
+GROQ_API_KEY=your_groq_api_key
+
+# Search Tools
+TAVILY_API_KEY=your_tavily_api_key
+
+# Observability
+LANGFUSE_PUBLIC_KEY=your_langfuse_public_key
+LANGFUSE_SECRET_KEY=your_langfuse_secret_key
+LANGFUSE_HOST=https://cloud.langfuse.com
+
+# Memory (Optional)
+SUPABASE_URL=your_supabase_url
+SUPABASE_SERVICE_KEY=your_supabase_service_key
+```
+
+### Dependencies
+The system requires:
+- `langgraph>=0.4.8`
+- `langchain>=0.3.0`
+- `langchain-groq`
+- `langfuse>=3.0.0`
+- `python-dotenv`
+- `tavily-python`
+
+## Usage
+
+### Basic Usage
+
+```python
+import asyncio
+from langgraph_agent_system import run_agent_system
+
+async def main():
+    result = await run_agent_system(
+        query="What is the capital of Maharashtra?",
+        user_id="user_123",
+        session_id="session_456"
+    )
+    print(f"Answer: {result}")
+
+asyncio.run(main())
+```
+
+### Testing
+
+Run the test suite to verify functionality:
+
+```bash
+python test_new_multi_agent_system.py
+```
+
+Test Langfuse v3 observability integration:
+
+```bash
+python test_observability.py
+```
+
+### Direct Graph Access
+
+```python
+from langgraph_agent_system import create_agent_graph
+
+# Create and compile the workflow
+workflow = create_agent_graph()
+app = workflow.compile()
+
+# Run with initial state
+initial_state = {
+    "messages": [HumanMessage(content="Your question")],
+    "draft_answer": "",
+    "research_notes": "",
+    "code_outputs": "",
+    "loop_counter": 0,
+    "done": False,
+    "next": "research",
+    "final_answer": "",
+    "user_id": "user_123",
+    "session_id": "session_456"
+}
+
+final_state = await app.ainvoke(initial_state)
+print(final_state["final_answer"])
+```
+
+## Workflow Details
+
+### Iterative Loop
+1. **Lead Agent** analyzes the query and decides on next action
+2. If research needed → **Research Agent** gathers information
+3. If computation needed → **Code Agent** performs calculations
+4. Back to **Lead Agent** for synthesis and next decision
+5. When sufficient information → **Answer Formatter** creates final answer
+
+### Routing Logic
+The Lead Agent uses the following criteria:
+- **Research**: Factual information, current events, citations needed
+- **Code**: Mathematical calculations, data analysis, programming tasks
+- **Formatter**: Sufficient information gathered OR max iterations reached
+
+### GAIA Compliance
+The Answer Formatter ensures exact-match requirements:
+- **Numbers**: No commas, units, or extra symbols
+- **Strings**: Remove unnecessary articles and formatting
+- **Lists**: Comma and space separation
+- **No surrounding text**: No "Answer:", quotes, or brackets
+
+## Best Practices Implemented
+
+### LangGraph Patterns
+- ✅ Pure functions (AgentState → Command)
+- ✅ Immutable state with explicit updates
+- ✅ Typed state schema with operator annotations
+- ✅ Clear routing separated from business logic
+
+### Langfuse v3 Observability
+- ✅ OTEL-native SDK with automatic trace correlation
+- ✅ Single global callback handler for seamless LangGraph integration
+- ✅ Predictable span naming (`agent/<role>`, `tool/<name>`, `llm/<model>`)
+- ✅ Session and user tracking with environment tagging
+- ✅ Background trace flushing for performance
+- ✅ Graceful degradation when observability unavailable
+
+### Memory Management
+- ✅ TTL-based caching for performance
+- ✅ Vector store integration for learning
+- ✅ Duplicate detection and prevention
+- ✅ Session cleanup for long-running instances
+
+## Error Handling
+
+The system implements graceful degradation:
+- **Tool failures**: Continue with available tools
+- **API timeouts**: Retry with backoff
+- **Memory errors**: Degrade to LLM-only mode
+- **Agent failures**: Return informative error messages
+
+## Performance Considerations
+
+- **Caching**: Vector store searches cached for 5 minutes
+- **Parallelization**: Tools can be executed in parallel
+- **Memory limits**: Sandbox execution has resource constraints
+- **Loop termination**: Hard limit of 3 iterations prevents infinite loops
+
+## Extending the System
+
+### Adding New Agents
+1. Create agent file in `agents/` directory
+2. Implement agent function returning Command
+3. Add to workflow in `create_agent_graph()`
+4. Update routing logic in Lead Agent
+
+### Adding New Tools
+1. Implement tool following LangChain Tool interface
+2. Add to appropriate agent's tool list
+3. Update agent prompts to describe new capabilities
+
+### Custom Memory Backends
+1. Extend MemoryManager class
+2. Implement required interface methods
+3. Update initialization in memory_system.py
+
+## Troubleshooting
+
+### Common Issues
+- **Missing API keys**: Check env.local file setup
+- **Tool failures**: Verify network connectivity and API quotas
+- **Memory errors**: Check Supabase configuration (optional)
+- **Import errors**: Ensure all dependencies are installed
+
+### Debug Mode
+Set environment variable for detailed logging:
+```bash
+export LANGFUSE_DEBUG=true
+```
+
+This implementation follows the specified plan while incorporating LangGraph and Langfuse best practices for a robust, observable, and maintainable multi-agent system. 

agents/__init__.py

@@ -0,0 +1,21 @@
+"""
+Multi-Agent System Components
+
+This package contains the specialized agents for the LangGraph-based system:
+- LeadAgent: Orchestrates workflow and decision making
+- ResearchAgent: Information gathering and research tasks
+- CodeAgent: Computational and code execution tasks  
+- AnswerFormatter: Final answer formatting according to GAIA requirements
+"""
+
+from .lead_agent import lead_agent
+from .research_agent import research_agent
+from .code_agent import code_agent
+from .answer_formatter import answer_formatter
+
+__all__ = [
+    "lead_agent",
+    "research_agent", 
+    "code_agent",
+    "answer_formatter"
+] 

agents/answer_formatter.py

@@ -0,0 +1,243 @@
+"""
+Answer Formatter - Final answer formatting according to GAIA requirements
+
+The Answer Formatter is responsible for:
+1. Taking the draft answer and formatting it according to GAIA rules
+2. Extracting the final answer from comprehensive responses  
+3. Ensuring exact-match compliance
+4. Handling different answer types (numbers, strings, lists)
+"""
+
+import re
+from typing import Dict, Any
+from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage
+from langgraph.types import Command  
+from langchain_groq import ChatGroq
+from observability import agent_span
+from dotenv import load_dotenv
+
+load_dotenv("env.local")
+
+
+def extract_final_answer(text: str) -> str:
+    """
+    Extract the final answer from text following GAIA formatting rules.
+    
+    GAIA Rules:
+    • Single number → write the number only (no commas, units, or other symbols)  
+    • Single string/phrase → write the text only; omit articles and abbreviations unless explicitly required
+    • List → separate elements with a single comma and a space
+    • Never include surrounding text, quotes, brackets, or markdown
+    """
+    
+    if not text or not text.strip():
+        return ""
+    
+    # Clean the text
+    text = text.strip()
+    
+    # Look for explicit final answer markers
+    answer_patterns = [
+        r"final answer[:\s]*(.+?)(?:\n|$)",
+        r"answer[:\s]*(.+?)(?:\n|$)", 
+        r"result[:\s]*(.+?)(?:\n|$)",
+        r"conclusion[:\s]*(.+?)(?:\n|$)"
+    ]
+    
+    for pattern in answer_patterns:
+        match = re.search(pattern, text, re.IGNORECASE | re.MULTILINE)
+        if match:
+            text = match.group(1).strip()
+            break
+    
+    # Remove common prefixes/suffixes
+    prefixes_to_remove = [
+        "the answer is", "it is", "this is", "that is",
+        "final answer:", "answer:", "result:", "conclusion:",
+        "therefore", "thus", "so", "hence"
+    ]
+    
+    for prefix in prefixes_to_remove:
+        if text.lower().startswith(prefix.lower()):
+            text = text[len(prefix):].strip()
+    
+    # Remove quotes, brackets, and markdown
+    text = re.sub(r'^["\'\[\(]|["\'\]\)]$', '', text)
+    text = re.sub(r'^\*\*|\*\*$', '', text)  # Remove bold markdown
+    text = re.sub(r'^`|`$', '', text)  # Remove code markdown
+    
+    # Handle different answer types
+    
+    # Check if it's a pure number
+    number_match = re.match(r'^-?\d+(?:\.\d+)?$', text.strip())
+    if number_match:
+        # Return number without formatting
+        num = float(text.strip()) if '.' in text else int(text.strip())
+        return str(int(num)) if num == int(num) else str(num)
+    
+    # Check if it's a list (comma-separated)
+    if ',' in text:
+        items = [item.strip() for item in text.split(',')]
+        # Clean each item
+        cleaned_items = []
+        for item in items:
+            item = re.sub(r'^["\'\[\(]|["\'\]\)]$', '', item.strip())
+            if item:
+                cleaned_items.append(item)
+        return ', '.join(cleaned_items)
+    
+    # For single strings, remove articles if they're not essential
+    # But be careful not to remove essential parts
+    words = text.split()
+    if len(words) > 1 and words[0].lower() in ['the', 'a', 'an']:
+        # Only remove if the rest makes sense
+        remaining = ' '.join(words[1:])
+        if remaining and len(remaining) > 2:
+            text = remaining
+    
+    return text.strip()
+
+
+def load_formatter_prompt() -> str:
+    """Load the formatting prompt"""
+    try:
+        with open("archive/prompts/verification_prompt.txt", "r") as f:
+            return f.read()
+    except FileNotFoundError:
+        return """
+You are a final answer formatter ensuring compliance with GAIA benchmark requirements.
+
+Your task is to extract the precise final answer from a comprehensive response.
+
+CRITICAL FORMATTING RULES:
+• Single number → write the number only (no commas, units, or symbols)
+• Single string/phrase → write the text only; omit articles unless required  
+• List → separate elements with comma and space
+• NEVER include surrounding text like "Final Answer:", quotes, brackets, or markdown
+• The response must contain ONLY the answer itself
+
+Examples:
+Question: "What is 25 + 17?"  
+Draft: "After calculating, the answer is 42."
+Formatted: "42"
+
+Question: "What is the capital of France?"
+Draft: "The capital of France is Paris."  
+Formatted: "Paris"
+
+Question: "List the first 3 prime numbers"
+Draft: "The first three prime numbers are 2, 3, and 5."
+Formatted: "2, 3, 5"
+
+Extract ONLY the final answer following these rules exactly.
+"""
+
+
+def answer_formatter(state: Dict[str, Any]) -> Command:
+    """
+    Answer Formatter node that creates GAIA-compliant final answers.
+    
+    Takes the draft_answer and formats it according to GAIA requirements.
+    Returns Command to END the workflow.
+    """
+    
+    print("📝 Answer Formatter: Creating final formatted answer...")
+    
+    try:
+        # Get formatting prompt
+        formatter_prompt = load_formatter_prompt()
+        
+        # Initialize LLM for formatting
+        llm = ChatGroq(
+            model="llama-3.3-70b-versatile",
+            temperature=0.0,  # Zero temperature for consistent formatting
+            max_tokens=512
+        )
+        
+        # Create agent span for tracing
+        with agent_span(
+            "formatter",
+            metadata={
+                "draft_answer_length": len(state.get("draft_answer", "")),
+                "user_id": state.get("user_id", "unknown"),
+                "session_id": state.get("session_id", "unknown")
+            }
+        ) as span:
+            
+            # Get the draft answer
+            draft_answer = state.get("draft_answer", "")
+            
+            if not draft_answer:
+                final_answer = "No answer could be generated."
+            else:
+                # Get the original question for context
+                messages = state.get("messages", [])
+                user_query = ""
+                for msg in messages:
+                    if isinstance(msg, HumanMessage):
+                        user_query = msg.content
+                        break
+                
+                # Build formatting request
+                formatting_request = f"""
+Extract the final answer from this comprehensive response following GAIA formatting rules:
+
+Original Question: {user_query}
+
+Draft Response:
+{draft_answer}
+
+Instructions:
+1. Identify the core answer within the draft response
+2. Remove all explanatory text, prefixes, and formatting
+3. Apply GAIA formatting rules exactly
+4. Return ONLY the final answer
+
+What is the properly formatted final answer?
+"""
+                
+                # Create messages for formatting
+                formatting_messages = [
+                    SystemMessage(content=formatter_prompt),
+                    HumanMessage(content=formatting_request)
+                ]
+                
+                # Get formatted response
+                response = llm.invoke(formatting_messages)
+                
+                # Extract the final answer using our utility function
+                final_answer = extract_final_answer(response.content)
+                
+                # Fallback: if extraction fails, try direct extraction from draft
+                if not final_answer or len(final_answer) < 1:
+                    print("⚠️  LLM formatting failed, using direct extraction")
+                    final_answer = extract_final_answer(draft_answer)
+                
+                # Final fallback
+                if not final_answer:
+                    final_answer = "Unable to extract a clear answer."
+            
+            print(f"📝 Answer Formatter: Final answer = '{final_answer}'")
+            
+            # Update trace
+            if span:
+                span.update_trace(output={"final_answer": final_answer})
+            
+            # Return command to END the workflow
+            return Command(
+                goto="__end__",
+                update={
+                    "final_answer": final_answer
+                }
+            )
+            
+    except Exception as e:
+        print(f"❌ Answer Formatter Error: {e}")
+        
+        # Return error as final answer
+        return Command(
+            goto="__end__",
+            update={
+                "final_answer": f"Error formatting answer: {str(e)}"
+            }
+        ) 

agents/code_agent.py

@@ -0,0 +1,440 @@
+"""
+Code Agent - Computational tasks and code execution
+
+The Code Agent is responsible for:
+1. Performing mathematical calculations
+2. Executing Python code for data analysis
+3. Processing numerical data and computations
+4. Returning structured computational results
+"""
+
+import os
+import sys
+import io
+import contextlib
+from typing import Dict, Any, List
+from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage, AIMessage
+from langgraph.types import Command
+from langchain_groq import ChatGroq
+from langchain_core.tools import Tool
+from observability import agent_span, tool_span
+from dotenv import load_dotenv
+
+# Import calculator tools from the existing tools.py
+from tools import get_calculator_tool, get_hub_stats_tool
+
+load_dotenv("env.local")
+
+
+def create_code_tools() -> List[Tool]:
+    """Create LangChain-compatible computational tools"""
+    tools = []
+    
+    # Mathematical calculator tools
+    def multiply_func(a: float, b: float) -> str:
+        """Multiply two numbers"""
+        try:
+            result = a * b
+            return f"{a} × {b} = {result}"
+        except Exception as e:
+            return f"Error: {str(e)}"
+    
+    def add_func(a: float, b: float) -> str:
+        """Add two numbers"""
+        try:
+            result = a + b
+            return f"{a} + {b} = {result}"
+        except Exception as e:
+            return f"Error: {str(e)}"
+    
+    def subtract_func(a: float, b: float) -> str:
+        """Subtract two numbers"""
+        try:
+            result = a - b
+            return f"{a} - {b} = {result}"
+        except Exception as e:
+            return f"Error: {str(e)}"
+    
+    def divide_func(a: float, b: float) -> str:
+        """Divide two numbers"""
+        try:
+            if b == 0:
+                return "Error: Cannot divide by zero"
+            result = a / b
+            return f"{a} ÷ {b} = {result}"
+        except Exception as e:
+            return f"Error: {str(e)}"
+    
+    def modulus_func(a: int, b: int) -> str:
+        """Get the modulus of two numbers"""
+        try:
+            if b == 0:
+                return "Error: Cannot modulo by zero"
+            result = a % b
+            return f"{a} mod {b} = {result}"
+        except Exception as e:
+            return f"Error: {str(e)}"
+    
+    # Create calculator tools
+    calc_tools = [
+        Tool(name="multiply", description="Multiply two numbers. Use format: multiply(a, b)", func=lambda input_str: multiply_func(*map(float, input_str.split(',')))),
+        Tool(name="add", description="Add two numbers. Use format: add(a, b)", func=lambda input_str: add_func(*map(float, input_str.split(',')))),
+        Tool(name="subtract", description="Subtract two numbers. Use format: subtract(a, b)", func=lambda input_str: subtract_func(*map(float, input_str.split(',')))),
+        Tool(name="divide", description="Divide two numbers. Use format: divide(a, b)", func=lambda input_str: divide_func(*map(float, input_str.split(',')))),
+        Tool(name="modulus", description="Get modulus of two integers. Use format: modulus(a, b)", func=lambda input_str: modulus_func(*map(int, input_str.split(',')))),
+    ]
+    
+    tools.extend(calc_tools)
+    print(f"✅ Added {len(calc_tools)} calculator tools")
+    
+    # Hub stats tool
+    try:
+        from tools import get_hub_stats
+        
+        def hub_stats_func(author: str) -> str:
+            """Get Hugging Face Hub statistics for an author"""
+            try:
+                return get_hub_stats(author)
+            except Exception as e:
+                return f"Hub stats error: {str(e)}"
+        
+        hub_tool = Tool(
+            name="hub_stats",
+            description="Get statistics for Hugging Face Hub models by author",
+            func=hub_stats_func
+        )
+        tools.append(hub_tool)
+        print("✅ Added Hub stats tool")
+    except Exception as e:
+        print(f"⚠️  Could not load Hub stats tool: {e}")
+    
+    # Python execution tool
+    python_tool = create_python_execution_tool()
+    tools.append(python_tool)
+    print("✅ Added Python execution tool")
+    
+    print(f"🔧 Code Agent loaded {len(tools)} tools")
+    return tools
+
+
+def create_python_execution_tool() -> Tool:
+    """Create a tool for executing Python code safely"""
+    
+    def execute_python_code(code: str) -> str:
+        """
+        Execute Python code in a controlled environment.
+        
+        Args:
+            code: Python code to execute
+            
+        Returns:
+            String containing the output or error message
+        """
+        # Create a string buffer to capture output
+        output_buffer = io.StringIO()
+        error_buffer = io.StringIO()
+        
+        # Prepare a safe execution environment
+        safe_globals = {
+            '__builtins__': {
+                'print': lambda *args, **kwargs: print(*args, file=output_buffer, **kwargs),
+                'len': len,
+                'str': str,
+                'int': int,
+                'float': float,
+                'list': list,
+                'dict': dict,
+                'set': set,
+                'tuple': tuple,
+                'range': range,
+                'sum': sum,
+                'max': max,
+                'min': min,
+                'abs': abs,
+                'round': round,
+                'sorted': sorted,
+                'enumerate': enumerate,
+                'zip': zip,
+                'map': map,
+                'filter': filter,
+            }
+        }
+        
+        # Allow common safe modules
+        try:
+            import math
+            import statistics
+            import datetime
+            import json
+            import re
+            
+            safe_globals.update({
+                'math': math,
+                'statistics': statistics,
+                'datetime': datetime,
+                'json': json,
+                're': re,
+            })
+        except ImportError:
+            pass
+        
+        try:
+            # Execute the code
+            with contextlib.redirect_stdout(output_buffer), \
+                 contextlib.redirect_stderr(error_buffer):
+                exec(code, safe_globals)
+            
+            # Get the output
+            output = output_buffer.getvalue()
+            error = error_buffer.getvalue()
+            
+            if error:
+                return f"Error: {error}"
+            elif output:
+                return output.strip()
+            else:
+                return "Code executed successfully (no output)"
+                
+        except Exception as e:
+            return f"Execution error: {str(e)}"
+        finally:
+            output_buffer.close()
+            error_buffer.close()
+    
+    return Tool(
+        name="python_execution",
+        description="Execute Python code for calculations and data processing. Use for complex computations, data analysis, or when calculator tools are insufficient.",
+        func=execute_python_code
+    )
+
+
+def load_code_prompt() -> str:
+    """Load the code execution prompt"""
+    try:
+        with open("archive/prompts/execution_prompt.txt", "r") as f:
+            return f.read()
+    except FileNotFoundError:
+        return """
+You are a computational specialist focused on accurate calculations and code execution.
+
+Your goals:
+1. Perform mathematical calculations accurately
+2. Write and execute Python code for complex computations
+3. Process data and perform analysis as needed
+4. Provide clear, numerical results
+
+When handling computational tasks:
+- Use calculator tools for basic arithmetic operations
+- Use Python execution for complex calculations, data processing, or multi-step computations
+- Show your work and intermediate steps
+- Verify results when possible
+- Handle edge cases and potential errors
+
+Available tools:
+- Calculator tools: add, subtract, multiply, divide, modulus
+- Python execution: for complex computations and data analysis
+- Hub stats tool: for Hugging Face model information
+
+Format your response as:
+### Computational Analysis
+[Description of the approach]
+
+### Calculations
+[Step-by-step calculations or code]
+
+### Results
+[Final numerical results or outputs]
+"""
+
+
+def code_agent(state: Dict[str, Any]) -> Command:
+    """
+    Code Agent node that handles computational tasks and code execution.
+    
+    Returns Command with computational results appended to code_outputs.
+    """
+    
+    print("🧮 Code Agent: Processing computational tasks...")
+    
+    try:
+        # Get code execution prompt
+        code_prompt = load_code_prompt()
+        
+        # Initialize LLM with tools
+        llm = ChatGroq(
+            model="llama-3.3-70b-versatile",
+            temperature=0.1,  # Low temperature for accuracy in calculations
+            max_tokens=2048
+        )
+        
+        # Get computational tools
+        tools = create_code_tools()
+        
+        # Bind tools to LLM
+        llm_with_tools = llm.bind_tools(tools)
+        
+        # Create agent span for tracing
+        with agent_span(
+            "code",
+            metadata={
+                "tools_available": len(tools),
+                "research_context_length": len(state.get("research_notes", "")),
+                "user_id": state.get("user_id", "unknown"),
+                "session_id": state.get("session_id", "unknown")
+            }
+        ) as span:
+            
+            # Extract user query and research context
+            messages = state.get("messages", [])
+            user_query = ""
+            for msg in messages:
+                if isinstance(msg, HumanMessage):
+                    user_query = msg.content
+                    break
+            
+            research_notes = state.get("research_notes", "")
+            
+            # Build computational request
+            code_request = f"""
+Please analyze the following question and perform any necessary calculations or code execution:
+
+Question: {user_query}
+
+Research Context:
+{research_notes}
+
+Current computational work: {len(state.get('code_outputs', ''))} characters already completed
+
+Instructions:
+1. Identify any computational or mathematical aspects of the question
+2. Use appropriate tools for calculations or code execution
+3. Show your work and intermediate steps
+4. Provide clear, accurate results
+5. If no computation is needed, state that clearly
+
+Please perform all necessary calculations to help answer this question.
+"""
+            
+            # Create messages for code execution
+            code_messages = [
+                SystemMessage(content=code_prompt),
+                HumanMessage(content=code_request)
+            ]
+            
+            # Get computational response
+            response = llm_with_tools.invoke(code_messages)
+            
+            # Process the response - handle both tool calls and direct responses
+            computation_results = []
+            
+            # Check if the LLM wants to use tools
+            if hasattr(response, 'tool_calls') and response.tool_calls:
+                print(f"🛠️  Executing {len(response.tool_calls)} computational operations")
+                
+                # Execute tool calls and collect results
+                for tool_call in response.tool_calls:
+                    try:
+                        # Find the tool by name
+                        tool = next((t for t in tools if t.name == tool_call['name']), None)
+                        if tool:
+                            # Handle different argument formats
+                            args = tool_call.get('args', {})
+                            if isinstance(args, dict):
+                                # Convert dict args to string for simple tools
+                                if len(args) == 1:
+                                    arg_value = list(args.values())[0]
+                                else:
+                                    arg_value = ','.join(str(v) for v in args.values())
+                            else:
+                                arg_value = str(args)
+                            
+                            result = tool.func(arg_value)
+                            computation_results.append(f"**{tool.name}**: {result}")
+                        else:
+                            computation_results.append(f"**{tool_call['name']}**: Tool not found")
+                    except Exception as e:
+                        print(f"⚠️  Tool {tool_call.get('name', 'unknown')} failed: {e}")
+                        computation_results.append(f"**{tool_call.get('name', 'unknown')}**: Error - {str(e)}")
+            
+            # Compile computational results
+            if computation_results:
+                computational_findings = "\n\n".join(computation_results)
+            else:
+                # No tools used or tool calls failed, analyze if computation is needed
+                computational_findings = response.content if hasattr(response, 'content') else str(response)
+                
+                # If the response looks like it should have used tools but didn't, try direct calculation
+                if any(op in user_query.lower() for op in ['+', '-', '*', '/', 'calculate', 'compute', 'multiply', 'add', 'subtract', 'divide']):
+                    print("🔧 Attempting direct calculation...")
+                    
+                    # Try to extract and solve simple mathematical expressions
+                    import re
+                    
+                    # Look for simple math expressions
+                    math_patterns = [
+                        r'(\d+)\s*\+\s*(\d+)',  # addition
+                        r'(\d+)\s*\*\s*(\d+)',  # multiplication  
+                        r'(\d+)\s*-\s*(\d+)',   # subtraction
+                        r'(\d+)\s*/\s*(\d+)',   # division
+                    ]
+                    
+                    for pattern in math_patterns:
+                        matches = re.findall(pattern, user_query)
+                        if matches:
+                            for match in matches:
+                                a, b = int(match[0]), int(match[1])
+                                if '+' in user_query:
+                                    result = a + b
+                                    computational_findings += f"\n\nDirect calculation: {a} + {b} = {result}"
+                                elif '*' in user_query:
+                                    result = a * b
+                                    computational_findings += f"\n\nDirect calculation: {a} × {b} = {result}"
+                                elif '-' in user_query:
+                                    result = a - b
+                                    computational_findings += f"\n\nDirect calculation: {a} - {b} = {result}"
+                                elif '/' in user_query:
+                                    result = a / b
+                                    computational_findings += f"\n\nDirect calculation: {a} ÷ {b} = {result}"
+                            break
+            
+            # Format computational results
+            formatted_results = f"""
+### Computational Analysis {state.get('loop_counter', 0) + 1}
+
+{computational_findings}
+
+---
+"""
+            
+            print(f"🧮 Code Agent: Generated {len(formatted_results)} characters of computational results")
+            
+            # Update span with results if available
+            if span:
+                span.update_trace(metadata={
+                    "computation_length": len(formatted_results),
+                    "results_preview": formatted_results[:300] + "..."
+                })
+            
+            # Return command to go back to lead agent
+            return Command(
+                goto="lead",
+                update={
+                    "code_outputs": state.get("code_outputs", "") + formatted_results
+                }
+            )
+            
+    except Exception as e:
+        print(f"❌ Code Agent Error: {e}")
+        
+        # Return with error information
+        error_result = f"""
+### Computational Error
+An error occurred during code execution: {str(e)}
+
+"""
+        return Command(
+            goto="lead",
+            update={
+                "code_outputs": state.get("code_outputs", "") + error_result
+            }
+        ) 

agents/lead_agent.py

@@ -0,0 +1,243 @@
+"""
+Lead Agent - Orchestrates the multi-agent workflow
+
+The Lead Agent is responsible for:
+1. Analyzing user queries and determining next steps
+2. Managing the iterative research/code loop  
+3. Deciding when enough information has been gathered
+4. Coordinating between specialized agents
+5. Maintaining the overall workflow state
+"""
+
+import os
+from typing import Dict, Any, Literal
+from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage, AIMessage
+from langgraph.types import Command
+from langchain_groq import ChatGroq
+from observability import agent_span
+from dotenv import load_dotenv
+
+# Import memory system
+from memory_system import MemoryManager
+
+load_dotenv("env.local")
+
+# Initialize memory manager
+memory_manager = MemoryManager()
+
+def load_system_prompt() -> str:
+    """Load the system prompt for the lead agent"""
+    try:
+        with open("archive/prompts/system_prompt.txt", "r") as f:
+            base_prompt = f.read()
+        
+        lead_prompt = f"""
+{base_prompt}
+
+As the Lead Agent, you coordinate a team of specialists:
+- Research Agent: Gathers information from web, papers, and knowledge bases
+- Code Agent: Performs calculations and executes Python code
+
+Your responsibilities:
+1. Analyze the user's question to determine what information and computations are needed
+2. Decide whether to delegate to research, code, both, or proceed to final answer
+3. Synthesize results from specialists into a coherent draft answer
+4. Determine when sufficient information has been gathered
+
+Decision criteria:
+- If the question requires factual information, current events, or research → delegate to research
+- If the question requires calculations, data analysis, or code execution → delegate to code  
+- If you have sufficient information to answer → proceed to formatting
+- Maximum 3 iterations to prevent infinite loops
+
+Always maintain the exact formatting requirements specified in the system prompt.
+"""
+        return lead_prompt
+    except FileNotFoundError:
+        return """You are a helpful assistant coordinating a team of specialists to answer questions accurately."""
+
+
+def lead_agent(state: Dict[str, Any]) -> Command[Literal["research", "code", "formatter", "__end__"]]:
+    """
+    Lead Agent node that orchestrates the workflow.
+    
+    Makes decisions about:
+    - Whether more research is needed
+    - Whether code execution is needed  
+    - When to proceed to final formatting
+    - When the loop should terminate
+    
+    Returns Command with routing decision and state updates.
+    """
+    
+    loop_counter = state.get('loop_counter', 0)
+    max_iterations = state.get('max_iterations', 3)
+    
+    print(f"🎯 Lead Agent: Processing request (iteration {loop_counter})")
+    
+    # Check for termination conditions first
+    if loop_counter >= max_iterations:
+        print("🔄 Maximum iterations reached, proceeding to formatter")
+        return Command(
+            goto="formatter",
+            update={
+                "loop_counter": loop_counter + 1,
+                "next": "formatter"
+            }
+        )
+    
+    try:
+        # Get the system prompt
+        system_prompt = load_system_prompt()
+        
+        # Initialize LLM 
+        llm = ChatGroq(
+            model="llama-3.3-70b-versatile",  
+            temperature=0.1,  # Low temperature for consistent routing decisions
+            max_tokens=1024
+        )
+        
+        # Create agent span for tracing
+        with agent_span(
+            "lead",
+            metadata={
+                "loop_counter": loop_counter,
+                "research_notes_length": len(state.get("research_notes", "")),
+                "code_outputs_length": len(state.get("code_outputs", "")),
+                "user_id": state.get("user_id", "unknown"),
+                "session_id": state.get("session_id", "unknown")
+            }
+        ) as span:
+            
+            # Build context for decision making
+            messages = state.get("messages", [])
+            research_notes = state.get("research_notes", "")
+            code_outputs = state.get("code_outputs", "")
+            
+            # Get the original user query
+            user_query = ""
+            for msg in messages:
+                if isinstance(msg, HumanMessage):
+                    user_query = msg.content
+                    break
+            
+            # Check for similar questions in memory
+            similar_context = ""
+            if user_query:
+                try:
+                    similar_qa = memory_manager.get_similar_qa(user_query)
+                    if similar_qa:
+                        similar_context = f"\n\nSimilar previous Q&A:\n{similar_qa}"
+                except Exception as e:
+                    print(f"💾 Memory cache hit")  # Simplified message
+            
+            # Build decision prompt
+            decision_prompt = f"""
+Based on the user's question and current progress, decide the next action.
+
+Original Question: {user_query}
+
+Current Progress:
+- Loop iteration: {loop_counter}
+- Research gathered: {len(research_notes)} characters
+- Code outputs: {len(code_outputs)} characters
+
+Research Notes So Far:
+{research_notes if research_notes else "None yet"}
+
+Code Outputs So Far:  
+{code_outputs if code_outputs else "None yet"}
+
+{similar_context}
+
+Analyze what's still needed:
+1. Is factual information, current events, or research missing? → route to "research"
+2. Are calculations, data analysis, or code execution needed? → route to "code"  
+3. Do we have sufficient information to provide a complete answer? → route to "formatter"
+
+Respond with ONLY one of: research, code, formatter
+"""
+            
+            # Get decision from LLM
+            decision_messages = [
+                SystemMessage(content=system_prompt),
+                HumanMessage(content=decision_prompt)
+            ]
+            
+            response = llm.invoke(decision_messages)
+            decision = response.content.strip().lower()
+            
+            # Validate decision
+            valid_decisions = ["research", "code", "formatter"]
+            if decision not in valid_decisions:
+                print(f"⚠️  Invalid decision '{decision}', defaulting to 'research'")
+                decision = "research"
+            
+            # Prepare state updates
+            updates = {
+                "loop_counter": loop_counter + 1,
+                "next": decision
+            }
+            
+            # If we're done, create draft answer
+            if decision == "formatter":
+                # Create a comprehensive draft answer from gathered information
+                draft_prompt = f"""
+Create a comprehensive answer based on all gathered information:
+
+Original Question: {user_query}
+
+Research Information:
+{research_notes}
+
+Code Results:
+{code_outputs}
+
+Instructions:
+1. Synthesize all available information to answer the question
+2. If computational results are available, include them
+3. If research provides context, incorporate it
+4. Provide a clear, direct answer to the user's question
+5. Focus on accuracy and completeness
+
+What is your answer to the user's question?
+"""
+                
+                draft_messages = [
+                    SystemMessage(content=system_prompt),
+                    HumanMessage(content=draft_prompt)
+                ]
+                
+                try:
+                    draft_response = llm.invoke(draft_messages)
+                    draft_content = draft_response.content if hasattr(draft_response, 'content') else str(draft_response)
+                    updates["draft_answer"] = draft_content
+                    print(f"📝 Lead Agent: Created draft answer ({len(draft_content)} characters)")
+                except Exception as e:
+                    print(f"⚠️  Error creating draft answer: {e}")
+                    # Fallback - create a simple answer from available data
+                    fallback_answer = f"Based on the available information:\n\nResearch: {research_notes}\nCalculations: {code_outputs}"
+                    updates["draft_answer"] = fallback_answer
+            
+            # Log decision
+            print(f"🎯 Lead Agent Decision: {decision} (iteration {loop_counter + 1})")
+            
+            if span:
+                span.update_trace(output={"decision": decision, "updates": updates})
+            
+            return Command(
+                goto=decision,
+                update=updates
+            )
+            
+    except Exception as e:
+        print(f"❌ Lead Agent Error: {e}")
+        # On error, proceed to formatter with error message
+        return Command(
+            goto="formatter",
+            update={
+                "draft_answer": f"I encountered an error while processing your request: {str(e)}",
+                "loop_counter": loop_counter + 1,
+                "next": "formatter"
+            }
+        ) 

agents/research_agent.py

@@ -0,0 +1,295 @@
+"""
+Research Agent - Information gathering and research tasks
+
+The Research Agent is responsible for:
+1. Gathering information from multiple sources (web, Wikipedia, arXiv)
+2. Searching for relevant context and facts
+3. Compiling research results in a structured format
+4. Returning citations and source information
+"""
+
+import os
+from typing import Dict, Any, List
+from langchain_core.messages import BaseMessage, HumanMessage, SystemMessage, AIMessage
+from langgraph.types import Command
+from langchain_groq import ChatGroq
+from langchain_core.tools import Tool
+from observability import agent_span, tool_span
+from dotenv import load_dotenv
+
+# Import tools from the existing tools.py
+from tools import (
+    get_tavily_tool,
+    get_wikipedia_tool, 
+    get_arxiv_tool,
+    get_wikipedia_reader,
+    get_arxiv_reader
+)
+
+load_dotenv("env.local")
+
+
+def create_research_tools() -> List[Tool]:
+    """Create LangChain-compatible research tools"""
+    tools = []
+    
+    try:
+        # Import LlamaIndex tools and convert them
+        from tools import get_tavily_tool, get_wikipedia_tool, get_arxiv_tool
+        
+        # Tavily web search
+        try:
+            tavily_spec = get_tavily_tool()
+            if tavily_spec:
+                # Convert to LangChain tool
+                def tavily_search(query: str) -> str:
+                    try:
+                        tavily_tools = tavily_spec.to_tool_list()
+                        if tavily_tools:
+                            result = tavily_tools[0].call({"input": query})
+                            return str(result)
+                    except Exception as e:
+                        return f"Search error: {str(e)}"
+                    return "No search results found"
+                
+                tavily_tool = Tool(
+                    name="web_search",
+                    description="Search the web for current information and facts using Tavily API",
+                    func=tavily_search
+                )
+                tools.append(tavily_tool)
+                print(f"✅ Added Tavily web search tool")
+        except Exception as e:
+            print(f"⚠️  Could not load Tavily tools: {e}")
+        
+        # Wikipedia search
+        try:
+            wikipedia_tool = get_wikipedia_tool()
+            if wikipedia_tool:
+                def wikipedia_search(query: str) -> str:
+                    try:
+                        result = wikipedia_tool.call({"input": query})
+                        return str(result)
+                    except Exception as e:
+                        return f"Wikipedia search error: {str(e)}"
+                
+                wiki_tool = Tool(
+                    name="wikipedia_search",
+                    description="Search Wikipedia for encyclopedic information",
+                    func=wikipedia_search
+                )
+                tools.append(wiki_tool)
+                print("✅ Added Wikipedia tool")
+        except Exception as e:
+            print(f"⚠️  Could not load Wikipedia tool: {e}")
+        
+        # ArXiv search
+        try:
+            arxiv_tool = get_arxiv_tool()
+            if arxiv_tool:
+                def arxiv_search(query: str) -> str:
+                    try:
+                        result = arxiv_tool.call({"input": query})
+                        return str(result)
+                    except Exception as e:
+                        return f"ArXiv search error: {str(e)}"
+                
+                arxiv_lc_tool = Tool(
+                    name="arxiv_search",
+                    description="Search ArXiv for academic papers and research",
+                    func=arxiv_search
+                )
+                tools.append(arxiv_lc_tool)
+                print("✅ Added ArXiv tool")
+        except Exception as e:
+            print(f"⚠️  Could not load ArXiv tool: {e}")
+    
+    except Exception as e:
+        print(f"⚠️  Error setting up research tools: {e}")
+    
+    print(f"🔧 Research Agent loaded {len(tools)} tools")
+    return tools
+
+
+def load_research_prompt() -> str:
+    """Load the research-specific prompt"""
+    try:
+        with open("archive/prompts/retrieval_prompt.txt", "r") as f:
+            return f.read()
+    except FileNotFoundError:
+        return """
+You are a research specialist focused on gathering accurate information.
+
+Your goals:
+1. Search for factual, current, and relevant information
+2. Use multiple sources to verify facts
+3. Provide clear citations and sources
+4. Structure findings in an organized manner
+
+When researching:
+- Use web search for current information and facts
+- Use Wikipedia for encyclopedic knowledge  
+- Use ArXiv for academic and technical topics
+- Cross-reference information across sources
+- Note any conflicting information found
+
+Format your response as:
+### Research Results
+- **Source 1**: [findings]
+- **Source 2**: [findings]  
+- **Source 3**: [findings]
+
+### Key Facts
+- Fact 1
+- Fact 2
+- Fact 3
+
+### Citations
+- Citation 1
+- Citation 2
+"""
+
+
+def research_agent(state: Dict[str, Any]) -> Command:
+    """
+    Research Agent node that gathers information using available tools.
+    
+    Returns Command with research results appended to research_notes.
+    """
+    
+    print("🔍 Research Agent: Gathering information...")
+    
+    try:
+        # Get research prompt
+        research_prompt = load_research_prompt()
+        
+        # Initialize LLM with tools
+        llm = ChatGroq(
+            model="llama-3.3-70b-versatile",
+            temperature=0.3,  # Slightly higher for research creativity
+            max_tokens=2048
+        )
+        
+        # Get research tools
+        tools = create_research_tools()
+        
+        # Bind tools to LLM if available
+        if tools:
+            llm_with_tools = llm.bind_tools(tools)
+        else:
+            llm_with_tools = llm
+            print("⚠️  No tools available, proceeding with LLM only")
+        
+        # Create agent span for tracing
+        with agent_span(
+            "research",
+            metadata={
+                "tools_available": len(tools),
+                "user_id": state.get("user_id", "unknown"),
+                "session_id": state.get("session_id", "unknown")
+            }
+        ) as span:
+            
+            # Extract user query
+            messages = state.get("messages", [])
+            user_query = ""
+            for msg in messages:
+                if isinstance(msg, HumanMessage):
+                    user_query = msg.content
+                    break
+            
+            # Build research request
+            research_request = f"""
+Please research the following question using available tools:
+
+Question: {user_query}
+
+Current research status: {len(state.get('research_notes', ''))} characters already gathered
+
+Instructions:
+1. Search for factual information relevant to the question
+2. Use multiple sources if possible for verification
+3. Focus on accuracy and currency of information
+4. Provide clear citations and sources
+5. Structure your findings clearly
+
+Please gather comprehensive information to help answer this question.
+"""
+            
+            # Create messages for research
+            research_messages = [
+                SystemMessage(content=research_prompt),
+                HumanMessage(content=research_request)
+            ]
+            
+            # Get research response
+            if tools:
+                # Try using tools for research
+                response = llm_with_tools.invoke(research_messages)
+                
+                # If the response contains tool calls, execute them
+                if hasattr(response, 'tool_calls') and response.tool_calls:
+                    print(f"🛠️  Executing {len(response.tool_calls)} tool calls")
+                    
+                    # Execute tool calls and collect results
+                    tool_results = []
+                    for tool_call in response.tool_calls:
+                        try:
+                            # Find the tool
+                            tool = next((t for t in tools if t.name == tool_call['name']), None)
+                            if tool:
+                                result = tool.run(tool_call['args'])
+                                tool_results.append(f"**{tool.name}**: {result}")
+                        except Exception as e:
+                            print(f"⚠️  Tool {tool_call['name']} failed: {e}")
+                            tool_results.append(f"**{tool_call['name']}**: Error - {str(e)}")
+                    
+                    # Compile research results
+                    research_findings = "\n\n".join(tool_results) if tool_results else response.content
+                else:
+                    research_findings = response.content
+            else:
+                # No tools available, use LLM knowledge only
+                research_findings = llm.invoke(research_messages).content
+            
+            # Format research results
+            formatted_results = f"""
+### Research Iteration {state.get('loop_counter', 0) + 1}
+
+{research_findings}
+
+---
+"""
+            
+            print(f"📝 Research Agent: Gathered {len(formatted_results)} characters")
+            
+            # Update trace
+            if span:
+                span.update_trace(output={
+                    "research_length": len(formatted_results),
+                    "findings_preview": formatted_results[:300] + "..."
+                })
+            
+            # Return command to proceed back to lead agent for decision
+            return Command(
+                goto="lead",
+                update={
+                    "research_notes": formatted_results
+                }
+            )
+            
+    except Exception as e:
+        print(f"❌ Research Agent Error: {e}")
+        
+        # Return with error information
+        error_result = f"""
+### Research Error
+An error occurred during research: {str(e)}
+
+"""
+        return Command(
+            goto="lead",
+            update={
+                "research_notes": error_result
+            }
+        ) 

archive/.cursor/rules/archive.mdc

@@ -0,0 +1,6 @@
+---
+description: 
+globs: *.py,*.md
+alwaysApply: false
+---
+don't make any changes to these files, the files in this folder is only for reference, you can copy the file and then make changes to it, but never makes changes to the files in this folder. use the code for reference only.  

archive/README.md

@@ -0,0 +1 @@
+This folder contains previous attempts at agent creation which is not the correct workflow to create agents based on blogpost of https://www.anthropic.com/engineering/built-multi-agent-research-system and https://cognition.ai/blog/dont-build-multi-agents