Ultimate Unreal Engine MCP
133 tools. 26 domains. Full read/write access to Unreal Engine 5.7 — including live editor APIs, Blueprint graphs, and viewport screenshots.
MCP (Model Context Protocol) is a standard that lets AI assistants call tools on external systems — this server exposes Unreal Engine as those tools.
npx ultimate-unreal-engine-mcp setup
Table of Contents
- Quick Start
- What You Can Do
- Architecture
- Tool Catalog
- Visual Review Loop
- Automatic Self-Verification
- Headless vs Live
- Installation
- C++ Plugin Setup
- Configuration
- Development
- Requirements
- License
Quick Start
# Claude Desktop (default)
npx ultimate-unreal-engine-mcp setup
# Claude Code CLI
npx ultimate-unreal-engine-mcp setup --client claude-code
# Cursor
npx ultimate-unreal-engine-mcp setup --client cursor
# With a UE project (also installs the C++ plugin)
npx ultimate-unreal-engine-mcp setup --project "C:/MyGame"
This command writes the correct config for your client. The C++ plugin is optional — file-system tools (C++ parsing, code gen, configs, builds, docs) work without it. Install the plugin for live editor tools (Blueprints, actors, viewport, screenshots).
Zero optional dependencies. The C++ plugin compiles on any UE 5.7 install — binary or source. All 133 tools use runtime reflection for optional UE modules (MetaSound, LiveLink, GAS, etc.), so the plugin loads regardless of which plugins your project has enabled. Handlers gracefully report when their target module isn't available.
What You Can Do
The following walkthrough shows AI autonomously setting up a point light, doing a visual review loop, and correcting an intensity problem — all without leaving the conversation.
Prompt: "Spawn a point light named MainLight at the center of the level, set its intensity to 5000, then take a screenshot so I can review it."
Step 1 — Spawn the actor
ue_spawn_actor(class="PointLight", label="MainLight", location={x:0, y:0, z:300})
Claude: Actor
MainLightspawned at (0, 0, 300). UE returnedactor_id: "PointLight_0".
Step 2 — Navigate camera to the actor
ue_look_at(target="MainLight", angle="45deg", screenshot=true)
Claude: Camera positioned. [Screenshot returned inline — shows a bright white sphere flooding the scene with overexposed light.]
Step 3 — Visual review — something is wrong
ue_visual_review(focus="check if the lighting looks blown out")
Claude: The scene is severely overexposed. The intensity of 5000 lm is too high for this room scale. Reducing to 800 lm.
Step 4 — Adjust the property
ue_transform_actor(label="MainLight", properties={"Intensity": 800})
Claude: Property
Intensityupdated to 800 onMainLight.
Step 5 — Verify the fix
ue_orbit_review(target="MainLight", angles=[0, 90, 180, 270])
Claude: [Four screenshots returned — front, right, back, left.] Lighting is balanced. No blown-out surfaces visible from any angle. The area is well-lit without overexposure.
Step 6 — Cleanup
ue_cleanup_screenshots(confirm=true)
Claude: 5 MCP-generated screenshots removed from disk.
This loop — spawn, navigate, inspect, adjust, verify — runs entirely from the AI conversation. No manual editor interaction required.
Architecture
graph TD
A["AI Client\n(Claude / Cursor / VS Code)"]
B["MCP Protocol\n(stdio JSON-RPC)"]
C["TypeScript Server\nNode.js 22+"]
D["TCP Port 55557"]
E["C++ Plugin\nMCPBridge"]
F["UE 5.7 Editor APIs"]
A -->|tool calls| B
B --> C
C -->|file system ops\nC++ parsing\nconfig r/w\ndocs lookup\nbuild trigger| C
C -->|actor CRUD\nBlueprint graphs\nviewport screenshots\nPIE control\nasset registry| D
D --> E
E --> F
classDef ts fill:#3178c6,color:#fff,stroke:#2563eb
classDef cpp fill:#f97316,color:#fff,stroke:#ea580c
classDef ue fill:#76b900,color:#fff,stroke:#65a000
classDef proto fill:#6b7280,color:#fff,stroke:#4b5563
class C ts
class E cpp
class F ue
class B,D proto
TypeScript layer handles all file system operations without requiring the editor to be open: C++ header parsing (tree-sitter-unreal-cpp), INI config read/write, code generation, documentation lookup, and build triggering via UnrealBuildTool.
C++ plugin layer (MCPBridge) provides live editor access: actor CRUD, Blueprint graph read/write, viewport screenshots with inline base64 images, PIE session control, asset registry queries, and all other operations that require the UE Editor process.
Tool Catalog
Visual Review Loop
The Viewport & Visual Review domain enables an AI to navigate, see, judge, and act — autonomously.
navigate → screenshot → inspect → adjust → verify → cleanup
Core tools:
What makes this different: Screenshots are returned as inline base64 images in the MCP response. The AI receives and interprets the image in the same tool call — no file paths to resolve, no secondary reads. The AI can see the scene, evaluate it, and call the next tool in the same turn.
Typical loop:
ue_look_at("TargetActor", angle="45deg")
→ [image inline] AI sees overexposed area
ue_transform_actor("TargetActor", {"Intensity": 500})
→ property updated
ue_orbit_review("TargetActor", angles=[0, 90, 180, 270])
→ [4 images inline] all clear from every angle
ue_cleanup_screenshots(confirm=true)
→ disk cleaned
Automatic Self-Verification
Verification isn't a suggestion. It's server-side enforced. Every mutating tool automatically queries actor.componentBounds after the mutation completes and appends the verification data to the response. The AI sees bounds, positions, and component state in the same tool call result, whether it asked for it or not. If something is wrong, the data is right there and impossible to miss.
Why this matters: In spatial work (placing doors, aligning meshes, wiring components), a single transform can have cascading effects — rotating a mesh around a pivot shifts its world position, negative scale flips face normals making geometry invisible, collision volumes don't automatically follow mesh offsets. Without verification, the AI reports "done" while the door is floating 2 meters from the wall.
How it works:
ue_spawn_actor("BP_Door", location={x:1040, y:150, z:0})
→ {actor_label: "BP_Door", _verification: {bounds: {min: {x:806}, max: {x:994}}}}
← bounds auto-appended by server — in the doorway ✓
ue_set_actor_property("BP_Door", "DoorMesh.RelativeRotation", ...)
→ {success: true, _verification: {bounds: {min: {x:1040}, max: {x:1228}}}}
← bounds shifted! rotation moved mesh out of gap ✗
ue_set_actor_property("BP_Door", "DoorMesh.RelativeLocation", ...)
→ {success: true, _verification: {bounds: {min: {x:806}, max: {x:994}}}}
← back in place after offset compensation ✓
ue_look_at("BP_Door", angle="front")
→ [screenshot inline] door visible, handle correct side ✓
The Inspect-Reason-Fix cycle:
The AI also has access to a ue://best-practices/self-verification MCP resource that documents verification patterns, common spatial pitfalls, and the full verification matrix.
Headless vs Live
Some tools work without the UE Editor running. Others require the MCPBridge plugin connected to a live editor instance.
The TypeScript server starts in headless mode by default. Tools that require the plugin return a structured plugin_not_connected error with a clear message — they never silently fail.
When the plugin IS running but an optional UE module isn't enabled (e.g., MetaSound, LiveLink, GAS), the handler returns module_not_available with the module name — no crash, no missing DLL errors. Enable the plugin in your project settings and the handler starts working automatically.
Installation
Option 1: npx (quickest)
npx ultimate-unreal-engine-mcp setup
Detects your MCP client and writes the config automatically.
Option 2: Global install
npm install -g ultimate-unreal-engine-mcp
ultimate-unreal-engine-mcp setup
Option 3: Clone for development
git clone https://github.com/your-org/ultimateunrealenginemcp
cd ultimateunrealenginemcp
npm install
npm run build
Client configuration
Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json on macOS, %APPDATA%\Claude\claude_desktop_config.json on Windows):
{
"mcpServers": {
"unreal": {
"command": "npx",
"args": ["ultimate-unreal-engine-mcp"],
"env": {
"UE_PROJECT_ROOT": "/path/to/your/UEProject",
"UE_PLUGIN_PORT": "55557"
}
}
}
}
Cursor (.cursor/mcp.json in your project):
{
"mcpServers": {
"unreal": {
"command": "npx",
"args": ["ultimate-unreal-engine-mcp"],
"env": {
"UE_PROJECT_ROOT": "${workspaceFolder}",
"UE_PLUGIN_PORT": "55557"
}
}
}
}
VS Code (.vscode/settings.json):
{
"mcp.servers": {
"unreal": {
"command": "npx",
"args": ["ultimate-unreal-engine-mcp"],
"env": {
"UE_PROJECT_ROOT": "${workspaceFolder}",
"UE_PLUGIN_PORT": "55557"
}
}
}
}
C++ Plugin Setup
The MCPBridge plugin provides the live editor connection. Without it, all file system and code generation tools still work.
Install:
- Copy
unreal-plugin/MCPBridgeinto your project'sPlugins/directory:
YourProject/
Plugins/
MCPBridge/
MCPBridge.uplugin
Source/
MCPBridgeRuntime/
MCPBridgeEditor/
- Open your
.uprojectin a text editor and add the plugin:
{
"Plugins": [
{
"Name": "MCPBridge",
"Enabled": true
}
]
}
-
Right-click the
.uprojectfile and select "Generate Visual Studio project files" (or run UnrealBuildTool). Build the project from your IDE. -
Open the project in the UE Editor. The MCPBridge plugin initializes automatically and listens on port 55557.
Verify the connection:
curl http://localhost:55557/health
# → {"status":"ok","version":"1.0"}
Change the port:
Set UE_PLUGIN_PORT in your MCP client config and restart the editor. The plugin reads the port from a config ini on startup.
Configuration
Both variables are optional. UE_PROJECT_ROOT defaults to process.cwd(), which works correctly when the MCP server is started from inside the project directory.
Development
# Start dev server with hot reload
npm run dev
# Run all tests
npm test
# Run tests in watch mode
npm run test:watch
# Build production output
npm run build
# Lint
npm run lint
Test coverage: 1021 tests across 43 files.
The test suite covers all 26 tool domains, plugin bridge connection/disconnection behavior, INI config parsing edge cases, C++ header parsing with tree-sitter-unreal-cpp, and known-issues middleware.
Tech stack: TypeScript 5.x, Node.js 22+, @modelcontextprotocol/sdk 1.29.0, Zod 3.25+, Vitest 2.x, tree-sitter-unreal-cpp (WASM), MiniSearch, fast-glob, chokidar.
Requirements
- Node.js 22+ — the MCP server runtime
- MCP-compatible client — Claude Desktop, Cursor, VS Code with MCP extension, or any client implementing the MCP protocol
- Unreal Engine 5.7 — required only for tools marked
[requires_plugin]; file system tools work with any UE version
License
MIT — see LICENSE.