Which integrations are available for this server?

Parses Unity text-serialized .prefab, .unity, and .asset files, extracting Inspector-visible component data into clean YAML format, reducing token usage for LLM analysis.

How do I use Unity Prefab Parser MCP Server?

1. Click on "Install Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@Unity Prefab Parser MCP Server Parse the prefab at Assets/Enemies/BatPF.prefab" 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.

Unity Prefab Parser MCP Server

by luckynee

Overview Schema Related Servers Score Discussions

TypeScript

Local

Unity Prefab Parser MCP Server

An MCP (Model Context Protocol) server that parses Unity text-serialized .prefab, .unity, and .asset files and outputs only Inspector-visible data in a clean, hierarchical YAML format — reducing token usage by up to 96%.

Supports regular prefabs, prefab variants (shows overridden values grouped by GameObject and component), and scene files.

Works with any MCP-compatible AI client: Claude Desktop, OpenCode, VS Code Copilot, Cursor, Windsurf, Codex, and more.

Quick Start

git clone https://github.com/luckynee/unity-prefab-parser-mcp.git
cd unity-prefab-parser-mcp
npm install && npm run build

Then add to your AI client config (see Client Setup below).

Related MCP server: Unity MCP Server

Recommended Workflow

First time on a project

1. init_unity_project   — scan .meta files, build GUID cache (once per project)
2. browse_unity_project — navigate folder tree to find the right subfolder
3. list_unity_assets    — list assets in that folder (filter by type or name)
4. parse_unity_file     — parse with preset: "compact" for token-efficient output

Subsequent sessions

Skip init_unity_project if .unity-mcp-cache.json exists and is less than 24h old. Go straight to browse_unity_project or list_unity_assets.

Example prompt

Initialize my Unity project at /path/to/MyGame, then show me all enemy prefabs.

The AI will call init_unity_project → browse_unity_project → list_unity_assets → parse_unity_file automatically.

Tools

`init_unity_project`

Scans all .meta files in a Unity project and saves a GUID→asset name cache to .unity-mcp-cache.json. Run once per project. Subsequent parse calls load from cache automatically — zero rescan cost.

{
  "projectPath": "/path/to/MyUnityProject",
  "force": false
}

projectPath — path to the Unity project root (the folder containing Assets/, ProjectSettings/)
force — force rescan even if cache is fresh (default: false)

Returns: asset count, time taken, cache file location.

`browse_unity_project`

Navigate the Unity project folder tree with asset counts per folder. Use this to find the subfolder you want before calling list_unity_assets.

{
  "projectPath": "/path/to/MyUnityProject",
  "subPath": "Assets/Enemies",
  "depth": 2
}

Example output:

Assets/
├── Enemies/          (12 prefabs)
├── UI/               (8 prefabs, 3 assets)
│   ├── HUD/          (4 prefabs)
│   └── Menus/        (4 prefabs)
├── Levels/           (5 scenes)
└── ScriptableObjects/ (23 assets)

`list_unity_assets`

List .prefab, .unity, and .asset files in a directory with absolute paths ready to paste into parse_unity_file.

{
  "directory": "/path/to/MyUnityProject/Assets/Enemies",
  "type": "prefab",
  "search": "bat",
  "recursive": true,
  "limit": 50
}

type — "prefab", "unity", "asset", or "all" (default: "all")
search — case-insensitive name filter (e.g. "enemy" returns EnemyBat.prefab, EnemyWolf.prefab)
recursive — search subfolders (default: true)
limit — max results (default: 50)

`parse_unity_file`

Parse a Unity text-serialized file and extract Inspector-visible component data as clean YAML.

{
  "filePath": "/path/to/MyUnityProject/Assets/Enemies/BatPF.prefab",
  "config": {
    "preset": "compact"
  }
}

Presets:

Preset	Token reduction	Best for
`compact`	~93–96%	LLM analysis, comparisons
`standard`	~84%	When you need GUID comments
`minimal`	~95%	Quick structural overview

You can mix preset with overrides:

{ "preset": "compact", "includeDefaultValues": true }

`parse_unity_prefab` (deprecated)

Alias for parse_unity_file. Still works for backward compatibility.

Client Setup

