agno 1.7.12__py3-none-any.whl → 1.8.1__py3-none-any.whl

agno/tools/duckduckgo.py

@@ -5,9 +5,9 @@ from agno.tools import Toolkit
 from agno.utils.log import log_debug
 
 try:
-    from duckduckgo_search import DDGS
+    from ddgs import DDGS
 except ImportError:
-    raise ImportError("`duckduckgo-search` not installed. Please install using `pip install duckduckgo-search`")
+    raise ImportError("`duckduckgo-search` not installed. Please install using `pip install ddgs`")
 
 
 class DuckDuckGoTools(Toolkit):
@@ -18,9 +18,7 @@ class DuckDuckGoTools(Toolkit):
         news (bool): Enable DuckDuckGo news function.
         modifier (Optional[str]): A modifier to be used in the search request.
         fixed_max_results (Optional[int]): A fixed number of maximum results.
-        headers (Optional[Any]): Headers to be used in the search request.
         proxy (Optional[str]): Proxy to be used in the search request.
-        proxies (Optional[Any]): A list of proxies to be used in the search request.
         timeout (Optional[int]): The maximum number of seconds to wait for a response.
 
     """
@@ -31,16 +29,12 @@ class DuckDuckGoTools(Toolkit):
         news: bool = True,
         modifier: Optional[str] = None,
         fixed_max_results: Optional[int] = None,
-        headers: Optional[Any] = None,
         proxy: Optional[str] = None,
-        proxies: Optional[Any] = None,
         timeout: Optional[int] = 10,
         verify_ssl: bool = True,
         **kwargs,
     ):
-        self.headers: Optional[Any] = headers
         self.proxy: Optional[str] = proxy
-        self.proxies: Optional[Any] = proxies
         self.timeout: Optional[int] = timeout
         self.fixed_max_results: Optional[int] = fixed_max_results
         self.modifier: Optional[str] = modifier
@@ -68,11 +62,10 @@ class DuckDuckGoTools(Toolkit):
         search_query = f"{self.modifier} {query}" if self.modifier else query
 
         log_debug(f"Searching DDG for: {search_query}")
-        ddgs = DDGS(
-            headers=self.headers, proxy=self.proxy, proxies=self.proxies, timeout=self.timeout, verify=self.verify_ssl
-        )
+        with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
+            results = ddgs.text(search_query, max_results=actual_max_results)
 
-        return json.dumps(ddgs.text(keywords=search_query, max_results=actual_max_results), indent=2)
+        return json.dumps(results, indent=2)
 
     def duckduckgo_news(self, query: str, max_results: int = 5) -> str:
         """Use this function to get the latest news from DuckDuckGo.
@@ -87,8 +80,7 @@ class DuckDuckGoTools(Toolkit):
         actual_max_results = self.fixed_max_results or max_results
 
         log_debug(f"Searching DDG news for: {query}")
-        ddgs = DDGS(
-            headers=self.headers, proxy=self.proxy, proxies=self.proxies, timeout=self.timeout, verify=self.verify_ssl
-        )
+        with DDGS(proxy=self.proxy, timeout=self.timeout, verify=self.verify_ssl) as ddgs:
+            results = ddgs.news(query, max_results=actual_max_results)
 
-        return json.dumps(ddgs.news(keywords=query, max_results=actual_max_results), indent=2)
+        return json.dumps(results, indent=2)

agno/tools/e2b.py

@@ -58,7 +58,7 @@ class E2BTools(Toolkit):
 
         # According to official docs, the parameter is 'timeout' (in seconds), not 'timeout_ms'
         try:
-            self.sandbox = Sandbox(api_key=self.api_key, timeout=timeout, **self.sandbox_options)
+            self.sandbox = Sandbox.create(api_key=self.api_key, timeout=timeout, **self.sandbox_options)
         except Exception as e:
             logger.error(f"Warning: Could not create sandbox: {e}")
             raise e

agno/tools/github.py

@@ -1698,20 +1698,32 @@ class GithubTools(Toolkit):
             log_debug(f"Final search query: {search_query}")
             code_results = self.g.search_code(search_query)
 
