Composer

Name: Composer
Author: olivergrabner

olivergrabner/composer-mcp

4 repo stars
Updated April 9, 2026
olivergrabner/composer-mcp

Composer is an MCP server that provides an architecture canvas for AI coding agents to design and evolve diagrams.

About

Composer MCP gives your AI coding agent a dedicated architecture canvas for designing and evolving diagrams as your system takes shape. Developers often lose clarity when boxes and arrows live only in chat transcripts; Composer moves that work into a tool the agent can update as you refactor services, add integrations, or explain the app to future you. Install runs through stdio with npx using the @usecomposer/mcp package at version 0.1.7 from the composer-mcp repository. It fits early backend layout, frontend module boundaries, and agent-orchestration sketches before you over-commit to folder structure. Because it is MCP-native, Claude Code, Cursor, and similar clients can invoke diagram changes in the same session where they edit code. Composer does not replace a full design suite; it optimizes for fast, agent-driven architecture iteration tied to implementation. Use it when verbal descriptions are not enough and you want persistent visual structure the agent can maintain alongside your repo.

stdio MCP via npx @usecomposer/mcp (v0.1.7)
Architecture canvas the agent can design and evolve interactively
Purpose-built for AI coding agents planning system structure
Lightweight npm package from olivergrabner/composer-mcp on GitHub
Diagram-first workflow instead of one-off ASCII sketches in chat

Composer by the numbers

Data as of Jul 7, 2026 (Skillselion catalog sync)

terminal

claude mcp add composer -- npx -y @usecomposer/mcp

Add your badge

Show developers this MCP server is listed on Skillselion. Paste this into your README.

[![Listed on Skillselion](https://skillselion.com/badge/mcp/tool/io.github.OliverGrabner/composer.svg)](https://skillselion.com/mcp/tool/io.github.OliverGrabner/composer)

repo stars	★ 4
Package	@usecomposer/mcp
Transport	STDIO
Auth	None
Last updated	April 9, 2026
Repository	olivergrabner/composer-mcp ↗

What it does

Give your coding agent a live architecture canvas to create and revise system diagrams while you design the product.

Who is it for?

Best when you use Claude Code or Cursor and want agent-driven C4-style or system diagrams without leaving the MCP workflow.

Skip if: Skip if you need polished product design mockups, slide decks, or non-technical stakeholder branding work.

What you get

After adding Composer, your agent can maintain an evolving architecture canvas that stays aligned with design conversations and code changes.

Agent-maintained architecture diagrams on the Composer canvas
Iterative visual updates as components and integrations change
Shareable structural view alongside your codebase

By the numbers

npm package version 0.1.7
stdio transport via @usecomposer/mcp
Single-package MCP registry entry from composer-mcp repository

README.md

Composer demo

Composer logo Composer MCP Server

Give your AI coding agent an architecture canvas.
Design, visualize, and evolve software architecture diagrams - right from your IDE.

Composer is a visual system design tool that lets AI coding agents create and modify interactive architecture diagrams through MCP (Model Context Protocol). Your agent gets tools to add services, databases, queues, and connections, and you get a live canvas at usecomposer.com that updates in real-time.

Your IDE  <-->  MCP Server (this package)  <-->  Composer API  <-->  Your Diagram

Getting Started

Connect your IDE

Claude Code:

claude mcp add --transport http composer https://mcp.usecomposer.com

Cursor — create .cursor/mcp.json in your project root:

{
  "mcpServers": {
    "composer": {
      "type": "http",
      "url": "https://mcp.usecomposer.com"
    }
  }
}

Your browser will open for authorization on first use.

Claude Code

claude mcp add --transport http composer https://mcp.usecomposer.com

Cursor

Create .cursor/mcp.json in your project root:

{
  "mcpServers": {
    "composer": {
      "type": "http",
      "url": "https://mcp.usecomposer.com"
    }
  }
}

Codex

codex mcp add composer -- npx -y @usecomposer/mcp --stdio

VS Code (Copilot Chat)

Create .vscode/mcp.json in your project root:

{
  "servers": {
    "composer": {
      "type": "http",
      "url": "https://mcp.usecomposer.com"
    }
  }
}

VS Code (Cline)

Open Cline sidebar > Settings (gear icon) > MCP Servers > Add Remote Server:

{
  "mcpServers": {
    "composer": {
      "type": "http",
      "url": "https://mcp.usecomposer.com"
    }
  }
}

VS Code (Continue)

Add to .continue/config.yaml:

mcpServers:
  - name: composer
    url: https://mcp.usecomposer.com

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "composer": {
      "serverUrl": "https://mcp.usecomposer.com"
    }
  }
}

Note: Windsurf uses "serverUrl" instead of "url".

OpenCode

Create opencode.json in your project root:

{
  "mcp": {
    "composer": {
      "type": "remote",
      "url": "https://mcp.usecomposer.com"
    }
  }
}

Tools

Diagram Management

Tool	Description
`list_diagrams`	List all your diagrams. Call this first to find which diagram to work on
`create_diagram`	Create a new diagram and auto-select it for this session
`select_diagram`	Select which diagram to work on for this session
`rename_diagram`	Rename the currently selected diagram

Note: Call list_diagrams then select_diagram (or create_diagram) before using other tools.

Read

Tool	Description
`get_graph`	Get the full architecture diagram - all nodes and edges
`get_node`	Get details for a single node including connected edges
`search_graph`	Search nodes and edges by keyword
`get_screenshot`	Get a PNG thumbnail of the diagram from the last auto-save

Write

Tool	Description
`upsert_node`	Create or update a node (service, database, queue, etc.)
`upsert_edge`	Create or update a connection between two nodes
`define_api`	Define API endpoints on a backend service node
`delete_element`	Delete a node or edge from the diagram
`link_path`	Link a node to a file or folder in your codebase

Plan & Verify

Tool	Description
`verify_diagram`	Check for issues like missing endpoints or orphaned nodes
`plan_import`	Step-by-step workflow for importing an existing codebase
`get_guide`	Reference guide for node types, protocols, and best practices

Node Types

client · frontend · backend · database · cache · queue · storage · external

Edge Protocols

REST · gRPC · GraphQL · WebSocket · TCP · UDP · async · event · internal

Example Prompts

Once connected, try asking your AI agent:

Prompt	What it does
"Import this codebase into Composer"	Scans your repo and builds the architecture diagram
"Create a new Composer diagram called Backend Architecture"	Creates and auto-selects a new diagram
"Add a Redis cache between the API and the database in Composer"	Adds a new node and edges to the diagram
"Add analytics monitoring to the Composer diagram"	Adds observability nodes and connections
"Update the APIs I defined in Composer"	Refreshes endpoint definitions on backend nodes
"Verify my Composer diagram"	Checks for missing endpoints, orphaned nodes, etc.
"Link each Composer node to its source code"	Associates diagram nodes with file paths

How It Works

Authentication is handled via OAuth 2.1 — your browser opens for a one-time consent flow, and you're connected. Tool calls are proxied to the Composer API at mcp.usecomposer.com. Your diagram data lives on Composer's servers. The MCP server itself is stateless.

Changes made through MCP are immediately visible on the Composer canvas via real-time WebSocket sync.

Development

git clone https://github.com/olivergrabner/composer-mcp
cd composer-mcp
npm install
npm run dev        # Watch mode (rebuilds on change)
npm run build      # Production build