Log inSubmit server
ChiR24 Unreal MCP logo

ChiR24 Unreal MCP

Connects MCP clients to Unreal Editor for automated asset, level, gameplay, Blueprint, cinematic, and testing workflows.

InstallRepositoryWebsite
Full README Compare alternatives Embed widget Claim this listing

Install ChiR24 Unreal MCP

Pick your client, then add it in one click or paste the config.

STDIONode.js
~/Library/Application Support/Claude/claude_desktop_config.json
claude_desktop_config.json
{
  "mcpServers": {
    "chir24-unreal-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "unreal-engine-mcp-server"
      ],
      "env": {
        "UE_PROJECT_PATH": "YOUR_VALUE_HERE"
      }
    }
  }
}

Settings → Developer → Edit Config, merge this into mcpServers, then fully quit and reopen Claude Desktop.

Values are written into the snippet above so you can paste it as is. They never leave your browser.

Install not yet sandbox-tested— we haven't run this command through our automated sandbox yet. Not a red flag; we're working through the catalog.

Overview

ChiR24-unreal_mcp connects MCP clients to a running Unreal Editor through the EngineWire native C++ plugin. It exposes a unified `unreal` tool with more than 450 searchable capabilities covering assets, Blueprints, actors, levels, gameplay systems, effects, animation, audio, AI, networking, and editor control. Clients can connect directly over Streamable HTTP or use a Node.js stdio proxy, making it suitable for editor automation, procedural content creation, and Play-In-Editor verification. Use it with Unreal Engine 5.0–5.8 when an AI agent needs to inspect or modify a live project.

Use cases

  • Build and modify Unreal levels through an AI client
  • Create Blueprints, UMG widgets, materials, and Niagara effects
  • Generate procedural landscapes, foliage, PCG graphs, and geometry
  • Run Play-In-Editor tests and inspect screenshots, logs, and results
  • Automate gameplay, animation, AI, audio, cinematic, and networking setup

Key features

  • More than 450 searchable Unreal Editor actions behind one MCP tool
  • Native C++ plugin with Streamable HTTP and Node.js stdio connection modes
  • Blueprint, asset, level, actor, material, UI, and procedural-environment editing
  • Gameplay, AI, animation, physics, effects, audio, sequence, and networking controls
  • PIE, screenshots, logs, tests, Python execution, profiling, and build operations
  • Runtime enablement and disabling of capabilities

Tools23

What ChiR24 Unreal MCP lets your agent do. Expand a tool for its parameters.

Self-reported~428 tokens of context

Security & health

What it can reach and how reliably it runs — from our own checks, not the maintainer’s claims.

ActiveLast checked Today

Recent health check succeeded.

34/34 checks healthy over the last 90d

Supply-chain signal

No high-severity advisories surfaced by our automated scan.

Critical 0High 0Medium 0Low 0

Scanned 3d ago via OSV.dev · unreal-engine-mcp-server (npm)

Adoption & maintenance

Factual signals from GitHub, npm, and our automated checks — not a rating.

GitHub stars1kStargazers on the source repository.
npm downloads3.4kPackage downloads in the last 30 days.
Last commitTodayMost recent push to the default branch.
Tools exposed23Callable tools this server registers over MCP.
Directory activity7 viewsConfig copies, upvotes, and views on AllMCPs.

How ChiR24 Unreal MCP works

What ChiR24-unreal_mcp does

ChiR24-unreal_mcp gives MCP clients access to a running Unreal Editor through the EngineWire plugin. It is designed for agent-driven editor work rather than standalone asset processing: actions execute inside the project and can affect levels, assets, gameplay systems, and editor state.

The capability surface spans more than 450 actions behind one MCP tool named unreal. Agents can search for actions using plain-language descriptions instead of memorizing individual operation names. Supported work includes browsing and modifying assets, creating or editing Blueprints and UMG interfaces, placing actors, managing levels and World Partition data, building procedural environments, and working with materials, Niagara, PCG, animation, audio, cinematics, AI, inventory, combat, GAS, and networking.

How it works

The native plugin runs inside Unreal Editor and performs operations on the editor's game thread. It also hosts the MCP endpoint, normally at http://127.0.0.1:3000/mcp.

Two connection paths are available:

  • Native Streamable HTTP sends requests directly from the client to the plugin.
  • The Node.js stdio proxy receives local MCP requests and forwards them to the same HTTP endpoint.

Both paths expose the same unreal tool. The HTTP route suits clients such as Claude Code, Cursor, and VS Code, including setups where several clients share one editor. The stdio route is intended for clients that launch local commands, including Claude Desktop, and preserves the session while the editor restarts; requests return NOT_CONNECTED until the editor is available again.

