Merge branch 'main' into claude/issue-42-20250801-1705

Author: abrookins

agent-memory-client/agent_memory_client/models.py

@@ -110,7 +110,7 @@ class MemoryRecord(BaseModel):
     )
     discrete_memory_extracted: Literal["t", "f"] = Field(
         default="f",
-        description="Whether memory extraction has run for this memory (only messages)",
+        description="Whether memory extraction has run for this memory",
     )
     memory_type: MemoryTypeEnum = Field(
         default=MemoryTypeEnum.MESSAGE,
@@ -130,6 +130,19 @@ class MemoryRecord(BaseModel):
     )
 
 
+class ExtractedMemoryRecord(MemoryRecord):
+    """A memory record that has already been extracted (e.g., explicit memories from API/MCP)"""
+
+    discrete_memory_extracted: Literal["t", "f"] = Field(
+        default="t",
+        description="Whether memory extraction has run for this memory",
+    )
+    memory_type: MemoryTypeEnum = Field(
+        default=MemoryTypeEnum.SEMANTIC,
+        description="Type of memory",
+    )
+
+
 class ClientMemoryRecord(MemoryRecord):
     """A memory record with a client-provided ID"""
 

agent_memory_server/__init__.py

@@ -1,3 +1,3 @@
 """Redis Agent Memory Server - A memory system for conversational AI."""
 
-__version__ = "0.9.3"
+__version__ = "0.9.4"

agent_memory_server/cli.py

@@ -128,11 +128,14 @@ async def setup_and_run():
             logger.info(f"Starting MCP server on port {port}\n")
             await mcp_app.run_sse_async()
         elif mode == "stdio":
-            # Logging already configured above
+            # Don't run a task worker in stdio mode.
+            # TODO: Make configurable with a CLI flag?
+            settings.use_docket = False
             await mcp_app.run_stdio_async()
         else:
             raise ValueError(f"Invalid mode: {mode}")
 
+    # TODO: Do we really need to update the port again?
     # Update the port in settings
     settings.mcp_port = port
 

agent_memory_server/long_term_memory.py

