Scene (8)

GameObject (2)

Component (1)

Asset (6)

VFX (1)

Build & Testing (2)

Editor (7)

Console & Profiling (2)

UI Toolkit (6)

Guide & Diagnostics (2)

Export (1)

Recipes (2)

Canvas UI (4)

Input (1)

Search (1)

Utility (1)

Debug (4)

Scene

• scene://loaded — All currently loaded scenes and their status

Editor

• editor://state — Current editor state (play mode, compiling, focus, etc.)
• editor://selection — Currently selected objects in the editor
• editor://windows — Open editor windows and their states
• editor://prefab_stage — Current prefab editing stage information
• editor://active_tool — Currently active editor tool (Move, Rotate, Scale, etc.)

Project

• project://info — Project path, name, and Unity version
• project://tags — Project tags
• project://layers — Project layers and their indices
• project://player_settings — Player settings including icons, resolution, and platform settings
• project://quality — Quality settings and all quality levels
• project://physics — Physics settings including gravity, solver iterations, and layer collision matrix
• project://audio — Audio settings including speaker mode, DSP buffer, and sample rate
• project://input — Input system actions and bindings, or legacy input axes
• project://rendering — Rendering settings including render pipeline, ambient lighting, and fog

Build & Packages

• build://settings — Build target, scenes, and configuration
• packages://installed — Installed packages and their versions

Console & Tests

• console://summary — Error/warning/info counts from the console
• console://errors — Detailed compilation/runtime errors with file paths and line numbers
• tests://list — Available unit tests
• profiler://state — Profiler recording status and configuration

Menu

• menu://items — Available Unity Editor menu items

UI

• ui://unitymcp/scene-preview.html — Scene preview widget HTML for inline display

Resource Templates

These use URI parameters to query specific objects:

• scene://gameobject/{id} — GameObject details by instance ID
• scene://gameobject/{id}/components — List of components on a GameObject
• scene://gameobject/{id}/component/{type} — Specific component details on a GameObject
• tests://list/{mode} — Tests filtered by mode (EditMode or PlayMode)
• animation://controller/{path} — AnimatorController details including layers, parameters, and state machines
• assets://dependencies/{path} — Asset dependencies — what an asset uses and what uses it

• read_gameobject — Inspect a GameObject's transform, components, and optionally its children

  • name (required) — Name of the GameObject to inspect
  • include_children — Whether to include the children hierarchy (true/false)

• inspect_prefab — Examine a prefab asset by path

  • path (required) — Path to the prefab asset (e.g., Assets/Prefabs/Player.prefab)

• modify_component — Step-by-step guide to safely change a component property

  • target (required) — Name or path of the target GameObject
  • component (required) — Component type to modify (e.g., Rigidbody, BoxCollider)
  • property (required) — Property to modify (e.g., mass, isTrigger)

• setup_scene — Set up a new scene with appropriate defaults for 3D, 2D, or UI

  • scene_type — Type of scene: 3d, 2d, or ui (default: 3d)

• fps_prototype — Creates a basic FPS prototype scene with player capsule, ground plane, directional light, and camera at eye height

  • ground_size — Ground plane size (10–1000, default: 100)

• ui_canvas — Creates a Canvas with EventSystem and a 3-panel layout (header, content, footer)

• 3d_scene_template — Creates a basic 3D scene with directional light, ground plane, and camera positioned at (0, 5, -10)

• physics_playground — Creates a physics playground with a ground plane, three ramps (15°/30°/45°), five spheres, and three cubes — all with Rigidbodies

There are two ways to define tools: an action-based tool for grouping related operations under one tool name, and a single-method tool for standalone operations.

Action-based tools (recommended for related operations)

Place [MCPTool] on a static class and [MCPAction] on each action method. The framework generates a unified JSON schema with a required action enum parameter.

using UnityEditor;
using UnityMCP.Editor;
using UnityEngine;

[MCPTool("enemy_manager", "Manage enemies in the scene", Category = "Gameplay")]
public static class EnemyManagerTool
{
    [MCPAction("spawn", Description = "Spawn an enemy at a position",
        DestructiveHint = true)]
    public static object Spawn(
        [MCPParam("type", "Enemy type", required: true,
            Enum = new[] { "goblin", "skeleton", "dragon" })] string type,
        [MCPParam("x", "X position", required: true)] float x,
        [MCPParam("y", "Y position", required: true)] float y,
        [MCPParam("z", "Z position", required: true)] float z)
    {
        GameObject enemy = new GameObject($"Enemy_{type}");
        enemy.transform.position = new Vector3(x, y, z);
        return new { instanceID = enemy.GetInstanceID(), type };
    }

    [MCPAction("list", Description = "List all enemies in the scene",
        ReadOnlyHint = true)]
    public static object List()
    {
        var enemies = GameObject.FindGameObjectsWithTag("Enemy");
        return new { count = enemies.Length };
    }

