Plumb
Reads Figma files through a desktop-app plugin, normalizes screens into a semantic design graph for code generation and verification, and writes newly generated designs back into Figma.
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., "@Plumb turn this Figma landing page into React components and verify the code matches"
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.
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_nodenormalises a Figma screen;plumb_import_webnormalises 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_reactgenerates the same deterministic React/JSX whether the graph came from Figma or from a URL.plumb_diff,plumb_audit, andplumb_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_fitdiff 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_studiocomposes a brand-new Figma file from a brief, andplumb_reviewcritiques the render the same wayplumb_verifycritiques 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:
Researches references — finds best-in-class sites for your brief (Linear, Stripe, Mercury…) and screenshots them live onto a References page.
Extracts a brand — reads their computed CSS into a coherent palette + type scale, laid down as a Brand board.
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.
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 fitCLI 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 |
| PDS dedups design tokens ( |
| Plumb's plugin path has no per-call quota on any plan, including Free. |
| The plugin path doesn't touch REST. Zero rate limits. |
| Plumb reads Variables through the Figma Plugin API — works on every plan, for both local and team-library variables. |
| Plumb returns structured PDS (not parsed prose) and ships |
"How do I generate a Figma design from a prompt?" · "AI that designs UI in Figma" |
|
"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" |
|
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 demoIt 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 --helpnpm 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 |
| Self-description, key legend, connection state. Call first. |
| Every screen in the file (id, name, size). |
| Extract a screen as compact PDS — by id or by name. |
| Pull a slice ( |
| Text-only visual description — for image-blind harnesses. |
| Design-token table (colours, type, radii, shadows). |
| The user's live Figma selection. |
| Export icons (SVG) + images (PNG) — recursive, list, or surgical by ids. |
| Render any node to PNG/JPG. |
| Find nodes by name and/or type. |
| List components + instance usages, plus an opt-in design-system health report (unused components, near-duplicate names, variant outliers). |
| Diff rendered layout against the design — ΔE2000 colour, shadow/rotation/flex checks. |
| The self-healing loop: verify + a 0–100 convergence score + prioritised fixes. |
| Headless: read a saved |
| Semantic diff between two PDS snapshots — "the hero moved from (0, 0) to (0, 120)", not a JSON diff. |
| Heuristic accessibility checks — text contrast, button touch-target size. |
| Import a live webpage's structure and semantics — no Figma connection needed. Same role classifier Figma designs use. |
| Deterministic React/JSX generator from a PDS or a |
| Scan N live reference URLs and extract a per-role style digest (typical hero height, card-grid density, nav style) — for folding into a |
Write — prompt → design (the director)
Tool | What it does |
| 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. |
| 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. |
| Brief → live-screenshots best-in-class reference sites + a synthesized brand palette/type board on the canvas. |
| Author a design from Plumb's high-level Design DSL and build it into Figma (full control: pages, sections, components, motion). |
| 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. |
| 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_fitdiff 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_diffnarrates changes by role,plumb_auditflags contrast and touch-target issues,plumb_query'sselect: "role"andplumb_node'scollapseRolesfilter and compress by the same labels. The same underlying model reads a live webpage too —plumb_import_webextracts structure and roles from any URL, no Figma involved — andplumb_emit_reactgenerates 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 — |
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 |
| The Figma REST path ( | REST tools return an instruction-shaped error; the plugin path is unaffected |
| Alias for | — |
|
| Must be passed as an argument instead |
|
|
|
| Pinning the bridge to one port (containers, >10 concurrent sessions) | Scans the |
| An ordered pool to try, comma-separated; | Same built-in pool |
| Publishing the bridge from inside a container |
|
| The label this session shows as in the plugin panel | The current directory name |
|
|
|
|
| Human-readable lines |
| Honoured, never set — the standard conventions for disabling ANSI colour in | Colour when stdout is a TTY |
| Where |
|
| Where |
|
| Response cache root |
|
| Cache entry lifetime |
|
| Chrome binary for | Auto-detected from the standard install paths |
| Alias for | — |
| The standalone |
|
| Model override for that CLI | The built-in default |
| On-brief photography in the write direction (free tier) | Falls back to random Lorem Picsum placeholders |
| Same, alternative provider (free tier) | Same fallback |
| Same, alternative provider (free tier) | Same fallback |
| 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 toThe 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 pairingA 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-forwardas the way in.deploy/README.mdis explicit about what works in a cluster, what doesn't (the Figma plugin scans127.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 matchesplumb-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 |
| Whenever the plugin is paired |
Figma REST ( |
| Only if the plugin isn't paired, or for headless/CI use |
| The target URL(s) you pass in, via headless Chrome (CDP) | Only when you call these |
| The reference sites Plumb picks for your brief | Only in the prompt→design write direction |
Google Fonts |
| Only when a captured design/import references a Google Font |
| The respective photo API | Only in the write direction, only if a key is set |
|
| 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 fitCLI 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 toolsplumb_assetsPlumb · assetsAIdempotent
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 · auditARead-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 · componentsARead-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 · describeARead-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 · diffARead-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 reactARead-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 nodeARead-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 outlineARead-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 · fitARead-onlyIdempotent
Self-healing build loop — iterate to a pixel-perfect match instead of a one-shot check. The loop:
Build the component, stamping data-plumb-id="" on each element using the PDS handles (same
elkeys plumb_node/plumb_query return).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.
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 nextIf 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
deltasandcoverage.untaggedto see what you missed.
Inputs: rendered (required), id, url, name, +5 more.
plumb_import_webPlumb · import webARead-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 · nodeARead-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 · outlineARead-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 · queryARead-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 · reviewARead-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 referencesARead-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 · screenshotAIdempotent
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_searchPlumb · searchARead-onlyIdempotent
Find nodes across the file by name and/or type — 'where is the primary button?', 'every TEXT layer named Title', etc. Returns matches with id, name, type, page, and size. Drill into one with plumb_node, or pull its asset with plumb_assets. Plugin path; needs the Plumb plugin paired.
Inputs: page, type, query.
plumb_selectionPlumb · selectionARead-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 · statusARead-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 · tokensARead-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 · verifyARead-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
Scored across 28 tools
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.
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.
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.
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
Related MCP Connectors
The Figma MCP server brings Figma design context directly into your AI workflow.
Design canvas for agents: create, edit, render and export Figma-shaped designs over MCP.
Live React design-system APIs, patterns, and code validation so AI agents build real UI, not slop.
Serves your design system and coding standards to coding agents, so they stop guessing.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceMCP server that enables AI coding agents to read and write to a local-first HTML/CSS design canvas, bridging visual design and code generation.1MIT
- AlicenseAqualityDmaintenanceMCP server that gives LLMs deep knowledge of design systems and tokens, enabling intelligent design evolution, token analysis, and designer-to-developer handoffs.3713 npm2MIT
- AlicenseNot gradedqualityDmaintenanceAn 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 npm1MIT
- AlicenseNot gradedqualityDmaintenanceMCP 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 npmMIT