Skip to main content
Glama

Memory MCP

by JamesANZ

Memory MCP

A Model Context Protocol (MCP) server for logging and retrieving memories from LLM conversations with intelligent context window caching capabilities.

Features

  • Save Memories: Store memories from LLM conversations with timestamps and LLM identification
  • Retrieve Memories: Get all stored memories with detailed metadata
  • Add Memories: Append new memories without overwriting existing ones
  • Clear Memories: Remove all stored memories
  • Context Window Caching: Archive, retrieve, and summarize conversation context
  • Relevance Scoring: Automatically score archived content relevance to current context
  • Tag-based Search: Categorize and search context by tags
  • Conversation Orchestration: External system to manage context window caching
  • MongoDB Storage: Persistent storage using MongoDB database

Installation

  1. Install dependencies:
npm install
  1. Build the project:
npm run build

Configuration

Set the MongoDB connection string via environment variable:

export MONGODB_URI="mongodb://localhost:27017"

Default: mongodb://localhost:27017

Usage

Running the MCP Server

Start the MCP server:

npm start

Running the Conversation Orchestrator Demo

Try the interactive CLI demo:

npm run cli

The CLI demo allows you to:

  • Add messages to simulate conversation
  • See automatic archiving when context gets full
  • Trigger manual archiving and retrieval
  • Create summaries of archived content
  • Monitor conversation status and get recommendations

Basic Memory Tools

  1. save-memories: Save all memories to the database, overwriting existing ones
    • memories: Array of memory strings to save
    • llm: Name of the LLM (e.g., 'chatgpt', 'claude')
    • userId: Optional user identifier
  2. get-memories: Retrieve all memories from the database
    • No parameters required
  3. add-memories: Add new memories to the database without overwriting existing ones
    • memories: Array of memory strings to add
    • llm: Name of the LLM (e.g., 'chatgpt', 'claude')
    • userId: Optional user identifier
  4. clear-memories: Clear all memories from the database
    • No parameters required

Context Window Caching Tools

  1. archive-context: Archive context messages for a conversation with tags and metadata
    • conversationId: Unique identifier for the conversation
    • contextMessages: Array of context messages to archive
    • tags: Tags for categorizing the archived content
    • llm: Name of the LLM (e.g., 'chatgpt', 'claude')
    • userId: Optional user identifier
  2. retrieve-context: Retrieve relevant archived context for a conversation
    • conversationId: Unique identifier for the conversation
    • tags: Optional tags to filter by
    • minRelevanceScore: Minimum relevance score (0-1, default: 0.1)
    • limit: Maximum number of items to return (default: 10)
  3. score-relevance: Score the relevance of archived context against current conversation context
    • conversationId: Unique identifier for the conversation
    • currentContext: Current conversation context to compare against
    • llm: Name of the LLM (e.g., 'chatgpt', 'claude')
  4. create-summary: Create a summary of context items and link them to the summary
    • conversationId: Unique identifier for the conversation
    • contextItems: Context items to summarize
    • summaryText: Human-provided summary text
    • llm: Name of the LLM (e.g., 'chatgpt', 'claude')
    • userId: Optional user identifier
  5. get-conversation-summaries: Get all summaries for a specific conversation
    • conversationId: Unique identifier for the conversation
  6. search-context-by-tags: Search archived context and summaries by tags
    • tags: Tags to search for

Example Usage in LLM

Basic Memory Operations
  1. Save all memories (overwrites existing):
    User: "Save all my memories from this conversation to the MCP server" LLM: [Uses save-memories tool with current conversation memories]
  2. Retrieve all memories:
    User: "Get all my memories from the MCP server" LLM: [Uses get-memories tool to retrieve stored memories]
Context Window Caching Workflow
  1. Archive context when window gets full:
    User: "The conversation is getting long, archive the early parts" LLM: [Uses archive-context tool to store old messages with tags]
  2. Score relevance of archived content:
    User: "How relevant is the archived content to our current discussion?" LLM: [Uses score-relevance tool to evaluate archived content]
  3. Retrieve relevant archived context:
    User: "Bring back the relevant archived information" LLM: [Uses retrieve-context tool to get relevant archived content]
  4. Create summaries for long conversations:
    User: "Summarize the early parts of our conversation" LLM: [Uses create-summary tool to condense archived content]

Conversation Orchestration System

The ConversationOrchestrator class provides automatic context window management:

Key Features

  • Automatic Archiving: Archives content when context usage reaches 80%
  • Intelligent Retrieval: Retrieves relevant content when usage drops below 30%
  • Relevance Scoring: Uses keyword overlap to score archived content relevance
  • Smart Tagging: Automatically generates tags based on content keywords
  • Conversation State Management: Tracks active conversations and their context
  • Recommendations: Provides suggestions for optimal context management

