Skip to main content
Glama

Plumb (plumb-mcp) — the AI-native design engineering platform

Plumb is an AI-native design engineering platform, shipped as a single MCP server. Point it at a Figma file or a live website and it normalises either one into the same semantic design graph — deduped tokens, flexbox-resolved layout, conservative role labels (nav / hero / card …) — that your coding agent can build from and a verification loop can grade. Point it at a one-line prompt instead and it becomes an AI design director: it researches best-in-class references, extracts a brand, and generates a full, on-brand Figma file on your canvas, then critiques its own render until it clears the bar.

Design → code (Figma or the live web, verified, not vibes)  •  prompt → design (research → brand → generate → critique)  •  one semantic design graph underneath both. MCP-native — works with Claude Code, Cursor, Windsurf, or any agent that speaks Model Context Protocol.

📖 Full docs: https://tathagatmaitray.github.io/plumb-mcp/  ·  📦 npm: plumb-mcp  ·  🇨🇳 简体中文  ·  🇯🇵 日本語  ·  🇰🇷 한국어

Built for coding agents — Claude Code, Cursor, Windsurf, anything MCP-compatible. Design engineering, agent-native: no dashboard, no separate app to babysit, no human shuttling pixels between Figma and an editor. It reads Figma through a desktop-app plugin (no REST rate limits, works on every plan including Free), reads any live website through headless Chrome, writes new designs back into Figma through the same plugin, and returns compact normalised specs instead of the multi-hundred-thousand-token JSON the Figma API emits.


Why "design engineering platform," not "Figma converter"

Most Figma MCP servers — and most figma-to-code tools generally — are one shape in, one shape out: Figma JSON in, one framework's code out, done. Plumb's architecture is a hub, not a pipe:

  • Two independent sources feed the same graph. plumb_node normalises a Figma screen; plumb_import_web normalises a live webpage's DOM. Both land as the same platform-agnostic Semantic Graph — containment, repeat-group, and role edges — regardless of where the pixels came from.

  • Every consumer runs against either source, unmodified. plumb_emit_react generates the same deterministic React/JSX whether the graph came from Figma or from a URL. plumb_diff, plumb_audit, and plumb_query's role filters all work identically on both. That's the concrete proof it's a platform, not a converter with a second input bolted on.

  • Verification closes the loop on the way out, not just the way in. plumb_verify / plumb_fit diff your shipped code against the source of truth and hand back ranked fixes — "looks right" becomes measurably true.

  • Generation runs the loop in reverse. plumb_studio composes a brand-new Figma file from a brief, and plumb_review critiques the render the same way plumb_verify critiques code.

One semantic model. Multiple sources in (Figma, the web), multiple targets out (React code, Figma files), verified at both ends. That's the platform.


Related MCP server: systembridge-mcp

Two directions, one server

← Figma or the web → code (read direction)

Your agent extracts a screen — or any live URL via plumb_import_web — as a compact Plumb Design Spec (PDS) riding on the same semantic graph: auto-layout pre-resolved to flexbox, design tokens deduped, roles labelled. It builds the UI, then calls plumb_verify / plumb_fit to diff the rendered result against the source and self-correct to pixel-perfect. The only Figma MCP that closes the loop on code — and the only one that runs the identical loop against a plain webpage, no Figma file required.

→ prompt → design (write direction — the design director)

Give Plumb a one-line brief — "a premium fintech dashboard" — and it acts like a senior designer working live in your Figma:

  1. Researches references — finds best-in-class sites for your brief (Linear, Stripe, Mercury…) and screenshots them live onto a References page.

  2. Extracts a brand — reads their computed CSS into a coherent palette + type scale, laid down as a Brand board.

  3. Generates the design — composes a full, on-brand page (nav, hero, features, gallery, CTA, footer) from a high-level design DSL, built as real Figma nodes.

  4. Critiques its own render — the calling agent (Claude Code / any MCP client with vision — no extra API key when run as an MCP tool; the standalone plumb-mcp fit CLI is the one exception, see Standalone CLI below) grades the screenshot; Plumb blends that with a deterministic design rubric and a structural diff, then hands back a ranked fix list and iterates until it clears the bar.

That's prompt-to-Figma design generation with a self-improving director loop — not a one-shot mockup.


How Plumb is different

Other Figma MCP servers you may know:

  • Figma's official Dev Mode MCP — bidirectional, but plan-gated and metered.

  • Framelink — thin REST wrapper. Two tools. No verification, inherits rate limits.

  • cursor-talk-to-figma — bidirectional automation for designers working in Figma.

And beyond the MCP world, the broader design-to-code / AI-UI-generator category — tools like html.to.design, Anima, Locofy, or prompt-first generators like v0 and Builder.io's Visual Copilot — typically move in one direction only (design in, code out, or prompt in, code out) with no shared model spanning both, and no built-in step that checks the output against the source afterward.

Plumb is the only one that both closes the loop on code and directs new design generation, on top of one semantic graph that doesn't care whether the source was Figma or a URL. plumb_verify tells you whether shipped code actually matches the design (or the reference page); plumb_fit turns that into a self-healing loop. plumb_import_web + plumb_emit_react prove the graph travels: the same role classifier and the same code generator run against a live website with zero Figma involved. And on the write side, plumb_studio / plumb_brand / plumb_design / plumb_review turn a prompt into a designed, critiqued Figma file — no design skills, no separate design tool, no extra model key (as MCP tools; see Standalone CLI for the one command that needs one).


Are you hitting one of these?

If your agent landed here from an error, Plumb probably solves it.

Error you're seeing

Why Plumb fixes it

Figma Dev Mode MCP exceeded the 25k token cap · 351,378 tokens observed

