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

agno/app/agui/utils.py

@@ -129,7 +129,7 @@ def _create_events_from_chunk(
     Process a single chunk and return events to emit + updated message_started state.
     Returns: (events_to_emit, new_message_started_state)
     """
-    events_to_emit = []
+    events_to_emit: List[BaseEvent] = []
 
     # Extract content if the contextual event is a content event
     if chunk.event == RunEvent.run_response_content:

agno/app/fastapi/async_router.py

@@ -13,7 +13,7 @@ from agno.media import Audio, Image, Video
 from agno.media import File as FileMedia
 from agno.run.response import RunResponseErrorEvent
 from agno.run.team import RunResponseErrorEvent as TeamRunResponseErrorEvent
-from agno.run.team import TeamRunResponseEvent
+from agno.run.team import TeamRunResponse, TeamRunResponseEvent
 from agno.run.v2.workflow import WorkflowErrorEvent
 from agno.team.team import Team
 from agno.utils.log import logger
@@ -425,15 +425,18 @@ def get_async_router(
                 )
                 return run_response.to_dict()
             elif team:
-                team_run_response = await team.arun(
-                    message=message,
-                    session_id=session_id,
-                    user_id=user_id,
-                    images=base64_images if base64_images else None,
-                    audio=base64_audios if base64_audios else None,
-                    videos=base64_videos if base64_videos else None,
-                    files=document_files if document_files else None,
-                    stream=False,
+                team_run_response = cast(
+                    TeamRunResponse,
+                    await team.arun(
+                        message=message,
+                        session_id=session_id,
+                        user_id=user_id,
+                        images=base64_images if base64_images else None,
+                        audio=base64_audios if base64_audios else None,
+                        videos=base64_videos if base64_videos else None,
+                        files=document_files if document_files else None,
+                        stream=False,
+                    ),
                 )
                 return team_run_response.to_dict()
             elif workflow:

agno/knowledge/gcs/pdf.py

@@ -1,4 +1,4 @@
-from typing import AsyncIterator, Iterator, List, Optional, Dict, Any
+from typing import Any, AsyncIterator, Dict, Iterator, List, Optional
 
 from agno.document import Document
 from agno.document.reader.gcs.pdf_reader import GCSPDFReader
@@ -93,7 +93,7 @@ class GCSPDFKnowledgeBase(GCSKnowledgeBase):
         document_iterator = self.async_document_lists
         async for document_list in document_iterator:  # type: ignore
             documents_to_load = document_list
-            
+
             # Track metadata for filtering capabilities and collect metadata for filters
             filters_metadata: Optional[Dict[str, Any]] = None
             for doc in document_list:

agno/media.py

@@ -38,13 +38,34 @@ class ImageArtifact(Media):
     mime_type: Optional[str] = None
     alt_text: Optional[str] = None
 
+    def _normalise_content(self) -> Optional[Union[str, bytes]]:
+        if self.content is None:
+            return None
+        content_normalised: Union[str, bytes] = self.content
+        if content_normalised and isinstance(content_normalised, bytes):
+            from base64 import b64encode
+
+            try:
+                # First try to decode as UTF-8
+                content_normalised = content_normalised.decode("utf-8")  # type: ignore
+            except UnicodeDecodeError:
+                # Fallback to base64 encoding for binary content
+                content_normalised = b64encode(bytes(content_normalised)).decode("utf-8")  # type: ignore
+            except Exception:
+                # Last resort: try to convert to base64
+                try:
+                    content_normalised = b64encode(bytes(content_normalised)).decode("utf-8")  # type: ignore
+                except Exception:
+                    pass
+        return content_normalised
+
     def to_dict(self) -> Dict[str, Any]:
+        content_normalised = self._normalise_content()
+
         response_dict = {
             "id": self.id,
             "url": self.url,
-            "content": self.content.decode("utf-8")
-            if self.content and isinstance(self.content, bytes)
-            else self.content,
+            "content": content_normalised,
             "mime_type": self.mime_type,
             "alt_text": self.alt_text,
         }

agno/models/google/gemini.py

@@ -30,9 +30,11 @@ try:
         GoogleSearch,
         GoogleSearchRetrieval,
         Part,
+        Retrieval,
         ThinkingConfig,
         Tool,
         UrlContext,
+        VertexAISearch,
     )
     from google.genai.types import (
         File as GeminiFile,
@@ -70,6 +72,8 @@ class Gemini(Model):
     grounding: bool = False
     grounding_dynamic_threshold: Optional[float] = None
     url_context: bool = False
+    vertexai_search: bool = False
+    vertexai_search_datastore: Optional[str] = None
 
     temperature: Optional[float] = None
     top_p: Optional[float] = None
@@ -204,7 +208,9 @@ class Gemini(Model):
         builtin_tools = []
 
         if self.grounding:
-            log_info("Grounding enabled. This is a legacy tool. For Gemini 2.0+ Please use enable `search` flag instead.")
+            log_info(
+                "Grounding enabled. This is a legacy tool. For Gemini 2.0+ Please use enable `search` flag instead."
+            )
             builtin_tools.append(
                 Tool(
                     google_search=GoogleSearchRetrieval(
@@ -223,6 +229,15 @@ class Gemini(Model):
             log_info("URL context enabled.")
             builtin_tools.append(Tool(url_context=UrlContext()))
 
+        if self.vertexai_search:
+            log_info("Vertex AI Search enabled.")
+            if not self.vertexai_search_datastore:
+                log_error("vertexai_search_datastore must be provided when vertexai_search is enabled.")
+                raise ValueError("vertexai_search_datastore must be provided when vertexai_search is enabled.")
+            builtin_tools.append(
+                Tool(retrieval=Retrieval(vertex_ai_search=VertexAISearch(datastore=self.vertexai_search_datastore)))
+            )
+
         # Set tools in config
         if builtin_tools:
             if tools:

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/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/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