-            # Process results
-            results = []
-            # Limit to 50 results to prevent timeouts
-            for code in code_results[:50]:
-                code_info = {
-                    "repository": code.repository.full_name,
-                    "path": code.path,
-                    "name": code.name,
-                    "sha": code.sha,
-                    "html_url": code.html_url,
-                    "git_url": code.git_url,
-                    "score": code.score,
-                }
-                results.append(code_info)
+            results: list[dict] = []
+            limit = 60
+            max_pages = 2  # GitHub returns 30 items per page, so 2 pages covers our limit
+            page_index = 0
+
+            while len(results) < limit and page_index < max_pages:
+                # Fetch one page of results from GitHub API
+                page_items = code_results.get_page(page_index)
+
+                # Stop if no more results available
+                if not page_items:
+                    break
+
+                # Process each code result in the current page
+                for code in page_items:
+                    code_info = {
+                        "repository": code.repository.full_name,
+                        "path": code.path,
+                        "name": code.name,
+                        "sha": code.sha,
+                        "html_url": code.html_url,
+                        "git_url": code.git_url,
+                        "score": code.score,
+                    }
+                    results.append(code_info)
+                page_index += 1
 
             # Return search results
             return json.dumps(

agno/tools/gmail.py

@@ -133,7 +133,7 @@ class GmailTools(Toolkit):
             send_email (bool): Enable sending emails. Defaults to True.
             search_emails (bool): Enable searching emails. Defaults to True.
             send_email_reply (bool): Enable sending email replies. Defaults to True.
-            creds (Optional[Credentials]): Pre-existing credentials. Defaults to None.
+            creds (Optional[Credentials]): Pre-fetched OAuth credentials. Use this to skip a new auth flow. Defaults to None.
             credentials_path (Optional[str]): Path to credentials file. Defaults to None.
             token_path (Optional[str]): Path to token file. Defaults to None.
             scopes (Optional[List[str]]): Custom OAuth scopes. If None, uses DEFAULT_SCOPES.

agno/tools/memori.py

@@ -0,0 +1,387 @@
+import json
+from typing import Any, Dict, Optional
+
+from agno.agent import Agent
+from agno.tools.toolkit import Toolkit
+from agno.utils.log import log_debug, log_error, log_info, log_warning
+
+try:
+    from memori import Memori, create_memory_tool
+except ImportError:
+    raise ImportError("`memorisdk` package not found. Please install it with `pip install memorisdk`")
+
+
+class MemoriTools(Toolkit):
+    """
+    Memori ToolKit for Agno Agents and Teams, providing persistent memory capabilities.
+
+    This toolkit integrates Memori's memory system with Agno, allowing Agents and Teams to:
+    - Store and retrieve conversation history
+    - Search through past interactions
+    - Maintain user preferences and context
+    - Build long-term memory across sessions
+
+    Requirements:
+        - pip install memorisdk
+        - Database connection string (SQLite, PostgreSQL, etc.)
+
+    Example:
+        ```python
+        from agno.tools.memori import MemoriTools
+
+        # Initialize with SQLite (default)
+        memori_tools = MemoriTools(
+            database_connect="sqlite:///agent_memory.db",
+            namespace="my_agent",
+            auto_ingest=True  # Automatically ingest conversations
+        )
+
+        # Add to agent
+        agent = Agent(
+            model=OpenAIChat(),
+            tools=[memori_tools],
+            description="An AI assistant with persistent memory"
+        )
+        ```
+    """
+
+    def __init__(
+        self,
+        database_connect: Optional[str] = None,
+        namespace: Optional[str] = None,
+        conscious_ingest: bool = True,
+        auto_ingest: bool = True,
+        verbose: bool = False,
+        config: Optional[Dict[str, Any]] = None,
+        auto_enable: bool = True,
+        **kwargs,
+    ):
+        """
+        Initialize Memori toolkit.
+
+        Args:
+            database_connect: Database connection string (e.g., "sqlite:///memory.db")
+            namespace: Namespace for organizing memories (e.g., "agent_v1", "user_session")
+            conscious_ingest: Whether to use conscious memory ingestion
+            auto_ingest: Whether to automatically ingest conversations into memory
+            verbose: Enable verbose logging from Memori
+            config: Additional Memori configuration
+            auto_enable: Automatically enable the memory system on initialization
+            **kwargs: Additional arguments passed to Toolkit base class
+        """
+        super().__init__(
+            name="memori_tools",
+            tools=[
+                self.search_memory,
+                self.record_conversation,
+                self.get_memory_stats,
+            ],
+            **kwargs,
+        )
+
+        # Set default database connection if not provided
+        if not database_connect:
+            sqlite_db = "sqlite:///agno_memori_memory.db"
+            log_info(f"No database connection provided, using default SQLite database at {sqlite_db}")
+            database_connect = sqlite_db
+
+        self.database_connect = database_connect
+        self.namespace = namespace or "agno_default"
+        self.conscious_ingest = conscious_ingest
+        self.auto_ingest = auto_ingest
+        self.verbose = verbose
+        self.config = config or {}
+
+        try:
+            # Initialize Memori memory system
+            log_debug(f"Initializing Memori with database: {self.database_connect}")
+            self.memory_system = Memori(
+                database_connect=self.database_connect,
+                conscious_ingest=self.conscious_ingest,
+                auto_ingest=self.auto_ingest,
+                verbose=self.verbose,
+                namespace=self.namespace,
+                **self.config,
+            )
+
+            # Enable the memory system if auto_enable is True
+            if auto_enable:
+                self.memory_system.enable()
+                log_debug("Memori memory system enabled")
+
+            # Create the memory tool for internal use
+            self._memory_tool = create_memory_tool(self.memory_system)
+
+        except Exception as e:
+            log_error(f"Failed to initialize Memori: {e}")
+            raise ConnectionError("Failed to initialize Memori memory system") from e
+
+    def search_memory(
+        self,
+        agent: Agent,
+        query: str,
+        limit: Optional[int] = None,
+    ) -> str:
+        """
+        Search the Agent's memory for past conversations and information.
+
+        This performs semantic search across all stored memories to find
+        relevant information based on the provided query.
+
+        Args:
+            query: What to search for in memory (e.g., "past conversations about AI", "user preferences")
+            limit: Maximum number of results to return (optional)
+
+        Returns:
+            str: JSON-encoded search results or error message
+
+        Example:
+            search_memory("user's favorite programming languages")
+            search_memory("previous discussions about machine learning")
+        """
+        try:
+            if not query.strip():
+                return json.dumps({"error": "Please provide a search query"})
+
+            log_debug(f"Searching memory for: {query}")
+
+            # Execute search using Memori's memory tool
+            result = self._memory_tool.execute(query=query.strip())
+
+            if result:
+                # If limit is specified, truncate results
+                if limit and isinstance(result, list):
+                    result = result[:limit]
+
+                return json.dumps(
+                    {
+                        "success": True,
+                        "query": query,
+                        "results": result,
+                        "count": len(result) if isinstance(result, list) else 1,
+                    }
+                )
+            else:
+                return json.dumps(
+                    {
+                        "success": True,
+                        "query": query,
+                        "results": [],
+                        "count": 0,
+                        "message": "No relevant memories found",
+                    }
+                )
+
+        except Exception as e:
+            log_error(f"Error searching memory: {e}")
+            return json.dumps({"success": False, "error": f"Memory search error: {str(e)}"})
+
+    def record_conversation(self, agent: Agent, content: str) -> str:
+        """
+        Add important information or facts to memory.
+
+        Use this tool to store important information, user preferences, facts, or context that should be remembered
+        for future conversations.
+
+        Args:
+            content: The information/facts to store in memory
+
+        Returns:
+            str: Success message or error details
+
+        Example:
+            record_conversation("User prefers Python over JavaScript")
+            record_conversation("User is working on an e-commerce project using Django")
+            record_conversation("User's name is John and they live in NYC")
+        """
+        try:
+            if not content.strip():
+                return json.dumps({"success": False, "error": "Content cannot be empty"})
+
+            log_debug(f"Adding conversation: {content}")
+
+            # Extract the actual AI response from the agent's conversation history
+            ai_output = "I've noted this information and will remember it."
+
+            self.memory_system.record_conversation(user_input=content, ai_output=str(ai_output))
+            return json.dumps(
+                {
+                    "success": True,
+                    "message": "Memory added successfully via conversation recording",
+                    "content_length": len(content),
+                }
+            )
+
+        except Exception as e:
+            log_error(f"Error adding memory: {e}")
+            return json.dumps({"success": False, "error": f"Failed to add memory: {str(e)}"})
+
+    def get_memory_stats(
+        self,
+        agent: Agent,
+    ) -> str:
+        """
+        Get statistics about the memory system.
+
+        Returns information about the current state of the memory system,
+        including total memories, memory distribution by retention type
+        (short-term vs long-term), and system configuration.
+
+        Returns:
+            str: JSON-encoded memory statistics
+
+        Example:
+            Returns statistics like:
+            {
+                "success": true,
+                "total_memories": 42,
+                "memories_by_retention": {
+                    "short_term": 5,
+                    "long_term": 37
+                },
+                "namespace": "my_agent",
+                "conscious_ingest": true,
+                "auto_ingest": true,
+                "memory_system_enabled": true
+            }
+        """
+        try:
+            log_debug("Retrieving memory statistics")
+
+            # Base stats about the system configuration
+            stats = {
+                "success": True,
+                "namespace": self.namespace,
+                "database_connect": self.database_connect,
+                "conscious_ingest": self.conscious_ingest,
+                "auto_ingest": self.auto_ingest,
+                "verbose": self.verbose,
+                "memory_system_enabled": hasattr(self.memory_system, "_enabled") and self.memory_system._enabled,
+            }
+
+            # Get Memori's built-in memory statistics
+            try:
+                if hasattr(self.memory_system, "get_memory_stats"):
+                    # Use the get_memory_stats method as shown in the example
+                    memori_stats = self.memory_system.get_memory_stats()
+
+                    # Add the Memori-specific stats to our response
+                    if isinstance(memori_stats, dict):
+                        # Include total memories
+                        if "total_memories" in memori_stats:
+                            stats["total_memories"] = memori_stats["total_memories"]
+
+                        # Include memory distribution by retention type
+                        if "memories_by_retention" in memori_stats:
+                            stats["memories_by_retention"] = memori_stats["memories_by_retention"]
+
+                            # Also add individual counts for convenience
+                            retention_info = memori_stats["memories_by_retention"]
+                            stats["short_term_memories"] = retention_info.get("short_term", 0)
+                            stats["long_term_memories"] = retention_info.get("long_term", 0)
+
+                        # Include any other available stats
+                        for key, value in memori_stats.items():
+                            if key not in stats:
+                                stats[key] = value
+
+                    log_debug(
+                        f"Retrieved memory stats: total={stats.get('total_memories', 0)}, "
+                        f"short_term={stats.get('short_term_memories', 0)}, "
+                        f"long_term={stats.get('long_term_memories', 0)}"
+                    )
+
+                else:
+                    log_debug("get_memory_stats method not available, providing basic stats only")
+                    stats["total_memories"] = 0
+                    stats["memories_by_retention"] = {"short_term": 0, "long_term": 0}
+                    stats["short_term_memories"] = 0
+                    stats["long_term_memories"] = 0
+
+            except Exception as e:
+                log_debug(f"Could not retrieve detailed memory stats: {e}")
+                # Provide basic stats if detailed stats fail
+                stats["total_memories"] = 0
+                stats["memories_by_retention"] = {"short_term": 0, "long_term": 0}
+                stats["short_term_memories"] = 0
+                stats["long_term_memories"] = 0
+                stats["stats_warning"] = "Detailed memory statistics not available"
+
+            return json.dumps(stats)
+
+        except Exception as e:
+            log_error(f"Error getting memory stats: {e}")
+            return json.dumps({"success": False, "error": f"Failed to get memory statistics: {str(e)}"})
+
+    def enable_memory_system(self) -> bool:
+        """Enable the Memori memory system."""
+        try:
+            self.memory_system.enable()
+            log_debug("Memori memory system enabled")
+            return True
+        except Exception as e:
+            log_error(f"Failed to enable memory system: {e}")
+            return False
+
+    def disable_memory_system(self) -> bool:
+        """Disable the Memori memory system."""
+        try:
+            if hasattr(self.memory_system, "disable"):
+                self.memory_system.disable()
+                log_debug("Memori memory system disabled")
+                return True
+            else:
+                log_warning("Memory system disable method not available")
+                return False
+        except Exception as e:
+            log_error(f"Failed to disable memory system: {e}")
+            return False
+
+
+def create_memori_search_tool(memori_toolkit: MemoriTools):
+    """
+    Create a standalone memory search function for use with Agno agents.
+
+    This is a convenience function that creates a memory search tool similar
+    to the pattern shown in the Memori example code.
+
+    Args:
+        memori_toolkit: An initialized MemoriTools instance
+
+    Returns:
+        Callable: A memory search function that can be used as an agent tool
+
+    Example:
+        ```python
+        memori_tools = MemoriTools(database_connect="sqlite:///memory.db")
+        search_tool = create_memori_search_tool(memori_tools)
+
+        agent = Agent(
+            model=OpenAIChat(),
+            tools=[search_tool],
+            description="Agent with memory search capability"
+        )
+        ```
+    """
+
+    def search_memory(query: str) -> str:
+        """
+        Search the agent's memory for past conversations and information.
+
+        Args:
+            query: What to search for in memory
+
+        Returns:
+            str: Search results or error message
+        """
+        try:
+            if not query.strip():
+                return "Please provide a search query"
+
+            result = memori_toolkit._memory_tool.execute(query=query.strip())
+            return str(result) if result else "No relevant memories found"
+
+        except Exception as e:
+            return f"Memory search error: {str(e)}"
+
+    return search_memory

agno/tools/neo4j.py

@@ -0,0 +1,132 @@
+import os
+from typing import Any, List, Optional
+
+try:
+    from neo4j import GraphDatabase
+except ImportError:
+    raise ImportError("`neo4j` not installed. Please install using `pip install neo4j`")
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, logger
+
+
+class Neo4jTools(Toolkit):
+    def __init__(
+        self,
+        uri: Optional[str] = None,
+        user: Optional[str] = None,
+        password: Optional[str] = None,
+        database: Optional[str] = None,
+        list_labels: bool = True,
+        list_relationships: bool = True,
+        get_schema: bool = True,
+        run_cypher: bool = True,
+        **kwargs,
+    ):
+        """
+        Initialize the Neo4jTools toolkit.
+        Connection parameters (uri/user/password or host/port) can be provided.
+        If not provided, falls back to NEO4J_URI, NEO4J_USERNAME, NEO4J_PASSWORD env vars.
+
+        Args:
+            uri (Optional[str]): The Neo4j URI.
+            user (Optional[str]): The Neo4j username.
+            password (Optional[str]): The Neo4j password.
+            host (Optional[str]): The Neo4j host.
+            port (Optional[int]): The Neo4j port.
+            database (Optional[str]): The Neo4j database.
+            list_labels (bool): Whether to list node labels.
+            list_relationships (bool): Whether to list relationship types.
+            get_schema (bool): Whether to get the schema.
+            run_cypher (bool): Whether to run Cypher queries.
+            **kwargs: Additional keyword arguments.
+        """
+        # Determine the connection URI and credentials
+        uri = uri or os.getenv("NEO4J_URI", "bolt://localhost:7687")
+        user = user or os.getenv("NEO4J_USERNAME")
+        password = password or os.getenv("NEO4J_PASSWORD")
+
+        if user is None or password is None:
+            raise ValueError("Username or password for Neo4j not provided")
+
+        # Create the Neo4j driver
+        try:
+            self.driver = GraphDatabase.driver(uri, auth=(user, password))  # type: ignore
+            self.driver.verify_connectivity()
+            log_debug("Connected to Neo4j database")
+        except Exception as e:
+            logger.error(f"Failed to connect to Neo4j: {e}")
+            raise
+
+        self.database = database or "neo4j"
+
+        # Register toolkit methods as tools
+        tools: List[Any] = []
+        if list_labels:
+            tools.append(self.list_labels)
+        if list_relationships:
+            tools.append(self.list_relationship_types)
+        if get_schema:
+            tools.append(self.get_schema)
+        if run_cypher:
+            tools.append(self.run_cypher_query)
+        super().__init__(name="neo4j_tools", tools=tools, **kwargs)
+
+    def list_labels(self) -> list:
+        """
+        Retrieve all node labels present in the connected Neo4j database.
+        """
+        try:
+            log_debug("Listing node labels in Neo4j database")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.labels()")
+                labels = [record["label"] for record in result]
+            return labels
+        except Exception as e:
+            logger.error(f"Error listing labels: {e}")
+            return []
+
+    def list_relationship_types(self) -> list:
+        """
+        Retrieve all relationship types present in the connected Neo4j database.
+        """
+        try:
+            log_debug("Listing relationship types in Neo4j database")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.relationshipTypes()")
+                types = [record["relationshipType"] for record in result]
+            return types
+        except Exception as e:
+            logger.error(f"Error listing relationship types: {e}")
+            return []
+
+    def get_schema(self) -> list:
+        """
+        Retrieve a visualization of the database schema, including nodes and relationships.
+        """
+        try:
+            log_debug("Retrieving Neo4j schema visualization")
+            with self.driver.session(database=self.database) as session:
+                result = session.run("CALL db.schema.visualization()")
+                schema_data = result.data()
+            return schema_data
+        except Exception as e:
+            logger.error(f"Error getting Neo4j schema: {e}")
+            return []
+
+    def run_cypher_query(self, query: str) -> list:
+        """
+        Execute an arbitrary Cypher query against the connected Neo4j database.
+
+        Args:
+            query (str): The Cypher query string to execute.
+        """
+        try:
+            log_debug(f"Running Cypher query: {query}")
+            with self.driver.session(database=self.database) as session:
+                result = session.run(query)  # type: ignore[arg-type]
+                data = result.data()
+            return data
+        except Exception as e:
+            logger.error(f"Error running Cypher query: {e}")
+            return []