bedrock-agentcore-starter-toolkit 0.1.13__py3-none-any.whl → 0.1.15__py3-none-any.whl

bedrock_agentcore_starter_toolkit/operations/memory/models/strategies/base.py

@@ -0,0 +1,77 @@
+"""Base classes and types for memory strategies."""
+
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+
+from pydantic import BaseModel, ConfigDict, Field
+
+if TYPE_CHECKING:
+    from .custom import CustomSemanticStrategy, CustomSummaryStrategy, CustomUserPreferenceStrategy
+    from .semantic import SemanticStrategy
+    from .summary import SummaryStrategy
+    from .user_preference import UserPreferenceStrategy
+
+
+class ExtractionConfig(BaseModel):
+    """Configuration for memory extraction operations.
+
+    Attributes:
+        append_to_prompt: Additional prompt text for extraction
+        model_id: Model identifier for extraction operations
+    """
+
+    append_to_prompt: Optional[str] = Field(None, description="Additional prompt text for extraction")
+    model_id: Optional[str] = Field(None, description="Model identifier for extraction operations")
+
+    model_config = ConfigDict(validate_by_name=True)
+
+
+class ConsolidationConfig(BaseModel):
+    """Configuration for memory consolidation operations.
+
+    Attributes:
+        append_to_prompt: Additional prompt text for consolidation
+        model_id: Model identifier for consolidation operations
+    """
+
+    append_to_prompt: Optional[str] = Field(None, description="Additional prompt text for consolidation")
+    model_id: Optional[str] = Field(None, description="Model identifier for consolidation operations")
+
+    model_config = ConfigDict(validate_by_name=True)
+
+
+class BaseStrategy(BaseModel, ABC):
+    """Abstract base class for all memory strategies.
+
+    Attributes:
+        name: Strategy name (required)
+        description: Optional strategy description
+        namespaces: List of namespace patterns for the strategy
+    """
+
+    name: str = Field(..., description="Strategy name")
+    description: Optional[str] = Field(None, description="Strategy description")
+    namespaces: Optional[List[str]] = Field(None, description="Strategy namespaces")
+
+    @abstractmethod
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert strategy to dictionary format for API calls.
+
+        Returns:
+            Dictionary representation compatible with the AgentCore Memory API
+        """
+        pass
+
+    model_config = ConfigDict(validate_assignment=True)
+
+
+# Type union for all strategy types (including backward compatibility)
+StrategyType = Union[
+    "SemanticStrategy",
+    "SummaryStrategy",
+    "CustomSemanticStrategy",
+    "CustomSummaryStrategy",
+    "CustomUserPreferenceStrategy",
+    "UserPreferenceStrategy",
+    Dict[str, Any],  # Backward compatibility with dict-based strategies
+]

bedrock_agentcore_starter_toolkit/operations/memory/models/strategies/custom.py

@@ -0,0 +1,194 @@
+"""Custom memory strategy implementation."""
+
+from typing import Any, Dict
+
+from pydantic import Field
+
+from .base import BaseStrategy, ConsolidationConfig, ExtractionConfig
+
+
+class CustomSemanticStrategy(BaseStrategy):
+    """Custom semantic strategy with configurable extraction and consolidation.
+
+    This strategy allows customization of both extraction and consolidation
+    processes using custom prompts and models.
+
+    Attributes:
+        extraction_config: Configuration for extraction operations
+        consolidation_config: Configuration for consolidation operations
+
+    Example:
+        strategy = CustomSemanticStrategy(
+            name="CustomExtraction",
+            description="Custom semantic extraction with specific prompts",
+            extraction_config=ExtractionConfig(
+                append_to_prompt="Extract key business insights",
+                model_id="anthropic.claude-3-sonnet-20240229-v1:0"
+            ),
+            consolidation_config=ConsolidationConfig(
+                append_to_prompt="Consolidate business insights",
+                model_id="anthropic.claude-3-haiku-20240307-v1:0"
+            ),
+            namespaces=["custom/{actorId}/{sessionId}"]
+        )
+    """
+
+    extraction_config: ExtractionConfig = Field(..., description="Extraction configuration")
+    consolidation_config: ConsolidationConfig = Field(..., description="Consolidation configuration")
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary format for API calls."""
+        config = {
+            "name": self.name,
+            "configuration": {
+                "semanticOverride": {
+                    "extraction": self._convert_extraction_config(),
+                    "consolidation": self._convert_consolidation_config(),
+                }
+            },
+        }
+
+        if self.description is not None:
+            config["description"] = self.description
+
+        if self.namespaces is not None:
+            config["namespaces"] = self.namespaces
+
+        return {"customMemoryStrategy": config}
+
+    def _convert_extraction_config(self) -> Dict[str, Any]:
+        """Convert extraction config to API format."""
+        config = {}
+        if self.extraction_config.append_to_prompt is not None:
+            config["appendToPrompt"] = self.extraction_config.append_to_prompt
+        if self.extraction_config.model_id is not None:
+            config["modelId"] = self.extraction_config.model_id
+        return config
+
+    def _convert_consolidation_config(self) -> Dict[str, Any]:
+        """Convert consolidation config to API format."""
+        config = {}
+        if self.consolidation_config.append_to_prompt is not None:
+            config["appendToPrompt"] = self.consolidation_config.append_to_prompt
+        if self.consolidation_config.model_id is not None:
+            config["modelId"] = self.consolidation_config.model_id
+        return config
+
+
+class CustomSummaryStrategy(BaseStrategy):
+    """Custom summary strategy with configurable consolidation.
+
+    This strategy allows customization of consolidation using custom prompts and models.
+
+    Attributes:
+        consolidation_config: Configuration for consolidation operations
+
+    Example:
+        strategy = CustomSummaryStrategy(
+            name="CustomSummary",
+            description="Custom summary extraction with specific prompts",
+            consolidation_config=ConsolidationConfig(
+                append_to_prompt="Consolidate business insights",
+                model_id="anthropic.claude-3-haiku-20240307-v1:0"
+            ),
+            namespaces=["custom/{actorId}/{sessionId}"]
+        )
+    """
+
+    consolidation_config: ConsolidationConfig = Field(..., description="Consolidation configuration")
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary format for API calls."""
+        config = {
+            "name": self.name,
+            "configuration": {
+                "summaryOverride": {
+                    "consolidation": self._convert_consolidation_config(),
+                }
+            },
+        }
+
+        if self.description is not None:
+            config["description"] = self.description
+
+        if self.namespaces is not None:
+            config["namespaces"] = self.namespaces
+
+        return {"customMemoryStrategy": config}
+
+    def _convert_consolidation_config(self) -> Dict[str, Any]:
+        """Convert consolidation config to API format."""
+        config = {}
+        if self.consolidation_config.append_to_prompt is not None:
+            config["appendToPrompt"] = self.consolidation_config.append_to_prompt
+        if self.consolidation_config.model_id is not None:
+            config["modelId"] = self.consolidation_config.model_id
+        return config
+
+
+class CustomUserPreferenceStrategy(BaseStrategy):
+    """Custom userPreference strategy with configurable extraction and consolidation.
+
+    This strategy allows customization of both extraction and consolidation
+    processes using custom prompts and models.
+
+    Attributes:
+        extraction_config: Configuration for extraction operations
+        consolidation_config: Configuration for consolidation operations
+
+    Example:
+        strategy = CustomUserPreferenceStrategy(
+            name="CustomUserPreference",
+            description="Custom user preference extraction with specific prompts",
+            extraction_config=ExtractionConfig(
+                append_to_prompt="Extract key business insights",
+                model_id="anthropic.claude-3-sonnet-20240229-v1:0"
+            ),
+            consolidation_config=ConsolidationConfig(
+                append_to_prompt="Consolidate business insights",
+                model_id="anthropic.claude-3-haiku-20240307-v1:0"
+            ),
+            namespaces=["custom/{actorId}/{sessionId}"]
+        )
+    """
+
+    extraction_config: ExtractionConfig = Field(..., description="Extraction configuration")
+    consolidation_config: ConsolidationConfig = Field(..., description="Consolidation configuration")
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary format for API calls."""
+        config = {
+            "name": self.name,
+            "configuration": {
+                "userPreferenceOverride": {
+                    "extraction": self._convert_extraction_config(),
+                    "consolidation": self._convert_consolidation_config(),
+                }
+            },
+        }
+
+        if self.description is not None:
+            config["description"] = self.description
+
+        if self.namespaces is not None:
+            config["namespaces"] = self.namespaces
+
+        return {"customMemoryStrategy": config}
+
+    def _convert_extraction_config(self) -> Dict[str, Any]:
+        """Convert extraction config to API format."""
+        config = {}
+        if self.extraction_config.append_to_prompt is not None:
+            config["appendToPrompt"] = self.extraction_config.append_to_prompt
+        if self.extraction_config.model_id is not None:
+            config["modelId"] = self.extraction_config.model_id
+        return config
+
+    def _convert_consolidation_config(self) -> Dict[str, Any]:
+        """Convert consolidation config to API format."""
+        config = {}
+        if self.consolidation_config.append_to_prompt is not None:
+            config["appendToPrompt"] = self.consolidation_config.append_to_prompt
+        if self.consolidation_config.model_id is not None:
+            config["modelId"] = self.consolidation_config.model_id
+        return config

