Click on "Install 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., "@Figma MCP Generate a Unity prefab from the login frame in this Figma file."
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.
Figma MCP is a local FastMCP 3 server that converts a selected Figma Design Frame, Component, or Instance into an inspectable packet and a static Unity UGUI Direct YAML Prefab.
The project is intentionally small and independent. It uses the Figma REST API, stores rendered PNGs locally, and does not require a Figma plugin, OAuth flow, or Unity Editor extension.
中文文档：README.zh-CN.md
Python 3.10+
uv (recommended) or another Python environment manager
A Figma personal access token with file_content:read
Unity 2022.3 LTS or Unity 6 LTS for generated output
Related MCP server: Figma MCP Server
uv sync --extra dev
cp .env.example .envSet the token only in your local .env:
FIGMA_TOKEN=figd_your_token_hereThe token is used only in X-Figma-Token headers sent to
https://api.figma.com. Render downloads use a separate unauthenticated HTTP
client. The token is not stored in packets, generated assets, source maps, or
error details.
Loopback HTTP (default):
uv run figma-mcpThe endpoint is http://127.0.0.1:8127/mcp. Non-loopback HTTP binding is
rejected.
stdio:
./run-stdio.shor:
MCP_TRANSPORT=stdio uv run figma-mcpTool | Purpose |
| List selectable Frames, Components, Instances, and Component Set variants, including those nested under Sections. |
| Fetch one root, normalize it, batch-render PNG assets, and persist an active or diagnostic Packet. |
| Inspect |
| Transactionally write and statically pre-verify a UGUI Direct YAML Prefab. |
| Independently verify YAML, Sprite meta files, source map, ownership, fileIDs, and Unity version. |
Example flow:
Call figma_list_frames with a Figma Design URL or file key.
Call figma_prepare_design with a node id, exact/unique partial name, or
1-based list index. A URL node-id takes precedence.
Inspect view="unity_plan" and review warnings.
Call figma_generate_unity_prefab with an absolute Unity project path.
Call figma_verify_unity_prefab, then open the project in Unity for actual
import, compile, and visual validation.
Successful active Packets use a stable key derived from the Figma file key,
node id, image scale, semantic ruleset, and an explicit version-id when one is
requested. Frame listings and Packets for different explicit versions are kept
in separate cache namespaces. They persist across server restarts.
force_refresh=true is the only normal way to bypass a complete cache.
Refreshes download into a temporary staging directory. A complete refresh writes
an immutable asset version and atomically replaces the active Packet pointer. If
any render is missing or fails, the previous active Packet is preserved and a
separate diagnostic Packet is saved with generation_ready=false.
Figma render URLs are never treated as cache entries. Every rendered PNG is downloaded immediately and stored with its SHA-256 hash.
Figma child order is preserved. Increasing z_index is bottom-to-top and
Unity creates same-parent nodes in ascending order.
Coordinates are rebased to the selected root and use a top-left origin.
Standard constraints map to RectTransform anchors.
horizontal/vertical Auto Layout maps to LayoutGroup and LayoutElement hints. Wrap/grid combinations retain snapshot coordinates and emit warnings.
Editable text becomes UnityEngine.UI.Text; unmatched fonts fall back to
built-in Arial with a warning.
Hidden Figma nodes become inactive GameObjects. Group opacity uses one
CanvasGroup; leaf opacity is applied once to its generated Graphic.
Simple solid rectangles become UGUI Images. Vector, image fill, gradient, rounded, stroked, or effect-heavy visual leaves become PNG sprites.
Rotated visual leaves and containers use rendered PNGs so rotation is baked accurately. A rotated container keeps its descendant hierarchy and source mapping, while descendant source visuals are suppressed to avoid duplication.
Complex containers remain hierarchical. Rectangular clipsContent maps to
RectMask2D where safe; unsupported container visuals emit fidelity warnings.
Interactive generation defaults to conservative: confidence must be at least
0.8, review must not be required, and all references must be complete.
structure_only suppresses inferred Button/Toggle/Input/Dropdown/Slider/
ScrollRect components while retaining presentation hierarchy and safe layout or
mask components.
Explicit name tags include @button, @toggle, @input, @dropdown,
@slider, @scroll, @scrollbar, @tab, @radio, @mask, and @ignore.
They never create business scripts, UnityEvent bindings, navigation, or data
bindings.
The default output root is Assets/FigmaMCP. Generation uses staging, static
pre-verification, deterministic GUIDs, a source map, and an ownership manifest.
overwrite=false is the default. With overwrite=true, only unchanged files
already owned by the same Packet manifest can be replaced; every existing file
is checked against its previous SHA-256. If an owned file was edited manually,
generation returns owned_asset_modified. Set
force_overwrite_modified=true together with overwrite=true only when those
edits may be discarded. Direct YAML regeneration replaces complete owned files;
field-level preservation hints describe a future editor-side importer, not the
current writer. Historical orphaned files are reported but not deleted. A failed
commit rolls back files changed during that transaction.
All responses use api_version: "0.1" and a success/error envelope. Public
schemas are version 1:
figma-mcp.packet
figma-mcp.unity-plan
figma-mcp.prefab-source-map
figma-mcp.ownership-manifest
Generated JSON Schemas are in schemas/.
uv run pytest
uv run pytest --cov=figma_mcp --cov-report=term-missing
uv run ruff check src tests
uv run mypy src
uv buildThe test suite is offline: it mocks Figma REST and creates temporary Unity project structures. Passing tests prove the contracts, generated files, and static checks; they do not prove compatibility with every real Figma document, Unity Editor import/compilation, or visual parity.
Version 0.1.0 does not implement OAuth, Figma variables, FigJam/Slides, plugin templates, real Unity Prefab Instances/Variants, C# importers, visual diff, or a publishing pipeline.
MIT
Generate a staged, statically verified UGUI Direct YAML Prefab snapshot.
| Name | Required | Description | Default |
|---|---|---|---|
| overwrite | No | Replace unchanged files owned by the same Packet manifest. | |
| packet_id | Yes | Generation-ready Packet id returned by figma_prepare_design. | |
| asset_root | No | Generated asset directory below Assets/. | Assets/FigmaMCP |
| prefab_name | No | Optional prefab name. | |
| text_font_guid | No | Optional default Unity Font guid from an imported .ttf/.otf asset. | |
| component_policy | No | Interactive component policy. | conservative |
| include_reference | No | Copy the whole-frame Figma reference asset when available. | |
| text_font_map_json | No | Optional source-font-name to Unity Font guid JSON mapping. | |
| unity_project_path | Yes | Unity project root containing Assets and ProjectSettings. | |
| use_text_components | No | Use editable UnityEngine.UI.Text nodes. | |
| force_overwrite_modified | No | With overwrite=true, also replace owned files whose content no longer matches the previous manifest hash. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions 'staged' and 'statically verified' which hints at a multi-step process but does not reveal that this tool writes files, can overwrite existing assets, or has destructive potential via overwrite flags. The side effects are undisclosed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single sentence that is immediately comprehensible and front-loaded with the core action. No unnecessary words or repetition.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite a rich schema and output schema, the tool is complex (11 parameters, file-generation) and has no annotations. The description is too brief to cover essential context like file-writing behavior, overwrite risks, or workflow position. The agent is left to infer crucial operational details from the schema alone.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so the schema already documents all parameters. The description adds no extra meaning or context to parameters, thus the baseline score of 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Generate') and a specific resource ('UGUI Direct YAML Prefab snapshot') with qualifiers ('staged', 'statically verified') that clearly identify the tool's function. It distinguishes itself from sibling tools like figma_prepare_design and figma_verify_unity_prefab by focusing on the generation step.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention the prerequisite of a packet from figma_prepare_design or that it should precede figma_verify_unity_prefab. While the schema's packet_id parameter references figma_prepare_design, that is structured data, not the description's contribution.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Inspect a normal or diagnostic Figma Packet through a compact task-oriented view.
| Name | Required | Description | Default |
|---|---|---|---|
| view | No | Information view to return. | summary |
| node_ids | No | Node ids required by the nodes view. | |
| max_depth | No | Maximum hierarchy depth for tree view. | |
| packet_id | Yes | Packet id returned by figma_prepare_design. | |
| include_style | No | Include style/text/source fields in tree view. | |
| component_policy | No | Interactive component generation policy for Unity plan. | conservative |
| include_reference | No | Include the full Figma reference in slices or Unity plan. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden for disclosure. 'Inspect' implies a read-only operation, but it never explicitly states that there are no side effects, nor does it mention any behavioral traits like error conditions or data sensitivity. The lack of detail on what 'compact task-oriented view' means adds to the opacity.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, concise sentence with no fluff. However, it's under-specified; while concise, it sacrifices clarity by using the vague phrase 'compact task-oriented view', slightly diminishing its usefulness.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the output schema and rich input schema, the description is too brief to guide an agent on what the various views (summary, full, tree, nodes, assets, etc.) offer or when to use which. The tool has 7 parameters and 8 view options, but the description provides no high-level context about the inspection workflow or how it relates to packet preparation.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% parameter coverage, including descriptions for each property. The description adds no extra parameter semantics, but this is acceptable given the schema's thoroughness. Baseline 3 is appropriate.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'Inspect' and a clear resource ('Figma Packet'), which distinguishes it from siblings like figma_generate_unity_prefab. However, 'compact task-oriented view' is vague and doesn't specify what inspection entails beyond a general overview.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no explicit guidance on when to use this tool versus alternatives, nor any exclusions or prerequisites. The phrase 'normal or diagnostic' hints at context but doesn't tell the agent when to choose this over figma_prepare_design or other siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
List Frame, Component, and Instance roots available in a Figma Design file.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Figma Design URL or file key. | |
| force_refresh | No | Bypass the persistent frame listing cache. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It only states that it lists roots and does not disclose the caching behavior implied by the 'force_refresh' parameter, network/API dependence, or any access requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one concise sentence that is front-loaded with the primary verb and resource. Every word earns its place with no redundancy or filler.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a simple listing tool with an output schema and full schema parameter coverage, the description is mostly complete. However, the lack of behavioral context (e.g., caching, staleness) and usage guidance prevents a perfect score.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% with descriptions for both 'url' and 'force_refresh', so the schema carries the parameter semantics. The description adds no additional meaning beyond the schema, meriting the baseline score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses the specific verb 'List' and identifies the resource: 'Frame, Component, and Instance roots' in a Figma Design file. It is clearly differentiated from siblings like figma_inspect_design and figma_generate_unity_prefab by focusing on listing available roots.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No guidance is provided on when to use this tool versus alternatives. The description does not mention prerequisites, workflow position, or situations where another sibling tool would be preferred, leaving the agent to infer usage from context.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Fetch, normalize, render, download, validate, and persist one Figma design root.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Figma Design URL or file key. A node-id in the URL takes precedence. | |
| node | No | Frame/Component/Instance id, unique name, partial name, or 1-based list index. | |
| image_scale | No | PNG render scale from 0.01 to 4; defaults to FIGMA_ASSET_SCALE. | |
| force_refresh | No | Fetch Figma again instead of reusing the complete persistent Packet cache. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It lists the major operations (fetch, normalize, render, download, validate, persist), which gives a transparent summary of the tool's behavior. However, it does not disclose details like caching semantics (e.g., that force_refresh bypasses a cache), potential side effects of persisting, or error behavior. The action list is useful but sparse on deeper behavioral context.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single concise sentence that lists all major actions in a structured, front-loaded sequence. It is appropriately sized and free of filler. However, the list format is slightly dense and might benefit from a clarifying phrase about the tool's role as a preparation step, but it remains efficient.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the core workflow but lacks context about its role in the broader tool set. An output schema exists, so return values are likely covered elsewhere. Given the absence of annotations and no mention of when to use it, the description is not fully complete for an agent trying to decide between preparation and inspection tools.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema provides 100% coverage for all 4 parameters, each with detailed descriptions. The tool description itself adds no additional parameter information, so the baseline of 3 applies. The schema already explains URL, node, image_scale, and force_refresh effectively.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific, multi-step verb phrase ('Fetch, normalize, render, download, validate, and persist') with an explicit resource ('one Figma design root'). This clearly distinguishes it from sibling tools like figma_list_frames or figma_inspect_design, which focus on reading/list only, while this tool is a comprehensive preparation pipeline.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides no guidance on when to use this tool versus alternatives. It does not mention that it is a prerequisite for figma_generate_unity_prefab, nor does it describe scenarios where inspect or list would be more appropriate. Sibling tool names give context, but the description itself offers no explicit usage direction.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Statically verify generated Prefab YAML, ownership metadata, source map, sprites, and file ids.
| Name | Required | Description | Default |
|---|---|---|---|
| prefab_asset_path | Yes | Prefab path below Assets/. | |
| unity_project_path | Yes | Unity project root containing Assets and ProjectSettings. | |
| source_map_asset_path | No | Optional source map path below Assets/. |
| Name | Required | Description |
|---|---|---|
No output parameters | ||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. 'Statically verify' suggests a non-destructive read-only operation, and the listed verification aspects add context about what is checked. However, it does not disclose what happens on failure, whether any output files are written, or the exact return structure beyond what the output schema might provide.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is a single, front-loaded sentence with no unnecessary words. It efficiently enumerates the verification scope, making it highly concise and well-structured.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With a full input schema, an output schema, and a concise list of verified components, the description covers the core function well. The only gaps are lack of explicit usage timing and alternative guidance, but given the simplicity of the tool and the presence of structured data, it is reasonably complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100%, so the baseline is 3. The description adds some context by associating 'own metadata' and 'source map' with verification targets, but it does not add new meaning or clarify parameter formats beyond the schema definitions. The value added is marginal.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb 'statically verify' and explicitly lists the resources involved: Prefab YAML, ownership metadata, source map, sprites, and file ids. This clearly distinguishes the tool from siblings like 'generate' and 'inspect' by conveying a verification purpose.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The term 'generated Prefab' implies the tool is intended to be used after a generation step, but the description does not explicitly state when to use it relative to alternatives or provide prerequisites. The usage context is only implied by the naming and wording.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.0figma_generate_unity_prefabfigma_inspect_designfigma_list_framesfigma_prepare_designfigma_verify_unity_prefabEach tool targets a distinct stage of the Figma-to-Unity pipeline: listing frames, preparing design data, generating prefabs, inspecting, and verifying. No two tools appear to overlap in purpose.
All tools follow a consistent `figma_` prefix with a verb_noun pattern: list_frames, prepare_design, generate_unity_prefab, inspect_design, verify_unity_prefab. This makes the toolset predictable and easy to navigate.
Five tools is well-scoped for a focused Figma-to-Unity design-to-prefab workflow. Each tool fills a clear role without unnecessary bloat or missing core steps.
The workflow covers the essential stages: discover frames, prepare a design, generate a prefab, inspect it, and verify it. Minor gaps exist, such as no explicit tool for cleanup or batch operations, but these do not impede the primary pipeline.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
The Figma MCP server brings Figma design context directly into your AI workflow.
Access and maintain design system docs, tokens, components, skills, and contexts across any project.
Build and manage your design system with AI: tokens, themes, components, icons, Figma and code.
Control Unreal Engine to browse assets, import content, and manage levels and sequences. Automate…
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/isolamenter/figma-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
