Some tweaks

Author: abrookins

README.md

@@ -2,26 +2,32 @@
 
 Agent Memory Server is a high-performance and flexible server for managing
 short-term and long-term memory for agents using Redis. It provides both REST
-API endpoints and an MCP (Managed Control Plane) server interface for robust
+API endpoints and an MCP (Model Context Protocol) server interface for robust
 memory operations in AI applications.
 
 ## Features
 
 - **Short-Term Memory**
-  - Configurable window size for recent messages
-  - Automatic conversation summarization using LLMs
-  - Token limit management based on model capabilities
+  - Storage for messages, token count, context, and metadata for a session
+  - Automatically and recursively summarizes conversations
+  - Token limit management based on specific model capabilities
 
 - **Long-Term Memory**
-  - Semantic search over messages
-  - Automatic message indexing
-  - Topic modeling with BERTopic
-  - Named Entity Recognition using BERT
+  - Storage for long-term memories across sessions
+  - Semantic search to retrieve memories, with filters
+  - Automatic topic modeling for stored memories with BERTopic
+  - Automatic Entity Recognition using BERT
 
-- **Advanced Features**
+- **Other Features**
   - Support for OpenAI and Anthropic model providers
   - Namespace support for session isolation
+  - Both a REST interface and MCP server
 
+## Roadmap
+- Long-term memory deduplication
+- More options for moving session memory to long-term memory
+- Auth hooks
+- Use a background task system instead of `BackgroundTask`
 
 ## REST API Endpoints
 
@@ -42,7 +48,8 @@ The following endpoints are available:
   - `namespace` (string, optional): Filter sessions by namespace.
 
 - **GET /sessions/{session_id}/memory**
-  Retrieves conversation memory for a session, including messages and context.
+  Retrieves conversation memory for a session, including messages and
+  summarized older messages.
 
 - **POST /sessions/{session_id}/memory**
   Adds messages (and optional context) to a session's memory.
@@ -52,8 +59,7 @@ The following endpoints are available:
     "messages": [
       {"role": "user", "content": "Hello"},
       {"role": "assistant", "content": "Hi there"}
-    ],
-    "context": "Optional context"
+    ]
   }
   ```
 
@@ -70,14 +76,11 @@ The following endpoints are available:
   ```
 
 ## MCP Server Interface
-Agent Memory Server also offers an MCP (Model Context Protocol) server interface powered by FastMCP, providing tool-based memory operations:
-
-- **list_sessions**: Retrieve available memory sessions with optional pagination.
-- **get_session_memory**: Fetch memory (messages and context) for a specific session.
-- **add_memory**: Add messages and context to a session's memory.
-- **delete_session_memory**: Remove all memory data for a session.
-- **search_memory**: Perform semantic search across session messages.
-- **memory_prompt**: Generate prompts enriched with memory context and long-term memories.
+Agent Memory Server offers an MCP (Model Context Protocol) server interface powered by FastMCP, providing tool-based long-term memory management:
+
+- **create_long_term_memories**: Store long-term memories.
+- **search_memory**: Perform semantic search across long-term memories.
+- **memory_prompt**: Generate prompts enriched with session context and long-term memories.
 
 ## Getting Started
 

redis_memory_server/api.py

@@ -1,28 +1,27 @@
 from fastapi import APIRouter, BackgroundTasks, Depends, HTTPException
 
-from redis_memory_server import messages
+from redis_memory_server import long_term_memory, messages
 from redis_memory_server.config import settings
 from redis_memory_server.logging import get_logger
 from redis_memory_server.models import (
     AckResponse,
+    CreateLongTermMemoryPayload,
     GetSessionsQuery,
+    LongTermMemoryResultsResponse,
     SearchPayload,
-    SearchResults,
+    SessionListResponse,
     SessionMemory,
     SessionMemoryResponse,
 )
-from redis_memory_server.utils import (
-    get_openai_client,
-    get_redis_conn,
-)
+from redis_memory_server.utils import get_redis_conn
 
 
 logger = get_logger(__name__)
 
 router = APIRouter()
 
 
-@router.get("/sessions/", response_model=list[str])
+@router.get("/sessions/", response_model=SessionListResponse)
 async def list_sessions(
     options: GetSessionsQuery = Depends(),
 ):
@@ -35,19 +34,20 @@ async def list_sessions(
     Returns:
         List of session IDs
     """
-    # TODO: Pydantic should validate this
-    if options.page > 100:
-        raise HTTPException(status_code=400, detail="Page must not exceed 100")
-
     redis = get_redis_conn()
 
-    return await messages.list_sessions(
+    total, session_ids = await messages.list_sessions(
         redis=redis,
-        page=options.page,
-        size=options.size,
+        limit=options.limit,
+        offset=options.offset,
         namespace=options.namespace,
     )
 
+    return SessionListResponse(
+        sessions=session_ids,
+        total=total,
+    )
+
 
 @router.get("/sessions/{session_id}/memory", response_model=SessionMemoryResponse)
 async def get_session_memory(
@@ -133,12 +133,36 @@ async def delete_session_memory(
     return AckResponse(status="ok")
 
 
-@router.post("/messages/search", response_model=SearchResults)
-async def messages_search(payload: SearchPayload):
+@router.post("/long-term-memory", response_model=AckResponse)
+async def create_long_term_memory(payload: CreateLongTermMemoryPayload):
+    """
+    Create a long-term memory
+
+    Args:
+        payload: Long-term memory payload
+
+    Returns:
+        Acknowledgement response
+    """
+    redis = get_redis_conn()
+
+    if not settings.long_term_memory:
+        raise HTTPException(status_code=400, detail="Long-term memory is disabled")
+
+    await long_term_memory.index_long_term_memories(
+        redis=redis,
+        memories=payload.memories,
+    )
+    return AckResponse(status="ok")
+
+
+@router.post("/long-term-memory/search", response_model=LongTermMemoryResultsResponse)
+async def search_long_term_memory(payload: SearchPayload):
     """
-    Run a semantic search on messages
+    Run a semantic search on long-term memory
 
-    TODO: Infer topics for `text`
+    TODO: Infer topics, entities for `text` and attempt to use them
+          as boosts or filters in the search.
 
     Args:
         payload: Search payload
@@ -149,13 +173,9 @@ async def messages_search(payload: SearchPayload):
     redis = get_redis_conn()
 
     if not settings.long_term_memory:
-        raise HTTPException(status_code=400, detail="Long term memory is disabled")
+        raise HTTPException(status_code=400, detail="Long-term memory is disabled")
 
-    # For embeddings, we always use OpenAI models since Anthropic doesn't support embeddings
-    client = await get_openai_client()
-
-    return await messages.search_messages(
-        client=client,
-        redis_conn=redis,
+    return await long_term_memory.search_long_term_memories(
+        redis=redis,
         **payload.model_dump(exclude_none=True),
     )

redis_memory_server/extraction.py

@@ -50,6 +50,8 @@ def extract_entities(text: str) -> list[str]:
     """
     Extract named entities from text using the NER model.
 
+    TODO: Cache this output.
+
     Args:
         text: The text to extract entities from
 
@@ -89,6 +91,8 @@ def extract_topics(text: str, num_topics: int | None = None) -> list[str]:
     """
     Extract topics from text using the BERTopic model.
 
+    TODO: Cache this output.
+
     Args:
         text: The text to extract topics from