Memory MCP Server

A professional memory management server for VS Code and other MCP-compatible editors that provides comprehensive memory storage and retrieval across multiple memory types.

Features

��� Multiple Memory Types

• Episodic Memory: Store specific events and experiences with context and importance levels
• Procedural Memory: Store how-to knowledge, procedures, and step-by-step instructions
• Short-term Memory: Temporary working memory with automatic expiration
• Long-term Memory: Persistent knowledge storage with confidence levels
• Limited Memory AI: Context-aware memory with size limits and session management
• Semantic Memory: Factual knowledge and concepts with relationships
• Working Memory: Active task processing with status tracking

��� Technical Features

• SQLite Database: Fast, reliable local storage
• Zod Validation: Input validation and type safety
• Auto Cleanup: Automatic expiration and cleanup of temporary memories
• Session Management: Support for multiple concurrent sessions
• Priority System: Memory prioritization for better retrieval
• Rich Metadata: Support for tags, context, and custom metadata

Installation

Via NPX (Recommended)

npx memory-mcp-server

Manual Installation

git clone https://github.com/cbuntingde/memory-mcp-server.git
cd memory-mcp-server
npm install
npm start

Usage

VS Code Configuration

Add to your VS Code settings.json:

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["memory-mcp-server"],
      "env": {}
    }
  }
}

Claude Desktop Configuration

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["memory-mcp-server"]
    }
  }
}

Zed Editor Configuration

Add to your Zed settings.json (Cmd/Ctrl + ,):

{
  "context_servers": {
    "memory": {
      "source": "custom",
      "command": "npx",
      "args": ["memory-mcp-server"],
      "env": {}
    }
  }
}

Or use the provided mcp.zed.json file by copying its contents into your Zed settings.

Available Tools

Episodic Memory

Store and retrieve specific events and experiences:

// Store an episodic memory
await create_episodic_memory({
  title: "First successful deployment",
  content: "Successfully deployed the web application to production after fixing the database connection issue.",
  context: "Production deployment on 2025-12-16",
  tags: ["deployment", "success", "production"],
  importance: 5,
  source: "team_meeting",
  metadata: {
    project: "web-app",
    environment: "production"
  }
});

// Retrieve episodic memories
await get_episodic_memories({
  limit: 10,
  tags: "deployment"
});

Procedural Memory

Store and retrieve procedures and how-to knowledge:

// Store a procedure
await create_procedural_memory({
  procedure_name: "Deploy React App to Vercel",
  steps: [
    "Install Vercel CLI: npm i -g vercel",
    "Login to Vercel: vercel login",
    "Build the app: npm run build",
    "Deploy: vercel --prod"
  ],
  description: "Complete deployment process for React applications",
  category: "deployment",
  difficulty_level: 2,
  prerequisites: ["Node.js", "npm", "Vercel account"],
  tags: ["react", "vercel", "deployment"]
});

// Retrieve procedures
await get_procedural_memories({
  category: "deployment"
});

Short-term Memory

Temporary storage with automatic expiration:

// Store temporary information
await create_short_term_memory({
  content: "User mentioned they prefer dark mode for coding",
  context: "user_preference",
  expires_in_minutes: 120
});

// Retrieve active short-term memories
await get_short_term_memories({
  limit: 20
});

Long-term Memory

Persistent knowledge storage:

// Store long-term knowledge
await create_long_term_memory({
  concept_name: "React Hooks",
  description: "Functions that let you use state and other React features in functional components",
  category: "programming",
  related_concepts: ["useState", "useEffect", "functional components"],
  confidence_level: 0.95,
  evidence: "Official React documentation and extensive usage",
  tags: ["react", "hooks", "frontend"]
});

// Retrieve long-term memories
await get_long_term_memories({
  category: "programming"
});

Limited Memory AI

Session-aware memory with size limits:

// Store session memory
await create_limited_memory({
  session_id: "user-session-123",
  content: "Current task: Refactor authentication system",
  context_type: "task_context",
  priority: 8
});

// Retrieve session memories
await get_limited_memories({
  session_id: "user-session-123",
  limit: 50
});

Semantic Memory

Factual knowledge and concepts:

// Store semantic knowledge
await create_semantic_memory({
  concept: "Machine Learning",
  definition: "A subset of artificial intelligence that enables computers to learn and improve from experience without being explicitly programmed",
  category: "technology",
  attributes: {
    type: "AI technique",
    applications: ["prediction", "classification", "recommendation"],
    complexity: "high"
  },
  relationships: {
    "supervised_learning": "related",
    "neural_networks": "related",
    "data_science": "broader_concept"
  },
  examples: ["spam detection", "image recognition", "recommendation systems"],
  confidence: 0.9,
  source: "academic_papers"
});

// Retrieve semantic memories
await get_semantic_memories({
  category: "technology"
});

Working Memory

Active task processing:

// Store working memory
await create_working_memory({
  task_id: "task-456",
  content: "Implement user authentication with JWT tokens",
  workspace: "auth-service",
  priority: 9
});

// Retrieve working memories
await get_working_memories({
  status: "active"
});

// Update working memory
await update_working_memory({
  id: "memory-id",
  status: "completed",
  content: "Completed JWT authentication implementation"
});

Utility Tools

// Clean up expired memories
await cleanup_expired_memories();

// Get memory statistics
await get_memory_stats();

Memory Types Explained

Episodic Memory

Stores specific events and experiences with temporal context. Useful for remembering past interactions, decisions, and outcomes.

Procedural Memory

Stores how-to knowledge and procedures. Perfect for documenting workflows, processes, and step-by-step instructions.

Short-term Memory

Temporary storage for information that needs to be kept briefly. Automatically expires based on time limits.

Long-term Memory

Persistent storage for important knowledge and concepts. Includes confidence levels and evidence tracking.

Limited Memory AI

Context-aware memory designed for AI assistants. Manages conversation context with size limits and priority systems.

Semantic Memory

Stores factual knowledge and conceptual relationships. Includes attributes, examples, and confidence levels.

Working Memory

Active task processing memory. Tracks current work items with status and priority management.

Database Schema

The server uses SQLite with the following main tables:

• episodic_memory: Event and experience storage
• procedural_memory: Procedure and how-to storage
• short_term_memory: Temporary information storage
• long_term_memory: Persistent knowledge storage
• limited_memory_ai: Session-aware context storage
• semantic_memory: Factual knowledge storage
• working_memory: Active task storage

Development

Running in Development Mode

npm run dev

Testing

npm test

Contributing

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests
5. Submit a pull request

License

MIT License - see LICENSE file for details.

Support

For issues and questions:

• GitHub Issues: https://github.com/cbuntingde/memory-mcp-server/issues
• Email: [email protected]

Changelog

v1.0.0

• Initial release
• Support for 7 memory types
• SQLite database integration
• Zod validation
• MCP protocol compliance
• Auto-cleanup functionality