Unity-MCP

Automatically exposes any C# method as an MCP tool through a single-line attribute decorator, using .NET reflection to introspect method signatures, parameters, and return types at runtime. The system dynamically generates tool schemas compatible with Claude, Gemini, and OpenAI function-calling APIs without manual schema definition. This enables game developers to expose custom gameplay logic, editor utilities, or game systems directly to AI clients without boilerplate tool registration code.

Implements the Model Context Protocol (MCP) as an ASP.NET Core server that communicates with AI clients (Claude Code, Gemini, Copilot, Cursor) via SignalR WebSocket connections. The server translates MCP protocol messages into Unity Editor API calls and streams responses back asynchronously. This architecture enables real-time, low-latency interaction between AI clients and the Unity Editor running on a developer's machine, with automatic server binary management and multi-platform support (Windows, macOS, Linux).

Provides a framework for developers to create custom MCP tools by implementing C# methods with `[MCPTool]` attributes, with automatic schema generation, parameter validation, and error handling. The framework handles serialization/deserialization of complex types, supports async methods, and integrates with the MCP protocol automatically. Developers focus on business logic while the framework handles protocol compliance and client communication.

Abstracts IDE-specific MCP client implementations (Claude Code, Cursor, Windsurf, VS Code with Copilot) through a unified server interface that works identically across all clients. The system handles IDE-specific configuration formats, authentication mechanisms, and UI integration points. Developers configure Unity-MCP once and it works seamlessly with any MCP-compatible IDE without additional setup.

Implements strategies to minimize LLM token consumption by selectively exposing only relevant scene data, caching frequently-accessed resources, and pruning large hierarchies based on AI client interest. The system can filter GameObject hierarchy to show only relevant branches, compress asset metadata, and cache scene snapshots to avoid re-serializing unchanged data. This reduces token costs for long-running AI sessions and enables more complex reasoning within token budgets.

Exposes the Unity GameObject hierarchy as queryable resources through the MCP resource API, allowing AI clients to inspect scene structure, component composition, and property values in real-time. Implements reflection-based component property reading and writing, enabling AI agents to understand the current game state and modify GameObjects, components, and their properties through natural language commands. The system maintains a live view of the hierarchy that updates as the scene changes.

Enables AI clients to generate, modify, and compile C# scripts directly within the Unity Editor through MCP tools. The system handles script creation, code insertion/replacement, and triggers Unity's recompilation pipeline, providing real-time feedback on compilation errors. AI agents can write gameplay logic, editor tools, or utility scripts and immediately test them without manual file editing or IDE switching.

Exposes Unity's asset import pipeline and metadata system to AI clients, enabling them to configure import settings for textures, models, audio, and other assets without manual Inspector interaction. The system uses reflection to read/write asset importer properties and can trigger re-imports. AI agents can optimize asset settings (compression, format, LOD groups) based on project requirements or performance targets.

Integrates with Unity's Test Framework (UTF) to enable AI clients to discover, execute, and analyze test results through MCP tools. The system can run unit tests, integration tests, and play mode tests, capture output and assertions, and report pass/fail status back to the AI client. This enables AI agents to validate code changes, detect regressions, and guide development toward passing tests.

Abstracts differences between Claude, Gemini, OpenAI, and other LLM providers through a unified MCP client interface, handling provider-specific function-calling schemas, authentication, and response parsing. Developers configure their preferred LLM provider once, and all MCP tools work identically across providers without code changes. The system manages API keys, rate limiting, and provider-specific quirks transparently.

Provides a command-line interface for initializing Unity-MCP in a project, downloading platform-specific server binaries, configuring MCP clients (Claude Code, Cursor, Windsurf), and managing server startup/shutdown. The CLI automates the entire setup process, detecting the OS, downloading the correct binary, and generating configuration files for AI clients. Developers can get a fully functional AI-integrated Unity project running with a single command.

Packages the MCP server as a Docker image (ivanmurzakdev/unity-mcp-server:latest) that can be deployed to cloud environments, CI/CD pipelines, or remote machines. The Docker image includes the ASP.NET Core runtime and all dependencies, enabling deployment without requiring .NET installation on the target system. Supports multi-platform builds (Linux x86_64, ARM64) for deployment to various cloud providers and edge devices.

Implements MCP resource subscriptions that stream real-time updates of scene state, GameObject hierarchy changes, and property modifications to AI clients. When the scene changes (GameObjects added/removed, properties modified), the system automatically pushes updates through the SignalR connection without requiring the AI client to poll. This enables AI agents to maintain an up-to-date mental model of the game state and react to changes in real-time.