agno 2.3.1__py3-none-any.whl → 2.3.3__py3-none-any.whl

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/anthropic/claude.py

@@ -183,7 +183,7 @@ class Claude(Model):
             )
             return False
 
-        # Check for legacy model patterns that don't support structured outputs
+        # Check for legacy model patterns which don't support structured outputs
         if self.id.startswith("claude-3-"):
             return False
         if self.id.startswith("claude-sonnet-4-") and not self.id.startswith("claude-sonnet-4-5"):
@@ -222,64 +222,6 @@ class Claude(Model):
 
         return False
 
-    def _has_beta_features(
-        self,
-        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> bool:
-        """Check if the model has any Anthropic beta features enabled."""
-        return (
-            self.mcp_servers is not None
-            or self.context_management is not None
-            or self.skills is not None
-            or self.betas is not None
-            or self._using_structured_outputs(response_format, tools)
-        )
-
-    def get_client(self) -> AnthropicClient:
-        """
-        Returns an instance of the Anthropic client.
-        """
-        if self.client and not self.client.is_closed():
-            return self.client
-
-        _client_params = self._get_client_params()
-        if self.http_client:
-            if isinstance(self.http_client, httpx.Client):
-                _client_params["http_client"] = self.http_client
-            else:
-                log_warning("http_client is not an instance of httpx.Client. Using default global httpx.Client.")
-                # Use global sync client when user http_client is invalid
-                _client_params["http_client"] = get_default_sync_client()
-        else:
-            # Use global sync client when no custom http_client is provided
-            _client_params["http_client"] = get_default_sync_client()
-        self.client = AnthropicClient(**_client_params)
-        return self.client
-
-    def get_async_client(self) -> AsyncAnthropicClient:
-        """
-        Returns an instance of the async Anthropic client.
-        """
-        if self.async_client and not self.async_client.is_closed():
-            return self.async_client
-
-        _client_params = self._get_client_params()
-        if self.http_client:
-            if isinstance(self.http_client, httpx.AsyncClient):
-                _client_params["http_client"] = self.http_client
-            else:
-                log_warning(
-                    "http_client is not an instance of httpx.AsyncClient. Using default global httpx.AsyncClient."
-                )
-                # Use global async client when user http_client is invalid
-                _client_params["http_client"] = get_default_async_client()
-        else:
-            # Use global async client when no custom http_client is provided
-            _client_params["http_client"] = get_default_async_client()
-        self.async_client = AsyncAnthropicClient(**_client_params)
-        return self.async_client
-
     def _validate_thinking_support(self) -> None:
         """
         Validate that the current model supports extended thinking.
@@ -375,6 +317,81 @@ class Claude(Model):
 
         return None
 
+    def _validate_structured_outputs_usage(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> None:
+        """
+        Validate that structured outputs are only used with supported models.
+
+        Raises:
+            ValueError: If structured outputs are used with unsupported model
+        """
+        if not self._using_structured_outputs(response_format, tools):
+            return
+
+        if not self._supports_structured_outputs():
+            raise ValueError(f"Model '{self.id}' does not support structured outputs.\n\n")
+
+    def _has_beta_features(
+        self,
+        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
+        tools: Optional[List[Dict[str, Any]]] = None,
+    ) -> bool:
+        """Check if the model has any Anthropic beta features enabled."""
+        return (
+            self.mcp_servers is not None
+            or self.context_management is not None
+            or self.skills is not None
+            or self.betas is not None
+            or self._using_structured_outputs(response_format, tools)
+        )
+
+    def get_client(self) -> AnthropicClient:
+        """
+        Returns an instance of the Anthropic client.
+        """
+        if self.client and not self.client.is_closed():
+            return self.client
+
+        _client_params = self._get_client_params()
+        if self.http_client:
+            if isinstance(self.http_client, httpx.Client):
+                _client_params["http_client"] = self.http_client
+            else:
+                log_warning("http_client is not an instance of httpx.Client. Using default global httpx.Client.")
+                # Use global sync client when user http_client is invalid
+                _client_params["http_client"] = get_default_sync_client()
+        else:
+            # Use global sync client when no custom http_client is provided
+            _client_params["http_client"] = get_default_sync_client()
+        self.client = AnthropicClient(**_client_params)
+        return self.client
+
+    def get_async_client(self) -> AsyncAnthropicClient:
+        """
+        Returns an instance of the async Anthropic client.
+        """
+        if self.async_client and not self.async_client.is_closed():
+            return self.async_client
+
+        _client_params = self._get_client_params()
+        if self.http_client:
+            if isinstance(self.http_client, httpx.AsyncClient):
+                _client_params["http_client"] = self.http_client
+            else:
+                log_warning(
+                    "http_client is not an instance of httpx.AsyncClient. Using default global httpx.AsyncClient."
+                )
+                # Use global async client when user http_client is invalid
+                _client_params["http_client"] = get_default_async_client()
+        else:
+            # Use global async client when no custom http_client is provided
+            _client_params["http_client"] = get_default_async_client()
+        self.async_client = AsyncAnthropicClient(**_client_params)
+        return self.async_client
+
     def get_request_params(
         self,
         response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
@@ -427,23 +444,6 @@ class Claude(Model):
 
         return _request_params
 
-    def _validate_structured_outputs_usage(
-        self,
-        response_format: Optional[Union[Dict, Type[BaseModel]]] = None,
-        tools: Optional[List[Dict[str, Any]]] = None,
-    ) -> None:
-        """
-        Validate that structured outputs are only used with supported models.
-
-        Raises:
-            ValueError: If structured outputs are used with unsupported model
-        """
-        if not self._using_structured_outputs(response_format, tools):
-            return
-
-        if not self._supports_structured_outputs():
-            raise ValueError(f"Model '{self.id}' does not support structured outputs.\n\n")
-
     def _prepare_request_kwargs(
         self,
         system_message: str,
@@ -507,6 +507,7 @@ class Claude(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> ModelResponse:
         """
         Send a request to the Anthropic API to generate a response.
@@ -515,7 +516,7 @@ class Claude(Model):
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
 
-            chat_messages, system_message = format_messages(messages)
+            chat_messages, system_message = format_messages(messages, compress_tool_results=compress_tool_results)
             request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
             if self._has_beta_features(response_format=response_format, tools=tools):
@@ -563,6 +564,7 @@ class Claude(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> Any:
         """
         Stream a response from the Anthropic API.
@@ -578,7 +580,7 @@ class Claude(Model):
             RateLimitError: If the API rate limit is exceeded
             APIStatusError: For other API-related errors
         """
-        chat_messages, system_message = format_messages(messages)
+        chat_messages, system_message = format_messages(messages, compress_tool_results=compress_tool_results)
         request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
         try:
@@ -630,6 +632,7 @@ class Claude(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> ModelResponse:
         """
         Send an asynchronous request to the Anthropic API to generate a response.
@@ -638,7 +641,7 @@ class Claude(Model):
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
 
-            chat_messages, system_message = format_messages(messages)
+            chat_messages, system_message = format_messages(messages, compress_tool_results=compress_tool_results)
             request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
             # Beta features
@@ -687,6 +690,7 @@ class Claude(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> AsyncIterator[ModelResponse]:
         """
         Stream an asynchronous response from the Anthropic API.
@@ -703,7 +707,7 @@ class Claude(Model):
             if run_response and run_response.metrics:
                 run_response.metrics.set_time_to_first_token()
 
-            chat_messages, system_message = format_messages(messages)
+            chat_messages, system_message = format_messages(messages, compress_tool_results=compress_tool_results)
             request_kwargs = self._prepare_request_kwargs(system_message, tools=tools, response_format=response_format)
 
             if self._has_beta_features(response_format=response_format, tools=tools):

agno/models/aws/bedrock.py

@@ -219,21 +219,35 @@ class AwsBedrock(Model):
 
         return {k: v for k, v in request_kwargs.items() if v is not None}
 
-    def _format_messages(self, messages: List[Message]) -> Tuple[List[Dict[str, Any]], Optional[List[Dict[str, Any]]]]:
+    def _format_messages(
+        self, messages: List[Message], compress_tool_results: bool = False
+    ) -> Tuple[List[Dict[str, Any]], Optional[List[Dict[str, Any]]]]:
         """
         Format the messages for the request.
 
+        Args:
+            messages: List of messages to format
+            compress_tool_results: Whether to compress tool results
+
         Returns:
             Tuple[List[Dict[str, Any]], Optional[List[Dict[str, Any]]]]: The formatted messages.
         """
+
         formatted_messages: List[Dict[str, Any]] = []
         system_message = None
         for message in messages:
             if message.role == "system":
                 system_message = [{"text": message.content}]
+            elif message.role == "tool":
+                content = message.get_content(use_compressed_content=compress_tool_results)
+                tool_result = {
+                    "toolUseId": message.tool_call_id,
+                    "content": [{"json": {"result": content}}],
+                }
+                formatted_message: Dict[str, Any] = {"role": "user", "content": [{"toolResult": tool_result}]}
+                formatted_messages.append(formatted_message)
             else:
-                formatted_message: Dict[str, Any] = {"role": message.role, "content": []}
-                # Handle tool results
+                formatted_message = {"role": message.role, "content": []}
                 if isinstance(message.content, list):
                     formatted_message["content"].extend(message.content)
                 elif message.tool_calls:
@@ -352,12 +366,13 @@ class AwsBedrock(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> ModelResponse:
         """
         Invoke the Bedrock API.
         """
         try:
-            formatted_messages, system_message = self._format_messages(messages)
+            formatted_messages, system_message = self._format_messages(messages, compress_tool_results)
 
             tool_config = None
             if tools:
@@ -400,12 +415,13 @@ class AwsBedrock(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> Iterator[ModelResponse]:
         """
         Invoke the Bedrock API with streaming.
         """
         try:
-            formatted_messages, system_message = self._format_messages(messages)
+            formatted_messages, system_message = self._format_messages(messages, compress_tool_results)
 
             tool_config = None
             if tools:
@@ -452,12 +468,13 @@ class AwsBedrock(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> ModelResponse:
         """
         Async invoke the Bedrock API.
         """
         try:
-            formatted_messages, system_message = self._format_messages(messages)
+            formatted_messages, system_message = self._format_messages(messages, compress_tool_results)
 
             tool_config = None
             if tools:
@@ -503,12 +520,13 @@ class AwsBedrock(Model):
         tools: Optional[List[Dict[str, Any]]] = None,
         tool_choice: Optional[Union[str, Dict[str, Any]]] = None,
         run_response: Optional[RunOutput] = None,
+        compress_tool_results: bool = False,
     ) -> AsyncIterator[ModelResponse]:
         """
         Async invoke the Bedrock API with streaming.
         """
         try:
-            formatted_messages, system_message = self._format_messages(messages)
+            formatted_messages, system_message = self._format_messages(messages, compress_tool_results)
 
             tool_config = None
             if tools:
@@ -549,30 +567,34 @@ class AwsBedrock(Model):
 
     # Overwrite the default from the base model
     def format_function_call_results(
-        self, messages: List[Message], function_call_results: List[Message], **kwargs
+        self,
+        messages: List[Message],
+        function_call_results: List[Message],
+        compress_tool_results: bool = False,
+        **kwargs,
     ) -> None:
         """
-        Handle the results of function calls.
+        Handle the results of function calls for Bedrock.
+        Uses compressed_content if compress_tool_results is True.
 
         Args:
             messages (List[Message]): The list of conversation messages.
             function_call_results (List[Message]): The results of the function calls.
+            compress_tool_results: Whether to compress tool results.
             **kwargs: Additional arguments including tool_ids.
         """
+
         if function_call_results:
             tool_ids = kwargs.get("tool_ids", [])
-            tool_result_content: List = []
 
             for _fc_message_index, _fc_message in enumerate(function_call_results):
                 # Use tool_call_id from message if tool_ids list is insufficient
                 tool_id = tool_ids[_fc_message_index] if _fc_message_index < len(tool_ids) else _fc_message.tool_call_id
-                tool_result = {
-                    "toolUseId": tool_id,
-                    "content": [{"json": {"result": _fc_message.content}}],
-                }
-                tool_result_content.append({"toolResult": tool_result})
+                if not _fc_message.tool_call_id:
+                    _fc_message.tool_call_id = tool_id
 
-            messages.append(Message(role="user", content=tool_result_content))
+                # Append as standard role="tool" message
+                messages.append(_fc_message)
 
     def _parse_provider_response(self, response: Dict[str, Any], **kwargs) -> ModelResponse:
         """