Overview

Extended Memory MCP is a Model Context Protocol (MCP) server that gives the Desktop Claude app persistent, project-scoped memory. Instead of losing context whenever a conversation reaches token limits or you open a new chat, this server stores and retrieves relevant project data so Claude can remember architecture decisions, ongoing tasks, communication preferences, and other persistent facts across sessions.

The server runs locally and exposes memory operations through the MCP used by Claude Desktop. It supports importance scoring and tag-based organization for saved items, strict isolation between projects, and optional Redis-backed storage. The project is production-tested (400+ automated tests) and designed for developers who need reliable, private, long-lived chat memory without cloud syncing.

Features

Persistent, cross-session memory for Claude Desktop via MCP
Project-scoped isolation (each project has its own memory space)
Importance scoring to prioritize which memories to load
Tag-based organization and retrieval (search/filter by tags)
CRUD memory tools: save, load, forget, list projects, list tags
Local-first storage (SQLite by default); optional Redis backend
Simple MCP integration — runs as a separate MCP server process
Configurable via environment variables (LOG_LEVEL, STORAGE_CONNECTION_STRING)
Production-tested with 400+ unit/integration tests

Installation / Configuration

Requirements:

Python 3.8+

Install from PyPI (recommended):

pip install extended-memory-mcp

Install from source (development):

git clone https://github.com/ssmirnovpro/extended-memory-mcp.git
cd extended-memory-mcp
pip install -e ".[dev]"

Run the MCP server via the Desktop Claude app MCP configuration. Example MCP entry (add under “mcpServers” in Claude’s config):

{
  "mcpServers": {
    "extended-memory": {
      "command": "python3",
      "args": ["-m", "extended_memory_mcp.server"],
      "env": {
        "LOG_LEVEL": "INFO"
      }
    }
  }
}

If you installed from source, point to the server script:

{
  "mcpServers": {
    "extended-memory": {
      "command": "python3",
      "args": ["/path/to/extended-memory-mcp/mcp-server/server.py"],
      "env": {
        "LOG_LEVEL": "INFO"
      }
    }
  }
}

Common environment variables:

Variable	Purpose	Default
STORAGE_CONNECTION_STRING	Storage backend location	sqlite:///~/.local/share/extended-memory-mcp/memory.db
LOG_LEVEL	Logging verbosity	INFO

Redis (optional/experimental):

pip install extended-memory-mcp[redis]

Example Redis connection:

"env": {
  "STORAGE_CONNECTION_STRING": "redis://localhost:6379/0"
}

Windows note: use an explicit SQLite path:

"env": {
  "STORAGE_CONNECTION_STRING": "sqlite:///C:/Users/YourName/extended-memory/memory.db"
}

After configuration:

Restart the Claude Desktop app
Confirm the MCP connection in Developer Settings
Test by instructing Claude to save or load project context

Available Tools

Extended Memory exposes a set of memory operations (used by Claude via MCP). Commonly available tools:

save_context: Persist a piece of information into a project with tags and importance score
load_contexts: Retrieve relevant memories for the current project (supports tag/score filters)
forget_context: Remove specific memory entries
list_all_projects: Enumerate stored project scopes
get_popular_tags: Return frequently used tags for a project

Each tool accepts structured data (project_id, text, tags, importance score) and is intended to be called by Claude when it decides memory manipulation is appropriate.

Use Cases

Long-running projects: Keep architecture decisions, constraints, and past trade-offs available across chats.
Onboarding & handoffs: Preserve summaries and communication preferences for new team members.
Style & preferences: Remember coding/communication style and reuse it in future conversations.
Multi-project workflows: Switch between isolated project memories without leakage.
Non-linear work: Resume interrupted tasks and have Claude recall prior state and next steps.

Example best practice: Add a short project identifier to Claude custom instructions so saved and retrieved memories use the correct project scope:

You have external memory; follow its instructions. When using it, always use project_id "mobile_app" for read/write operations.

Privacy & Storage

Local-first: Data is stored locally by default (no cloud sync).
No external telemetry: The server stores data as-is; it does not analyze or transmit content externally.
Full user control: You manage the storage backend and file locations.

Troubleshooting & Tips

If Claude doesn’t load memories automatically, prompt it with: “Load my project context” or “What do you remember about this project?”
Ensure the MCP entry name matches the one configured in Claude’s Developer Settings.
On Windows, always use a fully qualified STORAGE_CONNECTION_STRING path to avoid directory issues.
Redis backend is experimental — prefer SQLite for stability unless you need a shared Redis instance.

Extended Memory MCP Server — Multi-Project Persistent Memory