Mindmap MCP Server: Generate Mindmaps from Markdown

Overview

The Mindmap MCP Server converts Markdown content into visual mindmaps and exposes that functionality through a small HTTP/MCP-compatible service. It is designed to be used as a tool backend for LLMs or as a standalone API so developers can generate diagram-friendly representations of hierarchical content (notes, README sections, meeting minutes, outlines) automatically.

The server parses Markdown structure (headings, lists, code fences, and simple metadata) and converts it into diagram formats such as Mermaid mindmap syntax or a structured JSON tree. Because it is built to be used as an MCP (Model Context Protocol) tool provider, the server can be connected to agent frameworks and LLM tool orchestration systems to produce visualizations on demand.

Repository: https://github.com/YuChenSSR/mindmap-mcp-server

Features

• Convert Markdown to mindmap diagrams (Mermaid and JSON tree outputs)
• Expose a simple HTTP API for programmatic generation
• MCP-compatible manifest so LLM agents can discover the tool automatically
• Accepts raw Markdown or URL to Markdown resources
• Optional caching of recent conversions for faster repeated requests
• Configurable output formats, layout options, and depth limits
• Docker-ready for fast deployment

Installation / Configuration

The project supports running via Docker (recommended) or from source. Replace environment values with your preferred configuration.

Using Docker (quick start)

# Pull and run (replace IMAGE with repo image or build locally)
docker run -p 8080:8080 \
  -e PORT=8080 \
  -e OUTPUT_FORMAT=mermaid \
  yu-chen/mindmap-mcp-server:latest

Run from source (Node.js example)

# Clone the repository
git clone https://github.com/YuChenSSR/mindmap-mcp-server.git
cd mindmap-mcp-server

# Install dependencies and start
npm install
npm run start

# or with yarn
yarn
yarn start

Configuration (example .env)

PORT=8080                  # HTTP port
OUTPUT_FORMAT=mermaid      # mermaid | json
CACHE_TTL_SECONDS=300      # optional caching
MAX_DEPTH=6                # limit nesting to avoid giant graphs
MCP_MANIFEST_PATH=/.well-known/mcp.json

If the repository includes a Dockerfile, you can build locally:

docker build -t mindmap-mcp-server .
docker run -p 8080:8080 -e PORT=8080 mindmap-mcp-server

Available Resources

The service typically exposes these resources and endpoints (adjust names to match your deployed server):

Example POST request

curl -X POST http://localhost:8080/convert \
  -H "Content-Type: application/json" \
  -d '{"markdown":"# Project\n\n## Plan\n- Task A\n- Task B","format":"mermaid"}'

Typical response (Mermaid mindmap)

mindmap
  root((Project))
    Plan
      Task A
      Task B

MCP manifest (example)

{
  "name": "mindmap-generator",
  "description": "Generate mindmaps from Markdown",
  "schema_version": "1.0",
  "endpoints": [
    { "path": "/convert", "method": "POST", "content_type": "application/json" }
  ]
}

Use Cases

• Documentation visualization: Convert README sections into a mindmap to help onboard contributors or to summarize a repo structure.
  • Input: Project README with headings and bullet lists
  • Output: Mermaid mindmap you can embed in docs or export as image
• Meeting notes and action items: Turn meeting minutes (bullet lists and headers) into a hierarchical mindmap for quick review and prioritization.
• Study outlines and learning paths: Convert course notes or outlines into a visual study plan by automatically extracting headings as nodes.
• API design and architecture: Produce a diagram of endpoints and components when you write architecture notes in Markdown.
• Automated LLM toolchain: Hook the MCP manifest into an LLM agent so the agent can request a mindmap generation tool during a workflow (e.g., summarize a document then generate a visual outline).

Concrete example

• Markdown:

  # Blog Post
  ## Research
  - sources
  - references
  ## Draft
  - intro
  - body
  - conclusion
  

• Send to /convert with format=mermaid and receive a mindmap you can paste into a Mermaid live editor or render with static site generators that support Mermaid.

Tips for developers

• Keep Markdown headings consistent: the conversion relies primarily on heading levels and lists.
• Limit depth for very large documents (use MAX_DEPTH) to avoid unreadable diagrams.
• Use the JSON output when you need to post-process or integrate nodes into other visualization tools.

For full usage details and latest updates, see the project repository at https://github.com/YuChenSSR/mindmap-mcp-server.