# io.github.ravi-labs/mindmap-mcp-server (npm · @ravi-labs/mindmap-mcp-server)

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

- Trust score: 68/100 (medium)
- Change this week: +42
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-06

## Components

- npm · `@ravi-labs/mindmap-mcp-server`: 68/100 (this document), [markdown](https://verifymcp.io/servers/ravi-labs-mindmap-mcp-server/ravi-labs-mindmap-mcp-server.md), [page](https://verifymcp.io/servers/ravi-labs-mindmap-mcp-server/ravi-labs-mindmap-mcp-server)

## Channel facts

- Registry: `npm`
- Package: `@ravi-labs/mindmap-mcp-server`
- Version: `0.5.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-06.

- **Supply Chain Security**: 87/100
  - No malware found by supply-chain analysis.
  - Known CVEs were checked across the 94 of 95 dependencies we could resolve, so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Dependency health was assessed across the 94 of 95 dependencies we could resolve, so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (Apache-2.0).
  - Actively maintained (last published 36 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 63/100
  - AI-judged instruction clarity (good).
  - Context-footprint check failed: tool/resource definitions use about 3829 tokens (~147/item across 26 items; 26 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 33/100
  - Stability observed for 10 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

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

### Codex

```bash
codex mcp add ravi-labs-mindmap-mcp-server -- npx -y @ravi-labs/mindmap-mcp-server
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "ravi-labs-mindmap-mcp-server": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "@ravi-labs/mindmap-mcp-server"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add ravi-labs-mindmap-mcp-server --command npx --arg -y --arg @ravi-labs/mindmap-mcp-server
```

### Hermes

```yaml
mcp_servers:
  ravi-labs-mindmap-mcp-server:
    command: "npx"
    args: ["-y", "@ravi-labs/mindmap-mcp-server"]
```

### Other

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

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-06 (score 68, +1)

No change was recorded against any check on this day. Stability & Change Management went from 30 to 33. That category is still filling its 30-day observation window: 9 days of observed history at the previous scan, 10 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-04 (score 67, +1)

No change was recorded against any check on this day. Stability & Change Management went from 23 to 27. That category is still filling its 30-day observation window: 7 days of observed history at the previous scan, 8 at this one. The score rises as the window fills, whether or not the server changes.

### 2026-08-02 (score 66, +61)

- [security regression] Provenance: unverified → fail
- [security improvement] Malware scan: unverified → pass
- [security improvement] Install scripts: unverified → pass
- [security improvement] Known CVEs: unverified → partial
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional improvement] Stability: unverified → 0.20
- [functional improvement] Tool coverage: unverified → 100
- [functional improvement] License: unverified → pass
- [functional improvement] MCP protocol: unverified → pass
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional] Licence: Apache-2.0

### 2026-08-01 (score 5, −46)

- [security regression] Known CVEs: partial → unverified
- [security regression] Provenance: fail → unverified
- [security regression] Install scripts: pass → unverified
- [security] Stability: Stability not yet verified: we do not have a sandbox capture of the MCP schema this version of the package serves yet.
- [functional regression] Capabilities: pass → unverified
- [functional regression] License: pass → unverified
- [functional regression] Tool coverage: 100 → unverified
- [functional regression] Dependency health: partial → unverified
- [functional regression] Maintenance: pass → unverified
- [functional] Licence: Apache-2.0

### 2026-07-31 (score 51, +25)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-30 (score 26, +2)

- [security regression] Malware scan: pass → unverified
- [functional improvement] Tool coverage: unverified → 100

### 2026-07-28 (score 24, −20)

- [functional regression] Tool coverage: 100 → unverified
- [functional] First check of Schema quality: unverified

### 2026-07-27 (score 44)

First indexed and scored.

## MCP tools (26)

### `mindmap_capture` (~486 tokens)

Capture context

Silently save a portable context summary from the current session so it can be resumed later in any tool. This is the effortless 'capture' half of the loop. New captures start as 'captured' (warm tier); they become trusted 'promoted' memories the first time you resume them.

CALL THIS PROACTIVELY (you don't need to be asked) when: a substantive discussion is wrapping up; the user says they're done / switching tasks / "remember this" / "save this"; a key decision, plan, or conclusion was reached; or the user signals they'll continue later. Write the summary so a future session in a DIFFERENT tool could pick up with full context. Skip trivial one-off exchanges.

Args:
  \- title (string): short topic title
  \- summary (string): the portable context to inject into a future session (markdown ok)
  \- key_points (string[]): scannable discussion points (optional)
  \- tags (string[]): topic tags for filtering (optional)
  \- source (string): Origin tool, e.g. 'claude-code', 'chatgpt', 'chat', 'cowork', 'claude-desktop'.
  \- links (string[]): ids of related threads to connect (optional)
  \- kind ('discussion'|'brainstorm'): mark brainstorm sessions so they can be resumed/clustered as ideas (default 'discussion')
  \- next_steps (string[]): open work / what to do next — capture this so resuming can CONTINUE the thread, not just re-read it (optional but high-value)

Returns: the created thread id and its formatted record.

Input parameters:

- `key_points` (array): Scannable discussion points
- `kind` (string): Thread kind
- `links` (array): ids of related threads to link
- `next_steps` (array): Open work / where you left off — so resuming can continue
- `source` (string): Origin tool, e.g. 'claude-code', 'chatgpt', 'chat', 'cowork', 'claude-desktop'.
- `summary` (string, required): Portable context summary (markdown ok)
- `tags` (array): Topic tags for filtering
- `title` (string, required): Short topic title
- `workspace` (string): Absolute project/workspace folder this is about — lets resume suggest where to continue

### `mindmap_resume` (~303 tokens)

Resume context

Restart a topic by describing it in plain words — "pick up the promotion-roadmap discussion", "continue the buyer-service refactor". Resolves your description to the best match, then reassembles the WHOLE topic: the anchor memory plus its linked + closely-related fragments (a topic is usually spread across several sessions/tools), merged into one thread to continue from. Promotes the anchor on reuse. If captured, surfaces "where you left off" (next steps) so you can keep going, not just re-read.

CALL THIS PROACTIVELY at the START of a session when the user references prior work — "let's continue", "restart the X discussion", "the X project", or any topic that may have history.

Args:
  \- query (string): topic / what you want to restart, in natural language
  \- id (string): resume a SPECIFIC memory by id — use after the user picks from mindmap_resume_options
  \- source (string): only resume memories from this origin tool (optional)
(Provide query OR id.)

Returns: a merged topic thread (anchor + related fragments) + where you left off + which workspace to continue in, or near-misses.

Input parameters:

- `id` (string): Resume this specific memory id (e.g. a picked choice)
- `query` (string): Topic / what you want to restart (natural language)
- `source` (string): Restrict to this origin tool

### `mindmap_resume_options` (~149 tokens)

List topics to resume (let the user pick)

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): restrict to one origin tool (optional)
Returns: up to 5 distinct candidate topics (id, title, workspace, source, last used).

Input parameters:

- `query` (string, required): What the user wants to resume
- `source` (string): Restrict to this origin tool

### `mindmap_brainstorm` (~222 tokens)

Brainstorm with memory

Start (or continue) a brainstorm on a topic WITH your shared memory. This pulls your prior thinking on the topic — past brainstorms first, then related discussions and your persona — so an idea you explored in one tool continues seamlessly in another. It does NOT replace your own brainstorming ability: use this to load context, then brainstorm with your full capability (and any brainstorming skill you have), then save the result.

CALL THIS PROACTIVELY when the user wants to brainstorm / ideate / "think through" / "explore options" on something that may have history. Reusing a past brainstorm promotes it (promote-on-reuse).

Flow: 1) call this with the topic → get prior context; 2) brainstorm, building on it; 3) save what's worth keeping with mindmap_capture(kind="brainstorm").

Args:
  \- topic (string): what you're brainstorming about
Returns: a brainstorm pack — persona + prior idea-threads to build on.

Input parameters:

- `topic` (string, required): Brainstorm topic / question

### `mindmap_search` (~179 tokens)

Search memories

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 (default 10)

Returns: ranked list of matching memories.

Input parameters:

- `include_archived` (boolean): Include forgotten traces
- `limit` (integer): Max results
- `query` (string): Keywords; empty = browse by recency
- `source` (string): Filter by origin tool
- `tag` (string): Filter by tag
- `tier` (string): Filter by tier

### `mindmap_list` (~102 tokens)

List memories

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.

Input parameters:

- `include_archived` (boolean): Include archived traces
- `limit` (integer): Max results
- `source` (string): Filter by origin tool
- `tag` (string): Filter by tag
- `tier` (string): Filter by tier

### `mindmap_get` (~48 tokens)

Get a memory

Fetch the full content of one memory by id. Read-only (does not change freshness).

Args: id (string). Returns: the full thread.

Input parameters:

- `id` (string, required): Thread id

### `mindmap_transcript` (~114 tokens)

Full discussion

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.

Args: id (string). Returns: the full discussion as turns, or why it's unavailable.

Input parameters:

- `id` (string, required): Thread id

### `mindmap_promote` (~76 tokens)

Promote a memory

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.

Input parameters:

- `id` (string, required): Thread id

### `mindmap_update` (~145 tokens)

Update / trim a memory

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.

Input parameters:

- `append` (boolean): Append instead of replace
- `id` (string, required): Thread id
- `key_points` (array): New (or appended) key points
- `summary` (string): New (or appended) summary
- `tags` (array): Replace tags
- `title` (string): New title

### `mindmap_link` (~82 tokens)

Link two memories

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.

Input parameters:

- `id` (string, required): First thread id
- `target_id` (string, required): Second thread id

### `mindmap_prune` (~90 tokens)

Prune / consolidate memory

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.

Input parameters:

- `dry_run` (boolean): Preview without writing changes

### `mindmap_forget` (~91 tokens)

Forget a memory

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.

Input parameters:

- `hard` (boolean): Permanently delete instead of archive
- `id` (string, required): Thread id

### `mindmap_health` (~65 tokens)

Memory 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_tidy` (~94 tokens)

Tidy pass

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.

Input parameters:

- `limit` (integer): How many to review

### `mindmap_config` (~124 tokens)

View / change settings

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.

Input parameters:

- `gamification` (boolean): Enable health/tidy surface
- `hot_window_days` (number): Days a thread stays hot
- `promoted_longevity_factor` (number): How much slower promoted memories decay
- `warm_window_days` (number): Days before warm→cold

### `mindmap_persona` (~137 tokens)

Get user 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 isn't covered.

Args:
  \- project (string, optional): include preferences scoped to this project on top of global ones.
Returns: an "About this user" block + fact count.

Input parameters:

- `project` (string): Current project name for scoped prefs

### `mindmap_persona_set` (~212 tokens)

Record a user preference

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: identity | stack | style | communication | constraints | workflow | goals
  \- polarity ('prefer'|'avoid'|'fact'): default 'prefer'
  \- project (string, optional): scope to one project instead of global
Returns: the saved fact.

Input parameters:

- `category` (string, required): Which dimension this preference is about
- `polarity` (string): prefer / avoid / fact
- `project` (string): Scope to a project (default: global)
- `text` (string, required): The preference statement

### `mindmap_persona_forget` (~88 tokens)

Forget a preference

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.

Input parameters:

- `hard` (boolean): Permanently delete instead of mute
- `id` (string, required): Persona fact id

### `mindmap_persona_learn` (~96 tokens)

Infer persona from memory

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 path ran.

### `mindmap_llm` (~216 tokens)

Configure optional LLM (BYO key)

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 optional — omit all to just see status):
  \- provider: none | anthropic | openai | google | ollama
  \- model: override the default model
  \- baseUrl: for ollama / self-hosted (default http://localhost:11434)
Returns: current provider/model, whether it's ready, and a rough cost note.

Input parameters:

- `baseUrl` (string): Base URL for ollama / self-hosted
- `model` (string): Model name override
- `provider` (string): LLM provider, or 'none' to disable

### `mindmap_audit` (~109 tokens)

Audit what's stored (glass-box)

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.

Input parameters:

- `limit` (integer): Max rows

### `mindmap_passport_export` (~90 tokens)

Export memory passport

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.

Input parameters:

- `path` (string): Output file path

### `mindmap_passport_import` (~164 tokens)

Import memory passport / data export

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 FILES are yours — this imports them as distilled memories.

Args: file (string, required), kind ('passport'|'chatgpt'|'claude', default 'passport'). Returns: import counts.

Input parameters:

- `file` (string, required): Path to the file to import
- `kind` (string): File kind

### `mindmap_persona_sync` (~162 tokens)

Write persona into your tools

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): specific target ids (claude-global, claude-project, cursor, copilot, windsurf)
  \- force (boolean, optional): write even if a tool isn't detected
