agno 2.3.25__py3-none-any.whl → 2.4.0__py3-none-any.whl

agno/tools/memory.py

@@ -1,10 +1,11 @@
 import json
 from textwrap import dedent
-from typing import Any, Dict, List, Optional
+from typing import Any, List, Optional
 from uuid import uuid4
 
 from agno.db.base import BaseDb
 from agno.db.schemas import UserMemory
+from agno.run import RunContext
 from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_error
 
@@ -62,7 +63,7 @@ class MemoryTools(Toolkit):
             **kwargs,
         )
 
-    def think(self, session_state: Dict[str, Any], thought: str) -> str:
+    def think(self, run_context: RunContext, thought: str) -> str:
         """Use this tool as a scratchpad to reason about memory operations, refine your approach, brainstorm memory content, or revise your plan.
 
         Call `Think` whenever you need to figure out what to do next, analyze the user's requirements, plan memory operations, or decide on execution strategy.
@@ -75,14 +76,14 @@ class MemoryTools(Toolkit):
             log_debug(f"Memory Thought: {thought}")
 
             # Add the thought to the session state
-            if session_state is None:
-                session_state = {}
-            if "memory_thoughts" not in session_state:
-                session_state["memory_thoughts"] = []
-            session_state["memory_thoughts"].append(thought)
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "memory_thoughts" not in run_context.session_state:
+                run_context.session_state["memory_thoughts"] = []
+            run_context.session_state["memory_thoughts"].append(thought)
 
             # Return the full log of thoughts and the new thought
-            thoughts = "\n".join([f"- {t}" for t in session_state["memory_thoughts"]])
+            thoughts = "\n".join([f"- {t}" for t in run_context.session_state["memory_thoughts"]])
             formatted_thoughts = dedent(
                 f"""Memory Thoughts:
                 {thoughts}
@@ -93,21 +94,21 @@ class MemoryTools(Toolkit):
             log_error(f"Error recording memory thought: {e}")
             return f"Error recording memory thought: {e}"
 
-    def get_memories(self, session_state: Dict[str, Any]) -> str:
+    def get_memories(self, run_context: RunContext) -> str:
         """
         Use this tool to get a list of memories for the current user from the database.
         """
         try:
-            # Get user info from session state
-            user_id = session_state.get("current_user_id") if session_state else None
+            # Get user info from run context
+            user_id = run_context.user_id
 
             memories = self.db.get_user_memories(user_id=user_id)
 
             # Store the result in session state for analysis
-            if session_state is None:
-                session_state = {}
-            if "memory_operations" not in session_state:
-                session_state["memory_operations"] = []
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "memory_operations" not in run_context.session_state:
+                run_context.session_state["memory_operations"] = []
 
             operation_result = {
                 "operation": "get_memories",
@@ -115,7 +116,7 @@ class MemoryTools(Toolkit):
                 "memories": [memory.to_dict() for memory in memories],  # type: ignore
                 "error": None,
             }
-            session_state["memory_operations"].append(operation_result)
+            run_context.session_state["memory_operations"].append(operation_result)
 
             return json.dumps([memory.to_dict() for memory in memories], indent=2)  # type: ignore
         except Exception as e:
@@ -124,7 +125,7 @@ class MemoryTools(Toolkit):
 
     def add_memory(
         self,
-        session_state: Dict[str, Any],
+        run_context: RunContext,
         memory: str,
         topics: Optional[List[str]] = None,
     ) -> str:
@@ -140,8 +141,8 @@ class MemoryTools(Toolkit):
         try:
             log_debug(f"Adding memory: {memory}")
 
-            # Get user and agent info from session state
-            user_id = session_state.get("current_user_id") if session_state else None
+            # Get user info from run context
+            user_id = run_context.user_id
 
             # Create UserMemory object
             user_memory = UserMemory(
@@ -155,10 +156,10 @@ class MemoryTools(Toolkit):
             created_memory = self.db.upsert_user_memory(user_memory)
 
             # Store the result in session state for analysis
-            if session_state is None:
-                session_state = {}
-            if "memory_operations" not in session_state:
-                session_state["memory_operations"] = []
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "memory_operations" not in run_context.session_state:
+                run_context.session_state["memory_operations"] = []
 
             memory_dict = created_memory.to_dict() if created_memory else None  # type: ignore
 
@@ -168,7 +169,7 @@ class MemoryTools(Toolkit):
                 "memory": memory_dict,
                 "error": None,
             }