All clients use the same MCP server binary. Replace /path/to/unity-prefab-parser-mcp with your actual clone path.

Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "unity-prefab-parser": {
      "command": "node",
      "args": ["/path/to/unity-prefab-parser-mcp/dist/index.js"]
    }
  }
}

OpenCode

Add to your opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "unity-parser": {
      "type": "local",
      "command": ["node", "/path/to/unity-prefab-parser-mcp/dist/index.js"],
      "enabled": true
    }
  }
}

OpenCode users: copy the bundled skills and commands to your OpenCode config directory:

# Copy all three Unity skills
cp -r /path/to/unity-prefab-parser-mcp/skills/unity-asset-workflow ~/.config/opencode/skills/
cp -r /path/to/unity-prefab-parser-mcp/skills/unity-diff-workflow ~/.config/opencode/skills/
cp -r /path/to/unity-prefab-parser-mcp/skills/unity-scene-workflow ~/.config/opencode/skills/

# Copy all Unity slash commands
cp /path/to/unity-prefab-parser-mcp/commands/*.md ~/.config/opencode/commands/

Then restart OpenCode. Skills appear in /skills, commands appear in /commands.

Skill	Purpose
`unity-asset-workflow`	General workflow — init, browse, list, parse
`unity-diff-workflow`	Compare prefabs, variants, scenes across versions
`unity-scene-workflow`	Navigate large `.unity` scenes token-efficiently

Slash commands available after installing:

/unity-init [path] — initialize project cache
/unity-browse [path] — browse project tree
/unity-list [path] [type] [search] — list assets
/unity-parse [path] — parse with compact preset
/unity-diff [pathA] [pathB] — compare two prefabs or scenes
/unity-scene [path] — token-efficient scene overview

VS Code (GitHub Copilot / MCP extension)

Add to .vscode/mcp.json in your workspace, or to VS Code user settings:

{
  "mcpServers": {
    "unity-prefab-parser": {
      "command": "node",
      "args": ["/path/to/unity-prefab-parser-mcp/dist/index.js"]
    }
  }
}

The .github/copilot-instructions.md bundled in this repo is auto-read by Copilot when the repo is open — no extra config needed for workflow guidance.

Cursor / Windsurf

Add to your MCP settings (Settings → MCP → Add Server):

{
  "unity-prefab-parser": {
    "command": "node",
    "args": ["/path/to/unity-prefab-parser-mcp/dist/index.js"]
  }
}

Codex / Claude Code (CLI agents)

The AGENTS.md file bundled in this repo is auto-read by Codex and Claude Code when they run in the project directory — no extra config needed. They will follow the init → browse → list → parse workflow automatically.

Unity Serialization Requirement

This server requires Unity's text serialization format. If a file is binary, the server will reject it with a clear error.

Enable text serialization: Edit → Project Settings → Editor → Asset Serialization → Mode = Force Text

Example Output

Regular Prefab (compact mode)

prefab_name: BatPF

hierarchy: |
  BatPF (t: Player, l: Layer28)
  ├── Geometry
  └── Data

components:
  BatPF:
    Transform:
      lPos: (27.13, -6.38, 0)
    Rigidbody2D:
      mass: 3
      linearDrag: 5
      angularDrag: 6
      gravity: 0
      bodyType: 0
      sleepingMode: 1
    CircleCollider2D: {trigger: true, radius: 0.5}
  Data:
    EntityData:
      _entityName: Bat
      _walkSpeed: 1.5
      _attack: 10
      _defense: 2
      _isAlive: true

Prefab Variant (compact mode)

Variants show variant_of and only the modifications from the base prefab, grouped by GameObject and actual component/script type:

prefab_name: Buck
variant_of: Buck Base

hierarchy: |
  Buck Base  # $
  ├── AI  # $
  ├── Hitable Geometry  # $
  └── Unknown  # $

components:
  Buck Base:
    Transform:  # $
      lPos: (-42.633396, -215.17801, 0)  # $
    GameObject:  # $
      name: Buck  # $
    Seeker:  # $
      tagPenalties.array.data: 10000  # $
  AI:
    AIBrain:  # $
      states.array.size: 7  # $
      states.array.data.stateName: Exit Scene  # $
      states.array.data.transitions.array.array.data.trueState: Flee  # $
  Hitable Geometry:
    GameObject:  # $
      layer: 20  # $
  Unknown:
    AggressiveAnimalData:  # $
      _defense: 3  # $
    Animator:  # $
      ctrl: Buck Anim Controller  # $

Variant markers:

Marker	Meaning
`# $`	Modified from base
`# +`	Added (new component or GameObject)
`# -`	Removed from base

Note: Unknown GameObjects are modification targets that live 2+ levels deep in nested prefab chains — their names can't be resolved without recursive loading.

Token Cost Reference

Real measurements on production prefabs:

File	Raw YAML	Parsed compact	Reduction
Buck.prefab (variant, 38KB)	~9,600 tokens	~400 tokens	96%
Buck Base.prefab (full, 73KB)	~18,000 tokens	~1,200 tokens	93%

Operation costs:

Operation	Approx tokens
`init_unity_project`	0 (disk only)
`browse_unity_project`	~200–500
`list_unity_assets` (50 files)	~800
`parse_unity_file` compact	~150–1,200
`parse_unity_file` standard	~300–2,000
Raw Unity YAML (same file)	~5,000–50,000

Configuration Reference

Option	Type	Default	Description
`preset`	`"minimal"` \| `"standard"` \| `"compact"`	—	Use a preset
`resolveAssetNames`	boolean	`true`	Resolve GUIDs to asset names
`showAssetTypes`	boolean	`true`	Show asset type as comment
`arrayMaxElements`	number	`20`	Max array elements before summarizing
`nestedObjectDepth`	number	`4`	Max depth for nested objects
`includeTransform`	boolean	`true`	Include Transform components
`includeDisabledObjects`	boolean	`true`	Include disabled GameObjects
`includeDefaultValues`	boolean	`false`	Include properties with default values
`includeNullReferences`	boolean	`false`	Include null/empty references
`includeHierarchy`	boolean	`true`	Include hierarchy section
`componentWhitelist`	string[]	`[]`	Only include these component types
`componentBlacklist`	string[]	`[]`	Exclude these component types
`useBooleans`	boolean	`false`	Convert 0/1 to true/false
`convertBitmasks`	boolean	`false`	Convert LayerMask to layer arrays
`useTreeHierarchy`	boolean	`false`	Use tree format for hierarchy
`abbreviateFieldNames`	boolean	`false`	Shorten field names (`lPos`, `lRot`)
`omitDefaultTransforms`	boolean	`false`	Omit default position/rotation/scale
`useShortRefs`	boolean	`false`	Use `@Name` instead of `<Type:Name>`
`useParenVectors`	boolean	`false`	Use `(x, y, z)` instead of `{x, y, z}`
`inlineSimpleComponents`	boolean	`false`	Inline components with 1–2 fields
`showVariantMarkers`	boolean	`true`	Show `# $`, `# +`, `# -` markers

Supported Components

Built-in field filters for:

Transform, RectTransform
Rigidbody, Rigidbody2D
All Collider types (Box, Sphere, Capsule, Circle, Polygon, Mesh)
SpriteRenderer, MeshRenderer, SkinnedMeshRenderer, MeshFilter
Animator, Animation
AudioSource, Camera, Light
Canvas, CanvasScaler, GraphicRaycaster
UI: Image, Text, TextMeshProUGUI, Button
ParticleSystem, ParticleSystemRenderer, TrailRenderer, LineRenderer
MonoBehaviour (custom scripts — all serialized fields shown)

Project Structure

unity-prefab-parser-mcp/
├── src/
│   ├── index.ts        # MCP server, all tool definitions
│   ├── parser.ts       # Unity YAML parsing
│   ├── resolver.ts     # Reference and value resolution
│   ├── components.ts   # Component field filters and renames
│   ├── hierarchy.ts    # GameObject tree builder
│   ├── formatter.ts    # YAML output formatter
│   ├── config.ts       # Configuration and presets
│   ├── cache.ts        # Meta file GUID cache
│   └── variant.ts      # Prefab variant detection
├── skills/
│   ├── unity-asset-workflow/
│   │   └── SKILL.md    # General workflow (init, browse, list, parse)
│   ├── unity-diff-workflow/
│   │   └── SKILL.md    # Compare prefabs, variants, scenes
│   └── unity-scene-workflow/
│       └── SKILL.md    # Navigate large scenes token-efficiently
├── commands/
│   ├── unity-init.md   # /unity-init [path]
│   ├── unity-browse.md # /unity-browse [path]
│   ├── unity-list.md   # /unity-list [path] [type] [search]
│   ├── unity-parse.md  # /unity-parse [path]
│   ├── unity-diff.md   # /unity-diff [pathA] [pathB]
│   └── unity-scene.md  # /unity-scene [path]
├── test/
│   └── parser.test.ts  # Test suite (103 tests)
├── AGENTS.md           # Auto-read by Codex and Claude Code
├── .github/
│   └── copilot-instructions.md  # Auto-read by GitHub Copilot
├── package.json
└── tsconfig.json

Development

npm install       # install dependencies
npm run build     # compile TypeScript
npm test          # run test suite (103 tests)
npm run dev       # run with tsx (no build needed)

License

MIT

Available Tools

5 tools

browse_unity_projectA

Browse the Unity project folder tree with asset counts. Use this to navigate large projects and find the subfolder containing the assets you want to work with.

WORKFLOW:

init_unity_project (once)
browse_unity_project (navigate to the right folder)
list_unity_assets (list assets in that folder)
parse_unity_file (parse specific assets)

ParametersJSON Schema

Name	Required	Description
`depth`	No	How many folder levels to show. Default: 2.
`subPath`	No	Subfolder to browse relative to Assets/. Omit to browse Assets/ root.
`projectPath`	Yes	Unity project root path (must have been initialized with init_unity_project first, or will auto-init).

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden. It discloses that browsing shows asset counts, that it requires initialization but can auto-init, and it positions the tool within a workflow. However, it does not detail the exact return structure or whether the operation is purely read-only, though browsing implies this.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and front-loaded with the main purpose, followed by a clear numbered workflow. Every sentence adds value, with no filler or repetition.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 3 parameters and no output schema, the description provides sufficient context through the workflow and usage guidance. It could mention the tree-like nature of the output explicitly, but the information provided is enough for an agent to invoke the tool correctly in sequence.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already has 100% description coverage and clear parameter descriptions (projectPath, depth, subPath). The description adds workflow context but does not elaborate further on parameter semantics beyond what the schema provides, so 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.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Browse the Unity project folder tree with asset counts.' This uses a specific verb ('browse') and resource ('Unity project folder tree'), and the workflow list differentiates it from sibling tools like listing assets or parsing files.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly provides a workflow ('init_unity_project → browse_unity_project → list_unity_assets → parse_unity_file') and states when to use this tool: 'Use this to navigate large projects and find the subfolder containing the assets you want to work with.' This gives clear context and distinguishes it from alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

init_unity_projectA

Initialize a Unity project for use with this MCP. Scans all .meta files to build a GUID→asset name cache, enabling full asset name resolution in parse_unity_file.

WORKFLOW: Call this ONCE per project before using parse_unity_file or browse_unity_project. The cache is saved to .unity-mcp-cache.json in the project root and reused automatically.

For large projects (100GB+), this may take 10-30 seconds but only needs to run once per session or when assets change significantly.

ParametersJSON Schema

Name	Required	Description	Default
`force`	No	Force rescan even if cache exists. Default: false.
`projectPath`	Yes	Path to Unity project root (the folder containing Assets/, ProjectSettings/, etc.). Required.

TDQS

A4.4/5.0

Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries full burden. It reveals the cache file location (.unity-mcp-cache.json), automatic reuse, and performance characteristics for large projects. However, it doesn't detail potential side effects on existing project files beyond creating the cache.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Three short paragraphs with clear front-loading: purpose first, workflow second, performance last. Every sentence earns its place, making it concise and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers purpose, workflow, prerequisites, and performance. It lacks explicit return value details, but there is no output schema and the tool is an initialization routine, so the provided information is mostly sufficient.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, with both parameters already described. The description adds no additional parameter-level semantics beyond what the schema provides, so baseline 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool initializes a Unity project for MCP use by building a GUID→asset name cache from .meta files. It distinguishes itself from siblings by being the required setup step for parse_unity_file and browse_unity_project.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly instructs to call ONCE per project before using parse_unity_file or browse_unity_project, and explains reuse and when to force rescan. This gives clear when-to-use and workflow context, directly guiding the agent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_unity_assetsA

Scan a directory for Unity asset files (.prefab, .unity, .asset) and return a grouped list with absolute paths ready to use with parse_unity_file.

ParametersJSON Schema

Name	Required	Description
`type`	No	Filter by file type. Default: all
`exact`	No	When true, only match files whose name (without extension) exactly equals the search term. E.g. search:"bat" exact:true returns Bat.prefab, BatPF.prefab but NOT CombatText.prefab. Default: false.
`limit`	No	Maximum number of results to return. Default: 50.
`search`	No	Filter assets by name (case-insensitive substring). E.g. "enemy" returns EnemyBat.prefab, EnemyWolf.prefab etc.
`directory`	No	Directory to scan. Can be a Unity project root, an Assets folder, or any subfolder. If omitted, uses current working directory.
`recursive`	No	Search recursively. Default: true

TDQS

A4/5.0

Behavior3/5

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 states the tool scans and returns a list, implying a read-only operation, but does not explicitly confirm non-destructiveness, error handling, or the nature of 'grouping'. This is adequate but leaves gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that efficiently conveys the action, target, and output. No filler or redundancy, and it even includes a workflow hint about parse_unity_file.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with six parameters, no output schema, and no annotations, the description covers the core purpose and output type. It could clarify what 'grouped' means and mention default/error behavior, but combined with the rich schema it is nearly sufficient for typical use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100% and all six parameters have rich descriptions (e.g., exact matching, default values). The tool description adds nothing about parameters beyond what the schema already provides, so a baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb ('Scan'), names the exact resource (directory for Unity asset files with .prefab, .unity, .asset), and clarifies the output (grouped list with absolute paths). This clearly distinguishes it from sibling tools like parse_unity_file and browse_unity_project.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the tool is used to discover files for subsequent parsing ('ready to use with parse_unity_file'), offering clear context. However, it does not explicitly mention alternatives or when not to use this tool, so it falls short of the highest bar.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

parse_unity_fileA

Parse a Unity text-serialized prefab, scene, or asset file and extract Inspector-visible component data in YAML format.

WORKFLOW: For best results with asset name resolution, call init_unity_project first. If already initialized, the cache is loaded automatically.

Automatically resolves asset names from GUIDs by scanning the project's .meta files (or using the initialized cache). Outputs a clean, hierarchical structure showing the GameObject tree and all component data.

IMPORTANT: Fields not shown in output have their default values or are null references.

Transform: lPos (0,0,0), lRot (0,0,0,1), lScale (1,1,1) are omitted when default
Null references and unresolved GUIDs are omitted
enabled:true is omitted (only enabled:false is shown)

Features:

Resolves script, material, sprite, and other asset references to human-readable names
Filters out Unity internal fields (m_ObjectHideFlags, serializedVersion, etc.)
Renames fields to match Unity Inspector names (m_LocalPosition -> localPosition)
Supports configurable detail levels: minimal, standard, or compact
Prefab Variant Support:
- Auto-detects prefab variants and nested prefab instances
- Shows variant_of field with base prefab name
- Groups all modifications under base prefab name
- Merges Vector3 properties (x, y, z -> single vector)
- Filters default values and null references
- Adds # + markers for variant modifications
Compact mode optimizations (83% token reduction):
- Short reference syntax (@Player instead of GameObject:Player)
- Parentheses vector notation: (1, 2, 3) instead of {x:1, y:2, z:3}
- Field abbreviations: lPos, lRot, lScale, trigger, order, mats
- Inline simple components: {value: 42, active: true}
- Omits null/Unknown references entirely
- Omits enabled:true, default offsets, flipX/flipY:false
- Removes redundant sortingLayerID (keeps sortingLayer)
- Converts 0/1 to true/false for boolean fields
- Converts bitmasks to layer arrays or 'all'
- Simplifies Unity events to show method names

ParametersJSON Schema

Name	Required	Description	Default
`config`	No	Optional configuration (uses "standard" preset if omitted)
`filePath`	Yes	Absolute path to the .prefab, .unity, or .asset file

TDQS

A4.4/5.0

Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It exhaustively documents output behavior: omitted fields (default values, null references, enabled:true), unity internal field filtering, field renaming to Inspector names, prefab variant handling, and compact mode optimizations. It also details specific examples like 'lPos (0,0,0)' and 'short reference syntax (@Player)'. This is exceptionally transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is long but well-structured with clear sections (WORKFLOW, IMPORTANT, Features, Prefab Variant Support, Compact mode optimizations). It is front-loaded with the core purpose and workflow, and each section adds relevant details. While some information could be trimmed (e.g., extensive compact mode enumeration), it is appropriate for the tool's complexity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (2 params with nested config, no output schema), the description is remarkably complete. It explains the output structure ('hierarchical structure showing the GameObject tree and all component data'), default value handling, reference resolution, and edge cases like prefab variants. It fully compensates for the lack of an output schema and provides context for all config options.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% for filePath and config properties, so the baseline is 3. The description adds substantial meaning beyond the schema, particularly for the 'preset' parameter by explaining presets (minimal, standard, compact) and detailing compact mode optimizations with token reduction percentages, syntax examples, and abbreviation conventions. This elevates the parameter understanding significantly.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's function: 'Parse a Unity text-serialized prefab, scene, or asset file and extract Inspector-visible component data in YAML format.' The verb 'Parse' and resource 'Unity text-serialized prefab, scene, or asset file' are specific. It distinguishes from siblings like parse_unity_prefab by explicitly covering prefabs, scenes, and assets, implying a broader file parser.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides a clear workflow: 'For best results with asset name resolution, call init_unity_project first. If already initialized, the cache is loaded automatically.' However, it does not explicitly state when to choose this over parse_unity_prefab or other sibling tools, nor does it mention exclusions or alternatives beyond the init prerequisite. This is a gap in usage differentiation.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

parse_unity_prefabA

Deprecated alias for parse_unity_file. Use parse_unity_file for new clients.

WORKFLOW: For best results with asset name resolution, call init_unity_project first. If already initialized, the cache is loaded automatically.

ParametersJSON Schema

Name	Required	Description	Default
`config`	No	Optional configuration (uses "standard" preset if omitted)
`filePath`	Yes	Absolute path to the .prefab, .unity, or .asset file

TDQS

A3.9/5.0

Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description discloses the deprecated status and the automatic cache-loading behavior. With no annotations, it adds some transparency, but it does not mention return structure, side effects, or error behaviors, leaving gaps in the tool's safety and outcome profile.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and effectively front-loaded with the deprecation notice. The WORKFLOW section adds relevant context without redundancy, making every sentence purposeful and well-structured.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

As a deprecated alias, the description appropriately points to parse_unity_file for core behavior, but it doesn't explain return values or deeper operational details, especially without an output schema. The workflow note adds some completeness, but the description remains dependent on the sibling tool for full context.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema fully describes both filePath and config parameters, and the description adds no additional parameter-level details. This meets the baseline but does not exceed what the schema already provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description identifies the tool as a deprecated alias for parse_unity_file, which clarifies its purpose by referencing the canonical tool. However, it does not independently describe what parsing entails, relying on the sibling tool's definition for full clarity.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly instructs users to adopt parse_unity_file for new clients, and provides a workflow step to call init_unity_project first. This directly distinguishes when to use this tool vs alternatives and offers clear contextual guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

5 tool updatesv1.1.0Aug 9, 2026
- First observedbrowse_unity_project
- First observedinit_unity_project
- First observedlist_unity_assets
- First observedparse_unity_file
- First observedparse_unity_prefab

Install Server

RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4.3/5.0

Disambiguation4/5

Most tools are distinct and clearly scoped, but parse_unity_file and parse_unity_prefab are duplicates, even though the latter is explicitly marked as deprecated. This could cause an agent to accidentally select the wrong one.

Naming Consistency5/5

All tool names follow a consistent verb_noun snake_case pattern (init_, browse_, parse_, list_). Even the deprecated alias parse_unity_prefab follows the same pattern, maintaining predictability.

Tool Count5/5

Five tools is a well-scoped set for a parser MCP. Each tool serves a clear step in the workflow: initialize, browse, list, and parse. No unnecessary bloat or missing core functionality.

Completeness5/5

The tool surface covers the full read-only workflow: project initialization for caching, navigation, asset discovery, and detailed parsing. The deprecated alias is redundant but doesn't create a functional gap. No obvious missing operations for the stated domain.

Maintenance

ActivityInactive

ResponsivenessNo issues

Resources

GitHub Repository

Need Help?

Related Servers

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

pinion05-supabase-mcp-lite
ai.smithery
Same functionality, consuming only 1/20 of the context window tokens.
Databases RAG Systems Vector Databases
22
ocr A
com.pennyocr
Read PDFs and images as markdown or text, with exact costs and hard spend caps. $0.75/1k pages.
Image & Video Processing AI & Machine Learning
21
stagenth · 文档解析 A
com.stagenth
Parse PDF/Word/PPT/HTML to Markdown; tables as JSON, image extraction, RAG chunking, page ranges.
RAG Systems File Systems
42
StructForge B
app.askqa
Turn messy text into strict JSON schemas agents can trust (invoice, receipt, contact, resume).
AI & Machine Learning Data Platforms
61

Related MCP Servers

Unity MCP Server
Developer Tools File Systems Documentation Access
rachitkumarrastogi
F
license
B
quality
B
maintenance
Provides AI assistants with structured access to Unity project metadata, build settings, and agent documentation directly from the filesystem. It enables querying project details and scene configurations without requiring the Unity Editor to be running.
Updated a month ago (2026-08-04 21:55 UTC)
100
124
5
-
Unity MCP Server
Developer Tools Coding Agents App Automation
coolmew
A
license
Not graded
quality
Not graded
maintenance
Exposes Unity Editor project context and manipulation tools to AI coding agents, enabling automated scene hierarchy analysis, script inspection, and asset management. It supports both read and write operations including GameObject editing, component configuration, and animation authoring within the Unity environment.
Updated 6 months ago (2026-03-11 21:09 UTC)
2
-
SpatialLens
Developer Tools AI & Machine Learning
RevivrStudios
F
license
Not graded
quality
D
maintenance
Parses USD/USDZ/USDA files into structured JSON for AI agents, enabling scene graph hierarchy, material shader graphs, spatial positions, and entity relationship analysis via CLI and MCP tools.
Updated 5 months ago (2026-03-22 15:18 UTC)
-
prefab-sentinel
File Systems Code Analysis Developer Tools
tyunta
A
license
Not graded
quality
A
maintenance
MCP server for safely inspecting and editing Unity/VRChat prefabs, scenes, and assets. It diagnoses override collisions, broken references, and runtime exceptions, with read-only YAML analysis and write operations via an Editor Bridge.
Updated 21 days ago (2026-08-15 22:17 UTC)
11
MIT

Latest Blog Posts

Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)
By Om-Shree-0709 on July 25, 2026.
mcp
Agent Identity
OAuth 2.1
Your AI Chatbot Just Exposed Your CEO's Salary to an Intern
By Om-Shree-0709 on July 2, 2026.
Agent Identity
MCP Security
OAuth Delegation
Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)
By Om-Shree-0709 on June 30, 2026.
Agentic Ai
Prompt Injection
WebAssembly

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/luckynee/unity-prefab-parser-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server

Unity Prefab Parser MCP Server

Quick Start

Recommended Workflow

First time on a project

Subsequent sessions

Example prompt

Tools

init_unity_project

browse_unity_project

list_unity_assets

parse_unity_file

parse_unity_prefab (deprecated)

Client Setup

Claude Desktop

OpenCode

VS Code (GitHub Copilot / MCP extension)

Cursor / Windsurf

Codex / Claude Code (CLI agents)

Unity Serialization Requirement

Example Output

Regular Prefab (compact mode)

Prefab Variant (compact mode)

Token Cost Reference

Configuration Reference

Supported Components

Project Structure

Development

License

Available Tools

Tool Schema Changelog

Maintenance

Resources

Looking for Admin?

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

`init_unity_project`

`browse_unity_project`

`list_unity_assets`

`parse_unity_file`

`parse_unity_prefab` (deprecated)