bedrock_agentcore_starter_toolkit/operations/memory/models/strategies/semantic.py

@@ -0,0 +1,35 @@
+"""Semantic memory strategy implementation."""
+
+from typing import Any, Dict
+
+from .base import BaseStrategy
+
+
+class SemanticStrategy(BaseStrategy):
+    """Semantic memory strategy for extracting and storing semantic information.
+
+    This strategy extracts semantic meaning from conversations and stores it
+    for later retrieval. It's ideal for capturing facts, concepts, and
+    contextual information from user interactions.
+
+    Example:
+        strategy = SemanticStrategy(
+            name="ConversationSemantics",
+            description="Extract semantic information from conversations",
+            namespaces=["semantics/{actorId}/{sessionId}"]
+        )
+    """
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary format for API calls."""
+        config = {
+            "name": self.name,
+        }
+
+        if self.description is not None:
+            config["description"] = self.description
+
+        if self.namespaces is not None:
+            config["namespaces"] = self.namespaces
+
+        return {"semanticMemoryStrategy": config}

bedrock_agentcore_starter_toolkit/operations/memory/models/strategies/summary.py

@@ -0,0 +1,35 @@
+"""Summary memory strategy implementation."""
+
+from typing import Any, Dict
+
+from .base import BaseStrategy
+
+
+class SummaryStrategy(BaseStrategy):
+    """Summary memory strategy for creating conversation summaries.
+
+    This strategy creates summaries of conversations, helping to maintain
+    context over long interactions and reducing the need to process
+    entire conversation histories.
+
+    Example:
+        strategy = SummaryStrategy(
+            name="ConversationSummary",
+            description="Summarize conversation content",
+            namespaces=["summaries/{actorId}/{sessionId}"]
+        )
+    """
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary format for API calls."""
+        config = {
+            "name": self.name,
+        }
+
+        if self.description is not None:
+            config["description"] = self.description
+
+        if self.namespaces is not None:
+            config["namespaces"] = self.namespaces
+
+        return {"summaryMemoryStrategy": config}

bedrock_agentcore_starter_toolkit/operations/memory/models/strategies/user_preference.py

@@ -0,0 +1,34 @@
+"""User preference memory strategy implementation."""
+
+from typing import Any, Dict
+
+from .base import BaseStrategy
+
+
+class UserPreferenceStrategy(BaseStrategy):
+    """User preference memory strategy for storing user preferences and settings.
+
+    This strategy captures and stores user preferences, settings, and
+    behavioral patterns that persist across sessions.
+
+    Example:
+        strategy = UserPreferenceStrategy(
+            name="UserPreferences",
+            description="Store user preferences and settings",
+            namespaces=["preferences/{actorId}"]
+        )
+    """
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary format for API calls."""
+        config = {
+            "name": self.name,
+        }
+
+        if self.description is not None:
+            config["description"] = self.description
+
+        if self.namespaces is not None:
+            config["namespaces"] = self.namespaces
+
+        return {"userPreferenceMemoryStrategy": config}