Add long_term_memory_strategy support to client and MCP

- Add long_term_memory_strategy parameter to client get_or_create_working_memory() and get_or_create_working_memory_tool()
- Add long_term_memory_strategy parameter to MCP set_working_memory() tool
- Add MemoryStrategyConfig model to client models
- Fix documentation example using non-existent 'thread_aware' strategy and incorrect field names
- Bump client version to 0.13.0

Author: abrookins

agent-memory-client/agent_memory_client/__init__.py

@@ -5,7 +5,7 @@
 memory management capabilities for AI agents and applications.
 """
 
-__version__ = "0.12.7"
+__version__ = "0.13.0"
 
 from .client import MemoryAPIClient, MemoryClientConfig, create_memory_client
 from .exceptions import (

agent-memory-client/agent_memory_client/client.py

@@ -40,6 +40,7 @@
     MemoryMessage,
     MemoryRecord,
     MemoryRecordResults,
+    MemoryStrategyConfig,
     MemoryTypeEnum,
     ModelNameLiteral,
     RecencyConfig,
@@ -304,6 +305,7 @@ async def get_or_create_working_memory(
         namespace: str | None = None,
         model_name: ModelNameLiteral | None = None,
         context_window_max: int | None = None,
+        long_term_memory_strategy: MemoryStrategyConfig | None = None,
     ) -> tuple[bool, WorkingMemory]:
         """
         Get working memory for a session, creating it if it doesn't exist.
