Unreal MCP Server: Blueprints and Claude Setup, Step by Step

You type one sentence into a chat window, and a Blueprint asset appears in your Content Browser. That is the promise of an Unreal MCP server: a small bridge program that lets Claude talk to a running Unreal Engine editor through the Model Context Protocol. The promise is real, but the setup has sharp edges. You deal with two editor plugins, a port or two, a JSON file, and a few limits that nobody mentions until you hit them. This article walks through the whole chain, from switching on the right plugins to writing prompts that produce clean Blueprints, and it is honest about what Claude cannot do inside a Blueprint graph yet.

What an Unreal MCP Server Does

An MCP server is a program that exposes tools to an AI client. Claude sees a menu such as "create Blueprint", "spawn actor" or "run editor script", and it picks from that menu whenever your prompt needs an action inside the engine. The Unreal side is simple because the editor already ships with ways to accept outside commands. The server translates Claude's tool calls into those commands and sends the editor's reply back.

The Three Moving Parts

Every setup has the same three pieces, whatever server you pick:

The client launches the server as a child process and talks to it over standard input and output. The server then reaches the editor over localhost. Nothing leaves your computer except the prompts you send to Claude itself.

Why Not Paste Code Instead

Without a bridge, you ask Claude for a Python script, copy it, paste it into the editor's Python console, read the error, and copy the error back. With the server, Claude runs the script itself, reads the editor's answer, and fixes its own mistakes. The loop closes without you in the middle.

• Claude sees the real result, so a wrong asset path gets corrected on the spot
• Repetitive chores like renaming 200 assets collapse into one prompt
• Your hands stay inside the editor while the chat handles setup work

The better servers go well beyond asset chores. UEMCP's page says Claude can spawn actors, build materials, author Blueprints, manage assets, fly the viewport camera and take screenshots, all from a conversation. Screenshots matter more than they sound: when your client supports image results, Claude can look at the viewport after a change and check the result against your request, instead of trusting a success message alone.

Pick the Right Server First

Several open source servers exist, and they reach the engine by three different routes. Choose by how you like to work, not by popularity.

Python Remote Execution Servers

UEMCP is the clearest example. It speaks the engine's built-in Python remote execution protocol, the same multicast lookup and TCP command channel that ships with Unreal. Its PyPI page lists Unreal Engine 5.0 to 5.6 and Python 3.10 or newer, and it exposes Blueprint tools for creating a Blueprint, adding a component and setting a default property. Nothing to compile.

Remote Control API Servers

unreal-engine-mcp takes the HTTP route. It combines the Remote Control API with in-editor Python, listens on port 30010 by default, and its page lists 162 tools, including asset import, level creation, material graphs, C++ class generation and packaging. It reports testing on Unreal Engine 5.8. Also nothing to compile.

C++ Plugin Servers

Some projects ship a C++ plugin that opens a socket inside the editor, and a Python server connects to that socket. You get deeper access, because plugin code reaches editor internals that Python does not. The price is a build per engine version. The UnrealMCP plugin works this way: you drop it in your project's Plugins folder, run its setup script, and point Claude Desktop at its run script.

💡 Quick pick: If you have never touched an MCP server, take the Python remote execution route. It needs one command in Claude Code and no compiler. Move to a C++ plugin only when you hit a wall that Python cannot cross.

Prepare the Unreal Editor

Both no-compile routes lean on plugins that ship with the engine. Switch them on once per project. Check your engine version against the server's listed range before anything else: UEMCP lists 5.0 to 5.6, while the Remote Control server reports testing on 5.8. On a version outside the list, expect some Python API calls to behave differently.

💡 Use a scratch project: Run your first session on a blank project with the same engine version. A throwaway level costs you nothing, and any surprise stays away from your real assets.

Enable the Plugins

1. Open Edit ▸ Plugins in the editor.
2. Search for Python Editor Script Plugin and tick it.
3. On the Remote Control route, also search for Remote Control API and tick it.
4. Restart the editor when it asks.
5. Open Edit ▸ Project Settings, search for "remote execution", and turn on Enable Remote Execution.