PDS dedups design tokens ($c1, $t1 …) and pre-resolves auto-layout to flexbox. A 178-node dialog comes back at ~2.6k tokens.

Dev Mode MCP: 6 tool calls per month limit · Starter plan tool-call limit reached

Plumb's plugin path has no per-call quota on any plan, including Free.

Framelink figma-developer-mcp HTTP 429 · Figma REST API rate limit exceeded

The plugin path doesn't touch REST. Zero rate limits.

Variables API requires Enterprise plan · 403 Forbidden on variables

Plumb reads Variables through the Figma Plugin API — works on every plan, for both local and team-library variables.

Figma MCP returned 85% wrong layout · hallucinated structure

Plumb returns structured PDS (not parsed prose) and ships plumb_verify + a plumb-mcp verify CLI that diffs your rendered DOM against the design.

"How do I generate a Figma design from a prompt?" · "AI that designs UI in Figma"

plumb_studio — brief → researched references → extracted brand → a full composed Figma page, critiqued and refined.

"Is there an AI-native design engineering platform?" · "AI design engineer agent"

Plumb — one MCP server, one semantic design graph, Figma and the web as sources, code and Figma as targets, verified on both ends.

"Convert a website to Figma" · "scrape a website into a design system" · "HTML to React with AI"

plumb_import_web reads any live URL into the same semantic graph as a Figma screen — no browser extension, no manual redraw — and plumb_emit_react generates React/JSX straight off it.

Install: npm install -g plumb-mcp → plumb-mcp init — or let your AI agent set it up.


See it work in 30 seconds — no account, no key, no network

Before you install anything or connect a Figma file, run the loop and watch it score itself:

npx plumb-mcp demo          # or: docker compose up demo

It takes a real design spec, hands the verification engine a build of that same screen with 13 planted mistakes in it — a headline one step down the type scale, a pill button rendered as a rounded rectangle, a gradient flattened to a flat fill, a badge that was never built at all — and prints what it caught:

  Round 1 · First pass — built straight from the spec, no verification
    ▰▰▰▰▰▰▰▱▱▱  71.0%   8 errors · 1 warnings · 32/34 key nodes built

    ✓ The "MOST POPULAR" badge was never built — no element carries its handle
      pro-badge           not built         no data-plumb-id for this handle in the DOM
    ✓ Headline came out one step down the type scale (48px → 40px)
      title               text.size         expected 48  ·  got 40
    ✓ Primary CTA is a hand-picked purple, not the brand token
      pro-cta             fill              expected #6366f1  ·  got #7c5cf5
    …

  Scoreboard
    Mistakes planted      13
    Caught                13   (100% recall)
    False positives       0   across 27 untouched nodes
    Convergence           71.0% → 96.2% → 100.0%

No Figma token, no plugin, no browser, no network — docker compose up demo even runs with network_mode: none. The engine scoring the demo is the same one behind plumb_verify and plumb_fit, and those numbers are asserted in src/demo/demo.test.ts, so the demo fails CI if it ever stops being true. plumb-mcp demo --pds prints the design spec it runs against; --json emits the results for scripting and exits non-zero if the engine missed anything.


Let your AI agent set it up

Paste this into Claude Code, Cursor, Windsurf, or any coding agent with a shell, from inside the project you want to use Plumb in. The agent does the installing and config work. It stops and walks you through the two steps only you can do: restarting your editor and clicking Pair in Figma.