@@ -318,6 +320,8 @@ async def get_or_create_working_memory(
             namespace: Optional namespace for the session
             model_name: Optional model name to determine context window size
             context_window_max: Optional direct specification of context window tokens
+            long_term_memory_strategy: Optional strategy configuration for memory extraction
+                when promoting to long-term memory
 
         Returns:
             Tuple of (created: bool, memory: WorkingMemory)
@@ -338,6 +342,16 @@ async def get_or_create_working_memory(
                 logging.info("Found existing session")
 
             logging.info(f"Session has {len(memory.messages)} messages")
+
+            # With custom memory extraction strategy
+            created, memory = await client.get_or_create_working_memory(
+                session_id="chat_session_456",
+                user_id="user_789",
+                long_term_memory_strategy=MemoryStrategyConfig(
+                    strategy="summary",
+                    config={"max_summary_length": 500}
+                )
+            )
             ```
         """
         try:
@@ -390,6 +404,8 @@ async def get_or_create_working_memory(
                     memories=[],
                     data={},
                     user_id=user_id,
+                    long_term_memory_strategy=long_term_memory_strategy
+                    or MemoryStrategyConfig(),
                 )
 
                 created_memory = await self.put_working_memory(
@@ -1211,6 +1227,7 @@ async def get_or_create_working_memory_tool(
         session_id: str,
         namespace: str | None = None,
         user_id: str | None = None,
+        long_term_memory_strategy: MemoryStrategyConfig | None = None,
     ) -> dict[str, Any]:
         """
         Get or create working memory state formatted for LLM consumption.
@@ -1223,6 +1240,8 @@ async def get_or_create_working_memory_tool(
             session_id: The session ID to get or create memory for
             namespace: Optional namespace for the session
             user_id: Optional user ID for the session
+            long_term_memory_strategy: Optional strategy configuration for memory extraction
+                when promoting to long-term memory
 
         Returns:
             Dict with formatted working memory information and creation status
@@ -1242,13 +1261,23 @@ async def get_or_create_working_memory_tool(
             logging.info(memory_state["summary"])  # Human-readable summary
             logging.info(f"Messages: {memory_state['message_count']}")
             logging.info(f"Memories: {len(memory_state['memories'])}")
+
+            # With custom memory extraction strategy
+            memory_state = await client.get_or_create_working_memory_tool(
+                session_id="current_session",
+                long_term_memory_strategy=MemoryStrategyConfig(
+                    strategy="preferences",
+                    config={}
+                )
+            )
             ```
         """
         try:
             created, result = await self.get_or_create_working_memory(
                 session_id=session_id,
                 namespace=namespace or self.config.default_namespace,
                 user_id=user_id,
+                long_term_memory_strategy=long_term_memory_strategy,
             )
 
             # Format for LLM consumption

agent-memory-client/agent_memory_client/models.py

@@ -48,6 +48,17 @@ class MemoryTypeEnum(str, Enum):
     MESSAGE = "message"
 
 
+class MemoryStrategyConfig(BaseModel):
+    """Configuration for memory extraction strategy."""
+
+    strategy: Literal["discrete", "summary", "preferences", "custom"] = Field(
+        default="discrete", description="Type of memory extraction strategy to use"
+    )
+    config: dict[str, Any] = Field(
+        default_factory=dict, description="Strategy-specific configuration options"
+    )
+
+
 class MemoryMessage(BaseModel):
     """A message in the memory system"""
 
@@ -198,6 +209,10 @@ class WorkingMemory(BaseModel):
         default=None,
         description="Optional namespace for the working memory",
     )
+    long_term_memory_strategy: MemoryStrategyConfig = Field(
+        default_factory=MemoryStrategyConfig,
+        description="Configuration for memory extraction strategy when promoting to long-term memory",
+    )
 
     # TTL and timestamps
     ttl_seconds: int | None = Field(

agent_memory_server/mcp.py

@@ -37,6 +37,7 @@
     MemoryPromptResponse,
     MemoryRecord,
     MemoryRecordResults,
+    MemoryStrategyConfig,
     MemoryTypeEnum,
     ModelNameLiteral,
     SearchRequest,
@@ -703,6 +704,7 @@ async def set_working_memory(
     namespace: str | None = settings.default_mcp_namespace,
     user_id: str | None = settings.default_mcp_user_id,
     ttl_seconds: int = 3600,
+    long_term_memory_strategy: MemoryStrategyConfig | None = None,
 ) -> WorkingMemoryResponse:
     """
     Set working memory for a session. This works like the PUT /sessions/{id}/memory API endpoint.
@@ -795,6 +797,12 @@ async def set_working_memory(
         namespace: Optional namespace for scoping
         user_id: Optional user ID
         ttl_seconds: TTL for the working memory (default 1 hour)
+        long_term_memory_strategy: Optional strategy configuration for memory extraction
+            when promoting to long-term memory. Examples:
+            - MemoryStrategyConfig(strategy="discrete", config={})  # Default
+            - MemoryStrategyConfig(strategy="summary", config={"max_summary_length": 500})
+            - MemoryStrategyConfig(strategy="preferences", config={})
+            - MemoryStrategyConfig(strategy="custom", config={"custom_prompt": "..."})
 
     Returns:
         Updated working memory response (may include summarization if window exceeded)
@@ -847,22 +855,24 @@ async def set_working_memory(
 
             processed_messages.append(processed_message)
 
-    # Create the working memory object
-    working_memory_obj = WorkingMemory(
-        session_id=session_id,
+    # Create the UpdateWorkingMemory object (without session_id, which comes from URL path)
+    from agent_memory_server.models import UpdateWorkingMemory
+
+    update_memory_obj = UpdateWorkingMemory(
         namespace=namespace,
         memories=processed_memories,
         messages=processed_messages,
         context=context,
         data=data or {},
         user_id=user_id,
         ttl_seconds=ttl_seconds,
+        long_term_memory_strategy=long_term_memory_strategy or MemoryStrategyConfig(),
     )
 
     # Update working memory via the API - this handles summarization and background promotion
     result = await core_put_working_memory(
         session_id=session_id,
-        memory=working_memory_obj,
+        memory=update_memory_obj,
         background_tasks=get_background_tasks(),
     )
 

docs/working-memory.md

@@ -118,14 +118,12 @@ Working memory can automatically extract and promote memories to long-term stora
 By default, the memory server automatically analyzes working memory content and extracts meaningful memories in the background. This is ideal when you want the memory server to handle all LLM operations internally.
 
 ```python
-# Configure automatic extraction strategy
+# Configure automatic extraction strategy - use "summary" to create conversation summaries
 working_memory = WorkingMemory(
     session_id="chat_123",
     long_term_memory_strategy=MemoryStrategyConfig(
-        extraction_strategy="thread_aware",  # Analyzes conversation threads
-        custom_prompt="Extract key facts about user preferences and important events",
-        enable_topic_extraction=True,
-        enable_entity_extraction=True
+        strategy="summary",  # Creates conversation summaries
+        config={"max_summary_length": 500}
     ),
     messages=[
         MemoryMessage(role="user", content="I'm a software engineer at TechCorp"),
@@ -134,9 +132,32 @@ working_memory = WorkingMemory(
     ]
 )
 
-# The server will automatically extract memories like:
+# The server will automatically extract a summary like:
+# - "User is a software engineer at TechCorp who works with Python and React for web applications"
+
+# Or use "discrete" strategy (default) to extract individual facts:
+working_memory = WorkingMemory(
+    session_id="chat_123",
+    long_term_memory_strategy=MemoryStrategyConfig(
+        strategy="discrete",  # Extracts individual semantic and episodic facts
+        config={}
+    ),
+    messages=[...]
+)
+
+# The discrete strategy will extract separate memories like:
 # - "User is a software engineer at TechCorp"
 # - "User works with Python and React for web applications"
+
+# Or use "custom" strategy with your own extraction prompt:
+working_memory = WorkingMemory(
+    session_id="chat_123",
+    long_term_memory_strategy=MemoryStrategyConfig(
+        strategy="custom",
+        config={"custom_prompt": "Extract key facts about user preferences and important events"}
+    ),
+    messages=[...]
+)
 ```
 
 ### Your LLM Extracts (Client-Side)

tests/test_client_strategy_support.py

@@ -0,0 +1,138 @@
+"""Tests for client long_term_memory_strategy parameter support."""
+
+import pytest
+from agent_memory_client import MemoryAPIClient, MemoryClientConfig
+from agent_memory_client.models import MemoryStrategyConfig
+
+
+@pytest.fixture
+async def memory_client(use_test_redis_connection):
+    """Create a memory client for testing."""
+    from agent_memory_client import __version__
+
+    config = MemoryClientConfig(
+        base_url="http://test",
+        disable_auth=True,
+    )
+
+    # Import here to avoid circular imports
+    from httpx import ASGITransport, AsyncClient
+
+    from agent_memory_server.main import app
+
+    async with AsyncClient(
+        transport=ASGITransport(app=app),
+        base_url="http://test",
+        headers={
+            "User-Agent": f"agent-memory-client/{__version__}",
+            "X-Client-Version": __version__,
+        },
+    ) as http_client:
+        client = MemoryAPIClient(config=config)
+        client._client = http_client
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_get_or_create_working_memory_with_strategy(
+    memory_client: MemoryAPIClient,
+):
+    """Test get_or_create_working_memory with long_term_memory_strategy parameter."""
+    session_id = "test-strategy-session-1"
+
+    # Create with custom strategy
+    strategy = MemoryStrategyConfig(
+        strategy="summary", config={"max_summary_length": 500}
+    )
+
+    created, memory = await memory_client.get_or_create_working_memory(
+        session_id=session_id,
+        long_term_memory_strategy=strategy,
+    )
+
+    assert created is True
+    assert memory.session_id == session_id
+    assert memory.long_term_memory_strategy.strategy == "summary"
+    assert memory.long_term_memory_strategy.config == {"max_summary_length": 500}
+
+    # Get existing session - strategy should be preserved
+    created2, memory2 = await memory_client.get_or_create_working_memory(
+        session_id=session_id,
+    )
+
+    assert created2 is False
+    assert memory2.session_id == session_id
+    assert memory2.long_term_memory_strategy.strategy == "summary"
+    assert memory2.long_term_memory_strategy.config == {"max_summary_length": 500}
+
+
+@pytest.mark.asyncio
+async def test_get_or_create_working_memory_tool_with_strategy(
+    memory_client: MemoryAPIClient,
+):
+    """Test get_or_create_working_memory_tool with long_term_memory_strategy parameter."""
+    session_id = "test-strategy-session-2"
+
+    # Create with preferences strategy
+    strategy = MemoryStrategyConfig(strategy="preferences", config={})
+
+    result = await memory_client.get_or_create_working_memory_tool(
+        session_id=session_id,
+        long_term_memory_strategy=strategy,
+    )
+
+    assert result["created"] is True
+    assert result["session_id"] == session_id
+
+    # Verify the strategy was applied by getting the session
+    created, memory = await memory_client.get_or_create_working_memory(
+        session_id=session_id,
+    )
+
+    assert created is False
+    assert memory.long_term_memory_strategy.strategy == "preferences"
+
+
+@pytest.mark.asyncio
+async def test_get_or_create_working_memory_with_custom_strategy(
+    memory_client: MemoryAPIClient,
+):
+    """Test get_or_create_working_memory with custom strategy."""
+    session_id = "test-strategy-session-3"
+
+    # Create with custom strategy
+    strategy = MemoryStrategyConfig(
+        strategy="custom",
+        config={
+            "custom_prompt": "Extract technical decisions from: {message}\nReturn JSON."
+        },
+    )
+
+    created, memory = await memory_client.get_or_create_working_memory(
+        session_id=session_id,
+        long_term_memory_strategy=strategy,
+    )
+
+    assert created is True
+    assert memory.session_id == session_id
+    assert memory.long_term_memory_strategy.strategy == "custom"
+    assert "custom_prompt" in memory.long_term_memory_strategy.config
+
+
+@pytest.mark.asyncio
+async def test_get_or_create_working_memory_default_strategy(
+    memory_client: MemoryAPIClient,
+):
+    """Test get_or_create_working_memory uses default strategy when not specified."""
+    session_id = "test-strategy-session-4"
+
+    # Create without specifying strategy
+    created, memory = await memory_client.get_or_create_working_memory(
+        session_id=session_id,
+    )
+
+    assert created is True
+    assert memory.session_id == session_id
+    # Should default to discrete strategy
+    assert memory.long_term_memory_strategy.strategy == "discrete"
+    assert memory.long_term_memory_strategy.config == {}