agno 2.3.2__py3-none-any.whl → 2.3.4__py3-none-any.whl

agno/knowledge/reader/pdf_reader.py

@@ -406,7 +406,7 @@ class PDFImageReader(BasePDFReader):
             return []
 
         # Read and chunk.
-        return self._pdf_reader_to_documents(pdf_reader, doc_name, read_images=True, use_uuid_for_id=False)
+        return self._pdf_reader_to_documents(pdf_reader, doc_name, read_images=True, use_uuid_for_id=True)
 
     async def async_read(
         self, pdf: Union[str, Path, IO[Any]], name: Optional[str] = None, password: Optional[str] = None
@@ -428,4 +428,4 @@ class PDFImageReader(BasePDFReader):
             return []
 
         # Read and chunk.
-        return await self._async_pdf_reader_to_documents(pdf_reader, doc_name, read_images=True, use_uuid_for_id=False)
+        return await self._async_pdf_reader_to_documents(pdf_reader, doc_name, read_images=True, use_uuid_for_id=True)

agno/knowledge/reader/tavily_reader.py

@@ -140,7 +140,6 @@ class TavilyReader(Reader):
                 documents.extend(self.chunk_document(Document(name=name or url, id=url, content=content)))
             else:
                 documents.append(Document(name=name or url, id=url, content=content))
-
             return documents
 
         except Exception as e:

agno/memory/__init__.py

@@ -1,3 +1,16 @@
 from agno.memory.manager import MemoryManager, UserMemory
+from agno.memory.strategies import (
+    MemoryOptimizationStrategy,
+    MemoryOptimizationStrategyFactory,
+    MemoryOptimizationStrategyType,
+    SummarizeStrategy,
+)
 
-__all__ = ["MemoryManager", "UserMemory"]
+__all__ = [
+    "MemoryManager",
+    "UserMemory",
+    "MemoryOptimizationStrategy",
+    "MemoryOptimizationStrategyType",
+    "MemoryOptimizationStrategyFactory",
+    "SummarizeStrategy",
+]

agno/memory/manager.py

@@ -1,6 +1,5 @@
 from copy import deepcopy
 from dataclasses import dataclass
-from datetime import datetime
 from os import getenv
 from textwrap import dedent
 from typing import Any, Callable, Dict, List, Literal, Optional, Type, Union
@@ -9,6 +8,11 @@ from pydantic import BaseModel, Field
 
 from agno.db.base import AsyncBaseDb, BaseDb
 from agno.db.schemas import UserMemory
+from agno.memory.strategies import MemoryOptimizationStrategy
+from agno.memory.strategies.types import (
+    MemoryOptimizationStrategyFactory,
+    MemoryOptimizationStrategyType,
+)
 from agno.models.base import Model
 from agno.models.message import Message
 from agno.models.utils import get_model
@@ -90,9 +94,6 @@ class MemoryManager:
         self.clear_memories = clear_memories
         self.debug_mode = debug_mode
 
-        self._get_models()
-
-    def _get_models(self) -> None:
         if self.model is not None:
             self.model = get_model(self.model)
 
@@ -292,6 +293,74 @@ class MemoryManager:
             log_warning("Memory DB not provided.")
             return None
 
+    def clear_user_memories(self, user_id: Optional[str] = None) -> None:
+        """Clear all memories for a specific user.
+
+        Args:
+            user_id (Optional[str]): The user id to clear memories for. If not provided, clears memories for the "default" user.
+        """
+        if user_id is None:
+            log_warning("Using default user id.")
+            user_id = "default"
+
+        if not self.db:
+            log_warning("Memory DB not provided.")
+            return
+
+        if isinstance(self.db, AsyncBaseDb):
+            raise ValueError(
+                "clear_user_memories() is not supported with an async DB. Please use aclear_user_memories() instead."
+            )
+
+        # TODO: This is inefficient - we fetch all memories just to get their IDs.
+        # Extend delete_user_memories() to accept just user_id and delete all memories
+        # for that user directly without requiring a list of memory_ids.
+        memories = self.get_user_memories(user_id=user_id)
+        if not memories:
+            log_debug(f"No memories found for user {user_id}")
+            return
+
+        # Extract memory IDs
+        memory_ids = [mem.memory_id for mem in memories if mem.memory_id]
+
+        if memory_ids:
+            # Delete all memories in a single batch operation
+            self.db.delete_user_memories(memory_ids=memory_ids, user_id=user_id)
+            log_debug(f"Cleared {len(memory_ids)} memories for user {user_id}")
+
+    async def aclear_user_memories(self, user_id: Optional[str] = None) -> None:
+        """Clear all memories for a specific user (async).
+
+        Args:
+            user_id (Optional[str]): The user id to clear memories for. If not provided, clears memories for the "default" user.
+        """
+        if user_id is None:
+            user_id = "default"
+
+        if not self.db:
+            log_warning("Memory DB not provided.")
+            return
+
+        if isinstance(self.db, AsyncBaseDb):
+            memories = await self.aget_user_memories(user_id=user_id)
+        else:
+            memories = self.get_user_memories(user_id=user_id)
+
+        if not memories:
+            log_debug(f"No memories found for user {user_id}")
+            return
+
+        # Extract memory IDs
+        memory_ids = [mem.memory_id for mem in memories if mem.memory_id]
+
+        if memory_ids:
+            # Delete all memories in a single batch operation
+            if isinstance(self.db, AsyncBaseDb):
+                await self.db.delete_user_memories(memory_ids=memory_ids, user_id=user_id)
+            else:
+                self.db.delete_user_memories(memory_ids=memory_ids, user_id=user_id)
+            log_debug(f"Cleared {len(memory_ids)} memories for user {user_id}")
+
     # -*- Agent Functions
     def create_user_memories(
         self,
@@ -714,6 +783,150 @@ class MemoryManager:
 
         return sorted_memories_list
 
+    def optimize_memories(
+        self,
+        user_id: Optional[str] = None,
+        strategy: Union[
+            MemoryOptimizationStrategyType, MemoryOptimizationStrategy
+        ] = MemoryOptimizationStrategyType.SUMMARIZE,
+        apply: bool = True,
+    ) -> List[UserMemory]:
+        """Optimize user memories using the specified strategy.
+
+        Args:
+            user_id: User ID to optimize memories for. Defaults to "default".
+            strategy: Optimization strategy. Can be:
+                - Enum: MemoryOptimizationStrategyType.SUMMARIZE
+                - Instance: Custom MemoryOptimizationStrategy instance
+            apply: If True, automatically replace memories in database.
+
+        Returns:
+            List of optimized UserMemory objects.
+        """
+        if user_id is None:
+            user_id = "default"
+
+        if isinstance(self.db, AsyncBaseDb):
+            raise ValueError(
+                "optimize_memories() is not supported with an async DB. Please use aoptimize_memories() instead."
+            )
+
+        # Get user memories
+        memories = self.get_user_memories(user_id=user_id)
+        if not memories:
+            log_debug("No memories to optimize")
+            return []
+
+        # Get strategy instance
+        if isinstance(strategy, MemoryOptimizationStrategyType):
+            strategy_instance = MemoryOptimizationStrategyFactory.create_strategy(strategy)
+        else:
+            # Already a strategy instance
+            strategy_instance = strategy
+
+        # Optimize memories using strategy
+        optimization_model = self.get_model()
+        optimized_memories = strategy_instance.optimize(memories=memories, model=optimization_model)
+
+        # Apply to database if requested
+        if apply:
+            log_debug(f"Applying optimized memories to database for user {user_id}")
+
+            if not self.db:
+                log_warning("Memory DB not provided. Cannot apply optimized memories.")
+                return optimized_memories
+
+            # Clear all existing memories for the user
+            self.clear_user_memories(user_id=user_id)
+
+            # Add all optimized memories
+            for opt_mem in optimized_memories:
+                # Ensure memory has an ID (generate if needed for new memories)
+                if not opt_mem.memory_id:
+                    from uuid import uuid4
+
+                    opt_mem.memory_id = str(uuid4())
+
+                self.db.upsert_user_memory(memory=opt_mem)
+
+        optimized_tokens = strategy_instance.count_tokens(optimized_memories)
+        log_debug(f"Optimization complete. New token count: {optimized_tokens}")
+
+        return optimized_memories
+
+    async def aoptimize_memories(
+        self,
+        user_id: Optional[str] = None,
+        strategy: Union[
+            MemoryOptimizationStrategyType, MemoryOptimizationStrategy
+        ] = MemoryOptimizationStrategyType.SUMMARIZE,
+        apply: bool = True,
+    ) -> List[UserMemory]:
+        """Async version of optimize_memories.
+
+        Args:
+            user_id: User ID to optimize memories for. Defaults to "default".
+            strategy: Optimization strategy. Can be:
+                - Enum: MemoryOptimizationStrategyType.SUMMARIZE
+                - Instance: Custom MemoryOptimizationStrategy instance
+            apply: If True, automatically replace memories in database.
+
+        Returns:
+            List of optimized UserMemory objects.
+        """
+        if user_id is None:
+            user_id = "default"
+
+        # Get user memories - handle both sync and async DBs
+        if isinstance(self.db, AsyncBaseDb):
+            memories = await self.aget_user_memories(user_id=user_id)
+        else:
+            memories = self.get_user_memories(user_id=user_id)
+
+        if not memories:
+            log_debug("No memories to optimize")
+            return []
+
+        # Get strategy instance
+        if isinstance(strategy, MemoryOptimizationStrategyType):
+            strategy_instance = MemoryOptimizationStrategyFactory.create_strategy(strategy)
+        else:
+            # Already a strategy instance
+            strategy_instance = strategy
+
+        # Optimize memories using strategy (async)
+        optimization_model = self.get_model()
+        optimized_memories = await strategy_instance.aoptimize(memories=memories, model=optimization_model)
+
+        # Apply to database if requested
+        if apply:
+            log_debug(f"Optimizing memories for user {user_id}")
+
+            if not self.db:
+                log_warning("Memory DB not provided. Cannot apply optimized memories.")
+                return optimized_memories
+
+            # Clear all existing memories for the user
+            await self.aclear_user_memories(user_id=user_id)
+
+            # Add all optimized memories
+            for opt_mem in optimized_memories:
+                # Ensure memory has an ID (generate if needed for new memories)
+                if not opt_mem.memory_id:
+                    from uuid import uuid4
+
+                    opt_mem.memory_id = str(uuid4())
+
+                if isinstance(self.db, AsyncBaseDb):
+                    await self.db.upsert_user_memory(memory=opt_mem)
+                elif isinstance(self.db, BaseDb):
+                    self.db.upsert_user_memory(memory=opt_mem)
+
+        optimized_tokens = strategy_instance.count_tokens(optimized_memories)
+        log_debug(f"Memory optimization complete. New token count: {optimized_tokens}")
+
+        return optimized_memories
+
     # --Memory Manager Functions--
     def determine_tools_for_model(self, tools: List[Callable]) -> List[Union[Function, dict]]:
         # Have to reset each time, because of different user IDs

agno/memory/strategies/__init__.py

@@ -0,0 +1,15 @@
+"""Memory optimization strategy implementations."""
+
+from agno.memory.strategies.base import MemoryOptimizationStrategy
+from agno.memory.strategies.summarize import SummarizeStrategy
+from agno.memory.strategies.types import (
+    MemoryOptimizationStrategyFactory,
+    MemoryOptimizationStrategyType,
+)
+
+__all__ = [
+    "MemoryOptimizationStrategy",
+    "MemoryOptimizationStrategyFactory",
+    "MemoryOptimizationStrategyType",
+    "SummarizeStrategy",
+]

agno/memory/strategies/base.py

@@ -0,0 +1,67 @@
+from abc import ABC, abstractmethod
+from typing import List
+
+from agno.db.schemas import UserMemory
+from agno.models.base import Model
+from agno.utils.tokens import count_tokens as count_text_tokens
+
+
+class MemoryOptimizationStrategy(ABC):
+    """Abstract base class for memory optimization strategies.
+
+    Subclasses must implement optimize() and aoptimize().
+    get_system_prompt() is optional and only needed for LLM-based strategies.
+    """
+
+    def get_system_prompt(self) -> str:
+        """Get system prompt for this optimization strategy.
+
+        Returns:
+            System prompt string for LLM-based strategies.
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    def optimize(
+        self,
+        memories: List[UserMemory],
+        model: Model,
+    ) -> List[UserMemory]:
+        """Optimize memories synchronously.
+
+        Args:
+            memories: List of UserMemory objects to optimize
+            model: Model to use for optimization (if needed)
+
+        Returns:
+            List of optimized UserMemory objects
+        """
+        raise NotImplementedError
+
+    @abstractmethod
+    async def aoptimize(
+        self,
+        memories: List[UserMemory],
+        model: Model,
+    ) -> List[UserMemory]:
+        """Optimize memories asynchronously.
+
+        Args:
+            memories: List of UserMemory objects to optimize
+            model: Model to use for optimization (if needed)
+
+        Returns:
+            List of optimized UserMemory objects
+        """
+        raise NotImplementedError
+
+    def count_tokens(self, memories: List[UserMemory]) -> int:
+        """Count total tokens across all memories.
+
+        Args:
+            memories: List of UserMemory objects
+
+        Returns:
+            Total token count using tiktoken (or fallback estimation)
+        """
+        return sum(count_text_tokens(mem.memory or "") for mem in memories)

agno/memory/strategies/summarize.py

@@ -0,0 +1,196 @@
+"""Summarize strategy: Combine all memories into single comprehensive summary."""
+
+from textwrap import dedent
+from typing import List
+from uuid import uuid4
+
+from agno.db.schemas import UserMemory
+from agno.memory.strategies import MemoryOptimizationStrategy
+from agno.models.base import Model
+from agno.models.message import Message
+from agno.utils.dttm import now_epoch_s
+from agno.utils.log import log_debug
+
+
+class SummarizeStrategy(MemoryOptimizationStrategy):
+    """Combine all memories into single comprehensive summary.
+
+    This strategy summarizes all memories into one coherent narrative,
+    achieving maximum compression by eliminating redundancy. All
+    metadata (topics, user_id) is preserved in the summarized memory.
+    """
+
+    def _get_system_prompt(self) -> str:
+        """Get system prompt for memory summarization.
+
+        Returns:
+            System prompt string for LLM
+        """
+        return dedent("""\
+            You are a memory compression assistant. Your task is to summarize multiple memories about a user
+            into a single comprehensive summary while preserving all key facts.
+
+            Requirements:
+            - Combine related information from all memories
+            - Preserve all factual information
+            - Remove redundancy and consolidate repeated facts
+            - Create a coherent narrative about the user
+            - Maintain third-person perspective
+            - Do not add information not present in the original memories
+
+            Return only the summarized memory text, nothing else.\
+        """)
+
+    def optimize(
+        self,
+        memories: List[UserMemory],
+        model: Model,
+    ) -> List[UserMemory]:
+        """Summarize multiple memories into single comprehensive summary.
+
+        Args:
+            memories: List of UserMemory objects to summarize
+            model: Model to use for summarization
+
+        Returns:
+            List containing single summarized UserMemory object
+
+        Raises:
+            ValueError: If memories list is empty or if user_id cannot be determined
+        """
+        # Validate memories list
+        if not memories:
+            raise ValueError("No Memories found")
+
+        # Extract user_id from first memory
+        user_id = memories[0].user_id
+        if user_id is None:
+            raise ValueError("Cannot determine user_id: first memory does not have a valid user_id or is None")
+
+        # Collect all memory contents
+        memory_contents = [mem.memory for mem in memories if mem.memory]
+
+        # Combine topics - get unique topics from all memories
+        all_topics: List[str] = []
+        for mem in memories:
+            if mem.topics:
+                all_topics.extend(mem.topics)
+        summarized_topics = list(set(all_topics)) if all_topics else None
+
+        # Check if agent_id and team_id are consistent
+        agent_ids = {mem.agent_id for mem in memories if mem.agent_id}
+        summarized_agent_id = list(agent_ids)[0] if len(agent_ids) == 1 else None
+
+        team_ids = {mem.team_id for mem in memories if mem.team_id}
+        summarized_team_id = list(team_ids)[0] if len(team_ids) == 1 else None
+
+        # Create comprehensive prompt for summarization
+        combined_content = "\n\n".join([f"Memory {i + 1}: {content}" for i, content in enumerate(memory_contents)])
+
+        system_prompt = self._get_system_prompt()
+
+        messages_for_model = [
+            Message(role="system", content=system_prompt),
+            Message(role="user", content=f"Summarize these memories into a single summary:\n\n{combined_content}"),
+        ]
+
+        # Generate summarized content
+        response = model.response(messages=messages_for_model)
+        summarized_content = response.content or " ".join(memory_contents)
+
+        # Generate new memory_id
+        new_memory_id = str(uuid4())
+
+        # Create summarized memory
+        summarized_memory = UserMemory(
+            memory_id=new_memory_id,
+            memory=summarized_content.strip(),
+            topics=summarized_topics,
+            user_id=user_id,
+            agent_id=summarized_agent_id,
+            team_id=summarized_team_id,
+            updated_at=now_epoch_s(),
+        )
+
+        log_debug(
+            f"Summarized {len(memories)} memories into 1: {self.count_tokens(memories)} -> {self.count_tokens([summarized_memory])} tokens"
+        )
+
+        return [summarized_memory]
+
+    async def aoptimize(
+        self,
+        memories: List[UserMemory],
+        model: Model,
+    ) -> List[UserMemory]:
+        """Async version: Summarize multiple memories into single comprehensive summary.
+
+        Args:
+            memories: List of UserMemory objects to summarize
+            model: Model to use for summarization
+
+        Returns:
+            List containing single summarized UserMemory object
+
+        Raises:
+            ValueError: If memories list is empty or if user_id cannot be determined
+        """
+        # Validate memories list
+        if not memories:
+            raise ValueError("No Memories found")
+
+        # Extract user_id from first memory
+        user_id = memories[0].user_id
+        if user_id is None:
+            raise ValueError("Cannot determine user_id: first memory does not have a valid user_id or is None")
+
+        # Collect all memory contents
+        memory_contents = [mem.memory for mem in memories if mem.memory]
+
+        # Combine topics - get unique topics from all memories
+        all_topics: List[str] = []
+        for mem in memories:
+            if mem.topics:
+                all_topics.extend(mem.topics)
+        summarized_topics = list(set(all_topics)) if all_topics else None
+
+        # Check if agent_id and team_id are consistent
+        agent_ids = {mem.agent_id for mem in memories if mem.agent_id}
+        summarized_agent_id = list(agent_ids)[0] if len(agent_ids) == 1 else None
+
+        team_ids = {mem.team_id for mem in memories if mem.team_id}
+        summarized_team_id = list(team_ids)[0] if len(team_ids) == 1 else None
+
+        # Create comprehensive prompt for summarization
+        combined_content = "\n\n".join([f"Memory {i + 1}: {content}" for i, content in enumerate(memory_contents)])
+
+        system_prompt = self._get_system_prompt()
+
+        messages_for_model = [
+            Message(role="system", content=system_prompt),
+            Message(role="user", content=f"Summarize these memories into a single summary:\n\n{combined_content}"),
+        ]
+
+        # Generate summarized content (async)
+        response = await model.aresponse(messages=messages_for_model)
+        summarized_content = response.content or " ".join(memory_contents)
+
+        # Generate new memory_id
+        new_memory_id = str(uuid4())
+
+        # Create summarized memory
+        summarized_memory = UserMemory(
+            memory_id=new_memory_id,
+            memory=summarized_content.strip(),
+            topics=summarized_topics,
+            user_id=user_id,
+            agent_id=summarized_agent_id,
+            team_id=summarized_team_id,
+            updated_at=now_epoch_s(),
+        )
+
+        log_debug(
+            f"Summarized {len(memories)} memories into 1: {self.count_tokens(memories)} -> {self.count_tokens([summarized_memory])} tokens"
+        )
+
+        return [summarized_memory]

agno/memory/strategies/types.py

@@ -0,0 +1,37 @@
+"""Memory optimization strategy types and factory."""
+
+from enum import Enum
+
+from agno.memory.strategies import MemoryOptimizationStrategy
+
+
+class MemoryOptimizationStrategyType(str, Enum):
+    """Enumeration of available memory optimization strategies."""
+
+    SUMMARIZE = "summarize"
+
+
+class MemoryOptimizationStrategyFactory:
+    """Factory for creating memory optimization strategy instances."""
+
+    @classmethod
+    def create_strategy(cls, strategy_type: MemoryOptimizationStrategyType, **kwargs) -> MemoryOptimizationStrategy:
+        """Create an instance of the optimization strategy with given parameters.
+
+        Args:
+            strategy_type: Type of strategy to create
+            **kwargs: Additional parameters for strategy initialization
+
+        Returns:
+            MemoryOptimizationStrategy instance
+        """
+        strategy_map = {
+            MemoryOptimizationStrategyType.SUMMARIZE: cls._create_summarize_strategy,
+        }
+        return strategy_map[strategy_type](**kwargs)
+
+    @classmethod
+    def _create_summarize_strategy(cls, **kwargs) -> MemoryOptimizationStrategy:
+        from agno.memory.strategies.summarize import SummarizeStrategy
+
+        return SummarizeStrategy(**kwargs)

agno/models/aimlapi/aimlapi.py

@@ -2,6 +2,7 @@ from dataclasses import dataclass, field
 from os import getenv
 from typing import Any, Dict, Optional
 
+from agno.exceptions import ModelProviderError
 from agno.models.message import Message
 from agno.models.openai.like import OpenAILike
 
@@ -28,6 +29,23 @@ class AIMLAPI(OpenAILike):
     base_url: str = "https://api.aimlapi.com/v1"
     max_tokens: int = 4096
 
+    def _get_client_params(self) -> Dict[str, Any]:
+        """
+        Returns client parameters for API requests, checking for AIMLAPI_API_KEY.
+
+        Returns:
+            Dict[str, Any]: A dictionary of client parameters for API requests.
+        """
+        if not self.api_key:
+            self.api_key = getenv("AIMLAPI_API_KEY")
+            if not self.api_key:
+                raise ModelProviderError(
+                    message="AIMLAPI_API_KEY not set. Please set the AIMLAPI_API_KEY environment variable.",
+                    model_name=self.name,
+                    model_id=self.id,
+                )
+        return super()._get_client_params()
+
     def _format_message(self, message: Message) -> Dict[str, Any]:
         """
         Minimal additional formatter that only replaces None with empty string.