-            session_state["memory_operations"].append(operation_result)
+            run_context.session_state["memory_operations"].append(operation_result)
 
             if created_memory:
                 return json.dumps({"success": True, "operation": "add_memory", "memory": memory_dict}, indent=2)
@@ -183,7 +184,7 @@ class MemoryTools(Toolkit):
 
     def update_memory(
         self,
-        session_state: Dict[str, Any],
+        run_context: RunContext,
         memory_id: str,
         memory: Optional[str] = None,
         topics: Optional[List[str]] = None,
@@ -221,10 +222,10 @@ class MemoryTools(Toolkit):
             updated_result = self.db.upsert_user_memory(updated_memory)
 
             # Store the result in session state for analysis
-            if session_state is None:
-                session_state = {}
-            if "memory_operations" not in session_state:
-                session_state["memory_operations"] = []
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "memory_operations" not in run_context.session_state:
+                run_context.session_state["memory_operations"] = []
 
             memory_dict = updated_result.to_dict() if updated_result else None  # type: ignore
 
@@ -234,7 +235,7 @@ class MemoryTools(Toolkit):
                 "memory": memory_dict,
                 "error": None,
             }
-            session_state["memory_operations"].append(operation_result)
+            run_context.session_state["memory_operations"].append(operation_result)
 
             if updated_result:
                 return json.dumps({"success": True, "operation": "update_memory", "memory": memory_dict}, indent=2)
@@ -249,7 +250,7 @@ class MemoryTools(Toolkit):
 
     def delete_memory(
         self,
-        session_state: Dict[str, Any],
+        run_context: RunContext,
         memory_id: str,
     ) -> str:
         """Use this tool to delete a memory from the database.
@@ -275,10 +276,10 @@ class MemoryTools(Toolkit):
             self.db.delete_user_memory(memory_id)
 
             # Store the result in session state for analysis
-            if session_state is None:
-                session_state = {}
-            if "memory_operations" not in session_state:
-                session_state["memory_operations"] = []
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "memory_operations" not in run_context.session_state:
+                run_context.session_state["memory_operations"] = []
 
             memory_dict = existing_memory.to_dict() if existing_memory else None  # type: ignore
 
@@ -289,7 +290,7 @@ class MemoryTools(Toolkit):
                 "deleted_memory": memory_dict,
                 "error": None,
             }
-            session_state["memory_operations"].append(operation_result)
+            run_context.session_state["memory_operations"].append(operation_result)
 
             return json.dumps(
                 {
@@ -305,7 +306,7 @@ class MemoryTools(Toolkit):
             log_error(f"Error deleting memory: {e}")
             return json.dumps({"success": False, "operation": "delete_memory", "error": str(e)}, indent=2)
 
-    def analyze(self, session_state: Dict[str, Any], analysis: str) -> str:
+    def analyze(self, run_context: RunContext, analysis: str) -> str:
         """Use this tool to evaluate whether the memory operations results are correct and sufficient.
         If not, go back to "Think" or use memory operations with refined parameters.
 
@@ -316,14 +317,14 @@ class MemoryTools(Toolkit):
             log_debug(f"Memory Analysis: {analysis}")
 
             # Add the analysis to the session state
-            if session_state is None:
-                session_state = {}
-            if "memory_analysis" not in session_state:
-                session_state["memory_analysis"] = []
-            session_state["memory_analysis"].append(analysis)
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "memory_analysis" not in run_context.session_state:
+                run_context.session_state["memory_analysis"] = []
+            run_context.session_state["memory_analysis"].append(analysis)
 
             # Return the full log of analysis and the new analysis
