updated research agent

agents/research_agent.py

@@ -29,86 +29,94 @@ from tools import (
 load_dotenv("env.local")
 
 
-def create_research_tools() -> List[Tool]:
-    """Create LangChain-compatible research tools"""
-    tools = []
+def create_research_functions() -> List[callable]:
+    """Create simple research functions that can be called directly"""
     
-    try:
-        # Import LlamaIndex tools and convert them
-        from tools import get_tavily_tool, get_wikipedia_tool, get_arxiv_tool
-        
-        # Tavily web search
+    def web_search(query: str) -> str:
+        """Search the web using Tavily API"""
         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:
+            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})
-                            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:
+                            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"⚠️  Could not load Tavily tools: {e}")
-        
-        # Wikipedia search
+            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:
-            wikipedia_tool = get_wikipedia_tool()
-            if wikipedia_tool:
-                def wikipedia_search(query: str) -> str:
+            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 = 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")
+                        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"⚠️  Could not load Wikipedia tool: {e}")
-        
-        # ArXiv search
+            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:
-            arxiv_tool = get_arxiv_tool()
-            if arxiv_tool:
-                def arxiv_search(query: str) -> str:
+            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({"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")
+                        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"⚠️  Could not load ArXiv tool: {e}")
+            print(f"ArXiv search failed: {e}")
+            return f"ArXiv search not available: {str(e)}"
     
-    except Exception as e:
-        print(f"⚠️  Error setting up research tools: {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.
+"""
     
-    print(f"🔧 Research Agent loaded {len(tools)} tools")
-    return tools
+    return [web_search, wikipedia_search, arxiv_search, fallback_research]
 
 
 def load_research_prompt() -> str:
@@ -133,15 +141,19 @@ 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 Results
-- **Source 1**: [findings]
-- **Source 2**: [findings]  
-- **Source 3**: [findings]
+### Research Strategy
+[Describe what searches are needed]
+
+### Analysis
+[Analyze the information once gathered]
 
 ### Key Facts
 - Fact 1
-- Fact 2
+- Fact 2  
 - Fact 3
 
 ### Citations
@@ -150,6 +162,46 @@ Format your response as:
 """
 
 
+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.
@@ -163,28 +215,21 @@ def research_agent(state: Dict[str, Any]) -> Command:
         # Get research prompt
         research_prompt = load_research_prompt()
         
-        # Initialize LLM with tools
+        # Initialize LLM without tool binding (we'll call tools manually)
         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")
+        # Get research functions
+        research_functions = create_research_functions()
         
         # Create agent span for tracing
         with agent_span(
             "research",
             metadata={
-                "tools_available": len(tools),
+                "tools_available": len(research_functions),
                 "user_id": state.get("user_id", "unknown"),
                 "session_id": state.get("session_id", "unknown")
             }
@@ -198,65 +243,49 @@ def research_agent(state: Dict[str, Any]) -> Command:
                     user_query = msg.content
                     break
             
-            # Build research request
-            research_request = f"""
-Please research the following question using available tools:
+            # Perform actual research searches
+            print(f"🔍 Researching: {user_query}")
+            research_raw_results = perform_research_searches(user_query, research_functions)
+            
+            # 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.
+
+Original Question: {user_query}
 
-Question: {user_query}
+Research Results:
+{research_raw_results}
 
 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
+1. Analyze the search results for relevant information
+2. Extract key facts that help answer the question
+3. Note any important details or findings
+4. Identify if additional specific searches might be needed
+5. Structure your findings clearly with citations
 
-Please gather comprehensive information to help answer this question.
+Please provide a comprehensive analysis of the research findings.
 """
             
-            # Create messages for research
-            research_messages = [
+            # Create messages for analysis
+            analysis_messages = [
                 SystemMessage(content=research_prompt),
-                HumanMessage(content=research_request)
+                HumanMessage(content=analysis_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
+            # 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"""
 ### Research Iteration {state.get('loop_counter', 0) + 1}
 
-{research_findings}
+{analysis_content}
+
+### Raw Search Results
+{research_raw_results}
 
 ---
 """