+ updated research tool

agents/code_agent.py

@@ -16,196 +16,97 @@ 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 langchain_core.tools import BaseTool, 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
+# Import LangChain-compatible tools
+from langgraph_tools import get_code_tools
 
 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)}"
+@tool("python_execution")
+def python_execution_tool(code: str) -> str:
+    """
+    Execute Python code in a controlled environment.
     
-    # 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(',')))),
-    ]
+    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()
     
-    tools.extend(calc_tools)
-    print(f"✅ Added {len(calc_tools)} calculator tools")
+    # 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,
+        }
+    }
     
-    # Hub stats tool
+    # Allow common safe modules
     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)}"
+        import math
+        import statistics
+        import datetime
+        import json
+        import re
         
-        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")
+        safe_globals.update({
+            'math': math,
+            'statistics': statistics,
+            'datetime': datetime,
+            'json': json,
+            're': re,
+        })
+    except ImportError:
+        pass
     
-    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,
-            }
-        }
+    try:
+        # Execute the code
+        with contextlib.redirect_stdout(output_buffer), \
+             contextlib.redirect_stderr(error_buffer):
+            exec(code, safe_globals)
         
-        # 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
+        # Get the output
+        output = output_buffer.getvalue()
+        error = error_buffer.getvalue()
         
-        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)"
             
-            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
-    )
+    except Exception as e:
+        return f"Execution error: {str(e)}"
+    finally:
+        output_buffer.close()
+        error_buffer.close()
 
 
 def load_code_prompt() -> str:
@@ -226,6 +127,7 @@ Your goals:
 When handling computational tasks:
 - Use calculator tools for basic arithmetic operations
 - Use Python execution for complex calculations, data processing, or multi-step computations
+- Use Hugging Face Hub stats for model information
 - Show your work and intermediate steps
 - Verify results when possible
 - Handle edge cases and potential errors
@@ -233,7 +135,7 @@ When handling computational tasks:
 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
+- Hugging Face Hub stats: for model information
 
 Format your response as:
 ### Computational Analysis
@@ -249,7 +151,7 @@ Format your response as:
 
 def code_agent(state: Dict[str, Any]) -> Command:
     """
-    Code Agent node that handles computational tasks and code execution.
+    Code Agent node that handles computational tasks using LangChain tools.
     
     Returns Command with computational results appended to code_outputs.
     """
@@ -267,17 +169,18 @@ def code_agent(state: Dict[str, Any]) -> Command:
             max_tokens=2048
         )
         
-        # Get computational tools
-        tools = create_code_tools()
+        # Get computational tools (calculator tools + hub stats + python execution)
+        code_tools = get_code_tools()
+        code_tools.append(python_execution_tool)  # Add Python execution tool
         
         # Bind tools to LLM
-        llm_with_tools = llm.bind_tools(tools)
+        llm_with_tools = llm.bind_tools(code_tools)
         
         # Create agent span for tracing
         with agent_span(
             "code",
             metadata={
-                "tools_available": len(tools),
+                "tools_available": len(code_tools),
                 "research_context_length": len(state.get("research_notes", "")),
                 "user_id": state.get("user_id", "unknown"),
                 "session_id": state.get("session_id", "unknown")
@@ -324,34 +227,25 @@ Please perform all necessary calculations to help answer this question.
             # Get computational response
             response = llm_with_tools.invoke(code_messages)
             
-            # Process the response - handle both tool calls and direct responses
+            # Process tool calls if any
             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)
+                        tool = next((t for t in code_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}")
+                            # Execute the tool
+                            with tool_span(tool.name, metadata={"args": tool_call.get('args', {})}) as tool_span_ctx:
+                                result = tool.invoke(tool_call.get('args', {}))
+                                computation_results.append(f"**{tool.name}**: {result}")
+                                if tool_span_ctx:
+                                    tool_span_ctx.update_trace(output={"result": str(result)[:200] + "..."})
                         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)}")
@@ -359,50 +253,52 @@ Please perform all necessary calculations to help answer this question.
             # 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"""
