Grab bag of updates, fixes

Author: abrookins

agent-memory-client/agent_memory_client/__init__.py

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

agent-memory-client/agent_memory_client/client.py

@@ -6,7 +6,7 @@
 
 import asyncio
 import re
-from collections.abc import AsyncIterator
+from collections.abc import AsyncIterator, Sequence
 from typing import TYPE_CHECKING, Any, Literal, TypedDict
 
 if TYPE_CHECKING:
@@ -416,7 +416,7 @@ async def set_working_memory_data(
     async def add_memories_to_working_memory(
         self,
         session_id: str,
-        memories: list[ClientMemoryRecord | MemoryRecord],
+        memories: Sequence[ClientMemoryRecord | MemoryRecord],
         namespace: str | None = None,
         replace: bool = False,
     ) -> WorkingMemoryResponse:
@@ -482,7 +482,7 @@ async def add_memories_to_working_memory(
         return await self.put_working_memory(session_id, working_memory)
 
     async def create_long_term_memory(
-        self, memories: list[ClientMemoryRecord | MemoryRecord]
+        self, memories: Sequence[ClientMemoryRecord | MemoryRecord]
     ) -> AckResponse:
         """
         Create long-term memories for later retrieval.
@@ -541,6 +541,29 @@ async def create_long_term_memory(
             self._handle_http_error(e.response)
             raise
 
+    async def delete_long_term_memories(self, memory_ids: Sequence[str]) -> AckResponse:
+        """
+        Delete long-term memories.
+
+        Args:
+            memory_ids: List of memory IDs to delete
+
+        Returns:
+            AckResponse indicating success
+        """
+        params = {"memory_ids": list(memory_ids)}
+
+        try:
+            response = await self._client.delete(
+                "/v1/long-term-memory",
+                params=params,
+            )
+            response.raise_for_status()
+            return AckResponse(**response.json())
+        except httpx.HTTPStatusError as e:
+            self._handle_http_error(e.response)
+            raise
+
     async def search_long_term_memory(
         self,
         text: str,
@@ -666,8 +689,8 @@ async def search_long_term_memory(
     async def search_memory_tool(
         self,
         query: str,
-        topics: list[str] | None = None,
-        entities: list[str] | None = None,
+        topics: Sequence[str] | None = None,
+        entities: Sequence[str] | None = None,
         memory_type: str | None = None,
         max_results: int = 5,
         min_relevance: float | None = None,
@@ -940,8 +963,8 @@ async def add_memory_tool(
         session_id: str,
         text: str,
         memory_type: str,
-        topics: list[str] | None = None,
-        entities: list[str] | None = None,
+        topics: Sequence[str] | None = None,
+        entities: Sequence[str] | None = None,
         namespace: str | None = None,
         user_id: str | None = None,
     ) -> dict[str, Any]:
@@ -1172,7 +1195,7 @@ def get_update_memory_data_tool_schema(cls) -> dict[str, Any]:
         }
 
     @classmethod
-    def get_all_memory_tool_schemas(cls) -> list[dict[str, Any]]:
+    def get_all_memory_tool_schemas(cls) -> Sequence[dict[str, Any]]:
         """
         Get all memory-related tool schemas for easy LLM integration.
 
@@ -1200,7 +1223,7 @@ def get_all_memory_tool_schemas(cls) -> list[dict[str, Any]]:
         ]
 
     @classmethod
-    def get_all_memory_tool_schemas_anthropic(cls) -> list[dict[str, Any]]:
+    def get_all_memory_tool_schemas_anthropic(cls) -> Sequence[dict[str, Any]]:
         """
         Get all memory-related tool schemas in Anthropic format.
 
@@ -1470,11 +1493,11 @@ async def resolve_tool_call(
 
     async def resolve_tool_calls(
         self,
-        tool_calls: list[dict[str, Any]],
+        tool_calls: Sequence[dict[str, Any]],
         session_id: str,
         namespace: str | None = None,
         user_id: str | None = None,
-    ) -> list[ToolCallResolutionResult]:
+    ) -> Sequence[ToolCallResolutionResult]:
         """
         Resolve multiple tool calls from any LLM provider format.
 
@@ -1713,11 +1736,11 @@ async def _resolve_update_memory_data(
 
     async def resolve_function_calls(
         self,
-        function_calls: list[dict[str, Any]],
+        function_calls: Sequence[dict[str, Any]],
         session_id: str,
         namespace: str | None = None,
         user_id: str | None = None,
-    ) -> list[ToolCallResolutionResult]:
+    ) -> Sequence[ToolCallResolutionResult]:
         """
         Resolve multiple function calls in batch.
 
@@ -1765,7 +1788,7 @@ async def resolve_function_calls(
     async def promote_working_memories_to_long_term(
         self,
         session_id: str,
-        memory_ids: list[str] | None = None,
+        memory_ids: Sequence[str] | None = None,
         namespace: str | None = None,
     ) -> AckResponse:
         """
@@ -1805,10 +1828,10 @@ async def promote_working_memories_to_long_term(
 
     async def bulk_create_long_term_memories(
         self,
-        memory_batches: list[list[ClientMemoryRecord | MemoryRecord]],
+        memory_batches: Sequence[Sequence[ClientMemoryRecord | MemoryRecord]],
         batch_size: int = 100,
         delay_between_batches: float = 0.1,
-    ) -> list[AckResponse]:
+    ) -> Sequence[AckResponse]:
         """
         Create multiple batches of memories with proper rate limiting.
 
@@ -2104,6 +2127,8 @@ async def memory_prompt(
         """
         Hydrate a user query with memory context and return a prompt ready to send to an LLM.
 
+        NOTE: `long_term_search` uses the same filter options as `search_long_term_memories`.
+
         Args:
             query: The input text to find relevant context for
             session_id: Optional session ID to include session messages
@@ -2163,9 +2188,17 @@ async def memory_prompt(
 
         # Add long-term search parameters if provided
         if long_term_search is not None:
+            if "namespace" not in long_term_search:
+                if namespace is not None:
+                    long_term_search["namespace"] = {"eq": namespace}
+                elif self.config.default_namespace is not None:
+                    long_term_search["namespace"] = {
+                        "eq": self.config.default_namespace
+                    }
             payload["long_term_search"] = long_term_search
 
         try:
+            print("Payload: ", payload)
             response = await self._client.post(
                 "/v1/memory/prompt",
                 json=payload,

agent_memory_server/__init__.py

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

agent_memory_server/api.py

@@ -1,5 +1,5 @@
 import tiktoken
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, HTTPException, Query
 from mcp.server.fastmcp.prompts import base
 from mcp.types import TextContent
 from ulid import ULID
@@ -338,7 +338,7 @@ async def put_working_memory(
                 updated_memory.namespace,
             )
 
-        # Index message-based memories (existing logic)
+        # Index message-based memories
         if updated_memory.messages:
             from agent_memory_server.models import MemoryRecord
 
@@ -348,6 +348,7 @@ async def put_working_memory(
                     session_id=session_id,
                     text=f"{msg.role}: {msg.content}",
                     namespace=updated_memory.namespace,
+                    user_id=updated_memory.user_id,
                     memory_type=MemoryTypeEnum.MESSAGE,
                 )
                 for msg in updated_memory.messages
@@ -452,20 +453,41 @@ async def search_long_term_memory(
     # Extract filter objects from the payload
     filters = payload.get_filters()
 
+    print("Long-term search filters: ", filters)
+
     kwargs = {
         "distance_threshold": payload.distance_threshold,
         "limit": payload.limit,
         "offset": payload.offset,
         **filters,
     }
 
-    if payload.text:
-        kwargs["text"] = payload.text
+    print("Kwargs: ", kwargs)
+
+    kwargs["text"] = payload.text or ""
 
     # Pass text and filter objects to the search function (no redis needed for vectorstore adapter)
     return await long_term_memory.search_long_term_memories(**kwargs)
 
 
+@router.delete("/v1/long-term-memory", response_model=AckResponse)
+async def delete_long_term_memory(
+    memory_ids: list[str] = Query(default=[], alias="memory_ids"),
+    current_user: UserInfo = Depends(get_current_user),
+):
+    """
+    Delete long-term memories by ID
+
+    Args:
+        memory_ids: List of memory IDs to delete (passed as query parameters)
+    """
+    if not settings.long_term_memory:
+        raise HTTPException(status_code=400, detail="Long-term memory is disabled")
+
+    count = await long_term_memory.delete_long_term_memories(ids=memory_ids)
+    return AckResponse(status=f"ok, deleted {count} memories")
+
+
 @router.post("/v1/memory/search", response_model=MemoryRecordResultsResponse)
 async def search_memory(
     payload: SearchRequest,
@@ -546,6 +568,8 @@ async def memory_prompt(
     redis = await get_redis_conn()
     _messages = []
 
+    print("Received params: ", params)
+
     if params.session:
         # Use token limit for memory prompt, fallback to message count for backward compatibility
         if params.session.model_name or params.session.context_window_max:
@@ -616,8 +640,17 @@ async def memory_prompt(
 
     if params.long_term_search:
         # TODO: Exclude session messages if we already included them from session memory
+
+        # If no text is provided in long_term_search, use the user's query
+        if not params.long_term_search.text:
+            # Create a new SearchRequest with the query as text
+            search_payload = params.long_term_search.model_copy()
+            search_payload.text = params.query
+        else:
+            search_payload = params.long_term_search
+
         long_term_memories = await search_long_term_memory(
-            params.long_term_search,
+            search_payload,
         )
 
         if long_term_memories.total > 0:

agent_memory_server/config.py

@@ -78,6 +78,8 @@ class Settings(BaseSettings):
 
     # Topic modeling
     topic_model_source: Literal["BERTopic", "LLM"] = "LLM"
+    # If using BERTopic, use a supported model, such as
+    # "MaartenGr/BERTopic_Wikipedia"
     topic_model: str = "gpt-4o-mini"
     enable_topic_extraction: bool = True
     top_k_topics: int = 3

agent_memory_server/docket_tasks.py

@@ -10,6 +10,7 @@
 from agent_memory_server.extraction import extract_discrete_memories
 from agent_memory_server.long_term_memory import (
     compact_long_term_memories,
+    delete_long_term_memories,
     extract_memory_structure,
     index_long_term_memories,
     promote_working_memory_to_long_term,
@@ -28,6 +29,7 @@
     compact_long_term_memories,
     extract_discrete_memories,
     promote_working_memory_to_long_term,
+    delete_long_term_memories,
 ]