    [MCPAction("despawn", Description = "Remove an enemy from the scene",
        DestructiveHint = true)]
    public static object Despawn(
        [MCPParam("instance_id", "Instance ID of the enemy to remove",
            required: true)] int instanceId)
    {
        var target = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
        if (target == null) return new { success = false, error = "Enemy not found." };
        Object.DestroyImmediate(target);
        return new { success = true };
    }
}

Annotation resolution for action-based tools:

• destructiveHint = true if any action has DestructiveHint = true
• readOnlyHint = true only if all actions have ReadOnlyHint = true

The server uses per-action metadata to tell AI assistants which specific actions warrant a checkpoint before proceeding, rather than flagging the entire tool.

Single-method tools (for standalone operations)

Place [MCPTool] directly on a static method:

using UnityMCP.Editor;
using UnityEngine;

public static class MyCustomTools
{
    [MCPTool("hello_world", "Says hello to the specified name")]
    public static string SayHello(
        [MCPParam("name", "Name to greet", required: true)] string name)
    {
        return $"Hello, {name}!";
    }

    [MCPTool("spawn_enemy", "Spawn an enemy at a position with difficulty scaling",
        Category = "Gameplay", DestructiveHint = true)]
    public static object SpawnEnemy(
        [MCPParam("enemy_type", "Type of enemy to spawn", required: true,
            Enum = new[] { "goblin", "skeleton", "dragon" })] string enemyType,
        [MCPParam("x", "X position", required: true)] float x,
        [MCPParam("y", "Y position", required: true)] float y,
        [MCPParam("z", "Z position", required: true)] float z,
        [MCPParam("difficulty", "Difficulty multiplier (1–10)",
            Minimum = 1, Maximum = 10)] float difficulty = 5)
    {
        GameObject enemy = new GameObject($"Enemy_{enemyType}");
        enemy.transform.position = new Vector3(x, y, z);

        return new
        {
            instanceID = enemy.GetInstanceID(),
            type = enemyType,
            difficulty
        };
    }
}

Tools are automatically discovered on domain reload. No registration needed.

Tool annotations

Set annotations on [MCPTool] for single-method tools, or on [MCPAction] for per-action accuracy on action-based tools.

Parameter constraints

Constraints are included in the JSON Schema sent to AI assistants:

Resources expose read-only data to AI assistants via URI patterns. Use [MCPResource]:

using UnityMCP.Editor;
using UnityEngine;

public static class MyCustomResources
{
    [MCPResource("unity://player/stats", "Current player statistics")]
    public static object GetPlayerStats()
    {
        var player = GameObject.Find("Player");
        if (player == null)
            return new { error = "Player not found" };

        return new
        {
            position = player.transform.position,
            health = player.GetComponent<Health>()?.CurrentHealth ?? 0,
            isGrounded = player.GetComponent<CharacterController>()?.isGrounded ?? false
        };
    }
}

Resources are read via resources/read using their URI (e.g., unity://player/stats). They are automatically discovered on domain reload.

Prompts provide reusable workflow templates for AI assistants. Use [MCPPrompt]:

using System.Collections.Generic;
using UnityMCP.Editor;
using UnityMCP.Editor.Core;

public static class MyCustomPrompts
{
    [MCPPrompt("debug_gameobject", "Debug a GameObject by inspecting its state")]
    public static PromptResult DebugGameObject(
        [MCPParam("name", "Name of the GameObject to debug", required: true)] string name,
        [MCPParam("verbose", "Include full component details (true/false)")] string verbose = "false")
    {
        bool isVerbose = verbose?.ToLower() == "true";

        string instructions = $@"Debug the GameObject ""{name}"" using these steps:

1. Use `find_gameobject` with search_term=""{name}"" to locate it
2. Use `manage_component` with action=""inspect"" to check each component";

        if (isVerbose)
        {
            instructions += $@"
3. Use `read_console` with filter=""{name}"" to check for related log messages";
        }

        return new PromptResult
        {
            description = $"Debug instructions for '{name}'",
            messages = new List<PromptMessage>
            {
                new PromptMessage
                {
                    role = "user",
                    content = new PromptMessageContent
                    {
                        type = "text",
                        text = instructions
                    }
                }
            }
        };
    }
}

Recipes are reusable scene setup templates invoked via execute_recipe. Use [MCPRecipe] on a static method:

using UnityMCP.Editor;

public static class MyRecipes
{
    [MCPRecipe("my_scene_setup", "Creates a custom scene layout")]
    public static object MySceneSetup(
        [MCPParam("size", "World size", Minimum = 10, Maximum = 500)] float size = 50)
    {
        // Create your scene objects here...
        return new { success = true, summary = "Scene created" };
    }
}

Recipes are automatically discovered on domain reload and appear in list_recipes output.