-            analysis_log = "\n".join([f"- {a}" for a in session_state["memory_analysis"]])
+            analysis_log = "\n".join([f"- {a}" for a in run_context.session_state["memory_analysis"]])
             formatted_analysis = dedent(
                 f"""Memory Analysis:
                 {analysis_log}
@@ -338,7 +339,7 @@ class MemoryTools(Toolkit):
         You have access to the Think, Add Memory, Update Memory, Delete Memory, and Analyze tools that will help you manage user memories and analyze their operations. Use these tools as frequently as needed to successfully complete memory management tasks.
 
         ## How to use the Think, Memory Operations, and Analyze tools:
-        
+
         1. **Think**
         - Purpose: A scratchpad for planning memory operations, brainstorming memory content, and refining your approach. You never reveal your "Think" content to the user.
         - Usage: Call `think` whenever you need to figure out what memory operations to perform, analyze requirements, or decide on strategy.
@@ -407,12 +408,12 @@ class MemoryTools(Toolkit):
         Analyze: Successfully deleted the outdated work schedule memory. The old information won't interfere with future scheduling requests.
 
         Final Answer: I've removed your old work schedule information. Feel free to share your new schedule when you're ready, and I'll store the updated information.
-        
+
         #### Example 4: Retrieving Memories
 
         User: What have you remembered about me?
         Think: The user wants to retrieve memories about themselves. I should use the get_memories tool to retrieve the memories.
-        Get Memories: 
+        Get Memories:
         Analyze: Successfully retrieved the memories about the user. The memories are relevant to the user's preferences and activities.
 
         Final Answer: I've retrieved the memories about you. You like to hike in the mountains on weekends and travel to new places and experience different cultures. You are planning to travel to Africa in December.\

agno/tools/parallel.py

@@ -41,7 +41,6 @@ class ParallelTools(Toolkit):
         include_domains (Optional[List[str]]): Default domains to restrict results to. Default is None.
         exclude_domains (Optional[List[str]]): Default domains to exclude from results. Default is None.
         max_age_seconds (Optional[int]): Default cache age threshold (minimum 600). Default is None.
-        timeout_seconds (Optional[float]): Default timeout for content retrieval. Default is None.
         disable_cache_fallback (Optional[bool]): Default cache fallback behavior. Default is None.
     """
 
@@ -58,7 +57,6 @@ class ParallelTools(Toolkit):
         include_domains: Optional[List[str]] = None,
         exclude_domains: Optional[List[str]] = None,
         max_age_seconds: Optional[int] = None,
-        timeout_seconds: Optional[float] = None,
         disable_cache_fallback: Optional[bool] = None,
         **kwargs,
     ):
@@ -73,7 +71,6 @@ class ParallelTools(Toolkit):
         self.include_domains = include_domains
         self.exclude_domains = exclude_domains
         self.max_age_seconds = max_age_seconds