+                # Ask LLM to analyze the computational results
+                analysis_request = f"""
+Based on the computational results below, provide a structured analysis:
+
+Original Question: {user_query}
+
+Computational Results:
+{computational_findings}
+
+Please analyze these results and provide:
+1. Summary of calculations performed
+2. Key numerical findings
+3. Interpretation of results
+4. How these results help answer the original question
+
+Structure your response clearly.
+"""
+                
+                analysis_messages = [
+                    SystemMessage(content=code_prompt),
+                    HumanMessage(content=analysis_request)
+                ]
+                
+                analysis_response = llm.invoke(analysis_messages)
+                analysis_content = analysis_response.content if hasattr(analysis_response, 'content') else str(analysis_response)
+                
+                # Format final computational results
+                formatted_results = f"""
 ### Computational Analysis {state.get('loop_counter', 0) + 1}
 
+{analysis_content}
+
+### Tool Results
 {computational_findings}
 
+---
+"""
+            else:
+                # No tools were called, use the LLM response directly
+                response_content = response.content if hasattr(response, 'content') else str(response)
+                formatted_results = f"""
+### Computational Analysis {state.get('loop_counter', 0) + 1}
+
+{response_content}
+
 ---
 """
             
@@ -412,6 +308,7 @@ Please perform all necessary calculations to help answer this question.
             if span:
                 span.update_trace(metadata={
                     "computation_length": len(formatted_results),
+                    "tools_used": len(computation_results),
                     "results_preview": formatted_results[:300] + "..."
                 })
             

agents/research_agent.py

@@ -13,112 +13,16 @@ 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 langchain_core.tools import BaseTool
 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
-)
+# Import LangChain-compatible tools
+from langgraph_tools import get_research_tools
 
 load_dotenv("env.local")
 
 
-def create_research_functions() -> List[callable]:
-    """Create simple research functions that can be called directly"""
-    
-    def web_search(query: str) -> str:
-        """Search the web using Tavily API"""
-        try:
-            with tool_span("tavily_search", metadata={"query": query}):
-                from tools import get_tavily_tool
-                tavily_spec = get_tavily_tool()
-                if tavily_spec:
-                    tavily_tools = tavily_spec.to_tool_list()
-                    if tavily_tools and len(tavily_tools) > 0:
-                        # Try different parameter formats for Tavily
-                        try:
-                            result = tavily_tools[0].call({"input": query})
-                        except Exception:
-                            try:
-                                result = tavily_tools[0].call({"query": query})
-                            except Exception:
-                                result = tavily_tools[0].call(query)
-                        return f"Web Search Results for '{query}':\n{str(result)}"
-                return "Web search tool not available"
-        except Exception as e:
-            print(f"Web search failed: {e}")
-            return f"Web search not available: {str(e)}"
-    
-    def wikipedia_search(query: str) -> str:
-        """Search Wikipedia for information"""
-        try:
-            with tool_span("wikipedia_search", metadata={"query": query}):
-                from tools import get_wikipedia_tool
-                wiki_tool = get_wikipedia_tool()
-                if wiki_tool:
-                    # Try different parameter formats for Wikipedia
-                    try:
-                        result = wiki_tool.call({"query_str": query})
-                    except Exception:
-                        try:
-                            result = wiki_tool.call({"input": query})
-                        except Exception:
-                            try:
-                                result = wiki_tool.call({"query": query})
-                            except Exception:
-                                result = wiki_tool.call(query)
-                    return f"Wikipedia Results for '{query}':\n{str(result)}"
-                return "Wikipedia tool not available"
-        except Exception as e:
-            print(f"Wikipedia search failed: {e}")
-            return f"Wikipedia search not available: {str(e)}"
-    
-    def arxiv_search(query: str) -> str:
-        """Search ArXiv for academic papers"""
-        try:
-            with tool_span("arxiv_search", metadata={"query": query}):
-                from tools import get_arxiv_tool
-                arxiv_tool = get_arxiv_tool()
-                if arxiv_tool:
-                    # Try different parameter formats for ArXiv
-                    try:
-                        result = arxiv_tool.call({"query_str": query})
-                    except Exception:
-                        try:
-                            result = arxiv_tool.call({"input": query})
-                        except Exception:
-                            try:
-                                result = arxiv_tool.call({"query": query})
-                            except Exception:
-                                result = arxiv_tool.call(query)
-                    return f"ArXiv Results for '{query}':\n{str(result)}"
-                return "ArXiv tool not available"
-        except Exception as e:
-            print(f"ArXiv search failed: {e}")
-            return f"ArXiv search not available: {str(e)}"
-    
-    # Add a simple fallback research function that doesn't use external APIs
-    def fallback_research(query: str) -> str:
-        """Provide basic context when external tools fail"""
-        return f"""
-Fallback Research for '{query}':
-
-This research uses general knowledge available in the system.
-For comprehensive research, external API access (Tavily, Wikipedia) would be needed.
-
-Basic information may be available through the language model's training data,
-but current information would require working API connections.
-"""
-    
-    return [web_search, wikipedia_search, arxiv_search, fallback_research]
-
-
 def load_research_prompt() -> str:
     """Load the research-specific prompt"""
     try:
