uefnmcp.com
Sign in Install uefn-mcp

One install. One server.

Install uefn-mcp. Your agent is connected.

Run one PowerShell command on the Windows box that has UEFN, then paste one line that points at CONNECT.md. The same process drives the editor and calls https://uefnmcp.com/mcp for Verse grounding. Do not add a second MCP server.

uefn-mcp

uefn-mcp

One PowerShell command on the Windows box that has UEFN. Source: BizaNator/uefn-mcp. Do not add a second MCP server.

  1. Run the installer

    If the client repo is private, the script uses gh or git with your existing GitHub login. The installer writes CONNECT.md and does not dump mcpServers JSON unless you pass -VerbosePaste.

    PowerShell
    irm https://uefnmcp.com/install.ps1 | iex

  2. Paste this to your agent

    One line. The installer writes the full brief to CONNECT.md (and UEFN-MCP-CONNECT.md on the island when the project is known). That file tells the agent to ASK THE HUMAN for the folder that contains the .uefnproject if needed, verify already-written .mcp.json, and run setup.ps1 so Content\Python is armed. One server only. A portal key is not required.

    paste to agent
    Read %LOCALAPPDATA%\uefn-mcp\CONNECT.md and configure UEFN-MCP according to those instructions. In every new session, call list_toolsets and enable_toolset(...) for any group the task needs that is not already listed.

  3. CONNECT.md

    The brief on disk tells the agent to verify already-written .mcp.json — do not hand-author. HOSTED_MCP_URL defaults to the hosted grounding endpoint. -VerbosePaste still prints the old mcpServers dump.

    uefn-mcp
    {
  "mcpServers": {
    "uefn-mcp": {
      "command": "node",
      "args": [
        "<path printed by the installer>\\index.js",
        "--stdio"
      ],
      "env": {
        "HOSTED_MCP_URL": "https://uefnmcp.com/mcp",
        "UEFN_PROJECT_PATH": "<absolute project folder — contains the .uefnproject>",
        "UEFN_PROJECT_ROOT": "<absolute Content/Verse or Plugins/<Plugin>/Content/Verse>"
      }
    }
  }
}

  4. Toolsets

    Setup lists the verse, scene, session and ui toolsets by default (UEFN_MCP_TOOLSETS=verse,scene,session,ui), and run_editor_python is always in core. call_epic_mcp reaches Epic's built-in UEFN MCP, which setup starts automatically. For anything else (audio, materials, fab, performance and more), the agent calls list_toolsets, then enable_toolset(...) before the task. That repeats in each new session, LAN sessions included. Codex is set to UEFN_MCP_TOOLSETS=all because it may not refresh its tool list after a change.

Driving the editor from another machine? See Remote control over LAN or VPN.

