home / skills / willsigmon / sigstack / mcp-memory-expert

mcp-memory-expert skill

safe

/plugins/memory-ai/skills/mcp-memory-expert

This skill adds persistent memory to Claude with MCP memory servers, enabling cross-session context, knowledge graphs, and automatic memory for tools.

npx playbooks add skill willsigmon/sigstack --skill mcp-memory-expert

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.1 KB

---
name: MCP Memory Expert
description: MCP memory servers - OpenMemory, knowledge graphs, persistent context for Claude
allowed-tools: Read, Edit, Bash
model: sonnet
---

# MCP Memory Expert

Add persistent memory to Claude using MCP memory servers.

## Top MCP Memory Solutions

### 1. OpenMemory MCP (Mem0)
- Cross-client memory (Claude ↔ Cursor ↔ Windsurf)
- Local storage, no cloud
- Full data ownership

### 2. Official Anthropic Memory Server
- Knowledge graph storage
- Entities and relations
- Semantic search
- Persistent across sessions

### 3. mcp-memory-service
- Automatic context memory
- Works with 13+ AI tools
- Stop re-explaining projects

### 4. mcp-knowledge-graph
- Local knowledge graph
- Entity-relation storage
- Query capabilities

## Setup

### OpenMemory MCP
```json
{
  "mcpServers": {
    "openmemory": {
      "command": "npx",
      "args": ["-y", "@mem0/openmemory-mcp"],
      "env": {
        "STORAGE_PATH": "~/.openmemory"
      }
    }
  }
}
```

### Anthropic Memory Server
```json
{
  "mcpServers": {
    "memory": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-memory"]
    }
  }
}
```

## Usage Patterns

### Store Context
```
User: Remember that I'm building an iOS app called Leavn using SwiftUI
Claude: [Calls memory MCP to store this fact]
       Got it! I'll remember you're building Leavn with SwiftUI.
```

### Retrieve Context
```
User: What framework am I using?
Claude: [Queries memory MCP]
       You're using SwiftUI for your Leavn iOS app.
```

### Knowledge Graph Pattern
```
Entities:
- User (developer, iOS focus)
- Project (Leavn, Bible study app)
- Technology (SwiftUI, SwiftData, CloudKit)

Relations:
- User → develops → Project
- Project → uses → Technology
```

## CLAUDE.md Integration

The two-tier memory pattern:
1. **CLAUDE.md** (~150 lines): High-confidence, frequently accessed
2. **MCP Memory**: Everything else, searchable

```markdown
# CLAUDE.md - Project Briefing
- Project: Leavn iOS app
- Stack: SwiftUI, SwiftData, CloudKit
- User: Vibecoder, novice with nomenclature
```

Use when: Cross-session memory, project context, learning user preferences

Overview

This skill adds persistent, cross-session memory to Claude by integrating MCP-compatible memory servers like OpenMemory, Anthropic Memory Server, and local knowledge-graph services. It enables Claude to store, retrieve, and semantically search user and project context so conversations remember facts, preferences, and entity relationships across sessions. The focus is on data ownership, flexible deployment (local or service), and structured knowledge graph patterns.

How this skill works

The skill wires Claude to MCP memory servers that accept store and query operations. It supports local file-based servers (OpenMemory), knowledge-graph backends (Anthropic Memory Server, mcp-knowledge-graph), and multi-tool memory services (mcp-memory-service). Claude writes high-confidence facts to a short-profile store (CLAUDE.md) and pushes broader context or entity relations into MCP memory for semantic retrieval and cross-client access.

When to use it

Preserve project-specific context across sessions (e.g., project name, stack, goals).
Stop re-explaining recurring details to the assistant or team.
Maintain user preferences and profile facts for personalized responses.
Implement entity-relation storage for search and reasoning (knowledge graph).
Run memory locally to retain full data ownership and avoid cloud storage.

Best practices

Keep a concise CLAUDE.md for high-confidence, frequently referenced facts.
Store broader, less critical details in MCP memory for semantic search and retrieval.
Use clear entity and relation naming when building the knowledge graph for consistent queries.
Prefer local OpenMemory for private data; use Anthropic Memory Server for structured graph capabilities.
Limit stored sensitive data and apply local encryption or access controls when needed.

Example use cases

Remembering a user’s project details (Leavn, SwiftUI, SwiftData) so Claude answers framework questions without re-explanation.
Populating a knowledge graph of users, projects, and technologies to answer relationship queries.
Cross-client memory sharing between Claude and other tools via OpenMemory MCP.
Using mcp-memory-service to auto-store conversation context so repeated information need not be reintroduced.
Running a local memory server to retain ownership of private or company-specific context.

FAQ

How do I decide what goes in CLAUDE.md vs MCP memory?

Put high-confidence, frequently accessed core facts in CLAUDE.md and push broader, mutable, or large-context items into MCP memory for semantic indexing and retrieval.

Can I run memory entirely on my machine?

Yes. OpenMemory and mcp-knowledge-graph support local deployments so you keep full control over storage and access.