Skip to main content
Glama
Sign In
Memory MCP Server

Memory MCP Server

by michael-denyer
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Local

๐Ÿง  Memory MCP

Give your AI assistant a persistent second brain

License: MIT Python 3.11+ MCP 1.0 Claude Code PyPI CI

Stop re-explaining your project every session.

Memory MCP learns what matters and keeps it ready โ€” instant recall for the stuff you use most, semantic search for everything else.

The Problem

Every new chat starts from scratch. You explain your architecture again. You paste the same patterns again. Your context window bloats with repetition.

Other memory solutions help, but they still require tool calls for every lookup โ€” adding latency and eating into Claude's thinking budget.

Memory MCP fixes this with a two-tier architecture:

  1. Hot cache (0ms) โ€” Frequently-used knowledge printed into context by the plugin's SessionStart and UserPromptSubmit hooks before Claude even starts thinking. Claude Code adds a hook's stdout to the conversation, so no tool call is needed.

  2. Cold storage (~50ms) โ€” Everything else, searchable by meaning via semantic similarity.

The system learns what you use and promotes it automatically. Your most valuable knowledge becomes instantly available. No manual curation required.

Related MCP server: CCCMemory MCP

Before & After

๐Ÿ˜ค Without Memory MCP

๐ŸŽฏ With Memory MCP

"Let me explain our architecture again..."

Project facts persist and isolate per repo

Copy-paste the same patterns every session

Patterns auto-promoted to instant access

500k+ token context windows

Hot cache keeps it lean (~20 items)

Tool call latency on every memory lookup

Hot cache: 0ms โ€” a hook already put it in context

Stale information lingers forever

Trust scoring demotes outdated facts

Flat list of disconnected facts

Knowledge graph connects related concepts

Install

# Install package
uv tool install hot-memory-mcp   # or: pip install hot-memory-mcp

# Add plugin (recommended)
claude plugins add michael-denyer/memory-mcp

The plugin gives you auto-configured hooks and slash commands. Embeddings run on sentence-transformers on every platform, including Apple Silicon.

Add to ~/.claude.json:

{
  "mcpServers": {
    "memory": {
      "command": "memory-mcp"
    }
  }
}

See Reference for full configuration options.

Restart Claude Code. Run memory-mcp-cli bootstrap once to seed memories from your project docs; the hooks inject whatever is promoted, but nothing seeds itself.

First run: Embedding model (~90MB) downloads automatically. Takes 30-60 seconds once.

How It Works

flowchart LR
    subgraph LLM["Claude"]
        REQ((Request))
    end

    subgraph Hot["HOT CACHE ยท 0ms"]
        HC[Session context]
        PM[(Promoted memories)]
    end

    subgraph Cold["COLD STORAGE ยท ~50ms"]
        VS[(Vector search)]
        KG[(Knowledge graph)]
    end

    REQ -->|"hook stdout"| HC
    HC -.->|"draws from"| PM
    REQ -->|"recall()"| VS
    VS <-->|"related"| KG

The hot cache (~10 items) reaches Claude through two plugin hooks. SessionStart runs memory-mcp-cli hot-cache --force and UserPromptSubmit runs memory-mcp-cli hot-cache, and Claude Code adds each command's stdout to the conversation. The command prints only when the text differs from what the session last saw, which is cheap while the set is stable and reprints in full when it shifts. The set combines recent recalls, predicted next memories, and top promoted items. Promoted memories (~20 items) is the backing store of frequently-used memories. Memories used 3+ times auto-promote; unused ones demote after 14 days.

What Makes It Different

Most memory systems make you pay a tool-call tax on every lookup. Memory MCP's hot cache bypasses this entirely โ€” a hook prints your most-used knowledge into the conversation before Claude starts thinking.

Memory MCP

Generic Memory Servers

Hot cache

Injected by a hook at 0ms

Every lookup = tool call

Self-organizing

Learns and promotes automatically

Manual curation required

Project-aware

Auto-isolates by git repo

One big pile of memories

Knowledge graph

Multi-hop recall across concepts

Flat list of facts