Something not connecting? Tell your agent to call get_skill('uefn-mcp-connectivity') first. It explains the three layers (client tools on the editor PC, uefnmcp.com, and Epic's UEFN MCP) and walks a fix for each, with children for install (uefn-mcp-install), Claude and Codex plus panels (uefn-mcp-clients), LAN or Tailscale (uefn-mcp-network), and a relay game-thread timeout (uefn-editor-dialogs).

Agent playbooks: get_skill('uefn-tool-contracts') maps each job to the exact tool (client, cloud, call_epic_mcp, call_unreal_mcp) and lists what can be created today versus the object types that still cannot. get_skill('verse-change-workflow') runs an intent check, a plan, compile_check and a two-part review before code is called done. get_skill('verse-dependency-audit') maps Verse dependencies with the local graph toolset (enable_toolset('graph')) before a delete, move, or rename. get_skill('uefn-performance-audit') measures Memory Calculation. A cook that fails because GameFeatureSet delmargfs is unavailable is the same skill: explain the error and follow the bug report. get_skill('uefn-memory-reduction') is the child for lowering that bar (instanced static meshes, a zone spawner, a building shell, a lazy device editable). A Lore check-in crash or packstore read error is get_skill('uefn-p4').

Hosted grounding signs in via browser OAuth on first use. Portal keys (uefn_sk_*) are optional — CI and overrides only. CI / override keys. Already installed? Update.

FAQ

Already installed?

Update the desktop client, then reconnect MCP.

on your machine

How do I update the desktop client?

Pull the latest client into %LOCALAPPDATA%\uefn-mcp. Then reconnect or reload MCP in your agent.

PowerShell
iex "& { $(irm https://uefnmcp.com/install.ps1) } -UpdateOnly"

After Computer-Use bridge changes, also re-run setup.ps1 against the island and relaunch UEFN so :8766 is replaced.

Already in a checkout? From that folder run npm run update or install.ps1 -UpdateOnly.

The updater refuses a dirty tree, a detached HEAD, the wrong branch, or local commits ahead of origin. A refused update exits nonzero and preserves HEAD and files. Do not treat that divergence as an authentication failure. Do not run gh repo sync ..

Remote control

Remote control over LAN or VPN

Agents on another computer can drive the editor PC directly, with every tool including Python and computer use, without SSH.

Endpoint

Once setup.ps1 has run, uefn-mcp on the editor PC serves MCP at http://<editor-pc>:8767/mcp. Each request carries Authorization: Bearer <key>. Everyone uses their own uefnmcp key (uefn_sk_*, from Keys). Never share keys.

Who gets in: the account that signed in on the editor PC, plus members of a studio it shares, viewers included. Everyone else is refused. The editor PC's client must be signed in to uefnmcp.

Claude Code

shell
claude mcp add --transport http uefn-lan http://<editor-pc>:8767/mcp --header "Authorization: Bearer $UEFNMCP_KEY"

Codex

~/.codex/config.toml
[mcp_servers.uefn-lan]
url = "http://<editor-pc>:8767/mcp"
bearer_token_env_var = "UEFNMCP_KEY"

Cursor

.cursor/mcp.json
{
  "mcpServers": {
    "uefn-lan": {
      "url": "http://<editor-pc>:8767/mcp",
      "headers": { "Authorization": "Bearer ${env:UEFNMCP_KEY}" }
    }
  }
}

Then enable toolsets

A LAN session gets core plus the verse, scene, session and ui toolsets, so Python, actor edits, playtest and computer use work right away. For other groups, call list_toolsets, then enable_toolset(...) before the task, in every new session.

Firewall and safety

  • Setup adds an inbound Windows Firewall rule for TCP 8767 on the Private profile only, from the local subnet and the Tailscale range, and updates an older local-subnet-only rule. It needs an admin shell. Without one, setup prints the command to run.
  • Traffic is plain HTTP, so keys cross the network unencrypted. Only use a trusted home or studio LAN, or a VPN.
  • Set UEFN_LAN=0 in the uefn-mcp server env to go back to local-only.

Over a VPN (Tailscale and similar)

Tailscale works as-is: 100.x addresses and MagicDNS names like editor-pc.your-tailnet.ts.net are accepted, and the firewall rule includes the Tailscale range (100.64.0.0/10). For other VPNs or custom DNS names, add the name to UEFN_LAN_ALLOWED_HOSTS (comma-separated) on the editor PC. Plain machine names and .local, .lan, .home.arpa and .internal names are accepted already. Windows may put a VPN adapter on the Public profile; set it to Private so the firewall rule applies.

Epic's own UEFN MCP

Setup also starts Epic's built-in UEFN MCP on the editor PC. It only listens on that machine, so LAN agents reach it through uefn-mcp's call_epic_mcp tool (action=list, then action=call). Use it for things only Epic's tools do, such as Scene Graph entities and UMG widget trees.

call_epic_mcp only talks to the editor PC's own loopback address. A URL that points at any other machine is refused before anything is sent. Over LAN it runs only for a caller signed in with their own key, so an unauthenticated request never reaches Epic's server. If Epic's server is off, read the error, then confirm the server. On 43.00, MCP settings live in Editor Settings (search Model Context Protocol): Auto Start Server, Start, Stop, and the config setup button. Builds before 43.00 still enable Python Editor Scripting and UEFN MCP Toolsets in Project Settings, then Auto Start Server, and relaunch UEFN. After it is up, action=instructions once, then action=list, then action=call. Playbook: get_skill('epic-valkyrie-mcp'). 43.00 Verse breaks are get_skill('uefn-verse-pitfalls'). Progression quests are get_skill('uefn-progression-quests'), the child of get_skill('uefn-multiplayer-state').

If Unreal Editor 5.8+ runs on the same PC, call_unreal_mcp reaches Epic's Unreal MCP the same way: loopback only, same LAN sign-in, default port 8011 so it doesn't clash with UEFN. Turn on the Unreal MCP and All Toolsets plugins and Auto Start Server in Unreal's Editor Preferences. Agents load get_skill('epic-unreal-mcp').

Troubleshooting

Agents load get_skill('uefn-mcp-network') for LAN and VPN problems and get_skill('uefn-mcp-connectivity') for anything else that will not connect. A relay game-thread timeout, or an editor that seems hung, is get_skill('uefn-editor-dialogs') (get_editor_dialogs / dismiss_editor_dialog on the ui toolset). On the editor PC, npm run doctor prints a lan line, and http://127.0.0.1:8767/lan-status shows the endpoint state.

Advanced

Cloud-only — no UEFN on this machine

When the box has no editor, add https://uefnmcp.com/mcp as a connector and sign in. This path does not spawn, place, screenshot, or play, but compile and verify works without the editor open. Do not use it as a second server next to uefn-mcp. The REST alias https://uefnmcp.com/mcp-api still works for older connectors.

Claude, ChatGPT, Codex, Grok

Add a custom connector with the URL https://uefnmcp.com/mcp and sign in.

Portal keys (uefn_sk_*) stay optional, for CI or overrides. Sign-in is enough for these clients.

In the client

Visual panels

A connected client can show an API symbol, lessons and info links, a skill, a Studio bundle, a Verse check, a screenshot gallery, and (with the uefn-mcp client) a Verse dependency graph.

Screenshot shares

Shares are hosted at shots.uefnmcp.com. Free links last 7 days. Pro and Studio links last 90 days. Pinned links never expire. Signed-in accounts can review theirs in the portal.

Verse dependency graph

The client's graph toolset is off by default. Turn it on with enable_toolset('graph'). It parses your project's Verse on your PC into a local graph (%LOCALAPPDATA%/uefn-mcp/verse-graph/). The verse_graph_* tools answer who calls or uses a symbol, why A depends on B, and what a change would affect. They also find cycles, check layer rules, and list code that is unreachable under a policy. verse_graph_bootstrap writes a project brief at session start. When the editor answers, that brief resolves placed Verse devices: each one is a VerseDevice wrapper actor, the Verse class is the instance on its script property, and @editable values are read from that instance. The reply lists at most 100 device rows by default; the saved brief keeps every row. Details-panel device-to-device event bindings are not exposed. verse_graph_open_panel shows a Graph tab and an Audit tab in Claude, Codex and ChatGPT, and other hosts get a text summary. Source appears only when you open a symbol, and nothing is uploaded.

The parser is heuristic, not the Verse compiler. Every edge is marked resolved, guessed, ambiguous or unknown. It does not infer types and cannot tell overloads apart. It can mistake an Epic API name for your own symbol. It does not see editor bindings, device wiring, asset references or reflection. Results never say "unused", only "unreachable under policy". Agents load get_skill('verse-dependency-audit').

Pak icons

extract_pak_icons runs on the computer that has the game install. It reads local paks and writes PNG icons for devices, characters, items, and props. dry_run lists paths and writes nothing. Build the CUE4Parse extractor and point UEFNMCP_PAK_EXTRACTOR at it. An optional staff upload accepts POST /mcp-api/pak-extract/<class>/<slug> or POST /mcp-api/pak-extract?class=&slug= and is not required for the tool to be useful. Agents load get_skill('uefn-asset-org').

Studio

Push a snapshot · author a runbook

Paying plans get per-project Studio Sync. Projects auto-list from your personal studio, named orgs, connected MCP clients, and the first snapshot or tool call. Paste snapshot JSON (or wait for uefn-mcp export_world_context) and write runbook markdown. Pack a Studio Sync bundle so another project can pull the same Verse or scene-graph module. Search is ACL-scoped full-text search over your project's files. Invite teammates with their own Discord, Google, or GitHub login. Agents call push_level_snapshot, list_snapshots, get_snapshot, list_studio_skills, get_studio_skill, put_studio_skill, list_studio_bundles, pack_studio_bundle, update_studio_bundle, install_studio_bundle, search_studio_verse, search_studio_bundles, list_studio_library.

Snapshot JSON

schema_version: 1. Fields: name, project_id, optional island_id, uefn_version, exported_at, actors[], devices[], summary. Max 4 MB. Full note: the hosted docs page in the repo (docs/UEFNMCP-STUDIO.md).