Returns: per-target outcomes.

Input parameters:

- `force` (boolean): Write even if tool not detected
- `targets` (array): Target ids to write

### `mindmap_import` (~185 tokens)

Import / sync sessions

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 ('all'|'code'|'cursor'|'copilot'|'cowork'): limit to one source (default all)
  \- reimport (boolean): also refresh already-imported sessions in place (default false)
Returns: how many sessions were imported / refreshed / skipped.

Input parameters:

- `reimport` (boolean): Refresh already-imported sessions too
- `source` (string): Which source(s) to import

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/ravi-labs-mindmap-mcp-server/ravi-labs-mindmap-mcp-server#diagnostics

## Score history

- 2026-08-06: 68
- 2026-08-05: 67
- 2026-08-04: 67
- 2026-08-03: 66
- 2026-08-02: 66
- 2026-08-01: 5
- 2026-07-31: 51
- 2026-07-30: 26
- 2026-07-28: 24
- 2026-07-27: 44

## Links

- npm package: https://www.npmjs.com/package/@ravi-labs/mindmap-mcp-server
- Socket report: https://socket.dev/npm/package/@ravi-labs/mindmap-mcp-server
- Repository: https://github.com/ravi-labs/mindmap-mcp-server
- Changelog RSS feed: https://verifymcp.io/servers/ravi-labs-mindmap-mcp-server/ravi-labs-mindmap-mcp-server.xml
- Changelog JSON feed: https://verifymcp.io/servers/ravi-labs-mindmap-mcp-server/ravi-labs-mindmap-mcp-server.json
- HTML version of this page: https://verifymcp.io/servers/ravi-labs-mindmap-mcp-server/ravi-labs-mindmap-mcp-server