# io.github.tathagat22/plumb-mcp (npm · plumb-mcp)

Two-way Figma MCP: extract + verify design-to-code, or generate on-brand Figma pages from a prompt.

- Trust score: 67/100 (medium)
- Change this week: +25
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-08-03

## Components

- npm · `plumb-mcp`: 67/100 (this document), [markdown](https://verifymcp.io/servers/tathagat22-plumb-mcp/plumb-mcp.md), [page](https://verifymcp.io/servers/tathagat22-plumb-mcp/plumb-mcp)

## Channel facts

- Registry: `npm`
- Package: `plumb-mcp`
- Version: `0.13.2`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-08-03.

- **Supply Chain Security**: 87/100
  - No malware found by supply-chain analysis.
  - Only part of the dependency tree could be resolved (100 of 104), so this covers what we could see, not the whole tree.
  - No install/post-install scripts declared.
  - Only part of the dependency tree could be resolved (100 of 104), so this covers what we could see, not the whole tree.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 30 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 63/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 6338 tokens (~275/item across 23 items; 23 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 27/100
  - Stability observed for 8 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### Claude

```bash
claude mcp add tathagat22-plumb-mcp -- npx -y plumb-mcp
```

### Codex

```bash
codex mcp add tathagat22-plumb-mcp -- npx -y plumb-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "tathagat22-plumb-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "plumb-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add tathagat22-plumb-mcp --command npx --arg -y --arg plumb-mcp
```

### Hermes

```yaml
mcp_servers:
  tathagat22-plumb-mcp:
    command: "npx"
    args: ["-y", "plumb-mcp"]
```

### Other

```json
{
  "mcpServers": {
    "tathagat22-plumb-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "plumb-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-08-03 (score 67, +4)

- [functional improvement] Stability: unverified → 0.27

### 2026-08-02 (score 63, +46)

- [security regression] Provenance: unverified → fail
- [security improvement] Known CVEs: unverified → partial
- [security improvement] Install scripts: unverified → pass
- [security improvement] Malware scan: unverified → pass
- [security] Stability: Stability not yet verified: not enough scan history yet (needs a 30-day window).
- [functional regression] Tool coverage: 100 → unverified
- [functional improvement] Schema quality: unverified → excellent
- [functional improvement] License: unverified → pass
- [functional improvement] Dependency health: unverified → partial
- [functional improvement] Maintenance: unverified → pass
- [functional improvement] MCP protocol: unverified → pass
- [functional] Licence: MIT

### 2026-08-01 (score 17, +12)

- [functional improvement] Tool coverage: unverified → 100

### 2026-07-31 (score 5, −37)

- [functional] We updated how we score, so this day's move reflects our rubric, not a change to the server

### 2026-07-27 (score 42)

First indexed and scored.

## MCP tools (23)

### `plumb_status` (~128 tokens)

Plumb · status

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.

### `plumb_outline` (~169 tokens)

Plumb · outline

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.

Input parameters:

- `fileKey` (string): Figma file key — for the REST path. Omit when the Plumb plugin is paired.
- `page` (string): Filter to a single Figma page by name (case-insensitive). Saves tokens on multi-page files where most pages are irrelevant.
- `url` (string): Paste a full Figma URL — fileKey is auto-extracted. Accepts /design/, /file/, /proto/, and branch URLs.

### `plumb_node` (~305 tokens)

Plumb · node

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`.

Input parameters:

- `depth` (integer): Levels to disclose. Default 3.
- `expandAll` (boolean): Walk the entire subtree in one call, ignoring `depth`. Subject to `maxTokens` (defaults to 60000 if omitted); if the spec exceeds the budget, depth is auto-trimmed and `meta.truncated` is set. Use th…
- `fileKey` (string): Figma file key — REST path. Omit when the Plumb plugin is paired.
- `id` (string): Node/screen id to extract.
- `maxTokens` (integer): Soft token budget; fit-to-budget reduces depth to fit.
- `name` (string): Screen name — plugin path; resolved against the paired file.
- `notes` (boolean): Include human-readable notes per node.
- `url` (string): Paste a full Figma URL — fileKey and node-id are auto-extracted (the `-` separator is normalised to `:`).

### `plumb_tokens` (~181 tokens)

Plumb · tokens

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.

Input parameters:

- `fileKey` (string): Figma file key — REST path. Omit when the Plumb plugin is paired.
- `id` (string): Node id whose design tokens to extract, e.g. "131:9592".
- `name` (string): Screen name — plugin path; resolved against the paired file.
- `url` (string): Paste a full Figma URL — fileKey and node-id are auto-extracted.

### `plumb_selection` (~119 tokens)

Plumb · selection

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.

Input parameters:

- `depth` (integer): Levels to disclose. Default 3.
- `maxTokens` (integer): Soft token budget; fit-to-budget reduces depth to fit.
- `notes` (boolean): Include human-readable notes per node.

### `plumb_assets` (~318 tokens)

Plumb · assets

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.

Input parameters:

- `id` (string): Screen/node id to scope the export to.
- `ids` (array): Surgical — export exactly these node ids (one each, no recursion).
- `inline` (boolean): Return asset bytes inline on each row: SVGs as raw markup, bitmaps under 64KB as a data: URI. Useful for dropping SVG icons straight into JSX without re-reading from disk. Files are still written; th…
- `list` (boolean): Manifest only — return id/name/format/parentId per candidate; no file writes.
- `name` (string): Screen name — resolved against the file.
- `raw` (boolean): For nodes with IMAGE fills, export the original uploaded bytes (JPG/PNG/GIF/WEBP) via getImageByHash, instead of a 2× rasterised PNG render. Other nodes (icons, vectors) export the same as default.

### `plumb_screenshot` (~162 tokens)

Plumb · screenshot

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.

Input parameters:

- `format` (string): Output format. Default PNG.
- `id` (string): Node id to render.
- `name` (string): Screen name — resolved against the file.
- `out` (string): Output path or filename. Absolute paths are honoured as-is; bare filenames are placed under the screenshots directory. Defaults to '<name>-<id>.<ext>', auto-suffixed on collision.
- `scale` (number): Render scale. Default 2.

### `plumb_describe` (~167 tokens)

Plumb · describe

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.

Input parameters:

- `depth` (integer): Levels of the tree to mine for the narrative. Default 2.
- `fileKey` (string): REST path file key.
- `id` (string): Node id to describe.
- `name` (string): Screen name (plugin path).
- `url` (string): Paste a full Figma URL — fileKey + node-id auto-extracted.

### `plumb_search` (~150 tokens)

Plumb · search

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.

Input parameters:

- `page` (string): Filter to a single Figma page by name (case-insensitive, substring-friendly). Drops noise on multi-page files.
- `query` (string): Substring match on node name (case-insensitive).
- `type` (string): Filter by node type, e.g. "TEXT", "FRAME", "INSTANCE", "VECTOR".

### `plumb_components` (~110 tokens)

Plumb · components

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. Plugin path; needs the Plumb plugin paired.

Input parameters:

- `page` (string): Filter components and instances to a single Figma page by name (case-insensitive, substring-friendly). Massive token saver on files that hide a 200-variant style guide on one page.

### `plumb_verify` (~562 tokens)

Plumb · verify

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="<assetId>" you rendered, plus img:true when it is a real <img>/<svg> (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.

Input parameters:

- `depth` (integer): PDS depth to fetch. Default 12 — deep enough for most screens.
- `fileKey` (string): File key (REST path).
- `id` (string): Screen id.
- `name` (string): Screen name (plugin path).
- `rendered` (array, required): Each element you tagged data-plumb-id="<el>".
- `tolerances` (object): Override default thresholds.
- `url` (string): Paste a full Figma URL — fileKey and node-id are auto-extracted.
- `viewport` (object): Browser viewport size (informational).

### `plumb_fit` (~444 tokens)

Plumb · fit

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="<el>" 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.

Input parameters:

- `accept` (number): Score at which to stop. Default 98.
- `depth` (integer): PDS depth to fetch. Default 12 — deep enough for most screens.
- `fileKey` (string): File key (REST path).
- `id` (string): Screen id.
- `iteration` (integer): Which pass this is (1, 2, 3…). Informational — sharpens the coaching.
- `name` (string): Screen name (plugin path).
- `rendered` (array, required): Each element you tagged data-plumb-id="<el>", with box + styles.
- `tolerances` (object): Override default thresholds.
- `url` (string): Paste a full Figma URL — fileKey and node-id are auto-extracted.

### `plumb_query` (~313 tokens)

Plumb · query

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. 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.

Input parameters:

- `componentId` (string): Filter for select: "components" — return only instances of this component.
- `fileKey` (string): Figma file key — REST path. Omit when the plugin is paired.
- `id` (string): Node/screen id to query within.
- `max` (number): Maximum font size for select: "text".
- `min` (number): Minimum font size for select: "text".
- `name` (string): Screen name — plugin path, resolved against the paired file.
- `select` (string, required): Query pattern. "skeleton" = structure-only (drops chars, fills, effects, vectorPath, text refs). "buttons" = nodes Plumb tagged with pattern: button. "text" = TEXT nodes, optionally filtered by font-…
- `url` (string): Paste a full Figma URL — fileKey and node-id auto-extracted.

### `plumb_fig_outline` (~96 tokens)

Plumb · fig outline

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.

Input parameters:

- `figPath` (string, required): Absolute path to a .fig file on disk.

### `plumb_fig_node` (~114 tokens)

Plumb · fig node

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.

Input parameters:

- `figPath` (string, required): Absolute path to a .fig file on disk.
- `id` (string, required): Node id — `sessionID:localID` form.

### `plumb_design` (~350 tokens)

Plumb · design (build)

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.

Input parameters:

- `brief` (object): Optional design-brief intake — records author intent alongside the build.
- `doc`: A Plumb Design DSL document (version "1": brand + pages of semantic sections). Validated against DesignDocSchema.
- `dryRun` (boolean): Compile + lower only; do NOT touch Figma. Returns plan stats + warnings so you can sanity-check before building.
- `mode` (string): `create` (default) — fresh nodes. `sync` — idempotent re-apply keyed on stable plumbKey (authored element handle); pair with `prune` to delete stale nodes.
- `pageWidth` (integer): Layout width hint for pages that don't set their own.
- `prune` (boolean): sync only — delete built nodes no longer in the design.
- `reveal` (boolean): Scroll + select the built root in Figma when done.
- `target` (object): Where to build. Defaults to a new top-level frame on the current page.

### `plumb_brand` (~216 tokens)

Plumb · brand (direct + build)

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.

Input parameters:

- `brief` (string, required): One-line description of what's being built, e.g. "a premium fintech dashboard". Drives reference discovery + palette.
- `count` (integer): How many reference sites to study + screenshot (default 4).
- `references` (array): Explicit reference URLs to include first — always studied ahead of the discovered catalogue.

### `plumb_studio` (~283 tokens)

Plumb · studio (direct + build a full page)

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.

Input parameters:

- `brief` (string, required): One-line description of what's being built, e.g. "a premium fintech dashboard". Drives reference discovery, palette, and copy.
- `count` (integer): How many reference sites to study + screenshot (default 4).
- `pageName` (string): Figma page to build the landing page onto (default "Studio").
- `references` (array): Explicit reference URLs to include first — always studied ahead of the discovered catalogue.

### `plumb_source` (~410 tokens)

Plumb · source

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.

Input parameters:

- `aspect` (number): Target width/height ratio (ranking hint).
- `h` (number): Desired height (photos / placeholders).
- `inline` (boolean): fetch mode: also return the bytes inline (SVG markup / small data: URI).
- `kind` (string): Constrain to one asset kind.
- `limit` (integer): Max candidates in search mode. Default 16.
- `minWidth` (number): Minimum acceptable pixel width.
- `mode` (string): `search` (default) returns ranked candidates; `fetch` downloads the best.
- `palette` (array): Brand hex colors — recolors monotone SVG icons.
- `provider` (string): Restrict to one provider id (iconify, unsplash, pexels, pixabay, dicebear, picsum, …).
- `query` (string, required): What to look for, e.g. 'rocket launch' or 'shopping cart'.
- `seed` (string): Deterministic seed for avatars / placeholders.
- `style` (array): Preferred style tags (ranking hint).
- `w` (number): Desired width (photos / placeholders).
- `weight` (string): Icon weight preference.

### `plumb_review` (~941 tokens)

Plumb · review

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 J…

Input parameters:

- `accept` (number): Blended score at which to stop. Default 90.
- `authored`: The authored PdsDocument (what the DSL compiled to). Inline alternative to authoredPath.
- `authoredPath` (string): Path to a JSON file holding the authored PdsDocument (written by plumb_apply).
- `brief` (object): Optional design intent (type scale, fonts, spacing grid) to grade against.
- `depth` (integer): PDS depth to re-serialize. Default 12.
- `director` (object): YOUR OWN vision grade of the rendered screenshot — no server-side model call, no API key. Look at the PNG from plumb_screenshot, grade it yourself as a demanding creative director (see directorGuidan…
- `fileKey` (string): File key (REST path).
- `id` (string): Emitted root node id (EmitResult.rootId).
- `ids` (object): EmitResult.ids — authored el → Figma node id. The join key for the structural diff.
- `iteration` (integer): Which refine pass this is (1, 2, 3…). Informational — sharpens the coaching.
- `name` (string): Screen name (plugin path).
- `tolerances` (object): Override default structural thresholds.
- `url` (string): Paste a full Figma URL — fileKey and node-id are auto-extracted.

### `plumb_studio_start` (~193 tokens)

Plumb · studio start (references + brand + open session)

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.

Input parameters:

- `brief` (string, required): One-line description, e.g. "a premium fintech dashboard".
- `count` (integer): How many reference sites to study (default 4).
- `pageName` (string): Figma page for the brand board (default "Brand").
- `references` (array): Explicit reference URLs to study first.

### `plumb_studio_kit` (~139 tokens)

Plumb · studio kit (build the component library)

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.

Input parameters:

- `pageName` (string): Figma page for the component library (default "Components").
- `sessionId` (string, required): Session id from plumb_studio_start.

### `plumb_studio_page` (~179 tokens)

Plumb · studio page (compose a product page)

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.

Input parameters:

- `kind` (string): Which page to compose (default landing).
- `pageName` (string, required): Figma page to build onto, e.g. "Landing".
- `sessionId` (string, required): Session id from plumb_studio_start.

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/tathagat22-plumb-mcp/plumb-mcp#diagnostics

## Score history

- 2026-08-03: 67
- 2026-08-02: 63
- 2026-08-01: 17
- 2026-07-31: 5
- 2026-07-30: 42
- 2026-07-28: 42
- 2026-07-27: 42

## Links

- npm package: https://www.npmjs.com/package/plumb-mcp
- Socket report: https://socket.dev/npm/package/plumb-mcp
- Repository: https://github.com/tathagat22/plumb-mcp
- Website: https://tathagat22.github.io/plumb-mcp/
- Changelog RSS feed: https://verifymcp.io/servers/tathagat22-plumb-mcp/plumb-mcp/changelog.xml
- Changelog JSON feed: https://verifymcp.io/servers/tathagat22-plumb-mcp/plumb-mcp/changelog.json
- HTML version of this page: https://verifymcp.io/servers/tathagat22-plumb-mcp/plumb-mcp