Set up Plumb (https://github.com/tathagatmaitray/plumb-mcp), the Figma MCP server, for
this project. Follow these steps in order and tell me what you did at each one.

1. Check prerequisites: Node 20+ (`node -v`) and npm. If Node is older than 20,
   stop and tell me how to upgrade. Don't upgrade it yourself.
2. Install: `npm install -g plumb-mcp`, then confirm it with `plumb-mcp --version`.
   If the global install fails with a permissions error, tell me and don't use sudo.
3. Smoke test: run `plumb-mcp demo`. It works offline and needs no Figma account.
   Its scoreboard should show "Caught 13 (100% recall)". If it doesn't, stop and
   show me the output.
4. Wire up the editor: run `plumb-mcp init` from this project's root. It detects
   Claude Code / Cursor / VS Code / Windsurf and writes the MCP config (for Claude
   Code that's `.mcp.json` here). It also adds those files to .gitignore. Show me
   which files it wrote and the Figma plugin manifest path it printed.
   - Leave the FIGMA_TOKEN placeholder alone unless I give you a token. The plugin
     path doesn't need one. Never commit a real token.
5. Hand off to me. Tell me exactly:
   a. Restart the editor / agent session so it loads the Plumb MCP server.
   b. Open the Figma DESKTOP app (the browser version can't sideload plugins) →
      Plugins → Development → Import plugin from manifest… → pick the manifest
      path from step 4.
   c. Open my design file, run the Plumb plugin, and click "Pair with Plumb".
6. After I restart and pair, call the `plumb_status` tool. Success means
   `connected: true` with a screen count. Then call `plumb_outline` and list my
   screens. If it isn't connected, follow the `note` field in the plumb_status
   response and try again.

Don't change any other files in this project during setup.

Once plumb_status reports connected, ask for real work, e.g. "Extract the Settings screen with Plumb, build it, then plumb_fit until it matches."


Quick start

# 1. Install
npm install -g plumb-mcp

# 2. Wire into your editor — auto-detects Claude Code / Cursor / VS Code / Windsurf
plumb-mcp init

# 3. Sideload the Figma plugin (one-time). Find the manifest:
echo "$(npm root -g)/plumb-mcp/figma-plugin/manifest.json"
#    Figma desktop → Plugins → Development → Import plugin from manifest…
#    Run Plumb → click "Pair with Plumb" → done. Future runs collapse to a dot.

Then, in your agent:

# Figma → code
"Extract the Settings screen with Plumb and build it, then plumb_fit until it matches."

# web → code, no Figma required
"Use plumb_import_web on https://example.com, then plumb_emit_react to scaffold it."

# prompt → design
"Use plumb_studio to design a premium fintech dashboard, then screenshot it and
 run plumb_review as the director until the score clears 90."

Other install paths: npx plumb-mcp · docker run --rm -i ghcr.io/tathagatmaitray/plumb-mcp:latest.

Requires Node 20+. Nothing below needs a credential or a Figma account:

git clone https://github.com/tathagatmaitray/plumb-mcp
cd plumb-mcp
npm ci
npm run demo        # the offline walkthrough — proves the checkout works
npm test            # 600+ specs
npm run typecheck   # strict TS, server + plugin
npm run lint
npm run build       # bundles the server, the Figma plugin, and Studio into dist/
node dist/index.js --help

npm run build produces dist/index.js (the MCP server), dist/studio/ (the live cockpit the bridge serves), and figma-plugin/code.js (the plugin main thread you sideload). If any step fails on a clean checkout, that's a bug — open an issue.


Twenty-eight tools, one semantic graph

Every tool below reads from or writes to the same semantic design graph described above — that's what makes adding a new source (the web) or a new target (React) additive, not a rewrite.

Read — Figma or the web → code

Tool

What it does

plumb_status

Self-description, key legend, connection state. Call first.

plumb_outline

Every screen in the file (id, name, size).

plumb_node

Extract a screen as compact PDS — by id or by name.

plumb_query

Pull a slice (skeleton / buttons / text / components / role) when a full screen would blow the token budget.

plumb_describe

Text-only visual description — for image-blind harnesses.

plumb_tokens

Design-token table (colours, type, radii, shadows).

plumb_selection

The user's live Figma selection.

plumb_assets

Export icons (SVG) + images (PNG) — recursive, list, or surgical by ids.

plumb_screenshot

Render any node to PNG/JPG.

plumb_search

Find nodes by name and/or type.

plumb_components

List components + instance usages, plus an opt-in design-system health report (unused components, near-duplicate names, variant outliers).

plumb_verify

Diff rendered layout against the design — ΔE2000 colour, shadow/rotation/flex checks.

plumb_fit

The self-healing loop: verify + a 0–100 convergence score + prioritised fixes.

plumb_fig_outline / plumb_fig_node

Headless: read a saved .fig file from disk. No Figma desktop, no token.

plumb_diff

Semantic diff between two PDS snapshots — "the hero moved from (0, 0) to (0, 120)", not a JSON diff.

plumb_audit

Heuristic accessibility checks — text contrast, button touch-target size.

plumb_import_web

Import a live webpage's structure and semantics — no Figma connection needed. Same role classifier Figma designs use.

plumb_emit_react

Deterministic React/JSX generator from a PDS or a plumb_import_web result — same emitter, either source.

plumb_scan_references

Scan N live reference URLs and extract a per-role style digest (typical hero height, card-grid density, nav style) — for folding into a plumb_design DSL or plumb_studio brief by hand; it doesn't compose anything itself.

Write — prompt → design (the director)

Tool

What it does

plumb_studio

The design director. One brief → researched references → extracted brand → a full composed Figma page. Returns the node ids + authored spec so you can critique and refine.

plumb_studio_start / plumb_studio_kit / plumb_studio_page

The same director flow, split into three watchable steps (brand+references → component kit → product page) so you can review between each one, on separate named Figma pages, instead of one opaque call.

plumb_brand

Brief → live-screenshots best-in-class reference sites + a synthesized brand palette/type board on the canvas.

plumb_design

Author a design from Plumb's high-level Design DSL and build it into Figma (full control: pages, sections, components, motion).

plumb_review

The critique loop: blends a structural diff, a deterministic design rubric, and the calling agent's own vision verdict into one score + ranked fixes. No API key — the agent that drives the MCP server is the creative director.

plumb_source

Resolve on-brief assets (icons, photos, illustrations, patterns) for a design.


Why it wins on tokens and quality

  • Compact specs. A 178-node dialog that is 351k tokens of Figma REST JSON comes back as ~2.6k tokens of PDS — deduped tokens, flexbox-resolved layout, depth-stable handles.

  • Verified, not vibes. plumb_verify / plumb_fit diff the rendered result against the design (ΔE2000 perceptual colour, shadow, rotation, flex-child, fill-stack) — no pixel diff, runs in CI.

  • Designed, not defaulted. The write direction bakes real design craft in: size-aware letter-spacing, generous section rhythm, extracted brand palettes from real references, gradient text, full-bleed and asymmetric layouts, and a vision-based director that grades the render and pushes it up.

  • Understands structure, not just geometry — and not just Figma. Plumb tags nav/hero/footer/sidebar/card conservatively on top of the raw tree (node.pattern — silence over a guess when the signals don't line up) and builds on it: plumb_diff narrates changes by role, plumb_audit flags contrast and touch-target issues, plumb_query's select: "role" and plumb_node's collapseRoles filter and compress by the same labels. The same underlying model reads a live webpage too — plumb_import_web extracts structure and roles from any URL, no Figma involved — and plumb_emit_react generates deterministic React/JSX from either source.


Two data paths

Plugin (primary)

REST (secondary, headless)

Rate-limited

No. Reads the in-memory document.

Yes. Free/Starter get very low budgets.

Token required

No.

Yes — FIGMA_TOKEN.

Variables

Yes, every plan — local and team-library.

No — Variables REST is Enterprise-only.

Write (generate designs)

Yes.

No.

Headless / CI

No (needs Figma open).

Yes.

Tools auto-pick the path. With the plugin paired, omit fileKey and pass id or name.


Configuration

Nothing is required to try Plumb: npm run demo needs no configuration at all, and the plugin path (plumb_outline, plumb_node, plumb_selection, …) only needs the Figma plugin paired.

Copy .env.example to .env (gitignored) for local use. Plumb loads it from the working directory and the package root on startup — but an MCP client spawns the server as a fresh process, so the most reliable place for keys is your client's server env block.

Environment variables

Variable

Required for

Default when unset

FIGMA_TOKEN

The Figma REST path (plumb_fig_outline, plumb_fig_node) and the standalone CLIs

REST tools return an instruction-shaped error; the plugin path is unaffected

FIGMA_ACCESS_TOKEN

Alias for FIGMA_TOKEN, checked second

—

PLUMB_FILE_KEY

npm run prove; default file for the CLIs

Must be passed as an argument instead

PLUMB_NODE_ID

npm run prove

131:6950

PLUMB_BRIDGE_PORT

Pinning the bridge to one port (containers, >10 concurrent sessions)

Scans the 31337–31346 pool

PLUMB_BRIDGE_PORTS

An ordered pool to try, comma-separated; 0 means any free port

Same built-in pool

PLUMB_BRIDGE_HOST

Publishing the bridge from inside a container

127.0.0.1 — loopback only

PLUMB_SESSION_NAME

The label this session shows as in the plugin panel

The current directory name

PLUMB_LOG_LEVEL

debug | info | warn | error — logs always go to stderr, never stdout

info

PLUMB_LOG_FORMAT

json for one JSON object per line, for a log shipper

Human-readable lines

NO_COLOR / TERM

Honoured, never set — the standard conventions for disabling ANSI colour in plumb-mcp demo

Colour when stdout is a TTY

PLUMB_ASSETS_DIR

Where plumb_assets writes exports

./plumb-assets/

PLUMB_SCREENSHOTS_DIR

Where plumb_screenshot writes PNGs

./plumb-screenshots/

PLUMB_CACHE_DIR

Response cache root

~/.cache/plumb/

PLUMB_CACHE_TTL_MS

Cache entry lifetime

300000 (5 minutes)

PLUMB_CHROME

Chrome binary for plumb_verify / plumb_fit / plumb_import_web

Auto-detected from the standard install paths

CHROME_PATH

Alias for PLUMB_CHROME, checked second

—

ANTHROPIC_API_KEY

The standalone plumb-mcp fit CLI only — every MCP tool is key-free

plumb-mcp fit exits with a setup message

PLUMB_FIT_MODEL

Model override for that CLI

The built-in default

UNSPLASH_ACCESS_KEY

On-brief photography in the write direction (free tier)

Falls back to random Lorem Picsum placeholders

PEXELS_API_KEY

Same, alternative provider (free tier)

Same fallback

PIXABAY_API_KEY

Same, alternative provider (free tier)

Same fallback

GOOGLE_FONTS_API_KEY

Searching the full Google Fonts catalog

Popular-subset search still works


Run it in a container

docker compose up demo      # the offline walkthrough, network disabled — start here
docker compose up bridge    # bridge + Plumb Studio on http://127.0.0.1:31337
docker compose run --rm mcp # the stdio MCP server, for an editor to attach to

The bridge serves GET /healthz (aliased as /health) — liveness plus whether a plugin is actually paired — which is what the Compose healthcheck probes, and GET /metrics in Prometheus text format.

bridge publishes a single fixed port (containers can only publish ports they know, so PLUMB_BRIDGE_PORT replaces the scan) and maps it to the host's loopback only — no more reachable than running natively. Exported assets, screenshots, and the cache land in the plumb-data volume.

There is also a devcontainer: open the repo in VS Code or Codespaces, and it installs both workspaces and runs the demo on attach.


Run it on Kubernetes — and catch design drift on a schedule

helm install plumb ./deploy/helm/plumb --namespace plumb --create-namespace
helm test plumb --namespace plumb
kubectl -n plumb port-forward svc/plumb 31337:31337   # Studio + plugin pairing

A Helm chart, plain manifests, and a Terraform module — all three producing the same locked-down deployment, all validated in CI (helm lint, kubeconform -strict against real API schemas on two Kubernetes versions, terraform validate, Trivy and Checkov policy scans, and a regenerate-and-diff so the plain manifests can't drift from the chart).

The reason to put Plumb in a cluster rather than only on a laptop is continuous design verification: a CronJob renders a URL you already serve, diffs every [data-plumb-id] element against the Figma node it was built from, and fails when they drift.

verify:
  enabled: true
  schedule: "0 * * * *"
  targets:
    - name: dashboard
      url: http://app.default.svc.cluster.local/dashboard
      node: "190:109884"

A design regression stops being something someone notices in a review three weeks later, and becomes a failing job with a timestamp and a delta list.

The bridge has no authentication of its own — its security model is loopback plus a deliberate pairing click. So the defaults expose nothing: ClusterIP, a deny-all NetworkPolicy, no ingress, and kubectl port-forward as the way in. deploy/README.md is explicit about what works in a cluster, what doesn't (the Figma plugin scans 127.0.0.1, so it needs the port-forward), and what each switch actually exposes.


Standalone CLI

Two commands run outside any MCP client, straight from a terminal — useful for CI or for driving Plumb without an agent in the loop:

plumb-mcp verify <dev-url> --node <figma-node-id>   # diff a running page against the design
plumb-mcp fit <figma-url>                           # generate + self-correct an HTML build until it matches

plumb-mcp verify needs only FIGMA_TOKEN (or the plugin, if paired) — it diffs, it doesn't generate, so no model key. plumb-mcp fit is the one command in this whole project that calls an external model directly: it generates the HTML build itself (no agent to do that job for it), so it needs ANTHROPIC_API_KEY in addition to FIGMA_TOKEN. Every MCP tool, including plumb_fit and plumb_review, stays key-free because the calling agent supplies the generation/judgment instead.


Network egress

Call site

Talks to

When

Figma plugin bridge

localhost only (WebSocket)

Whenever the plugin is paired

Figma REST (FIGMA_TOKEN path)

api.figma.com

Only if the plugin isn't paired, or for headless/CI use

plumb_import_web / plumb_scan_references / headless CLIs

The target URL(s) you pass in, via headless Chrome (CDP)

Only when you call these

plumb_studio / plumb_brand reference research

The reference sites Plumb picks for your brief

Only in the prompt→design write direction

Google Fonts

fonts.googleapis.com / fonts.gstatic.com

Only when a captured design/import references a Google Font

UNSPLASH_ACCESS_KEY / PEXELS_API_KEY / PIXABAY_API_KEY providers

The respective photo API

Only in the write direction, only if a key is set

plumb-mcp fit CLI

api.anthropic.com

Only for this one standalone CLI command (see Standalone CLI)

Nothing above fires on its own — every network call is a direct consequence of a tool or CLI command you invoked. There's no background polling, telemetry, or phone-home.


Security

  • Loopback-only WebSocket bridge; a single paired plugin at a time (one deliberate click).

  • Zero telemetry. No personal-access token needed for the plugin path.

  • The write direction never calls an external model — the AI agent already driving the MCP server does the design judgment (the standalone plumb-mcp fit CLI is the sole exception; see Standalone CLI).


Contributing

Contributions welcome — from typo fixes to new verify checks to design-director upgrades. See CONTRIBUTING.md. New here? Browse the good first issue label.


License

MIT © Tathagat Maitray. See LICENSE.

Available Tools

28 tools
plumb_assetsPlumb · assetsA
Idempotent

Export Figma assets — icons as SVG, images as PNG — through the paired plugin. Three modes: • Default — id or name of a screen → recursive export of every asset in it, written to a local folder. • List — same + list: true → just the manifest (id, name, format, parentId) of available assets; no files written. Cheap; use first to see what's there. • Surgical — ids: [...] → export exactly those node ids (one file each, no recursion). Preferred once you know what you need.

Inputs: id, ids, raw, list, +2 more.

plumb_auditPlumb · auditA
Read-onlyIdempotent

Heuristic accessibility audit over a PDS snapshot — pass the raw JSON response from a prior plumb_node/plumb_outline/plumb_query call. Checks today: text contrast against its resolved ancestor background (WCAG AA, large-text threshold applied at ≥24px) and role:"button" nodes under the 44×44px minimum touch-target size. Each finding carries a plain-language note plus the raw ratio/box data. This is a heuristic problem-finder, not a certified WCAG audit — it reports failures only (a clean result means the checks it runs found nothing, not that the screen is fully accessible), and heading-order / missing-alt-text checks aren't built yet.

Inputs: doc (required).

plumb_brandPlumb · brand (direct + build)A

Direct a brand board from a one-line brief and BUILD it into the paired Figma file. Given a brief (e.g. "a premium fintech dashboard"), Plumb discovers a diverse set of best-in-class reference sites, screenshots them live, synthesizes a coherent semantic palette from their computed CSS, and assembles a single 1440-wide Brand page (reference screenshots + colour swatches + a type scale) — then compiles it down through the same DSL → PDS → emit-plan write path plumb_design uses and executes it via the plugin. Returns the picked references, the synthesized brand palette, and the built root node id. Requires the Plumb plugin to be paired.

Inputs: brief (required), count, references.

plumb_componentsPlumb · componentsA
Read-onlyIdempotent

List every Figma component definition in the file and the instance usages of each — useful for understanding the design system before building. Each component carries an instance count; each instance carries the component id, so you can match usage to definition. Pass health: true to also get a design-system health report: unused components (zero instances), possible duplicates (near-identical names — 'Button', 'Button copy', 'Button 2'), and variant outliers (an instance whose prop overrides don't match any other instance of the same component, among components with enough instances for a pattern to mean something). Plugin path; needs the Plumb plugin paired.

Inputs: page, health.

plumb_describePlumb · describeA
Read-onlyIdempotent

Text-only visual description of a Figma screen or node — useful when you can't read the rendered screenshot (image-blind harness, sandboxed Read, or token-conscious flows). Returns a per-region narrative ('top-left: ...') and a flat child summary derived from the PDS. Pair with plumb_node for the full structural spec, or pair with plumb_screenshot for the pixel reference.

Inputs: id, url, name, depth, +1 more.

plumb_designPlumb · design (build)A

Author a design from a high-level Plumb Design DSL document and BUILD it into the paired Figma file. This is the write direction: the DSL (semantic pages → sections → blocks + brand tokens) is validated, compiled DOWN to the PDS IR, lowered to a Figma-native emit plan, and executed by the plugin (auto-layout frames, text, images, icons). Returns the created node ids keyed by authored element handle — the join key you then feed to plumb_review / motion. Pass a brief to record intent (audience, tone, brand) alongside the build. Use dryRun: true to compile + validate without touching Figma.

Inputs: doc, mode, brief, prune, +4 more.

plumb_diffPlumb · diffA
Read-onlyIdempotent

Semantic diff between two PDS snapshots of the same screen — call plumb_node (or plumb_outline/plumb_query) once before a design change and once after, then pass both raw JSON responses here. Returns structured deltas (added/removed/renamed/changed nodes, each with a note — e.g. 'the hero moved from (0, 0) to (0, 120)') plus a one-line summary, not a JSON diff. Narration uses the same role labels plumb_node already returns on pattern (nav/hero/footer/sidebar/card/button) when available, so 'the hero moved' beats 'el btn-3 moved 40px' whenever a role was detected. This tool does no live Figma fetching itself — it only compares two documents you already have.

Inputs: after (required), before (required).

plumb_emit_reactPlumb · emit reactA
Read-onlyIdempotent

Deterministic PDS/WebSpec → React (JSX + inline styles) code generator. Pass the raw JSON from a prior plumb_node/plumb_outline/plumb_query call (Figma) OR a prior plumb_import_web call (a live site) — the same emitter handles both, proving the underlying graph is source-agnostic. Not an LLM call: template-based and deterministic, mirroring the existing PDS→Figma emit path's own 'every conversion happens here, mechanically' design. Output is PIXEL-FAITHFUL (every box's width/height is emitted explicitly), not a hand-tuned responsive component — there's no hug/fill/fixed sizing signal in the graph yet to generate flex:1/width:auto from. Check the warnings array: vector nodes render as empty boxes (no path data is reproduced) and images with no captured source get an empty src.

Inputs: doc (required), componentName.

plumb_fig_nodePlumb · fig nodeA
Read-onlyIdempotent

Read one node from a saved .fig file by its id (the sessionID:localID form returned by plumb_fig_outline). Returns the node's type, name, size, auto-layout mode, fills, opacity, and (for TEXT nodes) characters and font. Pair with plumb_fig_outline to find the id first.

Inputs: id (required), figPath (required).

plumb_fig_outlinePlumb · fig outlineA
Read-onlyIdempotent

Read a saved .fig file from disk and list every screen (top-level frame) across every page. The headless / CI counterpart to plumb_outline — works with no Figma desktop, no plugin pairing, no FIGMA_TOKEN. Use this when you've exported a .fig file and need to inspect or implement screens without opening Figma.

Inputs: figPath (required).

plumb_fitPlumb · fitA
Read-onlyIdempotent

Self-healing build loop — iterate to a pixel-perfect match instead of a one-shot check. The loop:

  1. Build the component, stamping data-plumb-id="" on each element using the PDS handles (same el keys plumb_node/plumb_query return).

  2. Capture box (getBoundingClientRect) + the getComputedStyle subset (backgroundColor, color, font*, padding*, gap, flex*, justifyContent, alignItems, borderRadius/Color/Width, opacity, textDecorationLine) + text for every tagged element. Same shape as plumb_verify.

  3. Call plumb_fit with rendered. You get back: • score — 0–100 convergence (coverage × fidelity), climbs as you go • done — true once score ≥ accept (default 98) and no errors remain • topFixes — the highest-leverage changes, sorted error-first • bar — a printable ▰▱ progress bar • instruction — what to do next

  4. If done=false, apply topFixes, re-render, call plumb_fit again. Repeat until done=true. Each round the score should rise; if it stalls, read the full deltas and coverage.untagged to see what you missed.

Inputs: rendered (required), id, url, name, +5 more.

plumb_import_webPlumb · import webA
Read-only

Import a live webpage's structure and semantics — no Figma connection needed. Drives headless Chrome to walk the page's visible DOM (skipping script/style/hidden elements), maps it onto the same Semantic Graph Figma designs use, and returns nodes carrying real CSS values (hex colors, literal px) plus a detected role (nav/hero/footer/sidebar) using the exact same classifier plumb_node's pattern field uses. Use this to understand an existing site's structure, audit it (plumb_audit accepts this shape too), or track it over time (plumb_diff two imports of the same URL). Text nodes also carry fontFamily, and the result carries fontLinks — URLs for every captured family that matches a known Google Fonts family — so generated code doesn't silently fall back to a system font. Pass viewports to capture the SAME page at multiple sizes in one call (e.g. mobile + desktop) — a real responsive layout (a hamburger nav under 768px, a grid that collapses to one column) is invisible to a single fixed-size capture.

Inputs: url (required), selector, viewports.

plumb_nodePlumb · nodeA
Read-onlyIdempotent

Extract a Figma screen or node as a compact, normalized Plumb Design Spec (PDS): deduplicated design tokens plus a CSS-shaped node tree, with auto-layout pre-resolved to flexbox. With the Plumb plugin paired, pass a screen id or name (no file key) — duplicate names come back as a match list to disambiguate. On the REST path, pass fileKey + id.

Inputs: id, url, name, depth, +5 more.

plumb_outlinePlumb · outlineA
Read-onlyIdempotent

Map a Figma file cheaply: its pages and their top-level screens (id, name, size). The shallow entry point — call it to find the screen you want, then call plumb_node with that screen's id (or name) to extract it. With the Plumb plugin paired, no file key is needed.

Inputs: url, page, fileKey.

plumb_queryPlumb · queryA
Read-onlyIdempotent

Query a Figma subtree by pattern instead of dumping the whole tree. Use this on dense screens where plumb_node would be too big — pull a skeleton (structure only, no text/fills/effects), every button, every TEXT node above a size, every instance of a component, or every node Plumb classified with a given semantic role (nav/hero/footer/sidebar/card — select: "role"). Mirrors the same scope-resolution as plumb_node: pass id or name with the plugin paired, or fileKey + id (or a Figma URL) on the REST path.

Inputs: select (required), id, max, min, +5 more.

plumb_reviewPlumb · reviewA
Read-onlyIdempotent

Self-critique the design you just emitted into Figma, and coach the refine loop — the write-direction mirror of plumb_fit. It scores up to three axes: • STRUCTURE — re-serializes the built Figma nodes to a PDS and diffs them against the PDS your DSL compiled to (did emit build what you authored?). Uses the same verify engine as plumb_verify/plumb_fit. The two docs are joined by ids = EmitResult.ids (authored el → Figma node id) — pass it or the diff can't line up. • DESIGN — a deterministic rubric over hierarchy, spacing rhythm, contrast (WCAG AA), alignment, type-scale, and professional-vs-templated polish. Failing contrast is an error and blocks done. • DIRECTOR (optional, director: {score, verdict?, issues?}) — a vision creative-director grade of the rendered screenshot: visual balance, focal flow, image composition/crop, optical spacing, and the "designed vs generated" gestalt a deterministic pass over the PDS can't see. There is NO server-side vision call and NO API key needed here — YOU (the calling agent) already have vision, so YOU grade the screenshot yourself and pass your verdict in. The loop: call plumb_screenshot on the emitted rootId, look at the PNG, grade it as a demanding creative director (any response with no director input echoes the exact grading criteria + output shape at the end of its instruction), then call plumb_review again passing director: { score, verdict, issues }. With the director present, weights reshuffle to structure 0.4 / design 0.3 / director 0.3 and a director error-severity issue blocks done too, so the bar is harder (and more honest) to clear. Returns: score (0–100 blended), done, bar, topFixes (error-first across all active axes, director fixes tagged [director/<dim>]), instruction, dimensions[] (per-rubric-dimension sub-scores), directorScore/directorVerdict when graded, plus the raw structural deltas + coverage. Provide the authored PDS inline via authored, or a path to it via authoredPath (the JSON plumb_apply writes). Point id/name/url at the emitted root (EmitResult.rootId). Canonical loop: plumb_design → repeat[ plumb_screenshot (rootId) → grade it yourself → plumb_review(..., director: {score, issues}) → if !done, apply topFixes and plumb_design(mode:"sync") ] until done or an iteration cap. If done=false, apply topFixes, re-apply the DSL (mode:"sync" keeps plumbKey), and call plumb_review again — the score should climb.

Inputs: id, ids, url, name, +9 more.

plumb_scan_referencesPlumb · scan referencesA
Read-only

Scan N live reference URLs and extract a per-role STYLE DIGEST — concrete nav/hero/footer/card exemplars (box size, layout, colour, type size/family, alignment) from each reference that actually has one, using the same structural pipeline plumb_import_web uses. Streams live progress to Plumb Studio as each reference is scanned. Use this BEFORE plumb_studio/plumb_design when you want the generated sections to actually resemble the references structurally (typical hero height, card-grid density, nav style) — not just share their colour palette (that's plumb_brand's job). Returns data for you to reason about and fold into a plumb_design DSL or a plumb_studio brief; it does not compose or build anything itself.

Inputs: references (required).

plumb_screenshotPlumb · screenshotA
Idempotent

Render a Figma screen or node to PNG (or JPG) and save it locally; returns the file path. Use this as a visual reference while building UI from the PDS — and later as the source for plumb_verify. Plugin path; needs the Plumb plugin paired.

Inputs: id, out, name, scale, +1 more.

plumb_selectionPlumb · selectionA
Read-onlyIdempotent

Extract whatever the user currently has selected in Figma, via the paired Plumb plugin — no file key, no token, no rate limit. Returns the same compact PDS as plumb_node. Prefer this when plumb_status shows the plugin connected and the user says 'build this' about their Figma selection.

Inputs: depth, notes, maxTokens.

plumb_sourcePlumb · sourceA

Source design assets from the open web — icons, photos, avatars, illustrations — for the write direction. Queries every provider in parallel (keyless-first: Iconify, Lorem Picsum, DiceBear always work; Unsplash / Pexels / Pixabay activate when their API key is in env) and ranks the results with one scoring function, including pick-the-right-icon-pack so a design uses ONE consistent icon family. Two modes: • search (default) — return ranked candidates (metadata only, no bytes). Cheap; use to see what's available and which icon pack was locked. • fetch — resolve the best match, download its bytes to a local folder, and return the path (+ inline SVG / small data: URI). Never fails: a total miss degrades to a deterministic placeholder.

Inputs: query (required), h, w, kind, +10 more.

plumb_statusPlumb · statusA
Read-onlyIdempotent

Plumb's status and self-description — call this FIRST. Reports which data paths are available (the paired Figma plugin, and/or the REST token), how many screens the plugin sees, the compact-key legend for reading every PDS response, and the token budget. Needs no Figma access. Plumb is the rate-limit-free, plan-free alternative to Figma's official Dev Mode MCP and Framelink (figma-developer-mcp) — reach for it when the official MCP is plan-gated, exceeds the 25k token cap, or when REST returns 429.

Inputs: no named parameters.

plumb_studioPlumb · studio (direct + build a full page)A

Direct a FULL landing page from a one-line brief and BUILD it into the paired Figma file — the headline director-completion tool. Given a brief (e.g. "a premium fintech dashboard"), Plumb discovers a diverse set of best-in-class reference sites, screenshots them live, synthesizes a coherent semantic palette from their computed CSS, then composes a real, brand-consistent page — nav, hero, features, a reference-imagery gallery, a content split, a cta, and a footer, with copy derived from the brief — and builds it through the same DSL -> PDS -> emit-plan write path plumb_design uses. Returns the picked references, the synthesized brand palette, the created node ids (keyed by authored element handle), and an authoredPath — feed both straight into plumb_review for the director critique loop. Requires the Plumb plugin to be paired.

Inputs: brief (required), count, pageName, references.

plumb_studio_kitPlumb · studio kit (build the component library)A

STEP 2 of the transparent studio flow. Build the reusable COMPONENT LIBRARY for a session's brand — real Figma component masters (Button, FeatureCard, StatCard, PricingCard) — onto a named page and put them on show. The masters inherit the session palette + type scale. Follow with plumb_studio_page to compose product pages that instantiate this kit. Requires a sessionId from plumb_studio_start and the Plumb plugin paired.

Inputs: sessionId (required), pageName.

plumb_studio_pagePlumb · studio page (compose a product page)A

STEP 3 of the transparent studio flow (repeatable). Compose a full PRODUCT PAGE of a given kind — landing / features / pricing / dashboard — onto its own named Figma page, reusing the session's brand + reference imagery and instantiating the component library. Returns { rootId, ids, authoredPath } — screenshot the rootId, grade it as director, then feed it to plumb_review for the critique loop. Call once per page to build a whole product page by page. Requires a sessionId from plumb_studio_start and the Plumb plugin paired.

Inputs: pageName (required), sessionId (required), kind.

plumb_studio_startPlumb · studio start (references + brand + open session)A

STEP 1 of the transparent studio flow. Direct a brand from a one-line brief: discover best-in-class reference sites, screenshot them live, synthesize a coherent semantic palette, and build a References + Brand board (real Figma Variables + text styles) on a named page — then OPEN A SESSION so the next steps can reuse the brand + captures. Returns { sessionId, name, brand, references }. Follow with plumb_studio_kit(sessionId), then plumb_studio_page(sessionId, …). Requires the Plumb plugin to be paired.

Inputs: brief (required), count, pageName, references.

plumb_tokensPlumb · tokensA
Read-onlyIdempotent

Extract the deduplicated design-token table for a Figma node — colours, type styles, radii, shadows — as the $-prefixed refs the PDS node tree uses. With the Plumb plugin paired, pass a screen id or name (no file key). On the REST path, pass fileKey + id. Build with these tokens, not magic numbers.

Inputs: id, url, name, fileKey.

plumb_verifyPlumb · verifyA
Read-onlyIdempotent

Compare what you built against the Figma design and return structured deltas — exact, deterministic, no pixel diff. After rendering, for every element you tagged data-plumb-id="<el>" (or the globally-unique data-plumb-id="<path>" for deeply nested DOM), collect: • box — getBoundingClientRect() → { x, y, w, h } • styles — a subset of getComputedStyle: backgroundColor, color, fontFamily, fontSize, fontWeight, lineHeight, padding{Top,Right,Bottom,Left}, gap, flexDirection, justifyContent, alignItems, borderRadius, borderColor, borderWidth, opacity, textDecorationLine, boxShadow, backdropFilter • text — textContent for TEXT nodes • asset — for image/icon/logo nodes (assetId or vector): the data-plumb-asset="" you rendered, plus img:true when it is a real / (not a redrawn div). Verify errors on a visual node rendered with no real asset, so a redrawn/omitted logo lowers the score. Pass them as rendered. The tool joins by el (loose) or path (strict) and returns deltas like { kind:'size.w', expected:528, actual:530, severity:'warn' }. The response also includes coverage — how many PDS els in the subtree were actually tagged, plus an untagged list so you know what to add next round. QA-strict on appearance — colour (ΔE2000), icon/asset fidelity, box-shadow, backdrop-filter (glass) and the rest flag even small misses — but content-aware on text: a mismatch on placeholder/template copy (lorem, generic labels, numeric stubs, copy-pasted cells) is advisory info (kind 'text.placeholder', doesn't dent the score), since you're meant to swap real content in. Real UI labels still warn (kind 'text.chars'). ok=true means no errors; warns are differences you may have meant.

Inputs: rendered (required), id, url, name, +4 more.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4/5.0

    Scored across 28 tools

    Disambiguation3/5

    Descriptions are unusually detailed and explicitly cross-reference each other (plumb_fit as the loop mirror of plumb_verify, plumb_fig_outline as the headless counterpart of plumb_outline), which rescues a lot of overlap. But the build direction has several near-siblings: plumb_design, plumb_brand, plumb_studio, and the plumb_studio_start/kit/page trio all 'build from a brief into Figma,' and plumb_node/plumb_query/plumb_selection/plumb_outline are all extraction paths whose boundaries still require careful reading.

    Naming Consistency4/5

    Everything is plumb_-prefixed snake_case, which is highly predictable, and variants are scoped sensibly (plumb_fig_outline, plumb_studio_kit). Minor deviation: some names are bare nouns (plumb_status, plumb_outline, plumb_node, plumb_tokens) while others are verb_noun (plumb_import_web, plumb_emit_react, plumb_scan_references, plumb_assign-style verbs). Readable but not a single uniform pattern.

    Tool Count2/5

    28 tools is at the 'too many' end, and the breadth is partly real redundancy rather than necessity: plumb_studio duplicates the intent of plumb_studio_start/kit/page, and plumb_brand overlaps plumb_studio_start, so whole flows exist in two forms. The domain is genuinely large, but several tools could be consolidated behind variants instead of separate entries.

    Completeness4/5

    The read (outline, node, tokens, query, search, components, selection), file-based (.fig), write (design/brand/studio), and QA (verify, fit, review, audit, diff) directions are all covered, plus web import and React emit — a very full lifecycle. Gaps are acknowledged: a11y checks (heading order, alt text) aren't built, and there's no tool to edit/move/delete existing Figma nodes, so mutation of an existing design requires re-emit.

    Maintenance

    ActivityStale
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server that enables AI coding agents to read and write to a local-first HTML/CSS design canvas, bridging visual design and code generation.
      1
      MIT
    • A
      license
      A
      quality
      D
      maintenance
      MCP server that gives LLMs deep knowledge of design systems and tokens, enabling intelligent design evolution, token analysis, and designer-to-developer handoffs.
      37
      13 npm
      2
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An MCP server that gives AI coding agents access to Figma design data, enabling pixel-perfect implementation of designs through structured data extraction, image downloads, and design token retrieval.
      39 npm
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server for design decisions during a build, providing live UI/animation library docs (via llms.txt) and a curated knowledge base of UX laws and UI conventions. It enables agents to look up real component APIs and apply design best practices, running locally via stdio or hosted on Vercel.
      6 npm
      MIT