@@ -141,70 +45,27 @@ When researching:
 - Cross-reference information across sources
 - Note any conflicting information found
 
-Important: You have access to research functions, but you cannot call them directly. 
-Instead, specify what searches you would like to perform and the system will execute them for you.
-
 Format your response as:
 ### Research Strategy
 [Describe what searches are needed]
 
-### Analysis
-[Analyze the information once gathered]
+### Findings
+[Key information discovered]
 
 ### Key Facts
 - Fact 1
 - Fact 2  
 - Fact 3
 
-### Citations
-- Citation 1
-- Citation 2
+### Sources
+- Source 1
+- Source 2
 """
 
 
-def perform_research_searches(query: str, research_functions: List[callable]) -> str:
-    """
-    Intelligently perform research searches based on the query
-    """
-    results = []
-    
-    # Always try web search first for current info
-    web_search, wikipedia_search, arxiv_search, fallback_research = research_functions
-    
-    print("🌐 Performing web search...")
-    web_result = web_search(query)
-    results.append(web_result)
-    
-    # Try Wikipedia for encyclopedic info
-    print("📚 Performing Wikipedia search...")
-    wiki_result = wikipedia_search(query)
-    results.append(wiki_result)
-    
-    # For academic/technical queries, try ArXiv
-    academic_keywords = ['research', 'study', 'paper', 'algorithm', 'model', 'theory', 'analysis']
-    if any(keyword in query.lower() for keyword in academic_keywords):
-        print("🎓 Performing ArXiv search...")
-        arxiv_result = arxiv_search(query)
-        results.append(arxiv_result)
-    
-    # Check if we got meaningful results, if not, use fallback
-    meaningful_results = []
-    for result in results:
-        if result and not ("not available" in result or "error" in result.lower()):
-            meaningful_results.append(result)
-    
-    # If no meaningful results, add fallback research
-    if not meaningful_results:
-        print("🔄 Using fallback research...")
-        fallback_result = fallback_research(query)
-        results.append(fallback_result)
-    
-    return "\n\n---\n\n".join(results)
-
-
 def research_agent(state: Dict[str, Any]) -> Command:
     """
