MCP Persistent Memory Server

A Model Context Protocol (MCP) server that provides persistent graph memory with automatic disk storage. Perfect for building knowledge graphs, storing entity relationships, and maintaining context across sessions.

Features

Persistent Storage: Automatically saves graph data to disk
Multiple Deployment Options: Run locally or deploy to cloud
MCP Compatible: Works with Claude Desktop, Cursor, and other MCP clients
Timestamped Backups: Automatic backup rotation
Fast Indexed Lookups: Map-based indices for quick searches
Multiple Export Formats: JSON, CSV for entities and relations
Remote Access: HTTP/WebSocket server for cloud deployment
RESTful API: Direct HTTP endpoints for convenience

Quick Start

Local Installation

# Clone the repository
git clone https://github.com/dirkenglund/mcp-persistent-memory.git
cd mcp-persistent-memory

# Install dependencies
npm install

# Run in stdio mode (for MCP clients)
npm start

# Or run HTTP server
npm run start:http

Add to Cursor

Edit ~/.cursor/mcp.json:

{
  "mcpServers": {
    "persistent-memory": {
      "command": "node",
      "args": [
        "/path/to/mcp-persistent-memory/src/index.mjs"
      ],
      "env": {
        "MEMORY_STORAGE_DIR": "~/.cursor/persistent-memory"
      }
    }
  }
}

Usage

Creating Entities

// Via MCP tool call
create_entities({
  entities: [
    {
      name: "Cursor",
      entityType: "Software",
      observations: [
        "An AI-powered code editor",
        "Supports MCP protocol",
        "Built on VSCode"
      ]
    }
  ]
})

Creating Relations

create_relations({
  relations: [
    {
      from: "Cursor",
      to: "VSCode",
      relationType: "based_on"
    }
  ]
})

Searching Nodes

search_nodes({
  query: "AI editor"
})

Getting Statistics

get_stats()
// Returns: { entities: 10, relations: 15, storage: '2.5 MB' }

REST API

When running in HTTP mode:

# Create entities
curl -X POST http://localhost:8080/api/entities \
  -H "Content-Type: application/json" \
  -d '{"entities": [{"name": "Test", "entityType": "Example", "observations": ["A test entity"]}]}'

# Search
curl http://localhost:8080/api/search?q=test

# Get full graph
curl http://localhost:8080/api/graph

# Export as CSV
curl http://localhost:8080/api/export?format=csv-entities > entities.csv

Cloud Deployment

Deploy to Google Cloud

# Make deploy script executable
chmod +x deploy/gcp-deploy.sh

# Deploy (requires gcloud CLI)
./deploy/gcp-deploy.sh my-mcp-server us-central1-a

Docker Deployment

# Build image
docker build -t mcp-persistent-memory .

# Run container
docker run -d \
  -p 8080:8080 \
  -v $(pwd)/data:/data \
  --name mcp-memory \
  mcp-persistent-memory

Using Remote Server

Add to Cursor config:

{
  "persistent-memory-remote": {
    "url": "http://YOUR-SERVER-IP:8080/mcp",
    "transport": "websocket"
  }
}

Storage Structure

data/memory/
├── graph.json          # Main graph data
├── backups/            # Timestamped backups
│   ├── graph-2025-07-06T10-30-00.json
│   ├── graph-2025-07-06T11-00-00.json
│   └── ...
└── exports/            # Manual exports

Environment Variables

MEMORY_STORAGE_DIR: Directory for storing graph data (default: ./data/memory)
MAX_BACKUPS: Maximum number of backup files to keep (default: 10)
PORT: HTTP server port (default: 8080)
HOST: HTTP server host (default: 0.0.0.0)

Development

# Run with auto-reload
npm run dev

# Run tests
npm test

# Build Docker image
npm run docker:build

API Reference

MCP Tools

create_entities: Create new entities in the graph
create_relations: Create relations between entities
search_nodes: Search entities by query
read_graph: Read the entire graph
open_nodes: Get specific nodes by name
add_observations: Add observations to existing entities
delete_entities: Delete entities and their relations
delete_relations: Delete specific relations
get_stats: Get graph statistics
export_graph: Export in various formats
clear_graph: Clear all data

HTTP Endpoints

GET /health: Health check
GET /info: Server information and stats
POST /api/entities: Create entities
POST /api/relations: Create relations
GET /api/search?q=query: Search nodes
GET /api/graph: Get full graph
GET /api/stats: Get statistics
GET /api/export?format=json|csv-entities|csv-relations: Export data

License

MIT

Contributing

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

Support

Issues: https://github.com/dirkenglund/mcp-persistent-memory/issues
Documentation: https://github.com/dirkenglund/mcp-persistent-memory/wiki

Built with ❤️ for the MCP ecosystem

This server cannot be installed

security - not tested

license - not found

quality - not tested

How are these scores calculated?

Provides persistent graph memory with automatic disk storage for building knowledge graphs, storing entity relationships, and maintaining context across sessions.

Related MCP Servers

Knowledge Graph Memory Server
modelcontextprotocol
-
security
A
license
-
quality
A basic implementation of persistent memory using a local knowledge graph. This lets Claude remember information about the user across chats.
Last updated -
9
26,187
58,172
TypeScript
MIT License
Memory MCP Server
evangstav
-
security
A
license
-
quality
Provides knowledge graph functionality for managing entities, relations, and observations in memory with strict validation rules to maintain data consistency.
Last updated -
6
Python
MIT License
Knowledge Graph Memory Server
AgentWong
-
security
A
license
-
quality
A persistent memory implementation using a local knowledge graph that lets Claude remember information about users across conversations.
Last updated -
4
Python
MIT License
Neo4j Knowledge Graph
mjftw
-
security
F
license
-
quality
Enables storage and retrieval of knowledge in a graph database format, allowing users to create, update, search, and delete entities and relationships in a Neo4j-powered knowledge graph through natural language.
Last updated -
Python

View all related MCP servers

MCP Persistent Memory Server