Trust scoring

Outdated info decays and sinks

All memories equal

Setup

One command, local SQLite

Often needs cloud setup

The Engram Insight: Human memory doesn't search โ€” frequently-used patterns are already there. That's what hot cache does for Claude.

Quick Reference

Slash Command

Tool

Description

/memory-mcp:remember

remember

Store a memory with semantic embedding

/memory-mcp:recall

recall

Search memories by meaning

/memory-mcp:hot-cache

promote / demote

Manage promoted memories

/memory-mcp:stats

memory_stats

Show statistics

/memory-mcp:bootstrap

bootstrap_project

Seed from project docs

โ€”

link_memories

Knowledge graph connections

See Reference for all 10 slash commands and full tool API.

Dashboard

memory-mcp-cli dashboard    # Opens at http://localhost:8765

Dashboard

Browse memories, hot cache, injection history, sessions, and the knowledge graph.

How to Use

Memory MCP is designed to run as three complementary components:

Component

Purpose

Claude Code Plugin

Hooks that inject the hot cache, plus the /memory-mcp:* slash commands

MCP Server

Core memory tools available to Claude via Model Context Protocol

Dashboard

Web UI to browse, manage, and debug your memory database

The plugin is recommended for most users โ€” it auto-configures the MCP server and adds productivity features. Run the dashboard alongside when you want visibility into what's being stored.

Documentation

Document

Description

Reference

Full API, CLI, configuration, MCP resources

Troubleshooting

Common issues and solutions

License

MIT

Available Tools

16 tools
bootstrap_projectBootstrap ProjectA

Bootstrap hot cache from project documentation files.

Scans for common project documentation files (README.md, CLAUDE.md, etc.), parses them into memories, and optionally promotes to hot cache.

This is ideal for quickly populating the hot cache when starting work on a new codebase.

Edge cases handled gracefully:

  • Empty repo: Returns success with files_found=0 and helpful message

  • No markdown files: Returns success with message

  • File read errors: Logged in errors list, continues with other files

  • Empty files: Skipped silently

  • Binary files: Skipped with warning

  • All content already exists: Returns memories_skipped count

Inputs: tags, root_path, memory_type, file_patterns, +1 more. Returns: Response for bootstrap operation.

db_maintenanceDb MaintenanceB

Run database maintenance (vacuum, analyze, auto-demote stale).

Compacts the database to reclaim unused space, updates query planner statistics, and demotes stale hot memories (if auto_demote is enabled).

Inputs: no named parameters. Returns: Response for maintenance operation.

demoteDemoteA

Remove a memory from hot cache (keeps in cold storage).

Inputs: memory_id (required). Returns: object

end_sessionEnd SessionA

End a session and consolidate episodic memories.

Mirrors human memory consolidation: short-term (episodic) memories that prove valuable get promoted to long-term (semantic) storage.

Top episodic memories are selected by salience score (combining importance, trust, access count, and recency). Only memories above the threshold are promoted.

Use this at the end of a conversation to preserve valuable learnings.

Inputs: session_id (required), promote_top, promote_type. Returns: object

forgetForgetB

Delete a memory permanently.

Inputs: memory_id (required). Returns: object

get_related_memoriesGet Related MemoriesA

Get memories related to a given memory.

Returns related memories along with their relationship information. Use this to explore the knowledge graph around a specific concept.

Inputs: memory_id (required), direction, relation_type. Returns: result

hot_cache_statusHot Cache StatusB

Show current hot cache contents, stats, and observability metrics.

Returns items sorted by hot_score (highest first), along with:

  • metrics.hits: Times hot cache resource was read with content

  • metrics.misses: Times hot cache resource was empty

  • metrics.evictions: Items removed to make space for new ones

  • metrics.promotions: Items added to hot cache

  • effectiveness: Value metrics (hit rate, tool calls saved, most/least used)

  • avg_hot_score: Average hot score of items (for LRU ranking)

Inputs: no named parameters. Returns: Response for hot cache status.

link_memoriesLink MemoriesA

Create a typed relationship between two memories.

