Skip to main content
Glama

figme

An MCP server that lets your AI agent read Figma .fig files — offline, with no Figma account or API token.

npm Node.js License: MIT

Save a design from Figma as a .fig file, and your agent can read everything in it: layers and layout, colours, text, components, design tokens and images. figme can also draw any frame as a picture, so the agent can compare what it built with the design.

you: "what does the tab component in design.fig look like?"

fig_overview  → 10 pages, 2,046 components, 273 variables, 212 images
fig_find      → "lv2/tab/large" is 2:1337, on page "Page 1"
fig_style     → display:flex, direction:row, gap:8, padding:"8px 16px",
                cornerRadius:4, stroke #FFFFFF bound to variable "tab/large/underline"
                (active #FFFFFF / inactive #333333)

Why figme

  • No account, token or network. figme reads the file on your disk and never contacts figma.com.

  • Everything in the file. Layers and geometry, auto-layout, fills, strokes, effects, text with mixed styles, components and instances, variables, prototype links and images. Layout comes back as CSS flexbox, colours as hex, and colours bound to variables keep their token names.

  • What Figma shows, not just what it stores. The layers inside a component instance come back with the instance's overrides applied, under the ids Figma itself gives them, and a shared style reports its live value rather than the stale copy cached beside it.

  • Pictures as well as numbers. fig_render draws any layer as a PNG or SVG.

  • Small responses. Even on a 116,000-node file, a response stays around 20 KB. Results are shallow by default, filterable and paged.

  • Robust to Figma updates. Every .fig carries the schema that describes it, and figme decodes the file with that schema, so fields Figma adds later don't break it.

Related MCP server: Figma MCP Server

Quick start

You need Node.js 22.15 or newer.

1. Save the design as a .fig file. In Figma, choose File → Save local copy… If it's a Community file, click Open in Figma first.

2. Add figme to your agent. In Claude Code:

claude mcp add figme -- npx -y figme-mcp

For Cursor, VS Code, Windsurf and other clients, see Set up your client.

3. Ask. Give the full path to the file, and paste a Figma link if you have one:

Using figme, read /Users/me/Desktop/App.fig and build this frame as a React component: https://www.figma.com/design/AbC123/App?node-id=3017-121

The agent picks the tools from there. A few more things to try:

  • "List the pages and the most-used components in /Users/me/Desktop/App.fig."

  • "Turn the colour variables in /Users/me/Desktop/App.fig into CSS custom properties."

  • "Render the sign-in screen in /Users/me/Desktop/App.fig to /Users/me/Desktop/sign-in.png."

Set up your client

Every client runs the same command, npx -y figme-mcp. Only the place you put it changes.

claude mcp add figme -- npx -y figme-mcp           # this project
claude mcp add -s user figme -- npx -y figme-mcp   # every project

To share the server with everyone who works on a repository, commit a .mcp.json at its root:

{
  "mcpServers": {
    "figme": { "command": "npx", "args": ["-y", "figme-mcp"] }
  }
}

The Claude Code extensions for VS Code and JetBrains use this same configuration. They don't read the editor's own MCP settings.

Add this to ~/.cursor/mcp.json for every project, or to .cursor/mcp.json for one:

{
  "mcpServers": {
    "figme": { "command": "npx", "args": ["-y", "figme-mcp"] }
  }
}

From a terminal:

code --add-mcp '{"name":"figme","command":"npx","args":["-y","figme-mcp"]}'

Or add this to .vscode/mcp.json. VS Code uses the key servers, not mcpServers:

{
  "servers": {
    "figme": { "type": "stdio", "command": "npx", "args": ["-y", "figme-mcp"] }
  }
}

Then switch the Chat view to Agent mode.

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

{
  "mcpServers": {
    "figme": { "command": "npx", "args": ["-y", "figme-mcp"] }
  }
}

Any client that can start a local (stdio) MCP server works. Give it:

{ "command": "npx", "args": ["-y", "figme-mcp"] }

Config file locations change between client releases. If a path above doesn't match what you see, check your client's MCP documentation.

On Windows, some clients can't find npx by themselves. If the server doesn't start, run it through cmd:

{ "command": "cmd", "args": ["/c", "npx", "-y", "figme-mcp"] }

Tips

  • Always give the full path to the file, even with a link. A Figma link can't tell figme which file on your disk it belongs to, and a relative path is resolved from wherever your client started the server.

  • Don't let the agent open the Figma link. The page needs a login, so the agent gets nothing useful back, and it may then invent a design from the words in the URL. figme tells agents not to; if yours tries anyway, stop it.

  • "Node not found" usually means the saved file isn't the one the link points to. Compare the document name that fig_overview reports with the name in the link, or ask the agent to find the layer by name instead.

  • Big files need memory. A 39 MB .fig takes about 900 MB of RAM once parsed, and figme keeps up to 4 parsed files. On a smaller machine, keep just one:

    { "command": "npx", "args": ["-y", "figme-mcp", "--max-files", "1"] }

Tools

Your agent picks these on its own; you don't need to name them.

Tool

What it gives the agent

fig_overview

The pages, node counts, and how many components, variables and images the file has

fig_tree

The layer tree under a node, a few levels at a time, instances opened

fig_node

One layer in detail: size, position, corner radii, auto-layout, children

fig_find

Layers whose name or text contains a string

fig_text

All the text, with fonts and mixed styles

fig_style

Fills, strokes, effects and typography, with auto-layout as CSS flexbox

fig_components

The components, their properties, and how often each is used

fig_instance

What an instance changes from its component

fig_variables

Design tokens: every collection, mode and value

fig_image

Embedded images, and the file's thumbnail

fig_blob

Raw vector data, for anything the other tools don't decode

fig_render

A PNG or SVG picture of any layer or page

Parameters and example responses for each are in docs/tools.md.

Limitations

  • Read-only. figme never changes your .fig. It writes a file only when you ask fig_image or fig_render to save one.

  • A snapshot, not a live link. A .fig holds the design as it was when you saved it. When the design changes, save it again; figme picks up the new file.

  • Rendering is close, not pixel-perfect. fig_render approximates a few effects, such as background blur and angular gradients, and skips a few things, such as emoji. Every render lists what it approximated or skipped. See docs/rendering.md.

  • Libraries from other files aren't included. Styles, variables and components published from another file show up as references, without their values.

  • Vector paths aren't decoded. fig_blob returns their raw bytes.

Contributing

Issues and pull requests are welcome. CONTRIBUTING.md explains how to build from source and run the tests, and how the parser works.

License

MIT

Available Tools

12 tools
fig_blobRaw blob bytesA
Read-only

Return the raw bytes of one entry in the file's blob table. Vector geometry, glyph outlines and similar bulk payloads are stored there and referenced by index from fields such as vectorData.vectorNetworkBlob and Path.commandsBlob (fig_node reports these as vector.networkBlob / vector.fillBlobs). This server does not decode the vector-network format — you get the bytes, base64 or hex, truncated to maxBytes with a flag when longer.

Inputs: file (required), index (required), encoding, maxBytes.

fig_componentsComponent catalogueA
Read-only

List the components (SYMBOL nodes) defined in the file: guid, name, description, the component-set it belongs to when it is a variant, its property definitions with defaults, and how many instances of it exist. Filter with query (case-insensitive substring of the name). Sorted by instance count, most-used first, so the load-bearing parts of the design system come back before one-off symbols. Follow up with fig_instance on a specific INSTANCE guid.

Inputs: file (required), limit, query, cursor.

fig_findSearch layers and textA
Read-only

Search a file for nodes by name and by text content (case-insensitive substring), optionally restricted to node types and/or a subtree. Each hit comes back with the page it lives on, a breadcrumb of ancestor names, and which field matched — so you can jump straight to a guid and then call fig_node / fig_style. Omit query to list every node of the given types.

Inputs: file (required), limit, query, scope, +2 more.

fig_imageEmbedded imageA

Fetch a bitmap stored inside the .fig: pass hash (the 40-hex image id reported by fig_node / fig_style on an image paint), or guid to take the image(s) used by that node, or hash:"thumbnail" for the document preview. Small images come back as viewable image content; larger ones come back as metadata (mime, byte size, pixel dimensions) — give savePath to write the exact bytes to disk instead. NOTE: a .fig contains no rendered pictures of frames, only the bitmaps placed in image fills plus thumbnail.png, so this cannot screenshot a design.

Inputs: file (required), guid, hash, savePath.

fig_instanceInstance overridesA
Read-only

Explain one component INSTANCE: which SYMBOL it points at, its component-property assignments with the property names resolved, and every override it applies — each with the path down into the component, the node that path addresses, and the fields it changes. Use it to see how an instance differs from its component without diffing two subtrees.

Inputs: file (required), guid (required).

fig_nodeInspect a nodeA
Read-only

Inspect one node by guid (e.g. "2:1339"). detail:"full" (default) gives geometry, fills/strokes/effects as hex colours, corner radii, auto-layout, text basics, component and variable links, plus child summaries. detail:"raw" returns the decoded Figma record verbatim — the escape hatch for fields this server does not map yet; it is limited to one node per call and can be large.

Inputs: file (required), guid (required), detail, includeChildren.

fig_overviewFigma file overviewA
Read-only

Open a local Figma .fig file and summarise it: document name, export date, node counts by type, the page list, and how many components / variables / images it holds. START HERE. Then fig_tree a page, then fig_node / fig_style on interesting guids; fig_find jumps straight to a name or a piece of text. Everything is read-only and offline.

Inputs: file (required).

fig_renderRender a node to an imageA

Render a node — frame, component, instance, group, shape, text, or a whole page — to a PNG the model can look at, or to SVG. Fully offline: geometry, text outlines and images all come from the file. Rendering is best-effort: read approximated and unsupported in the report before trusting fine details; exact values remain available from fig_node / fig_style / fig_text. Default output is PNG at 2x, capped to 1568 px on the longest edge; use savePath to write a file instead of inlining it.

Inputs: file (required), guid (required), scale, format, +4 more.

fig_styleResolved style of a nodeA
Read-only

The flattened style of one node, shaped for writing code: hex fills / strokes / effects, corner radii, typography, and auto-layout translated into CSS flexbox terms (display, direction, gap, padding, justifyContent, alignItems, sizing) plus how the node behaves inside its parent layout (flexGrow, alignSelf, margin). Shared styles and variable bindings are named whenever they resolve inside this file.

Inputs: file (required), guid (required), includeRuns.

fig_textText inventoryA
Read-only

Extract every string of copy in the file (or in one subtree via scope), in document order: guid, layer name, the characters, the page, and the base typography (font, size, line-height, colour). With includeRuns:true each node also carries its styled runs — the mixed-format spans Figma stores per UTF-16 code unit — with only the fields each run overrides. Use this for copy audits and translation passes rather than walking the tree.

Inputs: file (required), scope, cursor, includePath, +2 more.

fig_treeExplore the layer treeA
Read-only

List the layers under a node, breadth-limited by depth (default 2, max 6). Returns a FLAT list in document order; each entry carries depth (relative to the requested root) and parent, so the hierarchy is reconstructable, and children (count) so you can see where to deepen. format:"outline" returns indented text lines instead of JSON and is roughly 4x denser for browsing. Large subtrees are truncated with truncated:true and a nextCursor you can pass back to continue.

Inputs: file (required), root, depth, types, +2 more.

fig_variablesVariables and modesA
Read-only

List the design tokens in the file: every variable collection (VARIABLE_SET) with its modes, and every variable with its value per mode — colours as hex, numbers and strings verbatim. Aliases are followed when the target variable lives in this file; a variable published from another library is returned as its opaque assetRef instead. Filter with set (collection name or guid) or query (substring of the variable name).

Inputs: file (required), set, limit, query, +2 more.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 12 tools

    Disambiguation4/5

    Each tool targets a distinct concern: overview, tree, node, find, text, style, components, instances, images, blobs, render, variables. The only mild overlap is fig_node vs fig_style (both inspect a single node) and fig_image vs fig_blob (both fetch raw bytes), but descriptions clarify the different purposes.

    Naming Consistency4/5

    All tools share the fig_ prefix and use lowercase snake_case, which is consistent. The verbs are mostly clear (overview, tree, node, find, text, style, components, instance, image, blob, render, variables), though fig_overview is a noun-ish name rather than a verb_noun pattern like fig_list_pages or fig_get_overview.

    Tool Count5/5

    12 tools is well-scoped for a Figma file inspection server. Each tool covers a distinct aspect of the domain: navigation, inspection, text extraction, style extraction, components, instances, images, blobs, and rendering. No tool feels redundant or unnecessary.

    Completeness4/5

    The server covers the read-only Figma file inspection domain thoroughly: overview, tree navigation, node lookup, search, text extraction, style extraction, components, instances, images, blobs, and rendering. Minor gaps include no direct way to list all pages as a standalone tool (only via fig_overview) and no tool for comparing two nodes, but these are workarounds.

    Maintenance

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      D
      maintenance
      Enables offline reading and rendering of Figma .fig files, allowing AI agents to extract design specs, export assets, and generate code without needing the Figma API or network access.
      26
      2
      MIT
    • F
      license
      Not graded
      quality
      B
      maintenance
      Enables AI agents to access Figma design context, generate code from frames, extract variables, components, and layout data, and create or modify Figma files directly from MCP clients.
      -
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables agents to extract, inspect, search, and bundle design context from local Figma .fig files entirely offline, exposing frame summaries, node context, style tokens, assets, vector SVGs, and visual-match review via MCP.
      MIT
    • A
      license
      A
      quality
      B
      maintenance
      Provides read-only Figma design data to AI agents via MCP, supporting local .fig files and browser-based figma.com access without plugins or API tokens.
      18
      106 npm
      1
      MIT