unreal-ai-connection
This server lets you drive Unreal Engine 5.7 programmatically from any MCP-compliant AI client over a local TCP socket, exposing 146 tools for inspecting, authoring, and automating virtually every aspect of the Unreal Editor.
Python Execution
Run arbitrary
unreal.*Python, execute.pyfiles, maintain persistent sessions, and run scripts against the current editor selection.
Asset Management
Query, inspect, move, rename, duplicate, and delete assets; fix redirectors; find unused assets; walk dependency/reference graphs; create DataTables and DataAssets; bulk inspect/delete/move/rename/duplicate.
Blueprint & UI Widgets
Inspect, compile, and audit Blueprints; create Blueprints and add variables, functions, and K2 graph nodes; connect pins and set defaults. Inspect and mutate Widget Trees (including Editor Utility Widgets that UE Python cannot access).
Materials & Textures
Create material instances, set scalar/vector/texture parameters, add/connect material expression nodes, inspect materials and material functions. Import textures from disk and configure compression, sRGB, and LOD groups.
Level & Actor Authoring
Spawn, move, rotate, scale, delete, duplicate, and rename actors; set any UPROPERTY (bulk supported); attach components; set World Outliner folder paths; load/create levels; build static lighting; find actors by class.
Niagara VFX
Spawn Niagara systems at a location or attached to an actor, inspect emitter/parameter structure, and set user-exposed parameters on placed components.
Level Sequences & Cinematics
Create/inspect Level Sequences, bind actors, set playback range, add camera cut/audio/visibility tracks, add transform keyframes, and render via Movie Render Queue (async with task polling).
Viewport & Screenshots
Capture the active viewport as base64 PNG, take high-res screenshots, render off-screen camera views, focus and screenshot individual or multiple actors in batch, and get/set the editor viewport camera transform.
Console, CVars & Logs
Execute console commands, get/set/search console variables (bulk set with optional rollback), and read Output Log entries with category/verbosity filters.
Editor State & Settings
Undo/redo transactions; start/stop/query Play-In-Editor sessions; save dirty assets and levels; inspect project settings for any
UDeveloperSettingssubclass; inspect legacy and Enhanced Input mappings; get project summary and engine version.
Animation & Audio Introspection
Inspect Anim Blueprints, Montages, Skeletal Meshes, Static Meshes, Physics Assets, and Curves. Inspect SoundCue, SoundWave, SoundAttenuation, SoundClass, SoundSubmix, AudioBus, and MetaSound assets.
Long-Running Tasks & Events
Start, poll, and cancel background tasks (e.g., MRQ renders). Poll or subscribe to filtered editor event streams (actor spawn/delete, asset changes, level save, map change).
Mod / PAK Development
Compile UE mod plugins to
.pakfiles via RunUAT or direct UnrealPak invocation.
Miscellaneous
Compare assets (symmetric diff), inspect landscapes, convert HDRI to cubemap, import meshes, auto-remap materials, batch-spawn actors from CSV, and list all registered MCP tools (self-introspection).
Provides tools for controlling Unreal Engine 5.7 from MCP clients, enabling spawning actors, taking screenshots, executing Python code, loading levels, inspecting blueprints, and more via native C++ handlers and a TCP bridge.
Unreal AI Connection
Drive Unreal Engine 5.7 from any MCP-compliant client over a local TCP socket.
150+ tools. Zero pixel-clicking. ~50ms round-trip.


