MCP.Market

Mindmap MCP server

by ravi-labs·io.github.ravi-labs/mindmap-mcp-server·v0.5.0·4 stars

Local-first memory & context-handoff across AI tools — capture in one, resume in another. No cloud.

A86/100grade A
What users say
No reviews yet
Be the first
Safety scan
A86/100

full report

Adoption
Growing

4 stars47 downloads/wk

Reviews

Write one

Nobody has reviewed Mindmap yet.

If you have run it, two minutes of your experience saves the next person an afternoon.

Mindmap tools (26, 3 write)

write = sends, deletes, buys or posts

Read from the package source without running it. The installed server may list more.

  • mindmap_audit

    Show a transparent ledger of everything Mind Map knows — each memory's provenance (where it came from), trust (promote-on-reuse count), tier, last use, and when it will fade to a one-line trace. Use when the user asks "what do you know about me?", "what's stored?", or wants to review/clean their memory. Args: limit (number, optional, default 30). Returns: the ledger rows.

  • mindmap_brainstorm
  • mindmap_capture
  • mindmap_config

    View or change Mind Map settings: decay windows, the promoted longevity factor, and the gamification toggle. Omit all args to just view current settings. Args (all optional): hot_window_days, warm_window_days, promoted_longevity_factor, gamification. Returns: the effective config.

  • mindmap_forget

    Forget a memory. By default this is a soft forget: status→archived, kept only as a searchable one-line trace (recall never hard-fails). Set hard=true to permanently delete the file. Args: id (string), hard (boolean, default false). Returns: confirmation.

  • mindmap_get

    Fetch the full content of one memory by id. Read-only (does not change freshness). Args: id (string). Returns: the full thread.

  • mindmap_health

    The opt-in gamified curation surface. Reports a cleanliness score — the share of memory that is still live (hot+warm) vs stale — which rewards pruning, not hoarding. Also lists stale candidates worth a tidy pass. Args: none. Returns: health report.

  • mindmap_import

    Scan your local AI-tool history and import any NEW sessions into Mind Map — across Claude Code, Cursor, Copilot, and Cowork. Use this when the user says things like "import my sessions", "sync mind map", "update mind map with my latest work", "pull in my recent sessions", or "refresh my memory". (Mind Map also auto-imports periodically if enabled, but this does it on demand, now.) Args: - source (

  • mindmap_link

    Connect two memories so related threads (e.g. planning in Chat + code in Claude Code) cross-reference each other. Bidirectional. This is the lightweight 'map' connective tissue. Args: id (string), target_id (string). Returns: confirmation.

  • mindmap_list

    List saved memories with optional filters, newest-used first. Read-only. Args: source/tag/tier filters, include_archived (default false), limit (default 20). Returns: list of memories.

  • mindmap_llm

    Mind Map runs fully WITHOUT an LLM. This is opt-in: plug in your OWN provider to unlock smarter features (LLM-assisted persona inference, richer summaries). Security: Mind Map stores only the provider + model name. It NEVER stores your API key — the key is read from your environment (ANTHROPIC_API_KEY / OPENAI_API_KEY / GOOGLE_API_KEY; ollama needs none). Set the env var yourself. Args (all option

  • mindmap_passport_export

    Export all memories + persona to a single portable JSON file you own — to back up, move to another machine, or hand to a fork. This is your context, extractable. Args: path (string, optional) — output file (default ~/mindmap-passport-<date>.json). Returns: the file path and counts.

  • mindmap_passport_import

    Bring context IN. Either a Mind Map passport file (from another machine), or pull your conversations OUT of a walled garden by pointing at its exported data file: - kind 'passport' (default): a Mind Map passport JSON - kind 'chatgpt': ChatGPT's exported conversations.json - kind 'claude': Claude.ai's exported conversations.json The cloud chats themselves can't be reached live, but their EXPORT FIL

  • mindmap_persona

    Return the user's persona — a distilled profile of how they work (stack, style, communication, constraints), so you can make aligned defaults and AVOID re-asking things they've already established. CALL THIS PROACTIVELY at the start of a session before asking the user setup-style questions (their stack, preferences, conventions). Apply high-confidence facts silently; only ask when something needed

  • mindmap_persona_forgetwrite action

    Remove or mute a persona fact (e.g. it's wrong or out of date). Get ids from mindmap_persona. Default mutes (recoverable); hard=true deletes. Args: id (string), hard (boolean, default false). Returns: confirmation.

  • mindmap_persona_learn

    Derive persona facts from your existing memories. If you've configured an LLM (mindmap_llm), it extracts richer facts — style, constraints, workflow; otherwise it runs a no-LLM keyword heuristic over your stack/tools. Either way, inferred facts get lower confidence than declared ones and never override what you've explicitly set. Args: none. Returns: how many facts were added/updated and which pat

  • mindmap_persona_set

    Save a durable preference about how the user works, so future sessions don't re-ask. Use this when the user states a lasting preference — "I prefer X", "always Y", "never Z", "I'm on macOS", "we use Postgres". (For saving a *discussion*, use mindmap_capture instead — this is for standing preferences.) Args: - text (string): the preference, e.g. "Prefers concise, code-first answers" - category: ide

  • mindmap_persona_sync

    Project the user's persona into the native instruction files of their AI tools (Claude CLAUDE.md, Cursor rules, Copilot instructions, Windsurf rules), so even non-MCP tools know how they work — from one source. Writes only inside a managed block; never clobbers the user's own content. By default writes the global Claude config + any detected project tools. Args: - targets (string[], optional): spe

  • mindmap_promote

    Explicitly bless a memory as trusted: marks it 'promoted' and moves it to the hot tier so it ranks first and decays slower. Use when you know a memory matters even if you haven't resumed it yet. Args: id (string). Returns: the updated thread.

  • mindmap_prunewrite action

    Run the consolidation pass that the background thread runs automatically: recompute every memory's tier by age + usage, cooling unused ones and collapsing cold ones to a one-line trace (still searchable, never deleted). Nothing is destroyed. Args: dry_run (boolean, default false) — preview changes without writing. Returns: what moved between tiers.

  • mindmap_resume
  • mindmap_resume_options

    When the user's description is ambiguous or could match SEVERAL different topics, list the distinct candidate topics — each with the workspace it lived in — so you can ASK the user which one to resume instead of guessing. Read-only: promotes nothing. After the user picks, call mindmap_resume with that choice's id. Args: - query (string): the user's natural-language description - source (string): r

  • mindmap_search

    Search across all saved context (every tier, every tool) to relocate a past discussion. Read-only — does not change freshness or tiers (use mindmap_resume to actually pull a memory forward). Args: - query (string): keywords; empty string browses by recency - source/tag/tier: optional filters - include_archived (boolean): include forgotten traces (default false) - limit (number): max results (defau

  • mindmap_tidy

    Return a small batch of the stalest memories for a quick keep / trim / forget review — the opt-in curation game. Read-only: it only suggests. Act on items with mindmap_promote (keep), mindmap_update (trim), or mindmap_forget. Args: limit (number, default 5). Returns: stalest cold memories.

  • mindmap_transcript

    Reconstruct and return the FULL original conversation for a memory (every user + assistant turn), read live from its source transcript. The summary is the distilled gist; this is the complete discussion when you need the detail. Only available for transcript-backed sources (Claude Code, Cursor, Copilot). Cowork / Claude desktop-app sessions saved no transcript, so this returns a notice instead. Ar

  • mindmap_updatewrite action

    Edit a memory — the human curation moment. Trim a stale summary, refine key points, retitle, or retag. Any omitted field is left unchanged. Set append=true to append to summary/key_points instead of replacing. Args: id, title?, summary?, key_points?, tags?, append (default false). Returns: the updated thread.

Public scan report

scanner v0.1.9 · 2026-09-26 · same rubric, same numbers if you re-run it

no findings
  • Code scan47 source files scanned25/25
  • –Live reliabilityno gateway calls yet and no remote to proben/a
  • –Tool poisoningtools not inspected (local package is not executed); not countedn/a
  • Auth qualitylocal package, no credentials required12/15
  • Maintenancelast push 82 days ago12/15
  • Maintainer identityregistry namespace matches repository owner7/10
Overall 86/100. Components that don't apply are left out of the denominator. Any critical finding is an F.RubricAppeal a findingJSON

How Mindmap compares

Against every graded MCP server, from our own scans and uptime checks. Updated after each scan run.

Safety score
86/100
higher than 72% of 48,255 servers
Tools
26
the typical server has 7
Tools that change things
12%
typical: 0%. Fewer write tools means less an agent can break
GitHub stars
4
more than 82% of 28,688 servers
Downloads a week
47
more than 39% of 12,191 servers with a package

What its tools let an agent do: 23 read · 3 change

Install Mindmap in Claude Code, Cursor or VS Code

Runs npx -y @ravi-labs/mindmap-mcp-server on your machine. Read the scan report first; the gateway never runs local packages.

claude mcp add mindmap-mcp-server -- npx -y @ravi-labs/mindmap-mcp-server
Add to Cursor

What the publisher says

From the Mindmap repository's README, as published. We do not edit it. Read it on GitHub

🧠 Mind Map — MCP memory & context-handoff server

Ever lose the thread of a discussion across Claude Code, Claude Desktop, and your other AI tools? Mind Map is a small, local-first MCP server that acts as a shared memory layer across all your local MCP clients.

You capture context at the end of a session, and resume it in any other tool — no more re-explaining your project from scratch. Memory you stop using cools and decays gracefully into one-line traces (it's never silently deleted), so your shelf stays small and trustworthy instead of becoming another haystack.

Local-first by design. It runs on your machine; your memories are plain

files in ~/.mindmap that never leave your control. No account, no cloud, no

server to trust. Install once with npx @ravi-labs/mindmap-mcp-server install.

_ChatGPT and other cloud/web clients are out of scope for now — they can't

reach a local server without a public endpoint, which conflicts with

local-first. See Future._

The idea in one loop

reusing it is what promotes it to trusted memory. Throwaway sessions never get promoted, so they never clutter your shelf.

  1. Capture (effortless) — at the end of a discussion, save a portable summary.
  2. Resume (promote-on-reuse) — pull it forward in a new session. The act of

tiers (🔥 hot → 🌤️ warm → ❄️ cold) and collapses cold items to a searchable one-line trace. The moat isn't storing things — it's forgetting well.

  1. Consolidate (automatic) — a background pass cools unused memory through

hoarding.

  1. Tidy (opt-in, gamified) — a cleanliness score rewards pruning, not

Install (one command)

Once published to npm, the whole install is:

npx @ravi-labs/mindmap-mcp-server install

This auto-detects your local MCP clients (Claude Desktop, Cursor, Windsurf) and writes the config for you, and configures Claude Code via its CLI if present. Restart your client and Mind Map's tools are there. Preview first with npx @ravi-labs/mindmap-mcp-server install --dry-run; undo with npx @ravi-labs/mindmap-mcp-server uninstall.

Data lives in ~/.mindmap/ by default — override with the MINDMAP_DIR env var.

Manual setup (if you prefer)

Every client uses the same command — npx -y @ravi-labs/mindmap-mcp-server over stdio.

Claude Code:

claude mcp add mindmap -- npx -y @ravi-labs/mindmap-mcp-server

Claude Desktop — edit claudedesktopconfig.json (macOS: ~/Library/Application Support/Claude/claudedesktopconfig.json):

{
  "mcpServers": {
    "mindmap": {
      "command": "npx",
      "args": ["-y", "@ravi-labs/mindmap-mcp-server"]
    }
  }
}

Cursor / Windsurf / other clients — same command + args shape in that client's MCP config. Add an env block to relocate data:

{ "command": "npx", "args": ["-y", "@ravi-labs/mindmap-mcp-server"],
  "env": { "MINDMAP_DIR": "/path/to/my/memory" } }

From source (development)

git clone https://github.com/ravi-labs/mindmap-mcp-server.git && cd mindmap-mcp-server
npm install && npm run build
node dist/index.js install --local   # points clients at this checkout

Using it day to day

Just talk naturally inside your AI tool — the model calls the right tool:

Shortened. The full README is on GitHub.

Nothing above is checked by us. What we check is on the safety report.

Mindmap: common questions

Is Mindmap MCP server safe?
Yes, by our scan: it is graded A (86/100). Read the Mindmap safety report
How do I install Mindmap?
It runs on your machine. Copy the Claude Code, Cursor, VS Code or Claude Desktop config from the install section.
Does Mindmap need an API key?
Not as far as the registry entry and our scan can tell: no credentials are declared or required.
Is Mindmap maintained?
The last commit was 121 days ago (2026-07-06). The latest release is v0.5.0.
What can I use instead of Mindmap?
Servers from other publishers that do the same job: Memorix MCP server and Nautilus Compass Memory MCP server.
How does Mindmap compare with other MCP servers?
safety score 86/100 (higher than 72% of 48,255 servers); tools 26 (the typical server has 7); tools that change things 12% (typical: 0%. Fewer write tools means less an agent can break). Full comparison.

Alternatives to Mindmap

Same job from other publishers: the closest match first, then the best rated.

  • Memorix
    Local-first project memory with legacy MCP and 2026 discovery compatibility.
    B
  • Nautilus Compass Memory
    Local-first long-term memory for AI agents, with byte-recomputable signed verification receipts.
    B