Use this to build a knowledge graph connecting related concepts. Relationships are directional: from_memory -[relation_type]-> to_memory.

Examples:

  • "Python 3.12 features" -[supersedes]-> "Python 3.11 features"

  • "Auth implementation" -[depends_on]-> "Database schema"

  • "API endpoint details" -[elaborates]-> "API overview"

  • "Project notes" -[mentions]-> "PostgreSQL" (entity extraction)

Inputs: to_memory_id (required), relation_type (required), from_memory_id (required). Returns: result

list_memoriesList MemoriesC

List stored memories with pagination.

Inputs: limit, offset, memory_type. Returns: result

mark_memory_usedMark Memory UsedA

Mark a memory as actually used/helpful after recall.

Call this when a recalled memory was useful in your response. Helps improve ranking by tracking which memories are valuable.

Inputs: memory_id (required), feedback. Returns: object

memory_statsMemory StatsC

Get memory statistics.

Inputs: no named parameters. Returns: Response for stats operation.

pinPinA

Pin a hot cache memory to prevent auto-eviction.

Pinned memories stay in hot cache even when space is needed for new items. Only works on memories already in hot cache.

Inputs: memory_id (required). Returns: object

promotePromoteB

Manually promote a memory to hot cache for instant recall.

Inputs: memory_id (required). Returns: object

recallRecallA

Semantic search with confidence gating and composite ranking.

Modes:

  • 'precision': High threshold (0.8), few results (3), prioritizes similarity

  • 'balanced': Default settings, good for general use

  • 'exploratory': Low threshold (0.5), more results (10), diverse ranking

Returns memories with confidence level and hallucination-prevention guidance.

Inputs: query (required), mode, limit, threshold, +3 more. Returns: Response for recall operation.

rememberRememberC

Store a new memory. Returns the memory ID.

Inputs: content (required), tags, category, session_id, +1 more. Returns: object

unpinUnpinA

Unpin a memory, making it eligible for auto-eviction from hot cache.

Inputs: memory_id (required). Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelogโ€ฆ

    Deploy Server
    One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

    TDQS

    B3.4/5.0

    Scored across 16 tools

    Disambiguation4/5

    Most tools target distinct actions: remember/recall/forget cover core CRUD, while hot-cache operations (promote, demote, pin, unpin, hot_cache_status) form a coherent group. The subtle pairs (forget vs demote, promote vs pin) could be momentarily confused, but the descriptions clearly disambiguate permanent deletion, eviction eligibility, and eviction prevention.

    Naming Consistency3/5

    The set mixes bare verbs (remember, recall, forget, pin, unpin, promote, demote) with verb_noun patterns (list_memories, link_memories, get_related_memories, mark_memory_used, bootstrap_project, end_session) and pure noun forms (memory_stats, hot_cache_status, db_maintenance). It's readable and predictable-ish within sub-groups, but not a single consistent convention.

    Tool Count4/5

    16 tools is on the heavier side, but the surface is divided into legitimate subsystems (core memory, hot cache, knowledge graph, session consolidation, bootstrap, maintenance), each contributing distinct operations. Nothing feels obviously redundant, though trimming hot-cache bookkeeping could tighten it.

    Completeness4/5

    Coverage is broad: create/read/delete memories, semantic recall, graph linking and traversal, hot-cache lifecycle, statistics, maintenance, and session consolidation. The main gap is an explicit update/edit operation for memory content or importance, which agents must work around by forgetting and re-remembering.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Resources

    Related MCP Connectors

    Related MCP Servers

    • CCCMemory MCP

      xiaolai
      A
      license
      Not graded
      quality
      F
      maintenance
      Provides Claude with long-term memory by indexing conversation history, enabling semantic search, decision tracking, and cross-project search.
      18 npm
      29
      MIT

    • coding-memory-mcp

      ChinaCarlos
      A
      license
      Not graded
      quality
      D
      maintenance
      Provides a local long-term memory layer for AI coding tools like Cursor and Claude Code, enabling cross-session, cross-tool sharing of project facts, user preferences, decisions, and workflows.
      25 npm
      2
      MIT