agno 2.2.13__py3-none-any.whl

agno/tools/mem0.py

@@ -0,0 +1,193 @@
+import json
+from os import getenv
+from typing import Any, Dict, List, Optional, Union
+
+from agno.tools import Toolkit
+from agno.utils.log import log_debug, log_error, log_warning
+
+try:
+    from mem0.client.main import MemoryClient
+    from mem0.memory.main import Memory
+except ImportError:
+    raise ImportError("`mem0ai` package not found. Please install it with `pip install mem0ai`")
+
+
+class Mem0Tools(Toolkit):
+    def __init__(
+        self,
+        config: Optional[Dict[str, Any]] = None,
+        api_key: Optional[str] = None,
+        user_id: Optional[str] = None,
+        org_id: Optional[str] = None,
+        project_id: Optional[str] = None,
+        infer: bool = True,
+        enable_add_memory: bool = True,
+        enable_search_memory: bool = True,
+        enable_get_all_memories: bool = True,
+        enable_delete_all_memories: bool = True,
+        all: bool = False,
+        **kwargs,
+    ):
+        tools: List[Any] = []
+        if enable_add_memory or all:
+            tools.append(self.add_memory)
+        if enable_search_memory or all:
+            tools.append(self.search_memory)
+        if enable_get_all_memories or all:
+            tools.append(self.get_all_memories)
+        if enable_delete_all_memories or all:
+            tools.append(self.delete_all_memories)
+
+        super().__init__(name="mem0_tools", tools=tools, **kwargs)
+        self.api_key = api_key or getenv("MEM0_API_KEY")
+        self.user_id = user_id
+        self.org_id = org_id or getenv("MEM0_ORG_ID")
+        self.project_id = project_id or getenv("MEM0_PROJECT_ID")
+        self.client: Union[Memory, MemoryClient]
+        self.infer = infer
+
+        try:
+            if self.api_key:
+                log_debug("Using Mem0 Platform API key.")
+                client_kwargs = {"api_key": self.api_key}
+                if self.org_id:
+                    client_kwargs["org_id"] = self.org_id
+                if self.project_id:
+                    client_kwargs["project_id"] = self.project_id
+                self.client = MemoryClient(**client_kwargs)
+            elif config is not None:
+                log_debug("Using Mem0 with config.")
+                self.client = Memory.from_config(config)
+            else:
+                log_debug("Initializing Mem0 with default settings.")
+                self.client = Memory()
+        except Exception as e:
+            log_error(f"Failed to initialize Mem0 client: {e}")
+            raise ConnectionError("Failed to initialize Mem0 client. Ensure API keys/config are set.") from e
+
+    def _get_user_id(
+        self,
+        method_name: str,
+        session_state: Dict[str, Any],
+    ) -> str:
+        """Resolve the user ID"""
+        resolved_user_id = self.user_id
+        if not resolved_user_id:
+            try:
+                resolved_user_id = session_state.get("current_user_id")
+            except Exception:
+                pass
+        if not resolved_user_id:
+            error_msg = f"Error in {method_name}: A user_id must be provided in the method call."
+            log_error(error_msg)
+            return error_msg
+        return resolved_user_id
+
+    def add_memory(
+        self,
+        session_state,
+        content: Union[str, Dict[str, str]],
+    ) -> str:
+        """Add facts to the user's memory.
+        Args:
+            content(Union[str, Dict[str, str]]): The facts that should be stored.
+            Example:
+                content = "I live in NYC"
+                content = {"Name": "John", "Age": 30, "Location": "New York"}
+        Returns:
+            str: JSON-encoded Mem0 response or an error message.
+        """
+
+        resolved_user_id = self._get_user_id("add_memory", session_state=session_state)
+        if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in add_memory:"):
+            return resolved_user_id
+        try:
+            if isinstance(content, dict):
+                log_debug("Wrapping dict message into content string")
+                content = json.dumps(content)
+            elif not isinstance(content, str):
+                content = str(content)
+            messages_list = [{"role": "user", "content": content}]
+
+            result = self.client.add(
+                messages_list,
+                user_id=resolved_user_id,
+                infer=self.infer,
+            )
+            return json.dumps(result)
+        except Exception as e:
+            log_error(f"Error adding memory: {e}")
+            return f"Error adding memory: {e}"
+
+    def search_memory(
+        self,
+        session_state: Dict[str, Any],
+        query: str,
+    ) -> str:
+        """Semantic search for *query* across the user's stored memories."""
+
+        resolved_user_id = self._get_user_id("search_memory", session_state=session_state)
+        if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in search_memory:"):
+            return resolved_user_id
+        try:
+            results = self.client.search(
+                query=query,
+                user_id=resolved_user_id,
+            )
+
+            if isinstance(results, dict) and "results" in results:
+                search_results_list = results.get("results", [])
+            elif isinstance(results, list):
+                search_results_list = results
+            else:
+                log_warning(f"Unexpected return type from mem0.search: {type(results)}. Returning empty list.")
+                search_results_list = []
+
+            return json.dumps(search_results_list)
+        except ValueError as ve:
+            log_error(str(ve))
+            return str(ve)
+        except Exception as e:
+            log_error(f"Error searching memory: {e}")
+            return f"Error searching memory: {e}"
+
+    def get_all_memories(self, session_state: Dict[str, Any]) -> str:
+        """Return **all** memories for the current user as a JSON string."""
+
+        resolved_user_id = self._get_user_id("get_all_memories", session_state=session_state)
+        if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in get_all_memories:"):
+            return resolved_user_id
+        try:
+            results = self.client.get_all(
+                user_id=resolved_user_id,
+            )
+
+            if isinstance(results, dict) and "results" in results:
+                memories_list = results.get("results", [])
+            elif isinstance(results, list):
+                memories_list = results
+            else:
+                log_warning(f"Unexpected return type from mem0.get_all: {type(results)}. Returning empty list.")
+                memories_list = []
+            return json.dumps(memories_list)
+        except ValueError as ve:
+            log_error(str(ve))
+            return str(ve)
+        except Exception as e:
+            log_error(f"Error getting all memories: {e}")
+            return f"Error getting all memories: {e}"
+
+    def delete_all_memories(self, session_state: Dict[str, Any]) -> str:
+        """Delete *all* memories associated with the current user"""
+
+        resolved_user_id = self._get_user_id("delete_all_memories", session_state=session_state)
+        if isinstance(resolved_user_id, str) and resolved_user_id.startswith("Error in delete_all_memories:"):
+            error_msg = resolved_user_id
+            log_error(error_msg)
+            return f"Error deleting all memories: {error_msg}"
+        try:
+            self.client.delete_all(user_id=resolved_user_id)
+            return f"Successfully deleted all memories for user_id: {resolved_user_id}."
+        except Exception as e:
+            log_error(f"Error deleting all memories: {e}")
+            return f"Error deleting all memories: {e}"

agno/tools/memori.py

@@ -0,0 +1,339 @@
+import json
+from typing import Any, Dict, List, Optional
+
+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,
+        enable_search_memory: bool = True,
+        enable_record_conversation: bool = True,
+        enable_get_memory_stats: bool = True,
+        all: bool = False,
+        **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
+        """
+        tools: List[Any] = []
+        if all or enable_search_memory:
+            tools.append(self.search_memory)
+        if all or enable_record_conversation:
+            tools.append(self.record_conversation)
+        if all or enable_get_memory_stats:
+            tools.append(self.get_memory_stats)
+
+        super().__init__(name="memori_tools", tools=tools, **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,
+        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, 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,
+    ) -> 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