-        self.timeout_seconds = timeout_seconds
         self.disable_cache_fallback = disable_cache_fallback
 
         self.parallel_client = ParallelClient(
@@ -153,8 +150,6 @@ class ParallelTools(Toolkit):
             fetch_policy: Dict[str, Any] = {}
             if self.max_age_seconds is not None:
                 fetch_policy["max_age_seconds"] = self.max_age_seconds
-            if self.timeout_seconds is not None:
-                fetch_policy["timeout_seconds"] = self.timeout_seconds
             if self.disable_cache_fallback is not None:
                 fetch_policy["disable_cache_fallback"] = self.disable_cache_fallback
 
@@ -256,8 +251,6 @@ class ParallelTools(Toolkit):
             fetch_policy: Dict[str, Any] = {}
             if self.max_age_seconds is not None:
                 fetch_policy["max_age_seconds"] = self.max_age_seconds
-            if self.timeout_seconds is not None:
-                fetch_policy["timeout_seconds"] = self.timeout_seconds
             if self.disable_cache_fallback is not None:
                 fetch_policy["disable_cache_fallback"] = self.disable_cache_fallback
 

agno/tools/reasoning.py

@@ -1,7 +1,8 @@
 from textwrap import dedent
-from typing import Any, Dict, List, Optional
+from typing import Any, List, Optional
 
 from agno.reasoning.step import NextAction, ReasoningStep
+from agno.run import RunContext
 from agno.tools import Toolkit
 from agno.utils.log import log_debug, log_error
 
@@ -49,7 +50,7 @@ class ReasoningTools(Toolkit):
 
     def think(
         self,
-        session_state: Dict[str, Any],
+        run_context: RunContext,
         title: str,
         thought: str,
         action: Optional[str] = None,
@@ -80,21 +81,24 @@ class ReasoningTools(Toolkit):
                 confidence=confidence,
             )
 
-            current_run_id = session_state.get("current_run_id", None)
+            current_run_id = run_context.run_id
 
             # Add this step to the Agent's session state
-            if session_state is None:
-                session_state = {}
-            if "reasoning_steps" not in session_state:
-                session_state["reasoning_steps"] = {}
-            if current_run_id not in session_state["reasoning_steps"]:
-                session_state["reasoning_steps"][current_run_id] = []
-            session_state["reasoning_steps"][current_run_id].append(reasoning_step.model_dump_json())
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "reasoning_steps" not in run_context.session_state:
+                run_context.session_state["reasoning_steps"] = {}
+            if current_run_id not in run_context.session_state["reasoning_steps"]:
+                run_context.session_state["reasoning_steps"][current_run_id] = []
+            run_context.session_state["reasoning_steps"][current_run_id].append(reasoning_step.model_dump_json())
 
             # Return all previous reasoning_steps and the new reasoning_step
-            if "reasoning_steps" in session_state and current_run_id in session_state["reasoning_steps"]:
+            if (
+                "reasoning_steps" in run_context.session_state
+                and current_run_id in run_context.session_state["reasoning_steps"]
+            ):
                 formatted_reasoning_steps = ""
-                for i, step in enumerate(session_state["reasoning_steps"][current_run_id], 1):
+                for i, step in enumerate(run_context.session_state["reasoning_steps"][current_run_id], 1):
                     step_parsed = ReasoningStep.model_validate_json(step)
                     step_str = dedent(f"""\
 Step {i}:
@@ -112,7 +116,7 @@ Confidence: {step_parsed.confidence}
 
     def analyze(
         self,
-        session_state: Dict[str, Any],
+        run_context: RunContext,
         title: str,
         result: str,
         analysis: str,
@@ -150,20 +154,23 @@ Confidence: {step_parsed.confidence}
                 confidence=confidence,
             )
 
-            current_run_id = session_state.get("current_run_id", None)
+            current_run_id = run_context.run_id
             # Add this step to the Agent's session state
-            if session_state is None:
-                session_state = {}
-            if "reasoning_steps" not in session_state:
-                session_state["reasoning_steps"] = {}
-            if current_run_id not in session_state["reasoning_steps"]:
-                session_state["reasoning_steps"][current_run_id] = []
-            session_state["reasoning_steps"][current_run_id].append(reasoning_step.model_dump_json())
+            if run_context.session_state is None:
+                run_context.session_state = {}
+            if "reasoning_steps" not in run_context.session_state:
+                run_context.session_state["reasoning_steps"] = {}
+            if current_run_id not in run_context.session_state["reasoning_steps"]:
+                run_context.session_state["reasoning_steps"][current_run_id] = []
+            run_context.session_state["reasoning_steps"][current_run_id].append(reasoning_step.model_dump_json())
 
             # Return all previous reasoning_steps and the new reasoning_step
-            if "reasoning_steps" in session_state and current_run_id in session_state["reasoning_steps"]:
+            if (
+                "reasoning_steps" in run_context.session_state
+                and current_run_id in run_context.session_state["reasoning_steps"]
+            ):
                 formatted_reasoning_steps = ""
-                for i, step in enumerate(session_state["reasoning_steps"][current_run_id], 1):
+                for i, step in enumerate(run_context.session_state["reasoning_steps"][current_run_id], 1):
                     step_parsed = ReasoningStep.model_validate_json(step)
                     step_str = dedent(f"""\
 Step {i}:

agno/tools/tavily.py

@@ -15,6 +15,7 @@ class TavilyTools(Toolkit):
     def __init__(
         self,
         api_key: Optional[str] = None,
+        api_base_url: Optional[str] = None,
         enable_search: bool = True,
         enable_search_context: bool = False,
         enable_extract: bool = False,
@@ -34,6 +35,7 @@ class TavilyTools(Toolkit):
 
         Args:
             api_key: Tavily API key. If not provided, will use TAVILY_API_KEY env var.
+            api_base_url: Tavily API base URL. If not provided, will use TAVILY_API_BASE_URL env var. Defaults to None. If None - will use https://api.tavily.com.
             enable_search: Enable web search functionality. Defaults to True.
             enable_search_context: Use search context mode instead of regular search. Defaults to False.
             enable_extract: Enable URL content extraction functionality. Defaults to False.
@@ -52,8 +54,9 @@ class TavilyTools(Toolkit):
         self.api_key = api_key or getenv("TAVILY_API_KEY")
         if not self.api_key:
             logger.error("TAVILY_API_KEY not provided")
+        self.api_base_url = api_base_url or getenv("TAVILY_API_BASE_URL")
 
-        self.client: TavilyClient = TavilyClient(api_key=self.api_key)
+        self.client: TavilyClient = TavilyClient(api_key=self.api_key, api_base_url=self.api_base_url)
         self.search_depth: Literal["basic", "advanced"] = search_depth
         self.extract_depth: Literal["basic", "advanced"] = extract_depth
         self.max_tokens: int = max_tokens

agno/tools/websearch.py

@@ -0,0 +1,93 @@
+import json
+from typing import Any, List, Optional
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug
+
+try:
+    from ddgs import DDGS
+except ImportError:
+    raise ImportError("`ddgs` not installed. Please install using `pip install ddgs`")
+
+
+class WebSearchTools(Toolkit):
+    """
+    Toolkit for searching the web. Uses the meta-search library DDGS.
+    Multiple search backends (e.g. google, bing, duckduckgo) are available.
+
+    Args:
+        enable_search (bool): Enable web search function.
+        enable_news (bool): Enable news search function.
+        backend (str): The backend to use for searching. Defaults to "auto" which
+            automatically selects available backends. Other options include:
+            "duckduckgo", "google", "bing", "brave", "yandex", "yahoo", etc.
+        modifier (Optional[str]): A modifier to be prepended to search queries.
+        fixed_max_results (Optional[int]): A fixed number of maximum results.
+        proxy (Optional[str]): Proxy to be used for requests.
+        timeout (Optional[int]): The maximum number of seconds to wait for a response.
+        verify_ssl (bool): Whether to verify SSL certificates.
+    """
+
+    def __init__(
+        self,
+        enable_search: bool = True,
+        enable_news: bool = True,
+        backend: str = "auto",
+        modifier: Optional[str] = None,
+        fixed_max_results: Optional[int] = None,
+        proxy: Optional[str] = None,
+        timeout: Optional[int] = 10,
+        verify_ssl: bool = True,
+        **kwargs,
+    ):
+        self.proxy: Optional[str] = proxy
+        self.timeout: Optional[int] = timeout
+        self.fixed_max_results: Optional[int] = fixed_max_results
+        self.modifier: Optional[str] = modifier
+        self.verify_ssl: bool = verify_ssl
+        self.backend: str = backend
+
+        tools: List[Any] = []
+        if enable_search:
+            tools.append(self.web_search)
+        if enable_news:
+            tools.append(self.search_news)
+
+        super().__init__(name="websearch", tools=tools, **kwargs)
+
+    def web_search(self, query: str, max_results: int = 5) -> str:
+        """Use this function to search the web for a query.
+
+        Args:
+            query(str): The query to search for.
+            max_results (optional, default=5): The maximum number of results to return.
+
+        Returns:
+            The search results from the web.
+        """
+        actual_max_results = self.fixed_max_results or max_results
+        search_query = f"{self.modifier} {query}" if self.modifier else query
+
+        log_debug(f"Searching web for: {search_query} using backend: {self.backend}")
+        with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
+            results = ddgs.text(query=search_query, max_results=actual_max_results, backend=self.backend)
+
+        return json.dumps(results, indent=2)
+
+    def search_news(self, query: str, max_results: int = 5) -> str:
+        """Use this function to get the latest news from the web.
+
+        Args:
+            query(str): The query to search for.
+            max_results (optional, default=5): The maximum number of results to return.
+
+        Returns:
+            The latest news from the web.
+        """
+        actual_max_results = self.fixed_max_results or max_results
+
+        log_debug(f"Searching web news for: {query} using backend: {self.backend}")
+        with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
+            results = ddgs.news(query=query, max_results=actual_max_results, backend=self.backend)
+
+        return json.dumps(results, indent=2)

agno/tools/website.py

@@ -36,7 +36,7 @@ class WebsiteTools(Toolkit):
             return "Knowledge base not provided"
 
         log_debug(f"Adding to knowledge base: {url}")
-        self.knowledge.add_content(url=url)
+        self.knowledge.insert(url=url)
         return "Success"
 
     def read_url(self, url: str) -> str:

agno/tools/wikipedia.py

@@ -38,7 +38,7 @@ class WikipediaTools(Toolkit):
             return "Knowledge not provided"
 
         log_debug(f"Adding to knowledge: {topic}")
-        self.knowledge.add_content(
+        self.knowledge.insert(
             topics=[topic],
             reader=WikipediaReader(),
         )