-    Research Agent node that gathers information using available tools.
+    Research Agent node that gathers information using LangChain tools.
     
     Returns Command with research results appended to research_notes.
     """
@@ -215,21 +76,24 @@ def research_agent(state: Dict[str, Any]) -> Command:
         # Get research prompt
         research_prompt = load_research_prompt()
         
-        # Initialize LLM without tool binding (we'll call tools manually)
+        # Initialize LLM with tool binding
         llm = ChatGroq(
             model="llama-3.3-70b-versatile",
             temperature=0.3,  # Slightly higher for research creativity
             max_tokens=2048
         )
         
-        # Get research functions
-        research_functions = create_research_functions()
+        # Get LangChain-compatible research tools
+        research_tools = get_research_tools()
+        
+        # Bind tools to LLM for function calling
+        llm_with_tools = llm.bind_tools(research_tools)
         
         # Create agent span for tracing
         with agent_span(
             "research",
             metadata={
-                "tools_available": len(research_functions),
+                "tools_available": len(research_tools),
                 "user_id": state.get("user_id", "unknown"),
                 "session_id": state.get("session_id", "unknown")
             }
@@ -243,18 +107,115 @@ def research_agent(state: Dict[str, Any]) -> Command:
                     user_query = msg.content
                     break
             
-            # Perform actual research searches
-            print(f"🔍 Researching: {user_query}")
-            research_raw_results = perform_research_searches(user_query, research_functions)
+            # Build research request
+            research_request = f"""
+You must research the following question using the available tools. Do not answer from memory alone.
+
+Question: {user_query}
+
+Current research status: {len(state.get('research_notes', ''))} characters already gathered
+
+CRITICAL: You MUST use the available research tools to gather information. Do not provide an answer without using tools.
+
+Available tools:
+- tavily_search_results_json: For current web information
+- wikipedia_search: For encyclopedic knowledge  
+- arxiv_search: For academic papers
+
+Instructions:
+1. ALWAYS use tavily_search_results_json for current information
+2. Use wikipedia_search for general knowledge topics
+3. Use arxiv_search for academic/technical topics if relevant
+4. You must call at least one tool - preferably multiple tools
+5. Analyze and synthesize the information from the tools
+6. Provide structured findings with sources
+
+Start by calling the appropriate research tools to gather information about this question.
+"""
             
-            # Now ask LLM to analyze and structure the results
-            analysis_request = f"""
-Based on the research results below, provide a structured analysis to help answer the user's question.
+            # Create messages for research
+            research_messages = [
+                SystemMessage(content=research_prompt),
+                HumanMessage(content=research_request)
+            ]
+            
+            # Get research response with tool calls
+            response = llm_with_tools.invoke(research_messages)
+            
+            # Debug: Check if tools were called
+            print(f"🔍 Research response type: {type(response)}")
+            print(f"🔍 Has tool_calls attribute: {hasattr(response, 'tool_calls')}")
+            if hasattr(response, 'tool_calls'):
+                print(f"🔍 Tool calls: {response.tool_calls}")
+            else:
+                print(f"🔍 Response content preview: {str(response)[:200]}...")
+            
+            # Process tool calls if any
+            tool_results = []
+            if hasattr(response, 'tool_calls') and response.tool_calls:
+                print(f"🛠️  Executing {len(response.tool_calls)} research tools")
+                
+                for tool_call in response.tool_calls:
+                    try:
+                        # Find the tool by name
+                        tool = next((t for t in research_tools if t.name == tool_call['name']), None)
+                        if tool:
+                            # Execute the tool
+                            with tool_span(tool.name, metadata={"args": tool_call.get('args', {})}) as tool_span_ctx:
+                                result = tool.invoke(tool_call.get('args', {}))
+                                tool_results.append(f"**{tool.name}**: {result}")
+                                if tool_span_ctx:
+                                    tool_span_ctx.update_trace(output={"result": str(result)[:200] + "..."})
+                        else:
+                            tool_results.append(f"**{tool_call['name']}**: Tool not found")
+                            
+                    except Exception as e:
+                        print(f"⚠️  Tool {tool_call.get('name', 'unknown')} failed: {e}")
+                        tool_results.append(f"**{tool_call.get('name', 'unknown')}**: Error - {str(e)}")
+            else:
+                print("⚠️  No tool calls detected - LLM did not choose to use any tools")
+                # Force tool usage for research questions
+                print("🔧 Forcing tool usage for research...")
+                
+                # Manually call appropriate tools based on query
+                forced_tools = []
+                
+                # Always try web search for current info
+                tavily_tool = next((t for t in research_tools if t.name == "tavily_search_results_json"), None)
+                if tavily_tool:
+                    try:
+                        print("🌐 Forcing Tavily web search...")
+                        result = tavily_tool.invoke({"query": user_query})
+                        forced_tools.append(f"**tavily_search_results_json (forced)**: {result}")
+                    except Exception as e:
+                        print(f"⚠️  Forced Tavily search failed: {e}")
+                        forced_tools.append(f"**tavily_search_results_json (forced)**: Error - {str(e)}")
+                
+                # Try Wikipedia for general knowledge
+                wiki_tool = next((t for t in research_tools if t.name == "wikipedia_search"), None)
+                if wiki_tool:
+                    try:
+                        print("📚 Forcing Wikipedia search...")
+                        result = wiki_tool.invoke({"query": user_query})
+                        forced_tools.append(f"**wikipedia_search (forced)**: {result}")
+                    except Exception as e:
+                        print(f"⚠️  Forced Wikipedia search failed: {e}")
+                        forced_tools.append(f"**wikipedia_search (forced)**: Error - {str(e)}")
+                
+                tool_results = forced_tools
+            
+            # Compile research findings
+            if tool_results:
+                research_findings = "\n\n".join(tool_results)
+                
+                # Ask LLM to analyze the tool results
+                analysis_request = f"""
+Based on the research results below, provide a structured analysis:
 
 Original Question: {user_query}
 
 Research Results:
-{research_raw_results}
+{research_findings}
 
 Current research status: {len(state.get('research_notes', ''))} characters already gathered
 
@@ -267,25 +228,33 @@ Instructions:
 
 Please provide a comprehensive analysis of the research findings.
 """
-            
-            # Create messages for analysis
-            analysis_messages = [
-                SystemMessage(content=research_prompt),
-                HumanMessage(content=analysis_request)
-            ]
-            
-            # Get analysis response
-            response = llm.invoke(analysis_messages)
-            analysis_content = response.content if hasattr(response, 'content') else str(response)
-            
-            # Format research results
-            formatted_results = f"""
+                
+                analysis_messages = [
+                    SystemMessage(content=research_prompt),
+                    HumanMessage(content=analysis_request)
+                ]
+                
+                analysis_response = llm.invoke(analysis_messages)
+                analysis_content = analysis_response.content if hasattr(analysis_response, 'content') else str(analysis_response)
+                
+                # Format final research results
+                formatted_results = f"""
 ### Research Iteration {state.get('loop_counter', 0) + 1}
 
 {analysis_content}
 