The setting lives in your project config, so you do this once. Commit the config change to source control so teammates inherit it.

Start the Web Server

The Remote Control route needs its HTTP server running. Open the console in the Output Log and run:

WebControl.StartServer

Copy Prompt

The server answers on port 30010 unless you changed it. Keep the editor open and idle while you test: commands run inside the editor, so a busy editor compiling shaders answers slowly. UEMCP's default timeout is 120 seconds per command, which is generous but not infinite.

Connect Claude to the Editor

With the editor ready, register the server with your Claude client. Pick the client you already use.

Claude Code in One Command

For the Python remote execution route:

claude mcp add unreal -- uvx uemcp

Copy Prompt

For the Remote Control route:

claude mcp add unreal-mcp -- python -m unreal_mcp.server

Copy Prompt

The first command needs uv installed, because uvx runs the package without a manual install. Run claude mcp list to confirm the server is registered, or type /mcp inside a session to see its connection status.

Claude Desktop JSON Config

Open Settings ▸ Developer ▸ Edit Config. On Windows the file sits at %APPDATA%\Claude\claude_desktop_config.json. Add an entry under mcpServers:

{
  "mcpServers": {
    "unreal": {
      "command": "uvx",
      "args": ["uemcp"]
    }
  }
}

Copy Prompt

For the Remote Control server, pass the port through an environment variable:

{
  "mcpServers": {
    "unreal-mcp": {
      "command": "python",
      "args": ["-m", "unreal_mcp.server"],
      "env": { "UE_MCP_PORT": "30010" }
    }
  }
}

Copy Prompt

Quit Claude Desktop fully, not just the window, then reopen it.

💡 Watch the commas: A trailing comma or a missing brace makes the whole file invalid, and the server silently never appears. Paste the file into any JSON validator before you restart.

Test With a Simple Prompt

Open a project in the editor first, then ask:

List the actors in the current level and tell me how many of them are lights.

If Claude answers with names that match your World Outliner, the chain works. If it says it has no Unreal tools, the client never loaded the server, so recheck the config before touching the editor.

Build Blueprints From Chat

Once the connection holds, the useful work starts. A Blueprint is a class, and creating a class with components and default values is exactly the kind of structured task Claude handles well through tool calls.

What Claude Can Build Today

Through the Python-based servers, reliable tasks include:

• Creating a Blueprint class from a parent such as Actor, Pawn or Character
• Adding components: static meshes, box and sphere collision, point lights
• Setting default values for variables, meshes, materials and collision presets
• Spawning Blueprint instances into the open level at exact positions
• Creating materials and data assets, then saving them

Here is a prompt that exercises most of that list:

Create an Actor Blueprint at /Game/Blueprints/BP_Pickup.
Add a StaticMesh component named PickupMesh using the engine Sphere mesh,
and a SphereCollision component named PickupTrigger with radius 120.
Set PickupMesh scale to 0.5 on every axis.
Then spawn three instances in the open level, 400 units apart along X.
Report the asset path and actor names when you are done.

Copy Prompt

Claude splits that into several tool calls, checks each reply, and retries when the editor returns an error. You watch the assets appear in the Content Browser as it goes.

A good first session has four beats:

1. Ask for a read-only report, such as "list every Blueprint in /Game/Blueprints".
2. Request one new Blueprint with two components.
3. Open it in the editor and compare it with what Claude reported.
4. Ask for a small edit, like a bigger sphere radius, and confirm the value in the Details panel.

If all four beats work, you know the pipeline reads, writes and verifies. Only then should you ask for bigger jobs, like dressing a whole room with props.

Where Blueprint Graphs Stop

Here is the limit most tutorials skip. One server's documentation states plainly that Blueprint node graphs cannot be authored from Python. Components, defaults and variables are fine. Wiring an Event Graph node by node is not reliable on that route.