Usage Example

import { ConversationOrchestrator } from "./orchestrator.js"; const orchestrator = new ConversationOrchestrator(8000); // 8k word limit // Add a message (triggers automatic archiving/retrieval) const result = await orchestrator.addMessage( "conversation-123", "This is a new message in the conversation", "claude", ); // Check if archiving is needed if (result.archiveDecision?.shouldArchive) { await orchestrator.executeArchive(result.archiveDecision, result.state); } // Check if retrieval is needed if (result.retrievalDecision?.shouldRetrieve) { await orchestrator.executeRetrieval(result.retrievalDecision, result.state); }

Database Schema

Basic Memory Structure

type BasicMemory = { _id: ObjectId; memories: string[]; // Array of memory strings timestamp: Date; // When memories were saved llm: string; // LLM identifier (e.g., 'chatgpt', 'claude') userId?: string; // Optional user identifier };

Extended Memory Structure (Context Caching)

type ExtendedMemory = { _id: ObjectId; memories: string[]; // Array of memory strings timestamp: Date; // When memories were saved llm: string; // LLM identifier userId?: string; // Optional user identifier conversationId?: string; // Unique conversation identifier contextType?: "active" | "archived" | "summary"; relevanceScore?: number; // 0-1 relevance score tags?: string[]; // Categorization tags parentContextId?: ObjectId; // Reference to original content for summaries messageIndex?: number; // Order within conversation wordCount?: number; // Size tracking summaryText?: string; // Condensed version };

Context Window Caching Workflow

The orchestration system automatically:

  1. Monitors conversation length and context usage
  2. Archives content when context usage reaches 80%
  3. Scores relevance of archived content against current context
  4. Retrieves relevant content when usage drops below 30%
  5. Creates summaries to condense very long conversations

Key Features

  • Conversation Grouping: All archived content is linked to specific conversation IDs
  • Relevance Scoring: Simple keyword overlap scoring (can be enhanced with semantic similarity)
  • Tag-based Organization: Categorize content for easy retrieval
  • Summary Linking: Preserve links between summaries and original content
  • Backward Compatibility: All existing memory functions work unchanged
  • Automatic Management: No manual intervention required for basic operations

Development

To run in development mode:

npm run build node build/index.js

To run the CLI demo:

npm run cli

License

ISC

-
security - not tested
A
license - permissive license
-
quality - not tested

hybrid server

The server is able to function both locally and remotely, depending on the configuration or use case.

A Model Context Protocol server that allows saving, retrieving, adding, and clearing memories from LLM conversations with MongoDB persistence.

  1. Features
    1. Installation
      1. Configuration
        1. Usage
          1. Running the MCP Server
          2. Running the Conversation Orchestrator Demo
          3. Basic Memory Tools
          4. Context Window Caching Tools
          5. Example Usage in LLM
        2. Conversation Orchestration System
          1. Key Features
          2. Usage Example
        3. Database Schema
          1. Basic Memory Structure
          2. Extended Memory Structure (Context Caching)
        4. Context Window Caching Workflow
          1. Key Features
        5. Development
          1. License

            Related MCP Servers

            • A
              security
              A
              license
              A
              quality
              A Model Context Protocol server that provides access to MongoDB databases. This server enables LLMs to inspect collection schemas and execute read-only queries.
              Last updated -
              8
              377
              261
              TypeScript
              MIT License
              • Apple
            • -
              security
              A
              license
              -
              quality
              A Model Context Protocol server that enables LLMs to interact directly with MongoDB databases, allowing users to query collections, inspect schemas, and manage data through natural language.
              Last updated -
              136
              1
              TypeScript
              MIT License
              • Apple
            • -
              security
              A
              license
              -
              quality
              A Model Context Protocol server that enables LLMs to interact directly with MongoDB databases, allowing users to query collections, inspect schemas, and manage data through natural language.
              Last updated -
              136
              MIT License
              • Apple
            • -
              security
              A
              license
              -
              quality
              A Model Context Protocol (MCP) server that enables LLMs to interact directly with MongoDB databases, allowing them to query collections, inspect schemas, and manage data seamlessly through natural language.
              Last updated -
              136
              MIT License
              • Apple

            View all related MCP servers

            MCP directory API

            We provide all the information about MCP servers via our MCP API.

            curl -X GET 'https://glama.ai/api/mcp/v1/servers/JamesANZ/memory-mcp'

            If you have feedback or need assistance with the MCP directory API, please join our Discord server