Unreal MCP connects AI clients such as Cursor, Windsurf, and Claude Desktop to Unreal Engine through the Model Context Protocol. The chongdashu/unreal-mcp repository presents it as an integration for controlling Unreal Engine in natural language, with actors, Blueprints, node graphs, and viewport control. During the GitHub check on August 26, 2026, the repository had 2,065 stars and 340 forks; the README displayed an MIT license badge, while the GitHub API license field did not return a detected license.
For Educasium, this connector is interesting, but it needs stricter framing than Unity MCP. The README explicitly declares experimental status: breaking changes may occur, features may be incomplete or unstable, documentation may be outdated, and production use is not recommended. That sentence is not a detail; it is the starting point for any serious page about Unreal MCP.
Contents
- What Unreal MCP does
- Architecture and installation
- Actor, editor, and Blueprint tools
- Version inconsistencies to check
- Comparison with Unity, Blender, and TouchDesigner
- Security, limits, and production
- Educasium position
What Unreal MCP does
Key point: Unreal MCP gives an AI assistant commands to act inside the Unreal Editor, but the repository declares it experimental and advises against production. The right reading is controlled exploration, not client pipeline automation.
Advertised capabilities
The README groups capabilities into four families. Actor Management covers creating and deleting actors, transforms, properties, name search, and listing actors in the current level. Blueprint Development covers creating Blueprint classes, components, properties, physics, compilation, and spawning Blueprint actors.
Blueprint Node Graph covers adding event nodes, function calls, node connections, variables, and component or self references. Editor Control covers focusing the viewport on an actor or location, plus camera orientation and distance. This coverage fits an Unreal prototype, but it is not presented as stable.
Why experimental status changes the decision
The README's Experimental Status section is direct. It says the API, functionality, and implementation details may change significantly. It warns that breaking changes may occur without notice, features may be incomplete or unstable, documentation may be outdated or missing, and production use is not recommended at this time.
For an Educasium page, that warning should appear before examples. Without it, the reader might assume Unreal MCP is equivalent to a mature tool like Unity MCP. That is not what the repository says. The current value is experimentation and learning how MCP bridges can reach real-time engines.
Architecture and installation
Key point: Unreal MCP combines a C++ plugin inside Unreal and a Python MCP server that communicates with the plugin over a TCP socket. The README indicates port 55557 for the connection between Python server and plugin.
Repository components
The repository contains MCPGameProject, a sample Unreal project based on a Blank Project with the UnrealMCP plugin already added. It also contains MCPGameProject/Plugins/UnrealMCP, which carries the native C++ plugin, and Python/unreal_mcp_server.py, which implements the Python server. The README says the plugin integrates with Unreal Editor subsystems, implements actor manipulation tools, and handles command execution and responses.
The Python server manages TCP connections to the C++ plugin on port 55557, serializes commands, parses responses, handles errors, and loads tool modules from Python/tools. The verified modules are blueprint_tools.py, editor_tools.py, node_tools.py, project_tools.py, and umg_tools.py.
Practical installation
The README asks for Unreal Engine 5.5+, Python, and an MCP client such as Claude Desktop, Cursor, or Windsurf. For a quick start, it suggests using MCPGameProject, generating Visual Studio project files, opening the solution, choosing Development Editor, and building. For an existing project, copy MCPGameProject/Plugins/UnrealMCP into the project's Plugins folder, enable the plugin in Edit > Plugins, restart the editor, generate Visual Studio project files, and build.
The MCP configuration example uses the uv command with --directory pointing to the Python folder, then run unreal_mcp_server.py. The repository mcp.json file shows the same structure. This confirms the MCP assistant does not speak directly to Unreal: it launches a Python server that then talks to the C++ plugin.
Actor, editor, and Blueprint tools
Key point: the docs mainly detail actors, viewport, and Blueprints; the repository also contains modules for nodes, project, and UMG. Describe the coverage without promising a complete Unreal editor.
Actors and viewport
The Actor Tools documentation lists get_actors_in_level, find_actors_by_name, create_actor, delete_actor, set_actor_transform, and get_actor_properties. Supported actor types for create_actor include CUBE, SPHERE, CYLINDER, PLANE, POINT_LIGHT, SPOT_LIGHT, DIRECTIONAL_LIGHT, CAMERA, and EMPTY. Implementation notes say transforms must be lists of three floats and actor types must be uppercase.
The Editor Tools documentation lists focus_viewport and take_screenshot. focus_viewport can target an actor or a location, with distance and orientation. take_screenshot captures the viewport with a filename, show_ui option, and resolution. These tools are useful for visual demos, but the docs themselves include possible errors such as no active viewport or actor not found.
Blueprints
The Blueprint Tools documentation covers create_blueprint, add_component_to_blueprint, set_static_mesh_properties, set_component_property, set_physics_properties, compile_blueprint, and set_blueprint_property in the verified section. The README adds that the integration can create Blueprint classes, add and configure components, set properties and physics, compile Blueprints, and create input mappings.
For Educasium, this area matters because it brings the AI assistant closer to Unreal's visual language. It is also risky. A Blueprint that compiles may still be badly architected, fragile, or incompatible with project conventions. Keep demos small: create a simple Blueprint, add a component, compile it, place an actor, and verify the viewport.
Version inconsistencies to check
Key point: the repository files do not all say the same thing about the minimum Python version. The right instruction is to verify the environment at setup time.
Unreal and Python
The root README displays Unreal Engine 5.5+ and Python 3.12+ badges. Python/README.md, however, says to make sure Python 3.10+ is installed. The Python folder pyproject declares requires-python >=3.10, version 0.1.0, and dependencies such as mcp[cli] >=1.4.1, fastmcp >=0.2.0, uvicorn, fastapi, pydantic, and requests.
That divergence does not prevent testing the project, but it should be mentioned. In a workshop, prepare the environment in advance and record the Python version actually used by uv. In a studio, document Unreal, Python, plugin, server, and MCP client in an install log.
Young documentation
The docs index Actor Tools, Editor Tools, and Blueprint Tools, but Python/tools also contains node_tools.py, project_tools.py, and umg_tools.py. That matches the README warning that documentation may be outdated or incomplete. Do not turn a missing detailed page into absence of capability, or the reverse.
The sound method is to start from published docs for examples and verify code when a specific capability becomes important. For an SEO page, it is fair to cite verified modules, but for technical training, each tool should be tested inside Unreal before being included in an exercise.
Comparison with Unity, Blender, and TouchDesigner
Key point: Unreal MCP is an experimentation path for Unreal Engine, while Unity MCP appears more mature and documented at the time of this check. The choice should not be made only on engine preference.
| Option | Natural use | Main strength | Limit to watch |
|---|---|---|---|
| Unreal MCP | Unreal exploration, actors, Blueprints, viewport | Unreal Engine access and Blueprint graphs | Experimental status and production discouraged |
| Unity MCP | Unity prototypes, scenes, scripts, tests, builds | Rich manifest, documented security, broad adoption | C# execution and project mutations need control |
| Blender MCP | Accessible 3D modeling and assets | Good entry point for scene and render | Less suited to full engine projects |
| TouchDesigner MCP | Real-time visual installations | Live nodes, parameters, TOP image | .tox API version and Python scripts need attention |
Choose by maturity and risk
If the goal is exploratory Unreal training, Unreal MCP is relevant: it shows how an MCP can drive actors, viewport, and Blueprints. If the goal is a real pipeline with tests, builds, and documented security, Unity MCP currently looks stronger in the verified sources.
For simple 3D initiation, Blender remains more accessible. For a real-time installation, TouchDesigner maps better to live graphs and TOP outputs. Unreal MCP should therefore be presented as an advanced topic, with a stricter test protocol than more mature connectors.
Security, limits, and production
Key point: the README explicitly advises against production; this page should respect that limit. Every demo should happen on a sample project or copy.
Why stay in a sandbox
Unreal MCP acts inside an Unreal Editor through a native plugin and Python server. Even though the verified docs focus on actors, viewport, and Blueprints, this kind of tool can modify a scene, create assets, compile Blueprints, and produce files. A mistake can break a project, pollute a level, or generate a structure that is hard to maintain.
The best rule is to start from the provided MCPGameProject, then work on copies. Track changed files, read logs, keep frequent commits in the Unreal project, and never run a demo on the only copy of a client project. The repository itself gives enough reasons for that caution.
What to verify before going further
Before any workshop, verify Unreal Engine 5.5+, Visual Studio or build toolchain, plugin enabled, Python server installed, uv working, port 55557 available, MCP client configured, and unreal_mcp.log readable. Also check that an active viewport exists before capture or focus commands.
Before any professional recommendation, add an evaluation layer: stability across sessions, behavior after crashes, error handling, file boundaries, network security, compatibility with Unreal version control, and validation by an Unreal developer. Without that, the positioning stays at the study and experimentation level.
Educasium position
Key point: Educasium can present Unreal MCP as an advanced case study, not as a tool ready for client workflows. Honesty about experimental status makes the page more credible.
Proposed training
A reasonable Educasium module starts with the MCPGameProject sample. It shows plugin compilation, Python server launch, MCP client configuration, then a short sequence: list actors, create a cube, move the actor, focus the viewport, and take a screenshot. Only after that should it create a simple Blueprint, add a component, compile it, and place the actor.
This progression keeps risks visible. The learner understands the chain of C++ plugin, Python server, MCP client, and Unreal Editor. They also see that errors are part of the topic, especially in an experimental project.
Logical next step
The logical next step would be an Educasium grid for experimental real-time engines: repository maturity, README warnings, versions, native plugin, mutation surface, logs, rollback, scene tests, stability, and visual evidence. Unreal MCP is useful precisely because it forces this rigor.