@@ -30,6 +30,7 @@
     get_model_client,
 )
 from agent_memory_server.models import (
+    ExtractedMemoryRecord,
     MemoryMessage,
     MemoryRecord,
     MemoryRecordResults,
@@ -593,7 +594,7 @@ async def compact_long_term_memories(
 
 
 async def index_long_term_memories(
-    memories: list[MemoryRecord],
+    memories: list[MemoryRecord | ExtractedMemoryRecord],
     redis_client: Redis | None = None,
     deduplicate: bool = False,
     vector_distance_threshold: float = 0.12,
@@ -1204,7 +1205,6 @@ async def promote_working_memory_to_long_term(
                     text=f"{msg.role}: {msg.content}",
                     namespace=namespace,
                     user_id=current_working_memory.user_id,
-                    memory_type=MemoryTypeEnum.MESSAGE,
                     persisted_at=None,
                 )
 

agent_memory_server/mcp.py

@@ -310,9 +310,7 @@ async def create_long_term_memories(
         if mem.user_id is None and settings.default_mcp_user_id:
             mem.user_id = settings.default_mcp_user_id
 
-    payload = CreateMemoryRecordRequest(
-        memories=[MemoryRecord(**mem.model_dump()) for mem in memories]
-    )
+    payload = CreateMemoryRecordRequest(memories=memories)
     return await core_create_long_term_memory(
         payload, background_tasks=get_background_tasks()
     )
@@ -360,14 +358,23 @@ async def search_long_term_memory(
     search_long_term_memory(text="user's favorite color")
     ```
 
-    2. Search with simple session filter:
+    2. Get ALL memories for a user (e.g., "what do you remember about me?"):
+    ```python
+    search_long_term_memory(
+        text="",  # Empty string returns all memories for the user
+        user_id={"eq": "user_123"},
+        limit=50  # Adjust based on how many memories you want
+    )
+    ```
+
+    3. Search with simple session filter:
     ```python
     search_long_term_memory(text="user's favorite color", session_id={
         "eq": "session_12345"
     })
     ```
 
-    3. Search with complex filters:
+    4. Search with complex filters:
     ```python
     search_long_term_memory(
         text="user preferences",
@@ -381,7 +388,7 @@ async def search_long_term_memory(
     )
     ```
 
-    4. Search with datetime range filters:
+    5. Search with datetime range filters:
     ```python
     search_long_term_memory(
         text="recent conversations",
@@ -395,7 +402,7 @@ async def search_long_term_memory(
     )
     ```
 
-    5. Search with between datetime filter:
+    6. Search with between datetime filter:
     ```python
     search_long_term_memory(
         text="holiday discussions",
@@ -406,7 +413,7 @@ async def search_long_term_memory(
     ```
 
     Args:
-        text: The semantic search query text (required)
+        text: The semantic search query text (required). Use empty string "" to get all memories for a user.
         session_id: Filter by session ID
         namespace: Filter by namespace
         topics: Filter by topics
@@ -482,20 +489,14 @@ async def memory_prompt(
     """
     Hydrate a user query with relevant session history and long-term memories.
 
-    CRITICAL: Use this tool for EVERY question that might benefit from memory context,
-    especially when you don't have sufficient information to answer confidently.
-
     This tool enriches the user's query by retrieving:
     1. Context from the current conversation session
     2. Relevant long-term memories related to the query
 
-    ALWAYS use this tool when:
-    - The user references past conversations
-    - The question is about user preferences or personal information
-    - You need additional context to provide a complete answer
-    - The question seems to assume information you don't have in current context
+    The tool returns both the relevant memories AND the user's query in a format ready for
+    generating comprehensive responses.
 
-    The function uses the text field from the payload as the user's query,
+    The function uses the query field from the payload as the user's query,
     and any filters to retrieve relevant memories.
 
     DATETIME INPUT FORMAT:
@@ -512,12 +513,20 @@ async def memory_prompt(
     COMMON USAGE PATTERNS:
     ```python
     1. Hydrate a user prompt with long-term memory search:
-    hydrate_memory_prompt(text="What was my favorite color?")
+    memory_prompt(query="What was my favorite color?")
+    ```
+
+    2. Answer "what do you remember about me?" type questions:
+    memory_prompt(
+        query="What do you remember about me?",
+        user_id={"eq": "user_123"},
+        limit=50
+    )
     ```
 
-    2. Hydrate a user prompt with long-term memory search and session filter:
-    hydrate_memory_prompt(
-        text="What is my favorite color?",
+    3. Hydrate a user prompt with long-term memory search and session filter:
+    memory_prompt(
+        query="What is my favorite color?",
         session_id={
             "eq": "session_12345"
         },
@@ -526,9 +535,9 @@ async def memory_prompt(
         }
     )
 
-    3. Hydrate a user prompt with long-term memory search and complex filters:
-    hydrate_memory_prompt(
-        text="What was my favorite color?",
+    4. Hydrate a user prompt with long-term memory search and complex filters:
+    memory_prompt(
+        query="What was my favorite color?",
         topics={
             "any": ["preferences", "settings"]
         },
@@ -538,9 +547,9 @@ async def memory_prompt(
         limit=5
     )
 
-    4. Search with datetime range filters:
-    hydrate_memory_prompt(
-        text="What did we discuss recently?",
+    5. Search with datetime range filters:
+    memory_prompt(
+        query="What did we discuss recently?",
         created_at={
             "gte": "2024-01-01T00:00:00Z",
             "lt": "2024-02-01T00:00:00Z"
@@ -552,7 +561,7 @@ async def memory_prompt(
     ```
 
     Args:
-        - text: The user's query
+        - query: The user's query
         - session_id: Add conversation history from a working memory session
         - namespace: Filter session and long-term memory namespace
         - topics: Search for long-term memories matching topics

agent_memory_server/models.py

@@ -130,7 +130,7 @@ class MemoryRecord(BaseModel):
     )
     discrete_memory_extracted: Literal["t", "f"] = Field(
         default="f",
-        description="Whether memory extraction has run for this memory (only messages)",
+        description="Whether memory extraction has run for this memory",
     )
     memory_type: MemoryTypeEnum = Field(
         default=MemoryTypeEnum.MESSAGE,
@@ -150,6 +150,19 @@ class MemoryRecord(BaseModel):
     )
 
 
+class ExtractedMemoryRecord(MemoryRecord):
+    """A memory record that has already been extracted (e.g., explicit memories from API/MCP)"""
+
+    discrete_memory_extracted: Literal["t", "f"] = Field(
+        default="t",
+        description="Whether memory extraction has run for this memory",
+    )
+    memory_type: MemoryTypeEnum = Field(
+        default=MemoryTypeEnum.SEMANTIC,
+        description="Type of memory",
+    )
+
+
 class ClientMemoryRecord(MemoryRecord):
     """A memory record with a client-provided ID"""
 
@@ -268,7 +281,7 @@ class MemoryRecordResultsResponse(MemoryRecordResults):
 class CreateMemoryRecordRequest(BaseModel):
     """Payload for creating memory records"""
 
-    memories: list[MemoryRecord]
+    memories: list[ExtractedMemoryRecord]
 
 
 class GetSessionsQuery(BaseModel):
@@ -401,7 +414,7 @@ class MemoryPromptResponse(BaseModel):
     messages: list[base.Message | SystemMessage]
 
 
-class LenientMemoryRecord(MemoryRecord):
+class LenientMemoryRecord(ExtractedMemoryRecord):
     """A memory record that can be created without an ID"""
 
     id: str | None = Field(default_factory=lambda: str(ULID()))

agent_memory_server/vectorstore_adapter.py

@@ -874,6 +874,9 @@ def parse_timestamp_to_datetime(timestamp_val):
                 topics=self._parse_list_field(doc.metadata.get("topics")),
                 entities=self._parse_list_field(doc.metadata.get("entities")),
                 memory_hash=doc.metadata.get("memory_hash", ""),
+                discrete_memory_extracted=doc.metadata.get(
+                    "discrete_memory_extracted", "f"
+                ),
                 memory_type=doc.metadata.get("memory_type", "message"),
                 persisted_at=doc.metadata.get("persisted_at"),
                 extracted_from=self._parse_list_field(

tests/test_mcp.py

@@ -437,3 +437,34 @@ async def test_set_working_memory_auto_id_generation(self, mcp_test_setup):
                     memory = working_memory.memories[0]
                     assert memory.id is not None
                     assert len(memory.id) > 0  # ULID generates non-empty strings
+
+    @pytest.mark.asyncio
+    async def test_mcp_lenient_memory_record_defaults(self, session, mcp_test_setup):
+        """Test that LenientMemoryRecord used by MCP has correct defaults for discrete_memory_extracted."""
+        from agent_memory_server.models import (
+            ExtractedMemoryRecord,
+            LenientMemoryRecord,
+        )
+
+        # Test 1: LenientMemoryRecord should default to discrete_memory_extracted='t'
+        lenient_memory = LenientMemoryRecord(
+            text="User likes green tea",
+            memory_type="semantic",
+            namespace="user_preferences",
+        )
+
+        assert (
+            lenient_memory.discrete_memory_extracted == "t"
+        ), f"LenientMemoryRecord should default to 't', got '{lenient_memory.discrete_memory_extracted}'"
+        assert lenient_memory.memory_type.value == "semantic"
+        assert lenient_memory.id is not None
+
+        # Test 2: ExtractedMemoryRecord should also default to discrete_memory_extracted='t'
+        extracted_memory = ExtractedMemoryRecord(
+            id="test_001", text="User prefers coffee", memory_type="semantic"
+        )
+
+        assert (
+            extracted_memory.discrete_memory_extracted == "t"
+        ), f"ExtractedMemoryRecord should default to 't', got '{extracted_memory.discrete_memory_extracted}'"
+        assert extracted_memory.memory_type.value == "semantic"

tests/test_vectorstore_adapter.py

@@ -1,9 +1,11 @@
 """Tests for the VectorStore adapter functionality."""
 
+import asyncio
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 
+from agent_memory_server.filters import Namespace
 from agent_memory_server.models import MemoryRecord, MemoryTypeEnum
 from agent_memory_server.vectorstore_adapter import (
     LangChainVectorStoreAdapter,
@@ -544,3 +546,70 @@ async def asimilarity_search_with_relevance_scores(
             )
 
             assert len(unprocessed_results_after.memories) == 0
+
+    def test_redis_adapter_preserves_discrete_memory_extracted_flag(self):
+        """Regression test: Ensure Redis adapter preserves discrete_memory_extracted='t' during search.
+
+        This test catches the bug where MCP-created memories with discrete_memory_extracted='t'
+        were being returned as 'f' because the Redis vector store adapter wasn't populating
+        the field during document-to-memory conversion.
+        """
+        from datetime import UTC, datetime
+        from unittest.mock import MagicMock
+
+        # Create mock vectorstore and embeddings
+        mock_vectorstore = MagicMock()
+        mock_embeddings = MagicMock()
+
+        # Create Redis adapter
+        adapter = RedisVectorStoreAdapter(mock_vectorstore, mock_embeddings)
+
+        # Mock document that simulates what Redis returns for an MCP-created memory
+        mock_doc = MagicMock()
+        mock_doc.page_content = "User likes green tea"
+        mock_doc.metadata = {
+            "id_": "memory_001",
+            "session_id": None,
+            "user_id": None,
+            "namespace": "user_preferences",
+            "created_at": datetime.now(UTC).timestamp(),
+            "updated_at": datetime.now(UTC).timestamp(),
+            "last_accessed": datetime.now(UTC).timestamp(),
+            "topics": "preferences,beverages",
+            "entities": "",
+            "memory_hash": "abc123",
+            "discrete_memory_extracted": "t",  # This should be preserved!
+            "memory_type": "semantic",
+            "persisted_at": None,
+            "extracted_from": "",
+            "event_date": None,
+        }
+
+        # Mock the search to return our test document
+        mock_vectorstore.asimilarity_search_with_relevance_scores = AsyncMock(
+            return_value=[(mock_doc, 0.9)]
+        )
+
+        # Perform search
+        result = asyncio.run(
+            adapter.search_memories(
+                query="green tea",
+                namespace=Namespace(field="namespace", eq="user_preferences"),
+                limit=10,
+            )
+        )
+
+        # Verify we got the memory back
+        assert len(result.memories) == 1
+        memory = result.memories[0]
+
+        # REGRESSION TEST: This should be 't', not 'f'
+        assert memory.discrete_memory_extracted == "t", (
+            f"Regression: Expected discrete_memory_extracted='t', got '{memory.discrete_memory_extracted}'. "
+            f"This indicates the Redis adapter is not preserving the flag during search."
+        )
+
+        # Also verify other expected properties
+        assert memory.memory_type.value == "semantic"
+        assert memory.namespace == "user_preferences"
+        assert memory.text == "User likes green tea"