Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type @ followed by the MCP server name and your instructions, e.g., "@mindnode-mcp Read today's mind map and draft a standup update."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Connect MindNode to Claude and any AI agent — an MCP server for the mind-mapping app that has no API, no AppleScript, and no exportable files.
MindNode Next (the 2024+ generation of MindNode) moved all documents into a
private SQLite/CRDT library and ships zero automation surface: no
AppleScript dictionary, no CLI, no cloud API, not even .mindnode files on
disk anymore. This project reverse-engineered the storage format so AI agents
can finally read and create mind maps:
Read any mind map as a Markdown outline — straight from MindNode's local library (SQLite → protobuf → Apple LZ4 → CRDT decode), read-only, without even launching the app.
See the exact rendered map — MindNode's own preview JPEGs, pixel-perfect.
Create new mind maps from Markdown outlines (silent in-app import).
Open any map by name via the mindnode:// URL scheme.
Works with Claude Code, Claude Desktop, and any MCP client.
Looking for the classic file-based MindNode? Older plist-based tools cover
.mindnodedocuments; this server is for MindNode Next (2024+), the SQLite-library generation where those approaches no longer work. Verified on MindNode 2026.4.4.
tool | what it does |
| list all mind maps in the library (title, id, modified) |
| read a mind map as a Markdown outline (best-effort CRDT decode) |
| MindNode's own rendered JPEG preview — pixel-perfect ground truth |
| create a new mind map from a Markdown outline (imports via the app) |
| open a mind map in MindNode |
Related MCP server: Bruin
Requires macOS with MindNode 2024+ and Node.js ≥ 24.
Claude Code:
claude mcp add --scope user mindnode -- npx -y mindnode-mcpClaude Desktop / any MCP client (claude_desktop_config.json):
{
"mcpServers": {
"mindnode": {
"command": "npx",
"args": ["-y", "mindnode-mcp"]
}
}
}From source (Node ≥ 24 runs the TypeScript directly, no build step):
git clone https://github.com/jyuwaaw/mindnode-mcp.git
cd mindnode-mcp && npm install
claude mcp add --scope user mindnode -- node /path/to/mindnode-mcp/src/index.tsDebug with the MCP inspector: npm run inspect.
I keep a daily mind map (one per day, plus per-project maps) as my working memory — Raycast is set up to summon MindNode with a single keystroke, so capturing a thought costs nothing. This server closes the loop: at the end of the day an agent reads the map, turns it into a work log or blog draft, and can seed tomorrow's map from open threads. Ask Claude things like:
"list my mind maps"
"read today's map and draft a standup update"
"turn this outline into a mind map: …"
MindNode Next stores everything in a GRDB/SQLite library inside its sandbox
container. Each document is a protobuf base snapshot plus a stream of
CRDT operation batches, both wrapped in a tiny envelope (field 12345 =
version, field 678910 = payload — yes, really) and compressed with Apple's
LZ4 framing (bv41/bv4-/bv4$ blocks).
This repo carries a schema-less protobuf parser, a pure-TypeScript Apple-LZ4
decoder, and a tree reconstructor that replays node-creation and text ops.
The full reverse-engineering notes live in docs/FORMAT.md —
if you want to build your own MindNode tooling, start there.
tools/spelunk.py pretty-prints any library blob for
further digging.
Writes deliberately do not touch the database (it's CloudKit-synced;
corrupting it would be unforgivable). New documents go through MindNode's own
Markdown importer via open -a MindNode, which is silent and lossless.
get_mindmap reconstructs text from a CRDT op stream whose position
encoding isn't fully mapped: heavily edited strings can come back slightly
scrambled, and deleted nodes may linger as (untitled). Use
get_mindmap_image when exactness matters. Documents created via
create_mindmap read back losslessly.
create_mindmap launches MindNode (import happens in-app, silently). It
always lands the new document at the library root — targeting a folder
needs the App Intents route (see Roadmap) — and MindNode auto-renames the
document when the title already exists (the central node keeps the title
you asked for). There is no tool yet for adding nodes to an existing map,
renaming, or deleting.
If an import produces nothing, check MindNode itself: a modal dialog in the
app blocks every subsequent open/import, and open still exits 0. Only
Markdown imports work this way — MindNode registers as a viewer for OPML,
FreeMind and TaskPaper, but opening those files is silently ignored.
The library is read read-only, always. Format verified on MindNode
2026.4.4; a future MindNode update could shift field numbers — file an
issue with tools/spelunk.py output if outlines come back empty.
Node-level edits (add/rename/delete a single node) and lossless export via MindNode's 20 App Intents (CreateNode, EditNode, ExportDocument, …) wrapped in Shortcuts
Map the CRDT text-position encoding and deletions for exact reads
Folder titles, tags/stickers, notes fields
Create a new mind map in MindNode by importing Markdown. The first # heading becomes the central node; nested bullet lists (and deeper headings) become branches — write any consistent indentation, it is re-emitted at the four spaces per level MindNode requires. The document lands at the library root (placing it in a folder is not supported yet), and MindNode auto-renames the document if the title already exists — the central node keeps the requested title regardless.
Inputs: title (required), markdown (required).
Read a mind map's content as a Markdown outline (root heading + nested bullets), reconstructed from MindNode's local store. Best-effort: heavily edited text may be imperfect — cross-check with get_mindmap_image when exactness matters.
Inputs: document (required).
Return MindNode's own rendered preview (JPEG) of a mind map — the exact visual, useful to verify layout or ambiguous text.
Inputs: document (required), appearance.
List all mind maps in the local MindNode library (title, documentID, last modified). Read-only.
Inputs: includeTrashed.
Open a mind map in the MindNode app (brings it to the foreground).
Inputs: document (required).
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 5 tools
Each tool targets a clear, distinct action: listing, reading text, reading image, creating, and opening. While get_mindmap and get_mindmap_image both retrieve content, one is text and one is visual, and the descriptions explicitly differentiate them.
All names follow a consistent verb_noun pattern: list_mindmaps, get_mindmap, get_mindmap_image, create_mindmap, open_mindmap. The one plural noun in list_mindmaps is natural because listing returns multiple items, and the pattern remains predictable.
Five tools is a well-scoped size for a MindNode local-library integration. Each tool serves a distinct user need, and none feels redundant or unnecessary.
The read, create, and open workflow is well covered, and get_mindmap_image adds valuable visual confirmation. However, there is no update, delete, rename, or folder-management operation, so the surface is more read/create-oriented than full lifecycle coverage.
Turn outlines and hierarchical notes into interactive mind maps through a hosted remote MCP server.
Markdown-based note-taking with a hosted MCP server. Your notes serve you and your AI.
One memory, every AI. A shared, user-owned markdown memory your AI clients read and write over MCP.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