The workaround is a clean split of labor. Claude writes the logic in a C++ parent class, exposing it with UFUNCTION(BlueprintCallable) and BlueprintImplementableEvent. You compile. Then Claude creates a Blueprint child, sets its defaults, and places it in the level. The graph stays tiny because the real logic lives in C++.

Newer servers advertise direct Blueprint graph reading and editing on recent engine versions. Treat that as promising and test it on a copy of your project before you trust it with real work.

Prompts That Work in Unreal

The server does the typing. Your prompt still decides the outcome. These habits cut the retry rate noticeably:

• Name every asset and path. "BP_Pickup in /Game/Blueprints" beats "a pickup".
• Request one change at a time. Small steps are easy to verify and easy to undo.
• End with a report request. "List what you changed" gives you a checklist to compare with the editor.
• State your engine version. Python API names shift between releases, so say "Unreal 5.6" up front.
• Hold the save. Ask Claude to wait before saving all assets until you have reviewed the result.
• Commit first. Use Git with LFS or Perforce, and commit before every session so a bad run is one revert away.

💡 Four-line template: Goal, asset path, constraints, what to report. Use it every time and your prompts stay short and precise.

Long sessions drift. After 20 or 30 tool calls, Claude may lose track of which assets exist, and it starts guessing paths. When that happens, open a fresh chat and paste a short summary of the current state: the folders in use, the Blueprint names, and the naming rule. A ten-line summary beats a two-hour history.

Fix Connection Problems Fast

Most failures fall into a handful of patterns:

When something fails, read the editor's Output Log first. Python errors from remote commands print there, and Claude often needs that exact text to fix the problem. If your client did not forward the error, paste it into the chat yourself.

One server's docs also point to bEnableRemotePythonExecution=True in DefaultRemoteControl.ini when remote execution stays blocked, so check that file if the checklist above does not fix it.

Lock Down the Connection

UEMCP's own page warns that the remote execution protocol has no authentication. Anyone who can reach the port can run Python inside your editor. Keep the connection on localhost, never expose the ports on shared office Wi-Fi, and add a firewall rule if your machine sits on a network you do not control. Claude Code also asks permission before tool calls, so read any prompt that runs arbitrary Python before you approve it.

Try It With PicassoIA

An Unreal project needs more than Blueprints. It needs design specs, level briefs and reference art, and PicassoIA handles that side in the browser.

Use Claude Sonnet 5 on PicassoIA

Plan the system on PicassoIA first, then hand the tidy result to your Unreal session. Here is the routine with Claude Sonnet 5:

1. Open the Claude Sonnet 5 page on PicassoIA.
2. Describe the goal in plain words: "A pickup actor that rotates, plays a sound and destroys itself on overlap. Unreal 5.6."
3. Ask for a numbered spec listing components, variables, events and asset paths.
4. Ask it to rewrite each spec line as a standalone prompt that ends with "report what you changed".
5. Paste those prompts, one at a time, into your Claude Code session connected to the Unreal MCP server.

Two parameter tips: keep the request to a single system per run, and state the engine version in the first sentence. For a larger gameplay system, try Claude Fable 5 or Claude Opus 4.7, and for fast drafts of C++ headers, Gemini 3.5 Flash is quick.

Make Reference Images for Levels

Before you ask Claude to build a courtyard, ship interior or forest clearing, give everyone the same picture of the target mood. Image models on PicassoIA such as Seedream 5 Pro, GPT Image 2 and Flux 2 Pro turn a sentence into a photoreal reference frame in seconds. They produce 2D images, so use them as a visual brief for lighting, materials and set dressing, then ask Claude to build the level to match.

Pick one scene from your current Unreal project and write a one-paragraph description of it. Open PicassoIA, generate three reference images from that paragraph, and keep the one that feels right. Paste its description into your next Claude prompt, and watch how much closer the first pass lands. Your pipeline gets faster the moment the prompts and the pictures agree.