-### Raw Search Results
-{research_raw_results}
+### Raw Tool Results
+{research_findings}
+
+---
+"""
+            else:
+                # No tools were called, use the LLM response directly
+                response_content = response.content if hasattr(response, 'content') else str(response)
+                formatted_results = f"""
+### Research Iteration {state.get('loop_counter', 0) + 1}
+
+{response_content}
 
 ---
 """
@@ -296,6 +265,7 @@ Please provide a comprehensive analysis of the research findings.
             if span:
                 span.update_trace(output={
                     "research_length": len(formatted_results),
+                    "tools_used": len(tool_results),
                     "findings_preview": formatted_results[:300] + "..."
                 })
             

langgraph_tools.py

@@ -0,0 +1,199 @@
+"""
+LangChain-compatible tools for the LangGraph multi-agent system
+
+This module provides LangChain tools that work properly with LangGraph agents,
+replacing the LlamaIndex tools with native LangChain implementations.
+"""
+
+import os
+import wikipedia
+import arxiv
+from typing import List, Optional, Type
+from langchain_core.tools import BaseTool, tool
+from pydantic import BaseModel, Field
+from langchain_tavily import TavilySearch
+from huggingface_hub import list_models
+from observability import tool_span
+
+
+# Pydantic schemas for tool inputs
+class WikipediaSearchInput(BaseModel):
+    """Input for Wikipedia search tool."""
+    query: str = Field(description="The search query for Wikipedia")
+
+
+class ArxivSearchInput(BaseModel):
+    """Input for ArXiv search tool."""
+    query: str = Field(description="The search query for ArXiv papers")
+
+
+class HubStatsInput(BaseModel):
+    """Input for Hugging Face Hub stats tool."""
+    author: str = Field(description="The author/organization name on Hugging Face Hub")
+
+
+# LangChain-compatible tool implementations
+
+@tool("wikipedia_search", args_schema=WikipediaSearchInput)
+def wikipedia_search_tool(query: str) -> str:
+    """Search Wikipedia for information about a topic."""
+    try:
+        with tool_span("wikipedia_search", metadata={"query": query}):
+            # Use wikipedia library directly
+            try:
+                # Search for pages
+                search_results = wikipedia.search(query, results=3)
+                if not search_results:
+                    return f"No Wikipedia results found for '{query}'"
+                
+                # Get the first page that works
+                for page_title in search_results:
+                    try:
+                        page = wikipedia.page(page_title)
+                        # Get summary and first few paragraphs
+                        content = page.summary
+                        if len(content) > 1000:
+                            content = content[:1000] + "..."
+                        
+                        return f"Wikipedia: {page.title}\n\nURL: {page.url}\n\nSummary:\n{content}"
+                    
+                    except wikipedia.exceptions.DisambiguationError as e:
+                        # Try the first suggestion
+                        try:
+                            page = wikipedia.page(e.options[0])
+                            content = page.summary
+                            if len(content) > 1000:
+                                content = content[:1000] + "..."
+                            return f"Wikipedia: {page.title}\n\nURL: {page.url}\n\nSummary:\n{content}"
+                        except:
+                            continue
+                    except:
+                        continue
+                
+                return f"Could not retrieve Wikipedia content for '{query}'"
+                        
+            except Exception as e:
+                return f"Wikipedia search error: {str(e)}"
+                
+    except Exception as e:
+        return f"Wikipedia search failed: {str(e)}"
+
+
+@tool("arxiv_search", args_schema=ArxivSearchInput)
+def arxiv_search_tool(query: str) -> str:
+    """Search ArXiv for academic papers."""
+    try:
+        with tool_span("arxiv_search", metadata={"query": query}):
+            # Use arxiv library
+            search = arxiv.Search(
+                query=query,
+                max_results=3,
+                sort_by=arxiv.SortCriterion.Relevance
+            )
+            
+            results = []
+            for paper in search.results():
+                result = f"""Title: {paper.title}
+Authors: {', '.join([author.name for author in paper.authors])}
+Published: {paper.published.strftime('%Y-%m-%d')}
+URL: {paper.entry_id}
+Summary: {paper.summary[:500]}..."""
+                results.append(result)
+            
+            if results:
+                return f"ArXiv Search Results for '{query}':\n\n" + "\n\n---\n\n".join(results)
+            else:
+                return f"No ArXiv papers found for '{query}'"
+                
+    except Exception as e:
+        return f"ArXiv search failed: {str(e)}"
+
+
+@tool("huggingface_hub_stats", args_schema=HubStatsInput)
+def huggingface_hub_stats_tool(author: str) -> str:
+    """Get statistics for a Hugging Face Hub author."""
+    try:
+        with tool_span("huggingface_hub_stats", metadata={"author": author}):
+            models = list(list_models(author=author, sort="downloads", direction=-1, limit=5))
+            if models:
+                results = []
+                for i, model in enumerate(models, 1):
+                    results.append(f"{i}. {model.id} - {model.downloads:,} downloads")
+                
+                top_model = models[0]
+                summary = f"Top 5 models by {author}:\n" + "\n".join(results)
+                summary += f"\n\nMost popular: {top_model.id} with {top_model.downloads:,} downloads"
+                return summary
+            else:
+                return f"No models found for author '{author}'"
+                
+    except Exception as e:
+        return f"Hub stats error: {str(e)}"
+
+
+def get_tavily_search_tool() -> TavilySearch:
+    """Get the Tavily search tool from LangChain community."""
+    return TavilySearch(
+        api_key=os.getenv("TAVILY_API_KEY"),
+        max_results=6,
+        include_answer=True,
+        include_raw_content=True,
+        description="Search the web for current information and facts"
+    )
+
+
+def get_calculator_tools() -> List[BaseTool]:
+    """Get calculator tools as LangChain tools."""
+    
+    @tool("multiply")
+    def multiply(a: float, b: float) -> float:
+        """Multiply two numbers."""
+        return a * b
+    
+    @tool("add") 
+    def add(a: float, b: float) -> float:
+        """Add two numbers."""
+        return a + b
+    
+    @tool("subtract")
+    def subtract(a: float, b: float) -> float:
+        """Subtract two numbers."""
+        return a - b
+    
+    @tool("divide")
+    def divide(a: float, b: float) -> float:
+        """Divide two numbers."""
+        if b == 0:
+            raise ValueError("Cannot divide by zero")
+        return a / b
+    
+    @tool("modulus")
+    def modulus(a: int, b: int) -> int:
+        """Get the modulus of two integers."""
+        if b == 0:
+            raise ValueError("Cannot modulo by zero")
+        return a % b
+    
+    return [multiply, add, subtract, divide, modulus]
+
+
+def get_research_tools() -> List[BaseTool]:
+    """Get all research tools for the research agent."""
+    tools = [
+        get_tavily_search_tool(),
+        wikipedia_search_tool,
+        arxiv_search_tool,
+    ]
+    return tools
+
+
+def get_code_tools() -> List[BaseTool]:
+    """Get all code/computation tools for the code agent."""
+    tools = get_calculator_tools()
+    tools.append(huggingface_hub_stats_tool)
+    return tools
+
+
+def get_all_tools() -> List[BaseTool]:
+    """Get all available tools."""
+    return get_research_tools() + get_code_tools() 

pyproject.toml

@@ -35,4 +35,7 @@ dependencies = [
     "supabase>=2.15.3",
     "wikipedia>=1.4.0",
     "datasets>=2.19.1",
+    "arxiv>=2.2.0",
+    "langchain-tavily>=0.2.4",
+    "python-dotenv>=1.1.0",
 ]

test_langgraph_system.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python3
+"""
+Test script for the LangGraph multi-agent system with LangChain tools
+"""
+
+import asyncio
+import os
+from dotenv import load_dotenv
+
+# Load environment variables
+load_dotenv("env.local")
+
+async def test_langgraph_system():
+    """Test the LangGraph system with a simple question"""
+    
+    print("🔧 Testing LangGraph System with LangChain Tools")
+    print("=" * 60)
+    
+    try:
+        # Import the main system
+        from langgraph_agent_system import run_agent_system
+        
+        # Test with a simple computational question
+        test_query = "What is 25 + 17?"
+        print(f"📝 Test Query: {test_query}")
+        print("-" * 40)
+        
+        # Run the agent system
+        result = await run_agent_system(
+            query=test_query,
+            user_id="test_user", 
+            session_id="test_session",
+            max_iterations=2
+        )
+        
+        print("\n📊 Final Result:")
+        print(result)
+        print("\n✅ Test completed successfully!")
+        
+    except Exception as e:
+        print(f"❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+
+
+async def test_research_tools():
+    """Test the research tools separately"""
+    
+    print("\n🔍 Testing Research Tools")
+    print("=" * 40)
+    
+    try:
+        from langgraph_tools import get_research_tools
+        
+        # Get the tools
+        tools = get_research_tools()
+        print(f"✅ Loaded {len(tools)} research tools:")
+        for tool in tools:
+            print(f"  - {tool.name}: {tool.description}")
+        
+        # Test Wikipedia tool (if available)
+        wiki_tool = next((t for t in tools if t.name == "wikipedia_search"), None)
+        if wiki_tool:
+            print("\n📚 Testing Wikipedia search...")
+            result = wiki_tool.invoke({"query": "Python programming"})
+            print(f"Wikipedia result length: {len(str(result))} characters")
+            print(f"Preview: {str(result)[:200]}...")
+        
+    except Exception as e:
+        print(f"❌ Research tools test failed: {e}")
+
+
+async def test_code_tools():
+    """Test the code tools separately"""
+    
+    print("\n🧮 Testing Code Tools")
+    print("=" * 40)
+    
+    try:
+        from langgraph_tools import get_code_tools
+        
+        # Get the tools
+        tools = get_code_tools()
+        print(f"✅ Loaded {len(tools)} code tools:")
+        for tool in tools:
+            print(f"  - {tool.name}: {tool.description}")
+        
+        # Test add tool
+        add_tool = next((t for t in tools if t.name == "add"), None)
+        if add_tool:
+            print("\n➕ Testing addition...")
+            result = add_tool.invoke({"a": 25, "b": 17})
+            print(f"Addition result: {result}")
+        
+    except Exception as e:
+        print(f"❌ Code tools test failed: {e}")
+
+
+if __name__ == "__main__":
+    async def main():
+        await test_research_tools()
+        await test_code_tools()
+        await test_langgraph_system()
+    
+    asyncio.run(main()) 

uv.lock

@@ -528,6 +528,7 @@ name = "final-assignment-template"
 version = "0.1.0"
 source = { virtual = "." }
 dependencies = [
+    { name = "arxiv" },
     { name = "datasets" },
     { name = "dotenv" },
     { name = "gradio" },
@@ -541,6 +542,7 @@ dependencies = [
     { name = "langchain-groq" },
     { name = "langchain-huggingface" },
     { name = "langchain-openai" },
+    { name = "langchain-tavily" },
     { name = "langfuse" },
     { name = "langgraph" },
     { name = "langgraph-checkpoint" },
@@ -554,6 +556,7 @@ dependencies = [
     { name = "llama-index-tools-tavily-research" },
     { name = "opencv-python" },
     { name = "pandas" },
+    { name = "python-dotenv" },
     { name = "rich" },
     { name = "sentence-transformers" },
     { name = "supabase" },
@@ -562,6 +565,7 @@ dependencies = [
 
 [package.metadata]
 requires-dist = [
+    { name = "arxiv", specifier = ">=2.2.0" },
     { name = "datasets", specifier = ">=2.19.1" },
     { name = "dotenv", specifier = ">=0.9.9" },
     { name = "gradio", specifier = ">=5.34.1" },
@@ -575,6 +579,7 @@ requires-dist = [
     { name = "langchain-groq", specifier = ">=0.3.2" },
     { name = "langchain-huggingface", specifier = ">=0.3.0" },
     { name = "langchain-openai", specifier = ">=0.3.24" },
+    { name = "langchain-tavily", specifier = ">=0.2.4" },
     { name = "langfuse", specifier = ">=3.0.0" },
     { name = "langgraph", specifier = ">=0.4.8" },
     { name = "langgraph-checkpoint", specifier = ">=2.1.0" },
@@ -588,6 +593,7 @@ requires-dist = [
     { name = "llama-index-tools-tavily-research", specifier = ">=0.3.0" },
     { name = "opencv-python", specifier = ">=4.11.0.86" },
     { name = "pandas", specifier = ">=2.2.3" },
+    { name = "python-dotenv", specifier = ">=1.1.0" },
     { name = "rich", specifier = ">=14.0.0" },
     { name = "sentence-transformers", specifier = ">=4.1.0" },
     { name = "supabase", specifier = ">=2.15.3" },
@@ -1348,6 +1354,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/fc/9b/b8f86d78dbc651decd684ab938a1340e1ad3ba1dbcef805e12db65dee0ba/langchain_openai-0.3.24-py3-none-any.whl", hash = "sha256:3db7bb2964f86636276a8f4bbed4514daf13865b80896e547ff7ea13ce98e593", size = 68950 },
 ]
 
+[[package]]
+name = "langchain-tavily"
+version = "0.2.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "aiohttp" },
+    { name = "langchain" },
+    { name = "langchain-core" },
+    { name = "mypy" },
+    { name = "requests" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/15/df/faf9b205c93a048b96d013a88623bf31f974cf8d2785fc877d239861f1e8/langchain_tavily-0.2.4.tar.gz", hash = "sha256:68281a47e2e45e857a0d8087478f2638ea7e7c3a8a61a00cc0a2e3b7541240ea", size = 20722 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/61/10/9c7fc924a4a099840d03cf7b58da337f9ca54949bb0cfd26fe5320959c6c/langchain_tavily-0.2.4-py3-none-any.whl", hash = "sha256:36a80f2dd331cd68e26f4f6e6c3602e2615df4da21da05d787b904f7a564d487", size = 24465 },
+]
+
 [[package]]
 name = "langchain-text-splitters"
 version = "0.3.8"
@@ -1912,6 +1934,26 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/da/d9/f7f9379981e39b8c2511c9e0326d212accacb82f12fbfdc1aa2ce2a7b2b6/multiprocess-0.70.16-py39-none-any.whl", hash = "sha256:a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3", size = 133351 },
 ]
 
+[[package]]
+name = "mypy"
+version = "1.16.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mypy-extensions" },
+    { name = "pathspec" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/81/69/92c7fa98112e4d9eb075a239caa4ef4649ad7d441545ccffbd5e34607cbb/mypy-1.16.1.tar.gz", hash = "sha256:6bd00a0a2094841c5e47e7374bb42b83d64c527a502e3334e1173a0c24437bab", size = 3324747 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/28/e3/96964af4a75a949e67df4b95318fe2b7427ac8189bbc3ef28f92a1c5bc56/mypy-1.16.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:ddc91eb318c8751c69ddb200a5937f1232ee8efb4e64e9f4bc475a33719de438", size = 11063480 },
+    { url = "https://files.pythonhosted.org/packages/f5/4d/cd1a42b8e5be278fab7010fb289d9307a63e07153f0ae1510a3d7b703193/mypy-1.16.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:87ff2c13d58bdc4bbe7dc0dedfe622c0f04e2cb2a492269f3b418df2de05c536", size = 10090538 },
+    { url = "https://files.pythonhosted.org/packages/c9/4f/c3c6b4b66374b5f68bab07c8cabd63a049ff69796b844bc759a0ca99bb2a/mypy-1.16.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a7cfb0fe29fe5a9841b7c8ee6dffb52382c45acdf68f032145b75620acfbd6f", size = 11836839 },
+    { url = "https://files.pythonhosted.org/packages/b4/7e/81ca3b074021ad9775e5cb97ebe0089c0f13684b066a750b7dc208438403/mypy-1.16.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:051e1677689c9d9578b9c7f4d206d763f9bbd95723cd1416fad50db49d52f359", size = 12715634 },
+    { url = "https://files.pythonhosted.org/packages/e9/95/bdd40c8be346fa4c70edb4081d727a54d0a05382d84966869738cfa8a497/mypy-1.16.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:d5d2309511cc56c021b4b4e462907c2b12f669b2dbeb68300110ec27723971be", size = 12895584 },
+    { url = "https://files.pythonhosted.org/packages/5a/fd/d486a0827a1c597b3b48b1bdef47228a6e9ee8102ab8c28f944cb83b65dc/mypy-1.16.1-cp313-cp313-win_amd64.whl", hash = "sha256:4f58ac32771341e38a853c5d0ec0dfe27e18e27da9cdb8bbc882d2249c71a3ee", size = 9573886 },
+    { url = "https://files.pythonhosted.org/packages/cf/d3/53e684e78e07c1a2bf7105715e5edd09ce951fc3f47cf9ed095ec1b7a037/mypy-1.16.1-py3-none-any.whl", hash = "sha256:5fc2ac4027d0ef28d6ba69a0343737a23c4d1b83672bf38d1fe237bdc0643b37", size = 2265923 },
+]
+
 [[package]]
 name = "mypy-extensions"
 version = "1.1.0"
@@ -2348,6 +2390,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/c6/ac/dac4a63f978e4dcb3c6d3a78c4d8e0192a113d288502a1216950c41b1027/parso-0.8.4-py2.py3-none-any.whl", hash = "sha256:a418670a20291dacd2dddc80c377c5c3791378ee1e8d12bffc35420643d43f18", size = 103650 },
 ]
 
+[[package]]
+name = "pathspec"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191 },
+]
+
 [[package]]
 name = "pexpect"
 version = "4.9.0"