Long Term Memory

🚀 Memory MCP Server

A long-term memory storage system designed for Large Language Models (LLMs), adhering to the Model Context Protocol (MCP) standard. This system enables LLMs to retain contextual information throughout the project history, even across multiple sessions. It leverages semantic search and embedded vector technology to provide relevant context for past interactions and decisions.

🚀 Quick Start

The Memory MCP Server is a long - term memory storage system tailored for Large Language Models (LLMs). It uses the Model Context Protocol (MCP) to help LLMs remember context information across the project history, even over multiple sessions.

✨ Features

• Project - based Memory Organization: Manage memories by project.
• Semantic Search: Utilize Ollama embeddings (nomic - embed - text model, 768 dimensions).
• Multiple Memory Types:
  • Conversations: Conversation context and important discussions.
  • Code: Implementation details and changes.
  • Decisions: Key architectural and design choices.
  • References: Links to external resources and documentation.
• Rich Metadata Storage, including:
  • Implementation status.
  • Key decisions.
  • Created/modified files.
  • Code changes.
  • Added dependencies.
• Tag System: For memory organization.
• Relationship Tracking: Establish connections between memories.

📦 Installation

Prerequisites

• Node.js (v18 or higher)
• Ollama running locally (for embeddings)
  • The nomic - embed - text model must be installed.
• SQLite3

Installation Steps

1. Clone the repository.
2. Install dependencies:

   npm install
   

3. Build the project:

   npm run build
   

4. Create a configuration file .env:

   OLLAMA_HOST=http://localhost:11434
   DB_PATH=memory.db
   

💻 Usage Examples

Basic Usage

1. Start the server in development mode:

   npm run dev
   

   This will:

   • Compile TypeScript.
   • Copy the schema file.
   • Start the server with auto - reload functionality.

2. Connect compatibly with Cursor via standard input/output.

Advanced Usage

1. After installation, set environment variables:

   export OLLAMA_HOST=http://localhost:11434
   export DB_PATH=memory.db
   

2. Start the server:

   npm run dev
   

3. Use the tools:
   • Store a memory:

     nomic store - dev - memory --content "This is a test memory" --tags test,example
     

   • List memories:

     nomic list - dev - memories
     

   • Search for memories:

     nomic search --query example
     

📚 Documentation

Database Schema

The system uses SQLite and includes the following tables:

Core Tables

• projects: Project information and metadata.
• memories: Memory entries storing various development contexts.
• embeddings: Embedded vectors for semantic search (768 dimensions).

Organization Tables

• tags: Tags for memory organization.
• memory_tags: Many - to - many relationships between memories and tags.
• memory_relationships: Directed relationships between memory entries.

MCP Tools

The following tools are available via the MCP protocol:

Memory Management

• store - dev - memory: Create a new development memory, including:
  • Content
  • Type (conversation/code/decision/reference)
  • Tags
  • Code changes
  • Created/modified files
  • Key decisions
  • Implementation status
• list - dev - memories: List existing memories, with optional tag filtering.
• get - dev - memory: Get a specific memory by ID.
• search: Semantic search across memories using embedded vectors.

Development Environment

When developing:

npm run dev

This will:

1. Kill the existing server instance.
2. Rebuild the TypeScript code.
3. Copy schema.sql to the dist directory.
4. Start the server in development mode.

Dependencies

Key dependencies:

• @modelcontextprotocol/sdk@^1.7.0: MCP protocol implementation.
• better - sqlite3@^9.4.3: SQLite database interface.
• node - fetch@^3.3.2: HTTP client for the Ollama API.
• zod@^3.22.4: Runtime type checking and validation.

Project Structure

memory - mcp - server/
├── src/
│   ├── db/
│   │   ├── init.ts     # Database initialization
│   │   └── service.ts  # Database service layer
│   ├── memory.js      # Memory management logic
│   └── search.js      # Semantic search functionality
├── package.json       # Dependency management and scripts
└── .env               # Environment variable configuration

Notes

⚠️ Important Note

• Ensure that the Ollama service is running locally and the nomic - embed - text model is loaded.
• The database file (memory.db) will be created in the project directory to store memory data.
• Adjust the code and configuration files according to specific requirements.

Contribution Guidelines

💡 Usage Tip

Contributions are welcome! Please refer to CONTRIBUTING.md to participate in development.