@diagrammo/dgmo-mcp

Turn a conversation into a real diagram — without leaving your AI tool.

This MCP server gives Claude (and any MCP-compatible AI tool) the ability to render sequence diagrams, flowcharts, ER diagrams, C4 architecture, gantt charts, and 40+ other chart types from concise text markup — then hand the result off to a full editor for refinement. Ask for a diagram in chat; get a real one back.

What you can do

Ask in plain language — "diagram the auth flow as a sequence", "chart the Q3 plan as a gantt", "draw our services as a C4 diagram" — and Claude writes the markup and renders it. The markup stays readable and diffable:

Code

flowchart Mutiny Resolution
direction-tb

[Sail]     Set sail under the captain
{Trouble?} Discontent in the crew?
{Vote}     Crew vote called
[Mutiny]   Seize the ship

(Sail) -> (Trouble?)
(Trouble?) -Yes-> (Vote)
(Vote) -Mutiny-> (Mutiny)

→ renders to the flowchart above. All rendering happens locally — no diagram data leaves your machine.

Tools

Tool	What it does	Over HTTP
`render_diagram`	Render DGMO markup to SVG or PNG	yes
`validate_diagram`	Check markup and report parse errors, without rendering	yes
`suggest_chart_type`	Suggest the chart types that fit a description	yes
`list_chart_types`	List all supported chart types, marking the beta ones	yes
`get_language_reference`	Get DGMO syntax documentation for accurate generation	yes
`get_examples`	Fetch worked examples for a chart type	yes
`share_diagram`	Get a shareable diagrammo.app URL — hand your diagram to the web editor	yes
`open_in_app`	Open the diagram straight into the Diagrammo desktop app for editing	no
`check_app_installed`	Report whether the desktop app is installed	no
`preview_diagram`	Render one or more diagrams and open an HTML preview in the browser	no
`generate_report`	Build a polished multi-section HTML report with ToC and optional source	no

share_diagram and open_in_app are the bridge out of chat: a diagram Claude generates becomes something you can refine, restyle, and embed — see below.

The four marked no open a browser or launch the desktop app. Over HTTP that would happen on the machine running the server rather than on yours, so they are not offered there — see Serving over HTTP.

Beyond the MCP server

The MCP server is one entry point into Diagrammo — a whole ecosystem built on the same DGMO markup. Generate in chat, refine in a real editor, embed anywhere:

diagrammo.app — the desktop app. open_in_app drops an AI-generated diagram straight into it, with live preview, palettes, and export.
online.diagrammo.app — a full editor in the browser, zero install. share_diagram URLs open right here.
Docs integrations — drop DGMO fenced code blocks into your docs site: remark-dgmo, astro-dgmo, docusaurus-plugin-dgmo, fumadocs-dgmo.
Obsidian — the Diagrammo Diagrams community plugin renders DGMO in your vault.
CLI — npx @diagrammo/dgmo-cli file.dgmo -o out.png, or install via Homebrew.

One markup, everywhere. A diagram you generate here renders identically in the app, in your docs, and in Obsidian — because they all speak DGMO.

→ Try it free at diagrammo.app

Setup

Easiest — one command

Install the dgmo CLI and let it wire everything up:

Terminal

npm install -g @diagrammo/dgmo-cli   # or: brew install diagrammo/dgmo/dgmo
dgmo install                     # auto-detects Claude Code, Codex, Claude Desktop, Cursor, …

dgmo install configures each detected assistant non-interactively and points it at dgmo mcp, so there's no separate package to install or prompts to answer. Target one surface with dgmo install claude-code (or codex, claude-desktop, …).

Manual configuration

Prefer to edit configs yourself? Point any MCP client at the server via npx (no global install needed):

Claude Code — .claude/settings.local.json; Claude Desktop — ~/Library/Application Support/Claude/claude_desktop_config.json:

config.json

{
  "mcpServers": {
    "dgmo": {
      "command": "npx",
      "args": ["-y", "@diagrammo/dgmo-mcp"]
    }
  }
}

If you have the dgmo CLI installed, { "command": "dgmo", "args": ["mcp"] } works too. Restart the client after saving — the tools appear automatically.

Serving over HTTP

The setups above launch the server as a child process and talk to it over its standard input and output. That needs the server and the client on the same machine. Where they are not — a hosted agent platform, a container, one server shared by several people — start it as an HTTP endpoint instead:

Terminal

npx -y @diagrammo/dgmo-mcp --http            # http://127.0.0.1:3333/mcp
MCP_TRANSPORT=http MCP_PORT=8080 npx -y @diagrammo/dgmo-mcp

Every option takes a flag or an environment variable, whichever your setup can express:

Flag	Variable	Default	What
`--http`	`MCP_TRANSPORT=http`	off	Serve streamable HTTP instead of stdio
`--port <n>`	`MCP_PORT`	`3333`	Port to listen on
`--host <addr>`	`MCP_HOST`	`127.0.0.1`	Interface to bind
`--path <path>`	`MCP_PATH`	`/mcp`	Path the endpoint answers on
`--allow-host <h>`	`MCP_ALLOWED_HOSTS`	loopback	Extra `Host` headers to accept, repeatable
`--allow-origin <o>`	`MCP_ALLOWED_ORIGINS`	unset	`Origin` headers to accept, repeatable

Each request is served independently — no sessions, nothing kept between calls — so one endpoint can serve several clients at once.

The server has no authentication of its own. It binds loopback by default and rejects requests carrying a Host header it was not told to expect, which is enough for a client on the same machine or inside the same container. Anything reachable from a wider network needs your own authentication in front of it, and --allow-host for the hostname it will be reached by. Binding a non-loopback interface without naming a host prints a warning saying so.

--help prints all of this from the installed version.

Privacy

All rendering is local. Your diagram markup and the images it produces never leave your machine, except when you explicitly call share_diagram (which encodes the diagram into a diagrammo.app URL). See the privacy terms.

Dev hub (AI-tuning tools)

bash

pnpm hub

One command, one server, one browser tab. The hub opens a tabbed shell over the three AI-tuning dev tools — switch between them with the top tabs, no separate ports or commands to remember:

Trigger tuning — edit the phrase/concept vocabulary that drives suggest_chart_type, score prompts live, save back to triggers.json.
LLM judge — judge chart-type descriptions against prompts with claude -p.
Guidance studio — author the per-type styling guidance the server delivers (the  blocks in dgmo's language-reference.md, sliced into get_language_reference): pick a type, edit how the AI is told to style it, run a prompt against a committed dataset fixture (so inputs never move between runs), and see the generated DGMO + rendered image side by side. The picker doubles as a coverage bar; "Compare 3×" renders no-guidance vs your tips for a by-eye check; Save validates and writes back to language-reference.md.

These tools are dev-only and never bundled into the published server. (The standalone pnpm harness and pnpm studio scripts still run a single tool each if you ever want one in isolation.)

Contributing & releases

Development setup and the release workflow live in CONTRIBUTING.md.

License

MIT