Live capture — an MCP client builds the scene, places Niagara FX (spawn_niagara_at_location), and orbits a camera, entirely over the local TCP socket. Reproduce with scripts/capture_demo_gif.py.
Native C++ handlers — not Python Remote Execution. ~50 ms round-trips across 150+ tools · MIT · works with any MCP-compliant client (Claude Code, Cursor, Cline, Codex, Gemini, Continue, Windsurf, Zed, …).
The suite now spans inspection and authoring — read existing assets and create them: actors, levels, data tables/assets, Blueprints (incl. K2 graph nodes), material graphs, Niagara FX, Level Sequence cinematics (camera cuts, audio, visibility), and Movie Render Queue renders — all over the same socket.
⭐ If this saves you time, a star helps other devs find it.
Authoring high-quality assets: see docs/ASSET-PIPELINE-BLENDER.md.
Install (one paste, any client)
Every route below only wires the stdio bridge. You must separately install the UE 5.7 plugin into your project's
Plugins/folder and launch the editor (it binds127.0.0.1:18888). Seedocs/setup/README.mdfor the prerequisite, anddocs/DISTRIBUTION.mdfor how this is published.
Claude Code — paste the owner/repo, no clone needed:
/plugin marketplace add NAJEMWEHBE/unreal-ai-connection
/plugin install unreal-ai-connection@unreal-ai-connectionThe plugin starts the bridge with python3. On Windows that name can resolve to the Microsoft Store stub instead of Python (when where python3 lists a WindowsApps path first): if the server fails to start, install Python from python.org with "Add to PATH", or turn off the python3 alias in Settings > Apps > Advanced app settings > App execution aliases. A project .mcp.json can use py instead (docs/setup/claude-code.md).
Cursor — one-click deeplink. Base64-encode your machine's bridge path into this template:
cursor://anysphere.cursor-deeplink/mcp/install?name=unreal-ai-connection&config=<BASE64>where <BASE64> is base64 of {"command":"python3","args":["/ABSOLUTE/PATH/TO/bridge/unreal_ai_connection_bridge.py"]} (on Windows use "command":"py" if python3 is not on PATH). Manual fallback — .cursor/mcp.json:
{ "mcpServers": { "unreal-ai-connection": { "command": "python3", "args": ["/ABSOLUTE/PATH/TO/bridge/unreal_ai_connection_bridge.py"] } } }VS Code — install deeplink (URL-encode the JSON for your path):
vscode:mcp/install?<URL-ENCODED {"name":"unreal-ai-connection","command":"python3","args":["/ABSOLUTE/PATH/.../bridge/unreal_ai_connection_bridge.py"]}>Windows: all snippets use
python3; if that's not on PATH use thepylauncher instead ("command": "py"). The.claude-plugin/mcp-config.jsonmarketplace path usespython3for cross-platform consistency — Windows users withoutpython3should use the manual per-client recipe indocs/setup/withpy.
Every other client — copy-paste recipe per client:
Client | Route | Recipe |
Claude Code |
| |
Claude Desktop | edit | |
Cursor | deeplink / | |
Codex CLI |
| |
Windsurf |
| |
Continue |
| |
Cline | MCP Marketplace tab / settings | |
Zed |
| |
Gemini CLI |
| |
VS Code Copilot |
|
Also discoverable in the official MCP Registry as io.github.najemwehbe/unreal-ai-connection (feeds the VS Code MCP gallery, mcp.so, PulseMCP) and submittable to the Cline marketplace via llms-install.md.
Related MCP server: unreal-engine-mcp
Jump to
How it fits together — architecture diagram + per-call sequence
Why it exists — the UE 5.7 Python dead-ends this plugin sidesteps
Why MCP specifically — one protocol, every conforming client
Tools — 150+ tools grouped into 15 expandable categories
Quick start — copy-paste path to a running editor with the plugin live
What's in the box — directory tree
Status — release / test / build state
Contributing — house rules + how to add a tool
How it fits together
graph LR
A[Any MCP client] -->|stdio MCP| B[Python Bridge]
B -->|TCP 127.0.0.1:18888| C[UnrealAIConnection plugin<br/>UE editor module]
C -->|native C++ API| D[Unreal Editor 5.7]sequenceDiagram
participant User
participant Client as MCP client<br/>(e.g. Claude Code)
participant Bridge as Python bridge
participant Plugin as UE plugin module
participant Editor as Unreal Editor 5.7
User->>Client: "Spawn a Cube at origin"
Client->>Bridge: stdio MCP — tools/call spawn_actor
Bridge->>Plugin: TCP 127.0.0.1:18888<br/>JSON-RPC framed
Plugin->>Editor: GEditor->SpawnActor()
Editor-->>Plugin: success + actor ref
Plugin-->>Bridge: JSON-RPC result
Bridge-->>Client: MCP envelope
Client-->>User: rendered confirmation<br/>(~50ms total)You ask Claude Code: "Take a screenshot of my level and tell me what's there." — Claude resolves the request to a tool call, the bridge forwards it as JSON-RPC to the running editor, the plugin captures the viewport, and Claude renders the image inline. Same flow works for spawning actors, inspecting Blueprints, mutating Widget Trees, executing arbitrary unreal.* Python, listing actors, focusing the viewport, loading levels, taking high-res screenshots.
The plugin binds to 127.0.0.1 only — your running editor is never reachable across the network.
Why it exists
UE 5.7's Python reflection has known dead-ends. Most painfully: EditorUtilityWidgetBlueprint.WidgetTree is a UPROPERTY() without EditAnywhere, so neither get_editor_property nor direct attribute access can reach it. This blocks "let an LLM build me an editor utility panel" workflows entirely.
The plugin sidesteps these limits by calling UE's native C++ APIs directly inside the editor process. It's also dramatically faster than driving UE's GUI with screenshot pixel-clicks — ~50ms round-trip vs. minutes of GUI fiddling.
Why MCP specifically
MCP (Model Context Protocol) is a vendor-neutral I/O protocol designed for LLM tool-use. Because this plugin speaks MCP rather than baking in any one client, every conforming client gets every tool for free: Claude Code, Codex CLI, Cursor, Gemini CLI, Continue, Zed, Cline, and any future entrant. Switch clients without changing the plugin or the bridge.
The wire format is stdio MCP between client and bridge, then a tight length-prefixed JSON-RPC over TCP 127.0.0.1:18888 between bridge and the running UE editor. Either side can be reimplemented in another language; the contract is the JSON.
Tools
150+ tools. Most are native C++ handlers registered by the plugin at editor startup; the rest are bridge-side synthetic tools (wait_for_events, get_camera_transform, set_camera_transform, screenshot_actor, compile_mod_pak, compile_mod_pak_direct, bulk_delete_assets, bulk_move_assets, bulk_rename_assets, bulk_duplicate_assets, bulk_inspect_assets, inspect_data_asset, inspect_sound_class, inspect_sound_submix, inspect_audio_bus, inspect_material_function, inspect_metasound, find_unused_assets, get_reference_chain, bulk_compile_blueprints, audit_blueprint_compile_status, find_actors_by_class, bulk_focus_actors, bulk_screenshot_actors, bulk_set_actor_property, compare_assets, bulk_set_console_variables, inspect_dependency_graph, bulk_fix_redirectors, marketplace_search, marketplace_import, convert_hdri_to_cubemap, sequencer_add_transform_keyframe, import_mesh, material_auto_remap, batch_capture_cameras, batch_spawn_from_csv) that compose existing handlers without a dedicated UE round-trip (or, for compile_mod_pak and compile_mod_pak_direct, shell out to RunUAT or UnrealPak entirely outside the UE process) — see bridge/unreal_ai_connection_bridge.py's SYNTHETIC_TOOLS. Per-tool JSON schemas and examples live in docs/TOOLS.md. Grouped overview:
Progressive tool disclosure (opt-in). Advertising 150+ schemas up front is a lot of context — past ~30–50 tools, model tool-selection accuracy and token cost both degrade (Anthropic Tool Search Tool, MCP discussion #532). Set the environment variable
UCMCP_TOOL_MODE=progressiveon the bridge andtools/listreturns only a small core set (get_project_summary,list_tools,get_actors_in_level,execute_unreal_python,take_high_res_screenshot,get_viewport_screenshot,poll_events) plus a singlesearch_toolsdiscovery tool. The model callssearch_tools(query="add a camera keyframe", category="sequencer")to pull the schemas of just the tools it needs, on demand. Every one of the 147 tools stays directly callable viatools/callin both modes — progressive mode changes only what is advertised, never what is dispatchable, so existing clients keep working. Default (unset /all) is the legacy expose-everything behaviour.search_toolsruns entirely bridge-side (no UE round-trip), validates its input, and fails closed.
Python execution (5 tools)
Tool | Purpose |
| Universal escape hatch — run arbitrary |
| Execute a |
| Run a Python snippet with the editor's current selection bound as |
| Persistent Python session — variables defined in one call survive into the next. |
| Wipe the persistent session's globals. |
Project / asset registry (10 tools)
Tool | Purpose |
| Project name, engine version, enabled plugins, asset count. |
| Query the asset registry by class + path + name. |
| Class, tags, dependencies, referencers, on-disk size. |
| Move an asset to a different folder; UE creates a redirector at the source path. |
| Change an asset's leaf name in place; UE creates a redirector at the old name. |
| Copy an asset to a new path. |
| Delete an asset; refuses if referenced by other packages unless |
| Resolve all object redirectors under a folder. |
| Create a new |
| Create a new |
Blueprint / widget / animation — introspection + authoring (20 tools)
Tool | Purpose |
| Variables, function/event graphs, parent class of any Blueprint asset. |
| Recompile a Blueprint asset and report errors. |
| Read the widget hierarchy of a |
| Widget-BP-specific surface: animations, delegate bindings, palette category, inherited named slots, property-binding count, blueprint compile status. Pairs with |
| Mutate the tree: |
| Read variables and state machines of an Animation Blueprint. |
| Read sections, slots, and notify tracks of an |
| LODs, materials, collision, bounds for a |
| LODs, materials, sockets, skeleton info for a |
| Body setups (one per simulated bone), constraint setups (joints between bodies), bounds-bodies subset, named physical-animation + constraint profiles. Cross-links to |
| Emitters and exposed user parameters of a Niagara system. |
| Components, layers, and material info for a landscape actor. |
| RowStruct identity, sorted row names, per-property name+type for every |
| UCurveBase channel layout (1ch UCurveFloat / 4ch UCurveLinearColor / 3ch UCurveVector), per-channel name + key count + per-channel + global time/value range. |
| Create a new |
| Add a typed member variable (bool/int/float/string/name/vector/rotator/transform/object) to an existing |
| Add a new empty function graph to an existing |
| Add a K2 node ( |
| Wire two pins (exec or data) between nodes by GUID + pin name, via the schema-validated |
| Set a literal or object default on an input pin (verified by read-back). |
Materials (6 tools)
Tool | Purpose |
| Create a |
| Override a scalar/vector/texture parameter on a material instance. Type discriminator picks value shape. |
| List parameter names declared by a |
| Read a material instance's parent + currently-overridden parameter values. |
| Create a |
| Wire an expression's output to a material property input ( |
Textures (3 tools)
Tool | Purpose |
| Bring an image file (PNG / JPG / EXR / TGA / BMP / HDR) from disk into the project as a |
| Adjust SRGB / compression / LOD group / filter on an existing texture asset. |
| Texture class, surface dimensions, sRGB, compression, filter, LOD group, mip-gen, virtual-texture / never-stream flags, composite-texture cross-link. UTexture2D-specific size / mips / pixel format / imported source dimensions emitted conditionally. |
Level Sequences (9 tools)
Tool | Purpose |
| Read structure of a Level Sequence: tracks, sections, bindings, frame rate, playback range. |
| Create a new empty Level Sequence asset with a configured display rate and playback range. |
| Add a level actor as a possessable binding to a Level Sequence. |
| Set a Level Sequence's playback start/end (display-rate frames). |
| Spawn an |
| Add (or reuse) the camera-cut track and bind a camera over a |
| Add a master audio track + sound section to a Level Sequence. |
| Add an actor-visibility track that keys an actor shown/hidden over time (inverted |
| Async-render a Level Sequence (optional map override) to PNG / JPG / BMP / EXR via Movie Render Queue; returns a |
Level / actor authoring (24 tools)
Tool | Purpose |
| Name / class / transform of every actor; optional case-insensitive substring filter. |
| Create an actor at a location with optional rotation, label, and initial properties. Class path supports built-ins and Blueprints. |
| Move / rotate / scale an existing actor by name. Absolute or relative mode. |
| Remove an actor by name. Force flag overrides children-attached safety check. |
| Mutate any UPROPERTY on an actor. Supports primitives, FName/FText, vectors, rotators, colors, enums, and TSoftObjectPtr. |
| Attach a component (UActorComponent / USceneComponent subclass) to an existing actor at runtime, optionally socketed. |
| Clone an existing level actor (label or FName), optionally offset and relabel. Undoable (single Ctrl+Z). |
| Set an actor's World Outliner folder path (e.g. |
| Change an actor's World Outliner display label ( |
| Select an actor by label and frame the viewport on it. |
| Open a level by package path. |
| Create a new empty level ( |
| Invoke a static-lighting build on the active editor world. Non-interactive; may take time on large levels. |
| Place a Niagara system in the level ( |
| Attach a Niagara system component to an existing actor, optionally socketed. Undoable. |
| Set a user-exposed Niagara parameter (float / vec3 / linear-color / bool) on a placed Niagara component, with type-match validation. Undoable. |
| Filter the active level's actors by class. Composes |
| Frame the viewport on each actor in a sequence, optionally screenshotting each one. Composes |
| Focus + screenshot each actor in a sequence. Composes |
| Apply many |
| Symmetric diff between two assets' |
| Set many CVars in one call with optional atomic rollback. Composes |
| BFS the asset dependency graph (down by default, optional bidirectional sweep). Composes |
| Resolve redirectors across many content folders in one call. Composes |
Viewport / screenshots (3 tools)
Tool | Purpose |
| Active viewport as a PNG written to a project-confined disk path (throttle-proof fresh frame; optional small inline thumbnail). |
| Trigger UE's |
| Force a synchronous render of the level-editor viewport (or an off-screen SceneCapture2D at arbitrary resolution) and write a PNG — works headless where deferred screenshots fail. |
Console / logs (5 tools)
Tool | Purpose |
| Read recent UE Output Log entries from the in-process ring buffer. Filter by category and minimum verbosity. |
| Run a UE console command (e.g. |
| Read a single console variable's current value. |
| Write a value to a console variable. |
| Enumerate console variables matching a name pattern. |
Long-running tasks (4 tools)
Tool | Purpose |
| Reference long-running task — sleeps for N seconds. Used to exercise the task pattern from clients. |
| Read a task's current state / result. |
| Cancel an in-flight task by id. |
| Enumerate all tracked tasks and their states. |
Event push / subscriptions (5 tools)
Tool | Purpose |
| Drain queued editor events (actor spawn/delete, asset add/remove/rename/import, level save, map change) from the in-process EventBus. |
| Bridge-side synthetic tool — block until matching events arrive or |
| Open a per-client subscription channel for a filtered event stream. |
| Drain queued events from a specific subscription. |
| Close a subscription. |
Audio (3 tools — introspection trio)
Tool | Purpose |
| USoundCue duration, multipliers, attenuation cross-link, root sound-node class, full graph node list (sorted, with class taxonomy). |
| USoundWave sample rate, channels, frame count, duration, compression type + runtime format + compressed-data size, sound group, looping/streaming flags, loading behavior, subtitle + cue-point + loop-region counts. Editor-only LUFS / sample-peak / comment fields conditional. |
| USoundAttenuation 3D-playback rules: distance algorithm + shape, spatialization, air-absorption LPF/HPF, listener focus, occlusion tracing, reverb send, priority attenuation, plus assorted feature flags. Each major feature is gated by its master bitfield; sub-objects collapse to |
Camera (3 tools — bridge-side synthetic)
Tool | Purpose |
| Read the level-editor viewport camera's location + rotation. Composes |
| Set the level-editor viewport camera's location and/or rotation. Single |
| Frame the viewport on a specific actor and capture a focused PNG. Composes |
Editor state / undo (2 tools)
Tool | Purpose |
| Step the editor undo stack backward — the programmatic Ctrl+Z. Each mutating MCP edit (spawn/delete/transform/property/component) is one transaction, so this reverts the last such edit (or the last N via |
| Step the editor undo stack forward — the programmatic Ctrl+Y. Re-applies transactions previously reverted by |
Self-introspection (1 tool)
Tool | Purpose |
| Names of every registered method (for autodiscovery). |
Adding the next C++ handler is one .cpp file plus one line of registration — see docs/ARCHITECTURE.md. New synthetic tools are an entry in SYNTHETIC_TOOLS plus a function in bridge/unreal_ai_connection_bridge.py.
Quick start
Engineers (you already build UE projects from source)
Drop the plugin in. Copy
UnrealAIConnection/into<YourProject>/Plugins/.Regenerate project files. Right-click
<YourProject>.uproject→ Generate Visual Studio project files.Build the editor. Open the .sln, build Development Editor | Win64. First build takes ~5–15 min.
Launch. Open the .uproject. The MCP server auto-starts on
127.0.0.1:18888. Look for these lines in the Output Log:[LogUnrealAIConnection] Module started LogUCMCPHandler: Registered handler 'execute_unreal_python' ... (85 more handler lines) [LogUCMCP] Listening on 127.0.0.1:18888Wire your MCP client. Copy
examples/.mcp.json.exampleto your project root as.mcp.json, edit the path to point atbridge/unreal_ai_connection_bridge.py, restart your client, and approve the new MCP server. Same bridge works with Claude Code, Claude Desktop, Cursor, Codex CLI, Windsurf, Continue, Cline, Zed, Gemini CLI, and VS Code Copilot — seedocs/setup/for per-client copy-paste recipes.
Non-engineers / GUI-only users
See docs/INSTALLATION.md — step-by-step, screenshot-first.
Verify it works
The smoke test fires every default-on tool from a plain Python TCP client (not through Claude Code) — a fast way to confirm the plugin loaded and the server is alive:
python examples/smoke_test.pyYou'll see structured JSON output for every default-on step (eleven banner-headed sections, plus a few unbannered checks for the asset registry, sequencer and materials handlers — the last two skip with a print if your project has no Level Sequences or Materials in /Game/). Last line: "Smoke test complete."
What's in the box
UnrealAIConnection/ The Unreal Engine plugin (drop into <Project>/Plugins/)
Source/UnrealAIConnection/ C++ editor module
Resources/ MCP manifest JSON
UnrealAIConnection.uplugin Plugin manifest
bridge/
unreal_ai_connection_bridge.py Python stdio ↔ TCP bridge for any MCP client
examples/
smoke_test.py Connects to the live server, fires the safe tools
.mcp.json.example Template Claude Code MCP config
docs/
INSTALLATION.md Step-by-step install for a UE 5.7 project
TOOLS.md What each tool does + JSON examples
ARCHITECTURE.md How the pieces fit + UE 5.7 API gotchas
skills/
driving-unreal/ Bundled know-how skill — which tools to chain for common UE workflows (auto-discovered by MCP clients)
tests/ Pytest suite for the bridge (no UE required)
.github/workflows/ CI runs the bridge tests on every push & PRStatus
Latest release | v0.9.1 — 2026-05-23 |
Tools | 155 live — 118 native C++ handlers (one MCP method per |
Tested on | UE 5.7.4 / Windows 11 / Visual Studio Build Tools 2022 / MSVC 14.44 / NETFXSDK 4.8.1 |
Build status | Plugin compiles + loads against UE 5.7.4 host on Windows 11; every handler registers, TCP server binds |
Bridge tests | pytest suite, ~99% coverage, no UE needed; the CI badge above shows the current run |
CI | GitHub Actions on every push and PR |
Maintenance | Active. Development paused 2026-07-03 and the repo was marked deprecated 2026-07-17; maintenance and new work resumed 2026-11-05. Issues and PRs are read again. |
Development workflow | Multi-agent ensemble — Opus orchestrates, Codex authors C++, Sonnet handles Python + recon, NVIDIA cloud + local OSS LLMs run pre-PR diff review, Copilot CLI gives a second opinion, Gemini auto-review fires on every PR open. No single model gates a merge. |
Roadmap / status honesty
One in-flight item is stated plainly here so nothing is oversold:
Officially built & tested on UE 5.7. Other UE versions are community / best-effort: the cross-engine compatibility scaffold lets you build from source for your engine version (uncertified, not actively maintained, contributions welcome). See ADR-0001 / docs/PHASE-H-COMPAT.md.
Engine 5.3 and older, from source: re-pin an engine-appropriate MSVC toolchain in your
BuildConfiguration.xml(<CompilerVersion>); the maintainer's own pin is cleared (36th closing note indocs/HANDOFF.md).Engine 5.6, host-certified from source: Built with MSVC 14.38 and smoke-tested live (all suites green) on a real 5.6 editor. No prebuilt 5.6 binaries are published: build from source as for 5.7. DMX note: the DMX tools need the optional
UnrealAIConnectionDMXcompanion plugin, which pulls in the engine'sDMXEngine+DMXProtocol; the core plugin loads without them.
What this is NOT
A general MCP server framework — this is bonded to UE's editor process.
A live-broadcast tool — for that, look at vMix, OBS, NDI Studio Monitor.
An Aximmetry / Pixotope / Disguise replacement — those have multi-engineer multi-year codebases.
Contributing
Issues and PRs welcome. Two house rules:
Verify UE API claims against UE 5.7 source. Past reviewer subagents have made specific UE API claims that turned out wrong; ground-truth the engine source before committing.
Each new MCP handler is one
Handler_*.cppfile inSource/UnrealAIConnection/Private/MCP/Handlers/, plus oneexterndeclaration and oneReg.Register(Make_Handler_*())line inUnrealAIConnectionModule.cpp. Don't grow the foundation — add handlers.
Running tests
Bridge unit tests run without UE in under a second:
pip install pytest pytest-cov
pytest tests/CI runs the same suite on every push and PR (see .github/workflows/tests.yml). The live integration smoke test in examples/smoke_test.py requires a running UE editor — see tests/README.md.
License
MIT — see LICENSE. © 2026 HD Media (Kuwait).
Available Tools
105 toolsadd_componentA
Attach a component (UActorComponent or USceneComponent subclass) to an existing actor at runtime, optionally socketed and transformed relative to a parent component.
Inputs: actor_name (required), class_path (required), component_name, attach_to, +2 more.
apply_python_to_selectionA
Run user Python with the editor's current selection pre-bound: selection (selected level actors) and selected_assets (selected content-browser assets). Convenience wrapper around execute_unreal_python that injects the lookup boilerplate. Same output-capture caveat: ExecuteFile mode does not return stdout; use unreal.log marker + get_log_lines.
Inputs: code (required).
audit_blueprint_compile_statusA
Enumerate every Blueprint under a content path and report its compile-status bucket (UpToDate/Dirty/Error/Unknown/BeingCreated). Composes find_assets + inspect_blueprint bridge-side. This is a READ-ONLY audit (no recompile triggered); pair with bulk_compile_blueprints to actually fix anything found.
Inputs: path_under, compile_failures_only.
bind_actor_to_sequenceB
Add a level actor as a possessable binding to a Level Sequence. Creates the binding GUID and wires it to the live actor.
Inputs: sequence_path (required), actor_name (required).
bulk_compile_blueprintsA
Recompile multiple Blueprints in one MCP call by composing the compile_blueprint C++ handler bridge-side. Returns per-path success/failure plus aggregate counts. Mirrors the bulk_*_assets family shape (paths list + continue_on_error). Useful after batch-mutating BPs via execute_unreal_python or other tooling.
Inputs: paths (required), continue_on_error.
bulk_delete_assetsA
Delete multiple assets by composing the delete_asset C++ handler bridge-side. Returns per-path results plus aggregate counts. By default continues after individual failures (partial success is normal); set continue_on_error=false to stop on first failure. SYNTHETIC bridge-side handler.
Inputs: paths (required), continue_on_error.
bulk_duplicate_assetsA
Duplicate multiple assets in one call by composing the duplicate_asset C++ handler bridge-side. Schema mirrors bulk_rename_assets's per-entry mapping but uses dest_path (full destination path) instead of new_name (leaf name) since duplicate_asset takes a full destination, not a folder + name split. Unlike rename/move, duplicate does NOT leave a redirector at the source -- the source is preserved at its current path and a new copy is created at dest_path. Returns per-entry results plus aggregate counts. SYNTHETIC bridge-side handler.
Inputs: duplicates (required), continue_on_error.
bulk_fix_redirectorsA
Resolve UObjectRedirector stubs across multiple content folders in one MCP call. Composes fix_up_redirectors per folder. Useful as a follow-up to a sweep of bulk_move_assets / bulk_rename_assets calls (each of which leaves redirectors at the source paths) so the LLM does not have to issue one fix_up_redirectors per touched folder.
Inputs: folders (required), recursive, continue_on_error.
bulk_focus_actorsA
Frame the viewport on each actor in a sequence, optionally capturing a screenshot after each focus settles. Composes focus_actor (plus, when screenshot_each=true, get_viewport_screenshot) per name. Useful for 'show me each enemy / spawn / light in turn' walkthroughs where one screenshot_actor at a time would force the LLM into a polling loop.
Inputs: names (required), delay_ms, screenshot_each.
bulk_inspect_assetsA
Inspect multiple assets in one MCP call by composing the inspect_asset C++ handler bridge-side. Returns per-path inspection data plus aggregate counts; partial failures isolated per result. Mirrors the bulk_*_assets family shape. Use for pipeline audits (e.g. enumerate 500 textures and report which lack a power-of-two source).
Inputs: paths (required), continue_on_error.
bulk_move_assetsA
Move multiple assets into a single destination folder by composing the move_asset C++ handler bridge-side. Each move leaves a redirector at the source per UE's standard move semantics. Returns per-path results plus aggregate counts. By default continues after individual failures (partial success is normal); set continue_on_error=false to stop on first failure. SYNTHETIC bridge-side handler — mirrors bulk_delete_assets's shape so client code can switch between the two with a one-tool-name change.
Inputs: paths (required), dest_folder (required), continue_on_error.
bulk_rename_assetsA
Rename multiple assets in one call by composing the rename_asset C++ handler bridge-side. Each rename leaves a redirector at the source per UE's standard semantics. Schema differs from bulk_delete_assets / bulk_move_assets: takes a renames list of {path, new_name} objects so each asset gets a per-entry leaf name. Returns per-entry results plus aggregate counts. Mirrors the bulk_*_assets result-shape convention. SYNTHETIC bridge-side handler.
Inputs: renames (required), continue_on_error.
bulk_screenshot_actorsA
Frame and screenshot each actor in a sequence. Composes screenshot_actor (which itself composes focus_actor + get_viewport_screenshot) per name. Same shape as bulk_focus_actors but always captures a PNG — convenient for thumbnail-pipeline runs where every actor in a list needs a deterministic centered shot.
Inputs: names (required), delay_ms.
bulk_set_actor_propertyA
Apply many UPROPERTY mutations across many actors in one MCP call. Composes set_actor_property bridge-side; mirrors the bulk_*_assets family shape (assignments list + continue_on_error). Each assignment specifies its own {actor, property, value} so this is NOT 'set the same property on N actors' — it's 'run N individual sets'. Useful after batch-spawning to push initial-state mutations without N round-trips.
Inputs: assignments (required), continue_on_error.
bulk_set_console_variablesA
Set multiple Console Variables in one MCP call with optional atomic rollback. Composes get_console_variable (to capture each pre-value) plus set_console_variable (to apply each new value); on any per-cvar failure when rollback_on_error=true, the synthetic walks back every applied change to its captured pre-value. Mirrors the editor's 'apply scalability set then revert if any fail' pattern, with an explicit rollback failure list so callers know which restores themselves failed.
Inputs: assignments (required), rollback_on_error.
cancel_taskA
Request COOPERATIVE cancellation of a running task. Sets the task's atomic flag; the worker observes it on its next polling iteration (~50ms) and exits cleanly to status='cancelled'. UE has no safe forced-thread-termination, so workers that don't poll the flag run to completion regardless. Idempotent: returns ok=true with accepted=false for unknown ids and already-terminal tasks.
Inputs: task_id (required).
compare_assetsA
Symmetric diff between two assets' inspect_asset outputs. Composes inspect_asset bridge-side on both paths and returns the fields that differ. Useful for 'what changed between these two versions of the same blueprint?' walkthroughs and for cross-checking duplicated assets that should be identical. The path field is excluded from comparison (trivially different between the two inputs).
Inputs: path_a (required), path_b (required), fields.
compile_blueprintA
Explicit Blueprint recompile via FKismetEditorUtilities::CompileBlueprint. Use when a BP has been mutated externally (e.g. via execute_unreal_python) and needs to be recompiled without further mutation. Pairs with edit_widget_tree's compile=true flag.
Inputs: path (required), skip_save.
compile_mod_pakA
Compile a UE mod plugin to a .pak file via RunUAT BuildMod (game Dev Kits like Conan Exiles) or BuildPlugin (vanilla UE5), headless. No UE Editor session required. Especially useful for game Dev Kits in 'installed-build mode' where BuildPlugin is blocked (e.g. Conan Exiles Enhanced UE5) — falling back to BuildMod cleanly. BuildMod path produces a .pak in output_dir; BuildPlugin path produces a redistributable plugin package (no .pak generated by default — ok=true based on exit_code alone).
Inputs: project_path (required), output_dir (required), mod_name, plugin_path, +4 more.
compile_mod_pak_directA
Compile a UE5 mod into a .pak by invoking UnrealPak.exe directly with a response file, bypassing RunUAT entirely. Use when the Dev Kit's RunUAT BuildMod is broken (Funcom Conan Exiles Enhanced UE5 ships a ScriptModules manifest invalid-record bug — UAT deletes its own deps.json before BuildMod can run). Pre-condition: caller has already cooked the .uasset files (e.g. via execute_unreal_python on a running Editor, or a separate UnrealEditor-Cmd.exe -run=Cook pass). UnrealPak is a standalone UE binary and works regardless of UAT state — runs in seconds and produces a .pak that deploys directly to the server's Mods// folder. Complements compile_mod_pak (which uses RunUAT); use compile_mod_pak_direct when UAT is broken on your Dev Kit. SYNTHETIC bridge-side handler.
Inputs: unreal_pak_path (required), response_file (required), output_pak (required), compression, +2 more.
configure_textureA
Adjust SRGB/CompressionSettings/LODGroup/Filter on an existing UTexture asset and persist the change. Triggers UE's standard PreEditChange/PostEditChange flow and rebuilds the GPU resource.
Inputs: path (required), srgb, compression, lod_group, +2 more.
convert_hdri_to_cubemapA
Convert a longlat-projection HDRI (UTexture2D) into a UTextureCube so it can drive a SkyLight's SpecifiedCubemap slot. SYNTHETIC bridge-side handler. Pipeline: spawn an inside-out sphere with the HDRI as an unlit emissive material, capture it with a SceneCaptureCube into a TextureRenderTargetCube, then materialize the static UTextureCube via RenderingLibrary.render_target_create_static_texture_cube_editor_only. Temp render-target + temp material + temp actors are cleaned up before return. Closes the 23rd HANDOFF note's HDRI cubemap parked item.
Inputs: hdri_path (required), dest_path, dest_name, cube_size, +1 more.
create_material_instanceB
Create a UMaterialInstanceConstant asset and set its parent to an existing UMaterial or UMaterialInstance.
Inputs: parent_path (required), path (required), name (required).
create_sequenceA
Create a new Level Sequence asset. Initializes an empty MovieScene with the given display frame rate and playback end-frame.
Inputs: path (required), name (required), display_rate_fps, playback_end_frames.
delete_actorA
Remove an actor from the editor world by name (label or FName). Children are detached, not destroyed (UE's default behavior). Force flag overrides the children-attached safety check.
Inputs: name (required), force.
delete_assetA
Delete an asset. Refuses if referenced by other packages unless force=true. WARNING: deletion is permanent within the project; force-delete cannot recover via Undo.
Inputs: path (required), force.
duplicate_assetA
Copy an asset to a new path. Source asset is preserved; destination must not already exist. No redirector is created (callers reference the duplicate by its new path).
Inputs: path (required), dest_path (required).
edit_widget_treeA
Mutate a widget tree. ops: set_root | add_child | set_property. Solves UE 5.7 EUW WidgetTree population.
Inputs: path (required), op (required), class, name, +5 more.
exec_python_persistentA
Tier 2 PR #45: like execute_unreal_python but state PERSISTS across calls. Variables, imports, and function/class definitions defined in one call are visible in the next -- letting Claude build up state across turns without re-loading every time. Implemented via UE's FPythonCommandEx with FileExecutionScope=Public (shared globals dict with the editor's Python console). Pairs with reset_python_state. Same output-capture caveat as execute_unreal_python: ExecuteFile mode does not capture stdout via CommandResult; use unreal.log marker + get_log_lines.
Inputs: code (required).
execute_console_commandA
Run a UE console command (e.g. 'stat fps', 'r.ScreenPercentage 50') and optionally capture its output. Executes on the game thread in the editor world context.
Inputs: command (required), capture_output.
execute_unreal_pythonA
Run arbitrary unreal.* Python in the editor's embedded interpreter (universal escape hatch). Multi-line scripts allowed.
Inputs: code (required).
find_actors_by_classA
Filter the current level's actors by class. Composes get_actors_in_level bridge-side and matches each actor's short class name against the supplied class_name (accepts either a short name like 'StaticMeshActor' or a class path like '/Script/Engine.StaticMeshActor' — the synthetic strips the path prefix and matches case-insensitively). Useful for 'find every light' / 'find every spawn point' walkthroughs without forcing the LLM to grep through a thousand-actor get_actors_in_level dump.
Inputs: class_name (required), level.
find_assetsA
Query the asset registry by class + optional path + optional name substring + optional tag filters. Returns matching assets with structured records (name, package_path, class[, tags]).
Inputs: class_path (required), path_under, name_contains, limit, +2 more.
find_console_variablesA
Prefix-search the IConsoleManager registry; returns matching CVar names + types + read-only flags. Pairs with get_console_variable / set_console_variable for discovery workflows. C++ handler -- direct iteration of UE's internal console registry. Part of the language-shim experiment (PR #46): see docs/LANGUAGE-CHOICE-RETROSPECTIVE.md.
Inputs: prefix, limit.
find_unused_assetsA
Enumerate assets under a content path and report which have zero referencers (i.e. nothing in the project references them). Composes find_assets + inspect_asset bridge-side. Useful for content cleanup audits before shipping. Returns the first limit unused assets and a truncated flag when more remain.
Inputs: path_under, class_filter, limit.
fix_up_redirectorsA
Cascade-update consumers of UObjectRedirector assets under a folder, then delete the now-redundant redirector .uasset stubs. Cleans up after move_asset / rename_asset workflows. Mirrors the editor's right-click 'Fix Up Redirectors in Folder'.
Inputs: path (required).
focus_actorB
Select an actor by label or unique name and frame the editor viewport on it.
Inputs: name (required).
get_actors_in_levelA
Return name/class/transform of every actor in the active editor world. Optional name_contains filter.
Inputs: name_contains.
get_camera_transformA
Read the level-editor viewport camera transform. SYNTHETIC bridge-side handler (PR #46 language-shim experiment): composes execute_unreal_python + get_log_lines via the marker pattern. Returns { location: {x,y,z}, rotation: {pitch,yaw,roll} }.
Inputs: no named parameters.
get_console_variableA
Read a UE Console Variable by name. Returns the current value in all four representations (string/int/float/bool), the detected type (int|float|bool|string), the read-only flag, and the human-readable last-setter (e.g. 'Console', 'DeviceProfile'). Distinct from execute_console_command: this reads CVar state directly, never invokes the console exec engine.
Inputs: name (required).
get_engine_versionA
Structured engine-version snapshot — major / minor / patch / changelist / branch as separate fields, plus a 'minor_dotted' convenience like '5.7'. Use this when the LLM needs to branch on engine version without parsing get_project_summary's single 'engine_version' string.
Inputs: no named parameters.
get_log_linesA
Read recent UE Output Log entries from the in-process ring buffer. Supports category substring filter and minimum verbosity filter. Returns up to count lines (default 100, max 1000) at or above the requested severity.
Inputs: count, category_filter, min_verbosity.
get_project_summaryA
Project name, engine version, enabled plugins, asset counts.
Inputs: no named parameters.
get_reference_chainA
Walk the asset reference graph BFS from a root, returning every node and edge up to a depth bound. Composes inspect_asset recursively. direction=up follows referencers (who references me) — useful for impact-of-change analysis before deleting/renaming. direction=down follows dependencies (what I reference) — useful for dependency audits before packaging.
Inputs: path (required), depth, direction.
get_selected_actorsA
Return name/label/class/transform of every actor currently selected in the editor's World Outliner / viewport. Companion to apply_python_to_selection — lets the LLM observe what is selected before running code against it.
Inputs: no named parameters.
get_viewport_screenshotA
Capture the active editor viewport as a PNG, return base64-encoded inline.
Inputs: no named parameters.
import_textureA
Import an image file (PNG/JPG/EXR/TGA/BMP/HDR) from disk into the project as a UTexture2D asset, using the canonical UE asset import pipeline.
Inputs: source_path (required), dest_path (required), dest_name, replace_existing, +2 more.
inspect_anim_blueprintA
Read structural properties of a UAnimBlueprint asset: parent class, target skeleton, template flag, baked state machines, anim functions (with implemented flag), sync groups, parent anim blueprint chain. C++ handler -- guards UAnimBlueprintGeneratedClass for null (compiled data is empty / is_compiled=false when the blueprint has never been compiled). No new Build.cs deps (Engine module already present).
Inputs: path (required).
inspect_anim_montageA
Read structural properties of a UAnimMontage asset: target skeleton, play length, frame rate (rational), blend envelope (in/out times + auto-blend trigger), composite sections (with start/end times and next-section linkage), slot animation tracks, notify events. C++ handler; no new Build.cs deps (Engine module covers it). Completes the animation introspection trio with inspect_anim_blueprint and inspect_skeletal_mesh.
Inputs: path (required).
inspect_assetA
Read everything the asset registry knows about a single asset: class, all registry tags, dependency packages, referencer packages, on-disk file size.
Inputs: path (required).
inspect_audio_busA
Inspect a UAudioBus by package path: returns leaf class name, package path, audio_bus_channels enum stringified (Mono/Stereo/Quad/FivePointOne/SevenPointOne), and additional editor-accessible UPROPERTYs discovered via dir() permissive enumeration. SYNTHETIC bridge-side handler: composes execute_unreal_python + get_log_lines via the marker pattern. Logical errors (asset_not_found, wrong_asset_type, marker_not_found, invalid_json) return as ok=False success envelopes; transport-level errors return as JSON-RPC errors.
Inputs: path (required).
inspect_blueprintA
Read parent class, declared variables, function/event graph names, and compile status (UpToDate/Dirty/Error/Unknown/BeingCreated) of a Blueprint asset.
Inputs: path (required).
inspect_curveA
Read structural properties of a UCurveBase asset (UCurveFloat / UCurveLinearColor / UCurveVector / any subclass): curve class, channel count, global time + value range, and per-channel name + key count + per-channel time/value range. Channel layout: UCurveFloat = 1 channel, UCurveLinearColor = 4 (RGBA), UCurveVector = 3 (XYZ). C++ handler; no new Build.cs deps (Engine covers UCurveBase / FRichCurve).
Inputs: path (required).
inspect_data_assetA
Shallow-reflect a UDataAsset by package path and return class, parent class, package path, and editable property list (name, Python type, stringified value). SYNTHETIC bridge-side handler (PR #92 language-shim experiment): composes execute_unreal_python + get_log_lines via the marker pattern. Property values for nested structs / arrays / dicts are stringified as 'container:type' or '' — no recursion. Logical errors (asset not found, marker buffer overflow, payload unparseable) return as ok=False success envelopes; transport-level errors return as JSON-RPC errors.
Inputs: path (required).
inspect_data_tableA
Read structural properties of a UDataTable: RowStruct asset path + name, row count, sorted row names (FName.ToString), per-property name+type for each FProperty on the RowStruct (TFieldIterator with EFieldIterationFlags::None to skip super fields), client-strip flag, missing/extra-field tolerance flags, optional ImportKeyField. C++ handler; no new Build.cs deps (Engine + CoreUObject cover UDataTable / UScriptStruct / FProperty). Null-guards RowStruct (freshly-created DataTables can have no struct assigned).
Inputs: path (required).
inspect_dependency_graphA
Walk the asset dependency graph BFS from a root (dependencies, downward by default). Composes inspect_asset recursively; optionally also follows referencers (upward) for a bidirectional sweep. Distinct from get_reference_chain in that it defaults to direction=down (dependencies, packaging-audit framing) and supports a single bidirectional pass instead of forcing two separate calls. De-duplicates visited nodes across both directions.
Inputs: path (required), depth, include_referencers.
inspect_input_mappingsA
Dump the project's legacy UInputSettings: action_mappings (name+key+modifier flags) and axis_mappings (name+key+scale), plus a uses_enhanced_input flag that signals whether the project has migrated to the Enhanced Input system. The #1 context an LLM needs before touching gameplay code.
Inputs: no named parameters.
inspect_landscapeA
Read structural properties of an ALandscape (a SCENE ACTOR, not an asset): component dimensions, total component count across loaded streaming proxies, landscape material, world-space bounds, both LandscapeGuid (mutates on PIE/instancing) and OriginalLandscapeGuid (stable). Lookup by actor label or GUID; if neither is given and exactly one landscape exists, that one is returned. Diverges from sibling Inspect* handlers (which take asset paths) because UE landscapes have no .uasset.
Inputs: name, guid.
inspect_materialA
List parameter names declared by a UMaterial or UMaterialInstance: scalar, vector, texture, and static-switch parameters.
Inputs: path (required).
inspect_material_functionA
Inspect a UMaterialFunction by package path: returns leaf class name, package path, description, expose_to_library flag, library_categories (stringified Text values), function inputs (name + input_type enum stringified), function outputs (name), and additional editor-accessible UPROPERTYs via dir() permissive enumeration. SYNTHETIC bridge-side handler: composes execute_unreal_python + get_log_lines via the marker pattern. Logical errors (asset_not_found, wrong_asset_type, marker_not_found, invalid_json) return as ok=False success envelopes.
Inputs: path (required).
inspect_material_instanceA
Read a UMaterialInstanceConstant's parent + currently-overridden parameter values (scalar/vector/texture).
Inputs: path (required).
inspect_metasoundA
Inspect a MetaSoundSource or MetaSoundPatch asset by package path: returns leaf class name (which of the two it is), package path, and additional editor-accessible UPROPERTYs via dir() permissive enumeration. SYNTHETIC bridge-side handler: composes execute_unreal_python + get_log_lines via the marker pattern. Accepts either MetaSoundSource (emitter-attached) or MetaSoundPatch (reusable subgraph). Graph structure (nodes / connections) is NOT reflected here -- that requires a dedicated traversal pass. For surface-level metadata + exposed UPROPERTYs the permissive enumeration covers the common case. Logical errors (asset_not_found, wrong_asset_type, metasound_unavailable, marker_not_found, invalid_json) return as ok=False success envelopes.
Inputs: path (required).
inspect_niagara_systemA
Read structural properties of a UNiagaraSystem asset: emitter list (name + enabled + mode), user-exposed parameter list, system-level settings (looping, GPU usage, warmup + tick params when needed, fixed bounds, effect type). C++ handler -- requires Niagara runtime module + EnsureFullyLoaded() before reading lazy-loaded data.
Inputs: path (required).
inspect_physics_assetA
Read structural properties of a UPhysicsAsset: preview skeletal mesh cross-link, body setups (one per simulated bone with bConsiderForBounds + is_in_bounds_subset flags), constraint setups (joint between two bodies with child/parent bone names), bounds-bodies subset count, named physical-animation profiles, named constraint profiles. Pairs with inspect_skeletal_mesh via shared preview_skeletal_mesh path. C++ handler; no new Build.cs deps (Engine + PhysicsCore cover UPhysicsAsset / USkeletalBodySetup / UPhysicsConstraintTemplate). Null-skips TObjectPtr and TObjectPtr entries (PR #55->#57 lesson).
Inputs: path (required).
inspect_project_settingA
Reflect any UDeveloperSettings subclass (RendererSettings, PhysicsSettings, InputSettings, etc.) and dump editable UPROPERTY values as JSON. Bulk mode (omit 'property') returns every editable property; single mode (pass 'property') returns just that one. Closes the gap where the LLM had no access to per-system Project Settings.
Inputs: settings_class (required), property.
inspect_sequenceB
Read structure of a Level Sequence asset: tracks, sections, bindings, frame rate, playback range.
Inputs: path (required).
inspect_skeletal_meshA
Read structural properties of a USkeletalMesh asset: per-LOD vertex / triangle / section counts, bounding box (min/max/size/center) + sphere radius, target USkeleton, total + raw bone counts, material slots, morph targets (count + names), clothing assets, physics asset. C++ handler; no new Build.cs deps (Engine module covers it). Mirrors inspect_static_mesh's bounds shape for cross-handler consistency.
Inputs: path (required).
inspect_sound_attenuationA
Read structural properties of a USoundAttenuation asset (3D playback rules): distance algorithm + shape, spatialization, air-absorption LPF/HPF, listener focus, occlusion tracing, reverb send, priority attenuation, plus a feature_flags sub-object for assorted bool toggles. Each major feature group is collapsed to {"enabled":false} when its master gate (bAttenuate / bSpatialize / bAttenuateWithLPF / bEnableListenerFocus / bEnableOcclusion / bEnableReverbSend / bEnablePriorityAttenuation) is off, so the JSON stays compact for default-disabled assets. Completes the audio introspection trio with inspect_sound_cue + inspect_sound_wave. C++ handler; no new Build.cs deps (Engine covers USoundAttenuation / FSoundAttenuationSettings / FBaseAttenuationSettings).
Inputs: path (required).
inspect_sound_classA
Inspect a USoundClass by package path: returns leaf class name, package path, parent USoundClass asset path (for chaining), child USoundClass asset paths, and the editable FSoundClassProperties values (Volume, Pitch, low-pass filter, attenuation distance scale, voice-center-channel volume, radio-filter volume, eight boolean flags, OutputTarget enum). SYNTHETIC bridge-side handler: composes execute_unreal_python + get_log_lines via the marker pattern. UE Python field names are snake_case but the JSON output remaps to UE's native PascalCase FSoundClassProperties layout. Logical errors (asset_not_found, wrong_asset_type, marker_not_found, invalid_json) return as ok=False success envelopes; transport-level errors return as JSON-RPC errors.
Inputs: path (required).
inspect_sound_cueA
Read structural properties of a USoundCue asset: total duration, max distance, volume + pitch multipliers, subtitle priority, max audible distance, attenuation-settings cross-link, root sound-node class, and the full graph of sound nodes (sorted by name with class taxonomy). C++ handler; no new Build.cs deps (Engine covers USoundCue / USoundBase / USoundNode / USoundAttenuation). Null-skips TObjectPtr entries (PR #55->#57 lesson).
Inputs: path (required).
inspect_sound_submixA
Inspect a USoundSubmix by package path: returns leaf class name, package path, parent USoundSubmix asset path (for chaining), child submix asset paths, and additional editor-accessible UPROPERTYs discovered via dir() permissive enumeration. SYNTHETIC bridge-side handler: composes execute_unreal_python + get_log_lines via the marker pattern. Logical errors (asset_not_found, wrong_asset_type, marker_not_found, invalid_json) return as ok=False success envelopes; transport-level errors return as JSON-RPC errors.
Inputs: path (required).
inspect_sound_waveA
Read structural properties of a USoundWave asset: sample rate, channel count, frame count, duration, compression type + runtime format + (conditional) compressed data size, sound group, looping flag, streaming flag (via IsStreaming() not the deprecated bStreaming), loading behavior, subtitle count + supports flag, cue-point count + loop-region count (separated via GetCuePoints / GetLoopRegions). Editor-only fields (imported_sample_rate, lufs, sample_peak_db, comment) emit conditionally when non-default. C++ handler; no new Build.cs deps (Engine covers USoundWave / USoundBase / FSoundWaveCuePoint / FSubtitleCue). USoundWave's LoadBehavior=LazyOnDemand caveat handled by reading only declarative fields (no transient runtime state).
Inputs: path (required).
inspect_static_meshA
Read structural properties of a UStaticMesh asset: LOD count, per-LOD vertex/triangle counts, bounding box, material slots. Pairs with inspect_asset (registry metadata) and inspect_material (parameters). C++ handler -- benefits from native struct access. Part of the language-shim experiment (PR #46).
Inputs: path (required).
inspect_textureA
Read structural properties of a UTexture asset (UTexture2D / UTextureCube / UTextureRenderTarget / UTexture2DArray / ...): texture class, surface dimensions (width/height/depth via virtual accessors), sRGB, compression settings, filter, LOD group, LOD bias, mip-gen settings, virtual-texture streaming flag, never-stream flag, composite-texture cross-link. UTexture2D-specific: size_x / size_y / num_mips / pixel_format / imported_size_x|y. Pairs with the existing configure_texture handler (mutates these fields) and import_texture (creates the asset). C++ handler; no new Build.cs deps (Engine covers UTexture / UTexture2D / EPixelFormat).
Inputs: path (required).
inspect_widget_blueprintA
Read UWidgetBlueprint-specific structural properties: parent class, blueprint compile status, palette category, animations (with start/end/length and binding count), delegate property bindings, inherited named slots from parent class, and the property-bindings count. Complements inspect_blueprint (variables + graphs, inherited from UBlueprint) and inspect_widget_tree (widget hierarchy); cross-link via shared asset path. C++ handler; no new Build.cs deps (UMG + UMGEditor already present).
Inputs: path (required).
inspect_widget_treeB
Read the widget hierarchy of a UWidgetBlueprint or UEditorUtilityWidgetBlueprint.
Inputs: path (required).
list_levelsA
Enumerate every UWorld asset (level) in the project. Optional path_under defaults to '/Game/'; optional name_contains is case-insensitive substring filter. Closes the gap where load_level_by_path required the caller to already know the package path.
Inputs: path_under, name_contains.
list_tasksA
Enumerate all tasks in the FUCMCPTaskRegistry with optional status / type filters and a limit. Atomic snapshot under the registry's lock so the result is internally consistent. Returns total/matched/returned counts plus task records mirroring poll_task's shape.
Inputs: status_filter, type_filter, limit.
list_toolsA
Return the names of every registered MCP method on the UE server.
Inputs: no named parameters.
load_level_by_pathB
Load a UE level by package path, e.g. /Game/Maps/MyMap.
Inputs: path (required).
marketplace_importA
Download a CC0 asset from a marketplace (Polyhaven or AmbientCG) and import it into the project as a UTexture2D via the native import_texture handler. SYNTHETIC bridge-side handler. Polyhaven path: /files/{slug} catalog lookup -> direct download. AmbientCG path: /api/v2/full_json?id={slug}&include=downloadData -> downloads the per-resolution zip -> extracts the Color map (textures) or sole EXR/HDR (hdris) -> hands the file to import_texture. Supports texture (Color/Diffuse map) and hdri (EXR/HDR); model import is parked for a later PR (native handler has no mesh-import wrapper today). When multi_map=true is passed (texture only), the handler additionally pulls Normal/Roughness/AO/Displacement/Metalness when the source ships them — each map lands as a separate UTexture2D named <dest_name>_<map> (Color stays at <dest_name> for back-compat). Asset files: both sources are CC0 (public domain, no attribution required). API access: the Polyhaven public API is licensed for non-commercial and academic use only — commercial integrations require a custom license from Poly Haven (https://polyhaven.com/our-api). AmbientCG's public API and asset files are both CC0.
Inputs: slug (required), source, asset_type, resolution, +5 more.
marketplace_searchA
Search free CC0 asset marketplaces (Polyhaven, AmbientCG) for textures / HDRIs / models matching a keyword and return a normalised list of matches. SYNTHETIC bridge-side handler — fetches the source's public JSON catalog via plain HTTPS (no auth, no API key). Asset files are CC0 (public domain, free for any use including commercial). API-access terms differ from asset terms: the Polyhaven public API at api.polyhaven.com is licensed for non-commercial and academic use only — commercial integrations require a custom license from Poly Haven (https://polyhaven.com/our-api). AmbientCG asset terms are similarly CC0 with their own API ToS. Pair with marketplace_import to actually download and import a chosen result.
Inputs: query, source, asset_type, limit.
move_assetA
Move an asset to a different folder; leaf name unchanged. UE auto-creates a redirector at the source path.
Inputs: path (required), dest_folder (required).
pie_controlA
Start / stop / query Play-In-Editor sessions. Closes the 'did my edit actually work?' loop — LLM can scaffold a gameplay change, trigger PIE, observe the running state, then stop. action=start with mode=play|simulate; action=stop tears down current session; action=query returns is_playing + is_simulating booleans.
Inputs: action (required), mode.
poll_eventsA
Tier 2 entrypoint: drain editor events fired since the caller's last poll. Today UE pushes events from a starter set of delegates (actor_spawned, actor_deleted, asset_added) into a 1000-entry ring buffer (FUCMCPEventBus); this handler returns the slice with seq >= since_seq (inclusive cursor), capped at max_count. First call: pass since_seq=-1 (default) to discover the current next_seq, then poll with the previous response's next_seq for steady-state delta consumption. Response includes 'dropped' flag if the caller's since_seq fell below the oldest buffered event (i.e. buffer overflowed between polls).
Inputs: since_seq, max_count, event_filter.
poll_subscriptionA
Drain events for a server-side subscription. Per-sub cursor advances atomically with the read -- a successful poll never returns the same events twice. No since_seq param (cursor is server-side); no event_filter param (filter was set at register_subscription time and is immutable for that sub -- re-register if you need a different filter).
Inputs: subscription_id (required), max_count.
poll_taskA
Read current state of a task started via any start_*_task handler. Non-blocking: returns the registry snapshot and never waits for the task to advance. Status: pending | running | completed | cancelled | failed. Result populated when status=completed; error populated when status=failed.
Inputs: task_id (required).
register_subscriptionA
Tier 2 PR #43: create a server-side cursor + filter on the FUCMCPEventBus. Returns a subscription_id (FGuid string) usable with poll_subscription (drain matched events) and unsubscribe (release). The cursor starts at the bus's current next_seq -- subscribers see events fired AFTER subscription, not historical ones. PR #43 ships subscriptions WITHOUT TTL: they live until explicit unsubscribe.
Inputs: event_filter.
rename_assetA
Rename an asset's leaf name; folder unchanged. UE auto-creates a redirector at the old name.
Inputs: path (required), new_name (required).
render_camera_to_pngA
Force a synchronous render of the level-editor viewport (or an off-screen SceneCapture2D at arbitrary resolution) and write it to an absolute path as a PNG. Works headless/backgrounded where deferred screenshots fail.
Inputs: out_path (required), width, height, camera_label, +1 more.
reset_python_stateA
Clear all user-defined names from UE Python's public (shared-with-console) globals dict. Pairs with exec_python_persistent: lets Claude wipe accumulated state and start fresh without restarting the editor. Names starting with '_' (Python dunders + conventional private) are preserved. Imports the user explicitly added (e.g. 'import unreal') ARE cleared -- re-import in the next exec_python_persistent call.
Inputs: no named parameters.
run_python_fileA
Execute a .py file from disk via the editor's embedded Python. Complement to execute_unreal_python -- avoids escaping pain for non-trivial scripts. Output capture caveat: ExecuteFile mode does not return stdout/eval-result; use unreal.log marker + get_log_lines to round-trip results.
Inputs: path (required).
save_dirty_assetsA
Persist every in-memory-modified asset + map to disk. Same as editor 'Save All'. Closes the gap where edit-side tools (set_actor_property, set_mi_parameter, edit_widget_tree, etc.) mutated UObjects but left them dirty. Optional include_levels + include_content default to true.
Inputs: include_levels, include_content.
screenshot_actorA
Frame the editor viewport on an actor (by label or unique name) and capture a focused PNG screenshot. SYNTHETIC bridge-side handler: composes focus_actor + get_viewport_screenshot. Returns base64 PNG plus the focused actor's identity and world location.
Inputs: name (required).
sequencer_add_transform_keyframeA
Add a single keyframe on a Level Sequence's 3D Transform Track for a previously-bound actor. SYNTHETIC bridge-side handler. Closes the keyframe-authoring half of the 21st HANDOFF note's Sequencer parked item: create_sequence + bind_actor_to_sequence already exist; this tool wires up MovieSceneSequenceExtensions.find_binding_by_id + MovieSceneBindingProxy.add_track + MovieSceneScriptingDoubleChannel.add_key. Caller passes location/rotation/scale as optional 3-element triples; missing triples skip those channels. Rotation order is [pitch, yaw, roll] (unreal.Rotator convention) — mapped internally to the channel layout (Roll=X, Pitch=Y, Yaw=Z). Movie Render Queue remains parked.
Inputs: sequence_path (required), binding_id (required), time_seconds (required), location, +4 more.
set_actor_propertyA
Mutate any UPROPERTY on an actor. v0.4.0 supports primitives, all common UE structs, enums, TSoftObjectPtr, plus USTRUCT (recursive)/TArray/TMap (string-keyed)/TSet/FObjectProperty (hard UObject pointers via asset path). Property names accept dotted-path syntax for nested traversal (e.g. 'RootComponent.RelativeLocation'). FInstancedStruct deferred to v0.4.x.
Inputs: name (required), property (required), value (required).
set_actor_transformA
Move / rotate / scale an existing actor by name (label or FName). Supports both absolute and relative modes.
Inputs: name (required), location, rotation, scale, +1 more.
set_camera_transformC
Set the level-editor viewport camera transform. SYNTHETIC bridge-side handler (PR #46 language-shim experiment): single execute_unreal_python round-trip. All location/rotation fields are optional and default to 0.
Inputs: location, rotation.
set_console_variableA
Mutate a UE Console Variable by name. 'value' is polymorphic: string, number, or bool. Issues the change at ECVF_SetByConsole priority (matches user-typed-in-console semantics) so it overrides ini files and code-set values. Pre-rejects ECVF_ReadOnly CVars (those silently no-op after early init) with a clear error, and post-verifies the change landed.
Inputs: name (required), value (required).
set_mi_parameterA
Override a scalar/vector/texture parameter on a UMaterialInstanceConstant. Type discriminator: 'scalar' -> number, 'vector' -> {r,g,b,a}, 'texture' -> asset path string.
Inputs: path (required), parameter (required), type (required), value (required).
spawn_actorA
Create an actor in the current editor world at a location with optional rotation, label, and initial properties. Class path can be built-in (/Script/Engine.StaticMeshActor) or Blueprint (/Game/Blueprints/BP_X.BP_X_C).
Inputs: class_path (required), location, rotation, label, +1 more.
start_sleep_taskA
Tier 2 PR #44 framework tracer: spawn a background task that sleeps for duration_ms then completes. Returns immediately with a task_id; poll via poll_task or cancel via cancel_task. Useful by itself for 'wait N ms and then do something' workflows; primary purpose is to exercise the FUCMCPTaskRegistry threading + cancellation paths. Hard cap on duration_ms is 1 hour.
Inputs: duration_ms (required).
take_high_res_screenshotA
Trigger UE's HighResShot. Output -> Saved/Screenshots/Editor/ (Windows/Mac/Linux). Optional multiplier (1..8).
Inputs: multiplier.
unsubscribeA
Remove a subscription created via register_subscription. Idempotent: calling on an unknown id returns ok=true with was_present=false rather than an error, so callers can blanket-unsubscribe on shutdown without worrying about partial state.
Inputs: subscription_id (required).
wait_for_eventsA
Bridge-side composition of poll_events: repeatedly polls UE every poll_interval_ms until matching events arrive or timeout_ms expires. Implemented in the bridge (not as a UE handler) so the wait runs in this Python process -- UE's game thread keeps running between polls and game-thread events (actor_spawned, map_changed, etc.) actually fire during the wait. Same response shape and cursor semantics as poll_events, plus a 'timed_out' field. Default timeout 500ms; hard cap 30000ms (30s).
Inputs: timeout_ms, poll_interval_ms, since_seq, max_count, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 105 tools
Most tools are clearly separated by resource type (inspect_sound_*, inspect_blueprint, etc.), but several execution families overlap: execute_unreal_python / exec_python_persistent / run_python_file / apply_python_to_selection all run Python, and get_viewport_screenshot / screenshot_actor / take_high_res_screenshot / render_camera_to_png all capture images. Detailed descriptions mitigate the ambiguity, but an agent could easily misselect without reading carefully.
The server mostly follows a clean verb_noun snake_case pattern, with excellent family consistency in inspect_*, bulk_*, set_*, and poll_* tools. Minor deviations exist: pie_control and unsubscribe are single verbs, sequencer_add_transform_keyframe breaks the verb-first ordering, and some verbs alternate between get_ and inspect_ for similar read operations.
105 tools is an extreme surface, far beyond the 16-25 'heavy' range and even the 50+ extreme-mismatch bar. While Unreal Editor is a broad domain, this many tools creates severe context-window and selection burden, and many tools could be condensed into parameterized families or folded into the Python escape hatch.
The toolset is exceptionally broad: asset inspection/mutation, actor control, level sequencing, audio, niagara, materials, Python execution, console variables, events, marketplace import, and even mod packaging. Missing creation/lifecycle tools for many asset types and the lack of Blueprint graph editing are genuine gaps, but they are workable around via execute_unreal_python and the extensive bulk/batch helpers.
Maintenance
Related MCP Connectors
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to control Unreal E…
Control Unreal Engine to browse assets, import content, and manage levels and sequences. Automate…
Make games with AI: one MCP server that connects your agent to Unity, Unreal and Godot editors.
214 tools for AI agents over one MCP endpoint: image, video, audio, 3D, data, storage, mail, GPUs.
Related MCP Servers
- AlicenseNot gradedqualityAmaintenanceUnreal Engine 5.7 editor plugin that gives AI assistants full read/write access to Blueprints, Materials, Animation, Niagara, Config, and more via MCP. 119 actions across 9 domains, pure C++, embedded Streamable HTTP server.375MIT
- AlicenseBqualityCmaintenanceAn MCP server that gives AI agents broad control over Unreal Engine 5.7, enabling actor/asset/level management, Blueprint and material creation, screenshots, automation, and arbitrary editor Python execution.35MIT
- AlicenseCqualityDmaintenanceEnables AI clients to control Unreal Engine 5 editor for automated Blueprint authoring, level inspection, actor spawning, and other editor workflows via a local Python MCP server and UE plugin.5004AGPL 3.0
- AlicenseBqualityCmaintenanceAn MCP server that lets an AI agent drive Unreal Engine 5: create projects, import assets, build levels and Blueprints, configure replication, compile C++, run Play In Editor and package the game.100149 PyPI6MIT