Connections listen on localhost and use the project's capability token by default. Native HTTP clients provide the token through the X-MCP-Capability-Token header. The stdio proxy reads the project location from UE_PROJECT_PATH and obtains the token from the project.

Setup and configuration

Unreal Engine 5.0 through 5.8 is supported. The plugin can be installed through Fab, copied from a release into MyGame/Plugins/EngineWire/, or referenced from a repository clone through the project's additional plugin directories. Enable EngineWire in the editor's Plugins settings, enable the native MCP server under the EngineWire project settings, and restart the editor. A loaded plugin reports its MCP status in the editor status bar and serves on port 3000.

Fab installation does not require a compiler. Building from source may require a C++ project and a build through Visual Studio, Rider, or Xcode; prebuilt binaries are available for Blueprint-only projects. The stdio route requires Node.js 20.19 or later.

Tools and capabilities

The unified action set covers:

  • Asset, material, render-target, behavior-tree, Blueprint, SCS, graph, UMG, and binding operations.
  • Actor spawning, deletion, transforms, physics, tags, editor cameras, PIE, viewports, and screenshots.
  • Level loading and saving, sublevels, streaming, data layers, HLOD, volumes, lighting, landscapes, foliage, spline environments, and procedural geometry.
  • PCG graphs, Geometry Script, Niagara, animation physics, Control Rig, IK, cloth, vehicles, ragdolls, Gameplay Ability System, characters, combat, inventory, and interactions.
  • AI controllers, Behavior Trees, EQS, perception, State Trees, Smart Objects, NavMesh, audio, Sequencer, cinematics, replication, RPCs, sessions, input mappings, and split-screen.
  • Logs, tests, Unreal Build Tool operations, project settings, console variables, Python execution, profiling, and package-build workflows.

Dynamic tool management can enable or disable capabilities at runtime, while object introspection supports inspection of Unreal objects.

Limitations and notes

The editor must be running for actions to execute. Native HTTP clients need to reconnect after an editor restart; the stdio proxy keeps its MCP session but cannot complete calls until the editor returns. The server is local by default and token-protected unless that configuration is changed. The Fab distribution may lag behind the newest repository release because Fab updates undergo Epic review.

Read the full README View source on GitHub

Reviews

No reviews yet — be the first to share how it worked for you.

Frequently Asked Questions about ChiR24 Unreal MCP

ChiR24-unreal_mcp is an MCP server that connects AI clients to a running Unreal Editor through the EngineWire native C++ plugin. Its unified `unreal` tool supports more than 450 searchable actions for assets, levels, actors, Blueprints, gameplay, effects, animation, AI, audio, cinematics, testing, and editor control.

Install the EngineWire plugin through Fab, copy it from a release into your project's `Plugins/EngineWire/` directory, or reference the plugin from a repository clone. Enable it in Unreal Editor, enable the native MCP server in Project Settings, and restart the editor.

Connect directly to `http://127.0.0.1:3000/mcp` with Streamable HTTP, or launch the Node.js stdio proxy and let it forward requests to that endpoint. HTTP clients send the capability token in `X-MCP-Capability-Token`; the stdio path uses `UE_PROJECT_PATH`.

Yes, Cursor is named as a supported client for the native HTTP route. Configure it to connect to the local MCP endpoint, provide the project's capability token, and keep the Unreal Editor plugin running.

ChiR24-unreal_mcp supports Unreal Engine 5.0 through 5.8. Fab installation does not require a compiler, while building the plugin from source may require a C++ project and a supported desktop compiler.

Related MCP servers

All in Gaming All alternatives
Add a badge to your READMEShow it’s listed — live SVG, Markdown or HTML.

AllMCPs Directory Badge

Full Badge Customizer

Showcase your server listing on GitHub or your project documentation. Embed this dynamic SVG badge to highlight official listing status and live engagement.

Badge Style:
Live Dynamic SVG PreviewChiR24 Unreal MCP AllMCPs Directory Badge
Markdown (GitHub README)
[![AllMCPs](https://allmcps.com/api/badge/chir24-unreal-mcp?style=directory)](https://allmcps.com/mcp/chir24-unreal-mcp)
HTML Embed
<a href="https://allmcps.com/mcp/chir24-unreal-mcp"><img src="https://allmcps.com/api/badge/chir24-unreal-mcp?style=directory" alt="ChiR24 Unreal MCP on AllMCPs" /></a>