Update veryfinal.py

veryfinal.py

@@ -9,11 +9,12 @@ load_dotenv()
 from agno.agent import Agent
 from agno.models.groq import Groq
 from agno.models.google import Gemini
-from agno.tools.duckduckgo import DuckDuckGoTools
 from agno.tools.yfinance import YFinanceTools
 
+# Tavily import (replacing DuckDuckGo)
+from tavily import TavilyClient
+
 # Additional imports for custom tools
-from langchain_community.tools.tavily_search import TavilySearchResults
 from langchain_community.document_loaders import WikipediaLoader, ArxivLoader
 
 # Advanced Rate Limiter with exponential backoff (SILENT)
@@ -37,18 +38,6 @@ class AdvancedRateLimiter:
             wait_time = 60 - (current_time - self.request_times[0]) + random.uniform(2, 8)
             await asyncio.sleep(wait_time)
         
-        # Calculate wait time for tokens (SILENT)
-        if self.tokens_per_minute:
-            total_tokens = sum(tokens for _, tokens in self.token_usage)
-            if total_tokens + estimated_tokens > self.tokens_per_minute:
-                wait_time = 60 - (current_time - self.token_usage[0][0]) + random.uniform(3, 10)
-                await asyncio.sleep(wait_time)
-        
-        # Add exponential backoff for consecutive failures (SILENT)
-        if self.consecutive_failures > 0:
-            backoff_time = min(2 ** self.consecutive_failures, 120) + random.uniform(2, 6)
-            await asyncio.sleep(backoff_time)
-        
         # Record this request
         self.request_times.append(current_time)
         if self.tokens_per_minute:
@@ -63,6 +52,10 @@ class AdvancedRateLimiter:
 # Initialize rate limiters for free tiers
 groq_limiter = AdvancedRateLimiter(requests_per_minute=30, tokens_per_minute=6000)
 gemini_limiter = AdvancedRateLimiter(requests_per_minute=2, tokens_per_minute=32000)
+tavily_limiter = AdvancedRateLimiter(requests_per_minute=50)  # Tavily rate limit
+
+# Initialize Tavily client
+tavily_client = TavilyClient(os.getenv("TAVILY_API_KEY"))
 
 # Custom tool functions with rate limiting (SILENT)
 def multiply_tool(a: float, b: float) -> float:
@@ -83,14 +76,26 @@ def divide_tool(a: float, b: float) -> float:
         raise ValueError("Cannot divide by zero.")
     return a / b
 
-async def web_search_tool(query: str) -> str:
-    """Search the web using Tavily with rate limiting."""
+async def tavily_search_tool(query: str) -> str:
+    """Search using Tavily with rate limiting."""
     try:
-        await asyncio.sleep(random.uniform(2, 5))
-        search_docs = TavilySearchResults(max_results=2).invoke(query=query)
-        return "\n\n---\n\n".join([doc.get("content", "") for doc in search_docs])
+        await tavily_limiter.wait_if_needed()
+        response = tavily_client.search(
+            query=query,
+            max_results=3,
+            search_depth="basic",
+            include_answer=False
+        )
+        
+        # Format results
+        results = []
+        for result in response.get('results', []):
+            results.append(f"Title: {result.get('title', '')}\nContent: {result.get('content', '')}")
+        
+        return "\n\n---\n\n".join(results)
+        
     except Exception as e:
-        return f"Web search failed: {str(e)}"
+        return f"Tavily search failed: {str(e)}"
 
 async def wiki_search_tool(query: str) -> str:
     """Search Wikipedia with rate limiting."""
@@ -102,6 +107,15 @@ async def wiki_search_tool(query: str) -> str:
     except Exception as e:
         return f"Wikipedia search failed: {str(e)}"
 
+async def arxiv_search_tool(query: str) -> str:
+    """Search ArXiv with rate limiting."""
+    try:
+        await asyncio.sleep(random.uniform(1, 4))
+        search_docs = ArxivLoader(query=query, load_max_docs=2).load()
+        return "\n\n---\n\n".join([doc.page_content[:800] for doc in search_docs])
+    except Exception as e:
+        return f"ArXiv search failed: {str(e)}"
+
 # Create specialized Agno agents (SILENT)
 def create_agno_agents():
     """Create specialized Agno agents with the best free models"""
@@ -134,10 +148,10 @@ def create_agno_agents():
             api_key=os.getenv("GOOGLE_API_KEY"),
             temperature=0
         ),
-        tools=[DuckDuckGoTools(), web_search_tool, wiki_search_tool],
+        tools=[tavily_search_tool, wiki_search_tool, arxiv_search_tool],  # Using Tavily instead of DuckDuckGo
         instructions=[
             "You are a research specialist with access to multiple search tools.",
-            "Use appropriate search tools to gather comprehensive information.",
+            "Use Tavily search for current web information, Wikipedia for encyclopedic content, and ArXiv for academic papers.",
             "Always cite sources and provide well-researched answers.",
             "Synthesize information from multiple sources when possible.",
             "Finish with: FINAL ANSWER: [your researched answer]"
@@ -154,12 +168,11 @@ def create_agno_agents():
             api_key=os.getenv("GROQ_API_KEY"), 
             temperature=0
         ),
-        tools=[DuckDuckGoTools(), web_search_tool, wiki_search_tool],
+        tools=[tavily_search_tool, wiki_search_tool],  # Using Tavily instead of DuckDuckGo
         instructions=[
             "You are the main coordinator agent.",
             "Analyze queries and provide comprehensive responses.",
-            "Use search tools for factual information when needed.",
-            "Route complex math to calculation tools.",
+            "Use Tavily search for current information and Wikipedia for background context.",
             "Always finish with: FINAL ANSWER: [your final answer]"
         ],
         show_tool_calls=False,  # SILENT
@@ -218,11 +231,6 @@ class AgnoMultiAgentSystem:
                     await asyncio.sleep(wait_time)
                     continue
                 
-                elif any(keyword in error_msg for keyword in ['api', 'connection', 'timeout', 'service unavailable']):
-                    wait_time = (2 ** attempt) + random.uniform(5, 15)
-                    await asyncio.sleep(wait_time)
-                    continue
-                
                 elif attempt == max_retries - 1:
                     try:
                         return self.agents["coordinator"].run(f"Answer this as best you can: {query}", stream=False)
@@ -246,7 +254,6 @@ def main(query: str) -> str:
     try:
         loop = asyncio.get_event_loop()
         if loop.is_running():
-            # For Jupyter notebooks
             import nest_asyncio
             nest_asyncio.apply()
             return asyncio.run(main_async(query))
@@ -265,12 +272,12 @@ def get_final_answer(query: str) -> str:
     else:
         return full_response.strip()
 
-# For Jupyter notebooks - use this function directly
+# For Jupyter notebooks
 async def run_query(query: str) -> str:
     """Direct async function for Jupyter notebooks (SILENT)"""
     return await main_async(query)
 
 if __name__ == "__main__":
-    # Test the Agno system - CLEAN OUTPUT ONLY
+    # Test the Agno system with Tavily - CLEAN OUTPUT ONLY
     result = get_final_answer("What are the names of the US presidents who were assassinated?")
     print(result)