Unreal-MCP

Servidor MCP de código abierto que conecta agentes de IA a Unreal Engine 5.7, editor y tiempo de ejecución (plugin C++ + sidecar .NET).

GitHub

Prueba este MCPPatrocinado

Documentación

✨ AI Game Developer — Unreal MCP

Unreal MCP es un asistente de desarrollo de juegos impulsado por IA para el Unreal Editor. Conecta Claude, Cursor, Copilot o cualquier agente compatible con MCP a Unreal Engine y deja que inspeccione y controle tu proyecto: crea actores, edita niveles, crea Blueprints, gestiona assets, edita y compila C++, captura capturas de pantalla y mucho más.

Unreal-MCP es la contraparte de Unreal Engine de Unity-MCP y Godot-MCP: un plugin de editor en C++ que expone operaciones del Unreal Editor como AI Tools y las conecta a un servidor MCP a través del mismo backend en la nube alojado (ai-game.dev) que impulsa Unity-MCP y Godot-MCP — o tu propio servidor autoalojado. El servidor local es el compartido e independiente del motor GameDev-MCP-Server (binario gamedev-mcp-server) — un servidor consumido por Unity-MCP, Godot-MCP y Unreal-MCP; no hay código fuente del servidor en este repositorio.

A diferencia de Unity y Godot (motores C# que alojan el McpPlugin de .NET en proceso), el editor de Unreal es C++ — por lo que el host MCP de .NET se ejecuta como un proceso sidecar autogestionado (unreal-mcp-bridge) que el plugin genera y con el que se comunica a través de un canal IPC de localhost. El diseño completo está en docs/ARCHITECTURE.md (consulta el diagrama de visión general del sistema en §0).

Estado: beta. El plugin, el sidecar de .NET, el unreal-mcp-cli, la interfaz de editor AI Game Developer y 61 herramientas integradas en 7 familias (más 3 herramientas de sistema) se han publicado y son ejercitadas por CI. El unreal-mcp-cli está publicado en npm — instala el plugin con él (Opción B a continuación); el listado de Fab / Epic Marketplace para el plugin precompilado llegará pronto (Opción A). Las herramientas de captura de píxeles (capturas de pantalla) necesitan un editor con GPU; todo lo demás funciona sin interfaz gráfica.

💬 Únete a nuestro servidor de Discord — ¡Haz preguntas, muestra tu trabajo y conéctate con otros desarrolladores!

✔️ Agentes de IA — Usa los mejores agentes de Anthropic, OpenAI, Google o cualquier otro proveedor sin bloqueo de proveedor
✔️ 61 herramientas integradas — Una amplia gama de MCP Tools en 7 familias para operar el Unreal Editor
✔️ Creación de Blueprints — Crea, edita y compila Blueprints con un bucle de retroalimentación estructurado de errores/advertencias sobre el que la IA puede actuar
✔️ Edición y compilación de C++ — Lee, crea y edita el C++ del proyecto, luego compila (Live Coding o UBT) con un informe de errores estructurado
✔️ Retroalimentación visual — Captura capturas de pantalla del viewport, la vista de juego, la cámara y actores aislados que el LLM puede inspeccionar directamente
✔️ Herramientas, Prompts y Recursos personalizados — Registra tus propias AI Tools, plantillas de prompts y recursos desde cualquier plugin de UE sin fork — un contrato público de características modulares (Personaliza Herramientas, Prompts y Recursos)
✔️ Nube o autoalojado — Conéctate a ai-game.dev de inmediato, o apunta a tu propio GameDev-MCP-Server
✔️ Habilitar / deshabilitar por herramienta — Activa o desactiva cualquier herramienta desde la ventana MCP Tools; el interruptor se aplica en el límite de ejecución, no solo se oculta

AI Game Developer — Unreal MCP

Tabla de contenidos

Requisitos
Instalación
Actualizar el plugin
Primera ejecución
Herramientas — las 7 familias, 61 herramientas (+ 3 herramientas de sistema)
Habilitar / deshabilitar por herramienta
unreal-mcp-cli
Personaliza Herramientas, Prompts y Recursos
Uso en tiempo de ejecución (en el juego)
- Solo editor — excluye Unreal-MCP de los juegos empaquetados
Configuración y variables de entorno
Solución de problemas
Cómo funciona la arquitectura de Unreal MCP
Estructura del repositorio
Enlaces
Licencia

AI Game Developer — Unreal MCP

Requisitos

Unreal Engine 5.5+ (desarrollado y probado con CI contra 5.7, y verificado para compilar y ejecutar en 5.8). El plugin deliberadamente no incluye ningún pin de EngineVersion — UE trata ese campo como una coincidencia de compilación exacta, no como un mínimo, y se negaría a cargar en motores más nuevos.
.NET 9 SDK para compilar el sidecar puente desde el código fuente. (Los usuarios finales de una versión empaquetada NO lo necesitan — el sidecar autocontenido está incluido dentro del plugin y se genera automáticamente, ARQUITECTURA §6. El servidor MCP local se descarga como un binario precompilado de GameDev-MCP-Server, nunca se compila aquí.)
Node.js ^20.19.0 || >=22.12.0 para el unreal-mcp-cli opcional.
Un proyecto de Unreal en C++ (el plugin compila un módulo de Editor, por lo que el proyecto anfitrión debe poder compilar C++).

AI Game Developer — Unreal MCP

Instalación

Hay tres formas de instalar el plugin, en orden de preferencia. Fab / Epic Marketplace es el canal recomendado para usuarios finales — incluye binarios precompilados por motor y el Epic Games Launcher los mantiene actualizados automáticamente, por lo que hay cero compilación y cero riesgo de compilación obsoleta. Las instalaciones desde fuente / unreal-mcp-cli siguen siendo la vía actual para desarrolladores y adoptantes tempranos hasta que el listado de Fab esté disponible.

Opción A — Fab / Epic Marketplace (recomendado; próximamente)

Estado: aún no disponible. El listado de Fab está controlado por el operador y se rastrea por separado; hasta que se publique, usa la Opción B o C a continuación. El marco aquí es cómo será el flujo para el usuario final.

Instala Unreal-MCP desde Fab (el sucesor de Epic Marketplace) en tu motor a través del Epic Games Launcher.
Habilita el plugin para tu proyecto desde Edit → Plugins.
Abre el proyecto — UE carga el plugin precompilado (sin compilación de C++ en tu máquina). Al iniciar, el Output Log imprime [Unreal-MCP] plugin loaded.

Debido a que Fab incluye binarios precompilados y el Epic Launcher los actualiza en su lugar, nunca compilas el plugin ni tienes que limpiar una caché de compilación obsoleta — la vía más robusta para no desarrolladores.

Opción B — `unreal-mcp-cli` (actual / avanzado)

La CLI es la vía recomendada hoy, hasta que el listado de Fab esté disponible. Instálala desde npm — sin clonar el repositorio, sin paso de compilación. Por defecto, install-plugin / update usan un checkout local de UnrealMCP/ cuando está presente; de lo contrario, descargan el asset de fuente dedicado de unreal-mcp-plugin-source-<version>.zip desde el GitHub Release público que coincide con la versión de la CLI. Ese asset de fuente mantiene la semántica de descriptor distribuida (sin pin de EngineVersion) y lleva la carga útil del puente firmada bajo Source/ThirdParty/UnrealMcpBridge/<rid>/; el instalador lo materializa en Binaries/ThirdParty/... para mayor comodidad en la primera apertura. --plugin-source <dir> sigue siendo la anulación sin conexión / CI / desarrollo. La CLI copia (o, para desarrollo, crea junctions) el plugin en tu proyecto y, al actualizar, limpia automáticamente la caché de compilación obsoleta de UE para que siempre obtengas una recompilación limpia del nuevo código (consulta Actualizar el plugin). En plataformas de escritorio (Win64 / Mac / Linux), unreal-mcp-cli open también ejecuta una compilación previa al lanzamiento cuando el estado del proyecto/plugin aún necesita binarios nativos del editor, y luego descarta automáticamente los diálogos de bloqueo conocidos de Unreal (Missing ... Modules, UnrealMCP is Incompatible) si aún aparecen durante el inicio. La automatización de diálogos en Linux es solo X11; Wayland se detecta y se advierte como no compatible.

# 1. Install unreal-mcp-cli (or use `npx unreal-mcp-cli@latest <command>` for a one-off, no install)
npm install -g unreal-mcp-cli

# 2. Install the UnrealMCP plugin into your project
unreal-mcp-cli install-plugin ./YourProject

# 3. Authorize against the cloud server (ai-game.dev)
unreal-mcp-cli login ./YourProject

# 4. Open the Unreal Editor for the project (wires the MCP connection env vars)
unreal-mcp-cli open ./YourProject

Consulta cli/README.md para la referencia completa de los 16 comandos.

Opción C — manual

Copia UnrealMCP/ en <YourProject>/Plugins/UnrealMCP/ (o crea un junction / symlink de directorio hacia él para desarrollo en vivo).
Abre el proyecto; UE compila el módulo UnrealMcpEditor en el primer lanzamiento.
Al iniciar el editor, el Output Log imprime [Unreal-MCP] plugin loaded — eso confirma que el plugin y su despachador de hilo de juego se iniciaron.

El binario sidecar (unreal-mcp-bridge) está incluido dentro del plugin en una versión empaquetada: un binario precompilado y autocontenido para tu plataforma se envía bajo UnrealMCP/Binaries/ThirdParty/UnrealMcpBridge/<rid>/ y el editor lo genera automáticamente al inicio sin ninguna acción del usuario — sin instalación de .NET, sin variable de entorno, sin lanzamiento manual (ARQUITECTURA §6). La primera aprobación del navegador de código de dispositivo OAuth en la nube es el único paso humano restante; después de eso, la reconexión en lanzamientos posteriores es de un clic (el token de la nube se almacena en caché en Saved/Config/UnrealMcp/).

Cuando copias el checkout de fuente del repositorio directamente (Opción C/manual o un junction de desarrollo en vivo), el binario incluido no está presente — el plugin entonces resuelve el sidecar desde la variable de entorno UNREAL_MCP_BRIDGE_PATH en su lugar: apunta esa variable a un sidecar compilado localmente, o ejecuta unreal-mcp-cli bootstrap-local para compilar el puente desde el código fuente en <YourProject>/Intermediate/UnrealMCP/ y establece la variable al resultado. Sin un binario incluido ni la variable de entorno resuelta, el listener TCP del plugin aún se inicia pero registra [Unreal-MCP] no sidecar binary resolved for rid <rid> … y no genera nada.

AI Game Developer — Unreal MCP

Actualizar el plugin

Actualizar en su lugar siempre debe dejarte ejecutando el código nuevo. El riesgo es el compilador incremental de UE: si el código fuente del plugin cambia (nuevos archivos .cpp, un nuevo módulo) pero sobrevive la caché de compilación antigua de UnrealMCP/Intermediate/, UE puede hacer una recompilación parcial contra una lista de archivos de módulo obsoleta y dejarte silenciosamente en código antiguo/parcial. Cada canal maneja esto de manera diferente:

Fab / Epic Marketplace → automático. El Epic Games Launcher reemplaza los binarios precompilados en su lugar; nada que compilar, ninguna caché que limpiar. Por eso Fab es el canal recomendado.
unreal-mcp-cli update → reconstrucción limpia automática. update vuelve a copiar el código fuente del plugin y, por defecto, elimina el Intermediate/ obsoleto del plugin instalado y el Binaries/ de C++ para que UE realice una compilación limpia en el próximo lanzamiento del editor — sin pasos manuales. El puente sidecar incluido bajo Binaries/ThirdParty/UnrealMcpBridge/<rid>/ se mantiene intacto: las instalaciones desde fuente de lanzamiento lo actualizan desde Source/ThirdParty/..., mientras que las instalaciones de repositorio/desarrollo conservan la copia previamente incluida cuando es necesario. Las instalaciones de desarrollo con junction nunca se limpian (eso borraría las salidas de tu árbol de fuente en vivo). Pasa --no-clean para optar por no participar en la limpieza de caché.
```
node bin/unreal-mcp-cli.js update <YourProject>            # default: clean rebuild on version change
node bin/unreal-mcp-cli.js update <YourProject> --force    # re-copy even when versions match
node bin/unreal-mcp-cli.js update <YourProject> --no-clean # keep the existing build cache
```
Copia manual → limpia la caché tú mismo. Si sobrescribes <YourProject>/Plugins/UnrealMCP/ a mano, cierra el editor primero, elimina <YourProject>/Plugins/UnrealMCP/Intermediate/ y el Binaries/ de C++ (conserva Binaries/ThirdParty/ si hay un puente incluido presente), luego relanza para que UE recompile limpiamente.

AI Game Developer — Unreal MCP

Primera ejecución

Abre la ventana principal de AI Game Developer desde el menú Tools del editor (la pestaña está registrada bajo la categoría del menú Tools).
Elige un modo de conexión:
- Cloud (predeterminado) — se conecta a ai-game.dev. Haz clic en Authorize para iniciar el flujo de código de dispositivo OAuth: la ventana muestra una URL de verificación y un código de usuario corto; abre la URL, ingresa el código, aprueba y el editor termina la autorización. Usa Revoke para borrar el token de nube almacenado.
- Custom — se conecta a un gamedev-mcp-server local que tú ejecutas (o a cualquier servidor compatible). Ingresa la URL del servidor y apunta tu cliente de IA hacia él. (El plugin no inicia el servidor local por ti — ejecuta unreal-mcp-cli o tu propio proceso; consulta Troubleshooting.)
La sección Connection muestra un punto de estado, una etiqueta de estado y un botón Connect / Disconnect / Stop; el estado del puente muestra Running (restarts: N) o Stopped. Úsalos para confirmar que el sidecar está activo.
Apunta tu cliente de IA (Claude Code, Cursor, la aplicación AI Game Developer, …) al servidor. La sección AI agents lista los agentes actualmente conectados; para escribir una configuración de cliente MCP usa unreal-mcp-cli setup-mcp.

La configuración de conexión se guarda en <Project>/Saved/Config/UnrealMcp/ai-game-developer-config.json (Saved/ está en gitignore en todas las plantillas de UE, por lo que los tokens nunca llegan al VCS por defecto).

URL de cliente MCP fijada. unreal-mcp-cli setup-mcp <agent> escribe una configuración de cliente MCP que apunta a la URL de nube fijada al proyecto <base>/mcp/p/<pin>, de modo que el agente se enruta al editor de este proyecto incluso cuando tu cuenta maneja varios. Pasa --no-pin para escribir la URL <base>/mcp simple en su lugar. El pin es solo un segmento de ruta de enrutamiento — el recurso OAuth permanece en <base>/mcp.

Clave de proyecto. Cuando esta máquina tiene sesión iniciada (unreal-mcp-cli login, o el inicio de sesión del editor), una configuración de nube también lleva Authorization: Bearer agd_pk_… — una clave no expirable y revocable vinculada al pin de este proyecto — para cada agente, de modo que ningún agente necesite su propio OAuth. La clave se almacena en caché en ~/.ai-game-dev/project-keys.json y se reutiliza. Pasa --oauth para una configuración solo con URL (el agente inicia sesión por sí mismo), o --regenerate-key para generar una nueva clave y revocar la anterior (el panel de agentes de IA del editor tiene un botón Regenerate key). Sin sesión iniciada, o si el servidor no puede generar una clave ⇒ configuración solo con URL.

Eso es todo. Pídele a tu IA "Spawn three cubes in a row and a point light above them" y míralo suceder. ✨

AI Game Developer — Unreal MCP

Tools

Unreal-MCP incluye 61 herramientas integradas ("core") en 7 familias que tu IA puede llamar, más 3 herramientas de sistema que no puede (ver más abajo). Los ids de herramientas están en kebab-case (actor-create, blueprint-compile), coincidiendo con la convención de nombres de Unity/Godot. Las extensiones pueden agregar más (ver Customize Tools, Prompts & Resources).

Esta lista se genera a partir de las fuentes de registro de la superficie STANDARD (UnrealMCP/Source/UnrealMcpEditor/Private/Tools/UnrealMcp*Tools.cpp, excluyendo UnrealMcpSkillTools.cpp — su herramienta es una herramienta de sistema, listada por separado más abajo). Conteos: actor 13, blueprint 11, asset 11, editor/reflection 9, level 7, source 6, screenshot 4 = 61.

Familia Actor & component (13)

Tool id	Qué hace
`actor-create`	Genera un actor desde una ruta de clase (nativa o Blueprint), con nombre/ubicación/rotación/padre opcionales
`actor-destroy`	Destruye un actor
`actor-duplicate`	Duplica un actor
`actor-find`	Encuentra actores, con lecturas con alcance (`paths`/`viewQuery`)
`actor-modify`	Escribe valores `FProperty` de actor (incluyendo transform)
`actor-set-parent`	Adjunta un actor a un padre
`actor-component-add`	Agrega un componente a un actor
`actor-component-destroy`	Destruye un componente
`actor-component-get`	Lee los datos de un componente
`actor-component-modify`	Modifica las propiedades de un componente
`actor-component-list-all`	Lista las clases `UActorComponent` disponibles (paginado)
`object-get-data`	Lee cualquier `UObject` por ruta
`object-modify`	Modifica cualquier `UObject` por ruta

Familia Blueprint (11) — la superficie insignia de Unreal

Tool id	Qué hace
`blueprint-create`	Crea una nueva clase Blueprint desde una ruta `UClass` padre
`blueprint-get`	Resumen de grafo para inspección LLM (variables, componentes, funciones/eventos, cadena de padres)
`blueprint-add-component`	Agrega un componente vía el Simple Construction Script
`blueprint-remove-component`	Elimina un componente SCS
`blueprint-add-variable`	Agrega una variable miembro tipada
`blueprint-modify-variable`	Modifica una variable miembro
`blueprint-set-default`	Edita una propiedad CDO (class-default)
`blueprint-add-function`	Agrega un stub de función (nodos de entrada/resultado conectados)
`blueprint-add-event`	Agrega/vincula un stub de evento (BeginPlay, Tick, input, …)
`blueprint-compile`	Compila el Blueprint y devuelve una lista estructurada de errores/avisos (el bucle de retroalimentación de IA)
`blueprint-spawn`	Instancia el Blueprint en el nivel actual

Familia Asset / Content-Browser (11)

Tool id	Qué hace
`asset-find`	Busca en el AssetRegistry por nombre/clase/ruta/etiquetas
`asset-get-data`	Lee los datos de un asset (lecturas con alcance soportadas)
`asset-create-folder`	Crea una carpeta de Content
`asset-copy`	Copia un asset
`asset-move`	Mueve / renombra un asset
`asset-delete`	Elimina un asset
`asset-refresh`	Reescanea rutas de assets
`asset-material-create`	Crea una instancia de Material desde un material padre
`asset-material-modify`	Establece parámetros escalares/vectoriales/textura de instancia de material
`asset-material-get-data`	Lee información del grafo/parámetros de material (el análogo "shader")
`asset-import`	Importa FBX/texturas vía `AssetImportTask`

Familia Editor / consola / reflexión (9)

Tool id	Qué hace
`editor-application-get-state`	Lee el estado de la aplicación del editor (PIE, etc.)
`editor-application-set-state`	Inicia / detiene / pausa Play-In-Editor
`editor-selection-get`	Lee la selección actual del editor
`editor-selection-set`	Establece la selección del editor
`console-get-logs`	Lee registros recientes del editor desde el búfer circular `LogCollector`
`console-clear-logs`	Limpia el búfer circular de registros capturados
`console-run-command`	Ejecuta un comando de consola / CVar
`reflection-method-find`	Descubre `UFunction`s invocables (devuelve esquemas de invocación)
`reflection-method-call`	Invoca un `UFunction` (estático o de instancia, incl. `CallInEditor`)

Familia Level / map (7)

Tool id	Qué hace
`level-create`	Crea un nuevo nivel
`level-open`	Abre un nivel
`level-save`	Guarda el nivel (guardar como vía ruta opcional)
`level-get-data`	Instantánea del árbol de actores de un nivel (lecturas con alcance)
`level-list-loaded`	Lista subniveles persistentes + de streaming (compatible con World-Partition, solo lectura)
`level-set-current`	Establece el nivel actual/activo
`level-unload-sublevel`	Descarga un subnivel de streaming

Familia Source / C++ (6)

Tool id	Qué hace
`source-read`	Lee un archivo fuente C++ del proyecto (segmentado)
`source-create-class`	Crea un esqueleto de nueva clase C++ (header + cpp desde plantillas)
`source-update`	Edita un archivo fuente
`source-delete`	Elimina un archivo fuente
`source-list`	Lista archivos fuente del módulo
`source-compile`	Compila C++ del proyecto (Live Coding cuando está activo, si no UBT) con un informe de errores estructurado

Todas las operaciones de archivos están restringidas a <Project>/Source/.

Familia Screenshot / captura de viewport (4)

Tool id	Qué hace
`screenshot-viewport`	Captura el viewport activo del editor
`screenshot-game-view`	Captura la vista PIE / juego
`screenshot-camera`	Renderiza desde un actor de cámara resuelto vía `USceneCaptureComponent2D`
`screenshot-isolated`	Renderiza un actor de forma aislada (SceneCapture2D transitorio + lista de solo mostrar)

Las capturas devuelven un PNG base64 como contenido de imagen MCP para que el LLM pueda inspeccionar el render directamente. Las dimensiones están limitadas (predeterminado 1024, tope máximo 2048 por lado). La captura de píxeles necesita un editor con GPU; bajo -nullrhi sin cabeza estas herramientas devuelven un error estructurado.

Herramientas de sistema (3) — NO expuestas a tu IA

Estas son herramientas de sistema: infraestructura del host que el unreal-mcp-cli y la aplicación de escritorio manejan directamente sobre POST /api/system-tools/<name>. Están deliberadamente ausentes de tools/list de MCP, por lo que nunca aparecen para (ni gastan tokens en) una sesión de IA — la misma división que Unity y Godot usan para las mismas tres herramientas.

Tool id	Qué hace
`ping`	Sonda de actividad — recorre la cadena plugin ⇄ sidecar ⇄ servidor
`unreal-skill-create`	Genera una nueva herramienta MCP como archivo C++ en el módulo de editor del plugin. Requiere una reconstrucción del editor antes de que la nueva herramienta sea invocable (Live Coding, o reconstruir el proyecto) — el resultado lo dice explícitamente. Necesita una instalación fuente del plugin
`unreal-skill-generate`	Regenera cada `SKILL.md` desde las herramientas registradas en una carpeta de habilidades relativa al proyecto (predeterminado `.claude/skills`)

AI Game Developer — Unreal MCP

Habilitar / deshabilitar por herramienta

Cada herramienta puede habilitarse o deshabilitarse individualmente desde la ventana MCP Tools — la pestaña independiente MCP Tools (registrada bajo el menú Tools del editor). La ventana muestra el título, la familia y la descripción de cada herramienta, más una línea de resumen "N / M herramientas habilitadas". Deshabilitar una herramienta:

la elimina por completo del manifiesto servido — nunca aparece en el tools/list de MCP; y
se aplica también en el límite de ejecución — incluso si se despacha un tools/list obsoleto, una herramienta deshabilitada se rechaza en Execute() en lugar de ejecutarse.

Dos filtros se combinan para decidir si una herramienta se sirve (ver ARCHITECTURE §7/§8):

una whitelist (enabledTools, anulable vía UNREAL_MCP_TOOLS) — cuando no está vacía, solo se sirven las herramientas listadas; vacía significa "sin filtro"; y
una blocklist (disabledTools) — los interruptores por herramienta que alternas en la interfaz.

Una herramienta se sirve si y solo si pasa la whitelist y no está en la blocklist. Ambos conjuntos se persisten entre sesiones del editor y sobreviven a una recarga en caliente de extensiones (una herramienta re-registrada hereda el interruptor retenido, por lo que una reconstrucción nunca puede re-habilitar silenciosamente una herramienta que deshabilitaste).

Toda la configuración de conexión vive en la sección Connection de la única ventana principal AI Game Developer (no hay pestaña de Settings separada ni página de Project-Settings — paridad con Unity-MCP). Las ventanas MCP Prompts y MCP Resources están conectadas pero se envían vacías en esta versión — cada una muestra un mensaje de estado vacío atenuado (el resumen "N / M habilitadas" es exclusivo de la ventana Tools).

AI Game Developer — Unreal MCP

`unreal-mcp-cli`

Un CLI Node multiplataforma (unreal-mcp-cli) que crea proyectos, instala el plugin, configura ajustes de conexión, maneja el servidor local e invoca herramientas sobre HTTP. Es un port de unity-mcp-cli / godot-cli. Referencia completa: cli/README.md.

Publicado en npm — instala con npm install -g unreal-mcp-cli, o ejecuta una vez con npx unreal-mcp-cli@latest <command>.

La superficie completa de 16 comandos:

Comando	Qué hace
`create-project`	Crear un proyecto C++ mínimo de Unreal Engine
`open`	Iniciar el Unreal Editor para un proyecto, configurando las variables de entorno de conexión MCP
`close`	Terminar el proceso del Unreal Editor que ejecuta un proyecto
`install-plugin`	Instalar el plugin UnrealMCP en `<project>/Plugins` (copiar o `--junction`) desde un checkout local o el recurso fuente de GitHub con versión coincidente
`remove-plugin`	Eliminar el plugin UnrealMCP de `<project>/Plugins`
`configure`	Escribir valores de `UNREAL_MCP_*` en `<project>/.env` y agregar `.env` a gitignore
`setup-mcp`	Escribir un fragmento de configuración de cliente MCP para un agente
`login`	Autorizar contra ai-game.dev mediante el flujo de código de dispositivo OAuth
`status`	Informar el estado del paquete, proyecto, plugin y conexión en vivo
`wait-for-ready`	Bloquear hasta que el servidor MCP del proyecto responda a un ping
`run-tool`	Invocar una herramienta MCP a través del servidor MCP local del proyecto (HTTP)
`run-system-tool`	Invocar una herramienta de sistema a través del servidor MCP local del proyecto (HTTP)
`bootstrap-local`	Compilar el puente desde el código fuente en `<project>/Intermediate/UnrealMCP` (el servidor se descarga mediante `setup-mcp`, no se compila)
`update`	Actualizar el plugin UnrealMCP instalado en un proyecto desde un checkout local o el recurso fuente de GitHub con versión coincidente
`install-engine`	Detectar motores Unreal instalados; para una versión faltante, enlazar al launcher de Epic
`setup-skills`	Escribir un stub de habilidad de Claude-Code que impulse el servidor MCP de Unreal de este proyecto

AI Game Developer — Unreal MCP

Personalizar Herramientas, Prompts y Recursos

Esta es la característica de extensibilidad principal. Cualquier persona puede registrar sus propias Herramientas de IA, prompts y recursos — desde cualquier plugin de UE de terceros — y hacer que aparezcan en el manifiesto MCP junto con los integrados. Sin fork, sin acoplamiento en tiempo de enlace, sin suposiciones de orden de carga. Tus contribuciones se descubren automáticamente al iniciar el editor (y en carga tardía / descarga en caliente), se fusionan en orden determinista y se exponen a cada agente de IA conectado.

Los tres tipos usan el mismo contrato pequeño, público y basado en características modulares — una interfaz de proveedor más un constructor de registro fluido, ambos viven en el módulo UnrealMcpRuntime (reexportado por UnrealMcpEditor, por lo que el mismo contrato sirve para extensiones de editor y runtime). La guía completa para autores es docs/EXTENSIONS.md.

Herramientas

Implementa IUnrealMcpToolProvider y declara tus herramientas con el constructor fluido FUnrealMcpToolRegistry:

#include "IUnrealMcpToolProvider.h"
#include "UnrealMcpToolRegistry.h"

class FMyExtensionProvider : public IUnrealMcpToolProvider
{
public:
    virtual FString GetExtensionId() const override      { return TEXT("com.foo.my-extension"); }
    virtual FText   GetDisplayName() const override      { return NSLOCTEXT("Foo", "Name", "My Extension"); }
    virtual FString GetExtensionVersion() const override { return TEXT("1.0.0"); }

    virtual void RegisterTools(FUnrealMcpToolRegistry& Registry) override
    {
        Registry.Tool(TEXT("hello-extension"))
            .Title(TEXT("Hello Extension"))
            .Description(TEXT("Returns a friendly greeting."))
            .ParamString(TEXT("name"), TEXT("Who to greet. Defaults to 'world'."))
            .ReadOnlyHint(true)
            .IdempotentHint(true)
            .Handle([](const FUnrealMcpToolCall& Call) -> FUnrealMcpToolResult
            {
                const FString Name = Call.Has(TEXT("name")) ? Call.GetString(TEXT("name")) : TEXT("world");
                return FUnrealMcpToolResult::Success(FString::Printf(TEXT("Hello, %s!"), *Name));
            });
    }
};

Luego registra el proveedor como una característica modular en el StartupModule de tu módulo (y anula el registro en ShutdownModule):

// In StartupModule:
IModularFeatures::Get().RegisterModularFeature(
    IUnrealMcpToolProvider::GetModularFeatureName(), Provider.Get());

Prompts

Los prompts son plantillas de prompt reutilizables y parametrizadas que el agente obtiene mediante prompts/get. Implementa IUnrealMcpPromptProvider y declara prompts con FUnrealMcpPromptRegistry. Los argumentos de prompt reutilizan los mismos helpers de Param* que el constructor de herramientas; un manejador devuelve mensajes etiquetados por rol:

#include "IUnrealMcpPromptProvider.h"
#include "UnrealMcpPromptRegistry.h"

class FMyPromptProvider : public IUnrealMcpPromptProvider
{
public:
    virtual FString GetExtensionId() const override      { return TEXT("com.foo.my-extension"); }
    virtual FText   GetDisplayName() const override      { return NSLOCTEXT("Foo", "Name", "My Extension"); }
    virtual FString GetExtensionVersion() const override { return TEXT("1.0.0"); }

    virtual void RegisterPrompts(FUnrealMcpPromptRegistry& Registry) override
    {
        Registry.Prompt(TEXT("level-design-brief"))
            .Title(TEXT("Level Design Brief"))
            .Description(TEXT("Generate a level design brief from a single 'theme' argument."))
            .Role(EUnrealMcpPromptRole::User)
            .ParamString(TEXT("theme"), TEXT("The level theme (e.g. 'haunted forest')."),
                         EUnrealMcpParamRequirement::Required)
            .Handle([](const FUnrealMcpToolCall& Call) -> FUnrealMcpPromptResult
            {
                const FString Theme = Call.GetString(TEXT("theme"));
                if (Theme.IsEmpty())
                    return FUnrealMcpPromptResult::Error(TEXT("theme is required."));
                const FString Text = FString::Printf(
                    TEXT("Draft a level design brief for a \"%s\"-themed level."), *Theme);
                return FUnrealMcpPromptResult::Success(Text, EUnrealMcpPromptRole::User);
            });
    }
};

// Register under the prompt modular-feature name (and unregister in ShutdownModule):
IModularFeatures::Get().RegisterModularFeature(
    IUnrealMcpPromptProvider::GetModularFeatureName(), PromptProvider.Get());

level-design-brief es el prompt central incluido — consulta UnrealMCP/Source/UnrealMcpRuntime/Private/Prompts/UnrealMcpCorePrompts.cpp.

Recursos

Los recursos son contenido direccionable y legible que el agente obtiene mediante resources/read — el URI del recurso es su identidad. Implementa IUnrealMcpResourceProvider y declara recursos con FUnrealMcpResourceRegistry. Una lectura devuelve bloques de contenido — texto XOR un blob base64 + un tipo mime:

#include "IUnrealMcpResourceProvider.h"
#include "UnrealMcpResourceRegistry.h"

virtual void RegisterResources(FUnrealMcpResourceRegistry& Registry) override
{
    Registry.Resource(TEXT("unreal://project/levels"))                  // JSON (text) resource
        .Name(TEXT("Project Levels"))
        .Description(TEXT("A JSON snapshot of the active world and its levels."))
        .MimeType(TEXT("application/json"))
        .Read([](const FString& Uri) -> FUnrealMcpResourceResult
        {
            return FUnrealMcpResourceResult::Text(Uri, BuildLevelsJson(), TEXT("application/json"));
        });

    Registry.Resource(TEXT("unreal://project/icon"))                    // binary (blob) resource
        .Name(TEXT("Project Icon"))
        .Description(TEXT("A small PNG, returned as a base64 blob."))
        .MimeType(TEXT("image/png"))
        .Read([](const FString& Uri) -> FUnrealMcpResourceResult
        {
            const FString Base64 = FBase64::Encode(IconBytes, sizeof(IconBytes));
            return FUnrealMcpResourceResult::Blob(Uri, Base64, TEXT("image/png"));
        });
}

// Register under the resource modular-feature name (and unregister in ShutdownModule):
IModularFeatures::Get().RegisterModularFeature(
    IUnrealMcpResourceProvider::GetModularFeatureName(), ResourceProvider.Get());

unreal://project/levels y unreal://project/icon son los recursos centrales incluidos — consulta UnrealMCP/Source/UnrealMcpRuntime/Private/Resources/UnrealMcpCoreResources.cpp. Solo se admiten recursos estáticos, de URI fijo hoy (los URI templados / parametrizados están diferidos). Un blob es base64 en el lado de Unreal y en el cable IPC; una peculiaridad ascendente conocida en el GameDev-MCP-Server / MCP-Plugin-dotnet compartido puede emitir mal los bytes del blob en el cable MCP final hacia el cliente (los recursos de texto viajan limpiamente de extremo a extremo) — eso es un problema ascendente, no del plugin de Unreal o del puente.

Cómo se comporta (idéntico para herramientas, prompts y recursos):

Auto-descubrimiento y recarga en caliente. Unreal-MCP enumera cada proveedor registrado (UnrealMcpToolProvider / UnrealMcpPromptProvider / UnrealMcpResourceProvider) al iniciar, y se suscribe a eventos de registro / anulación de registro — por lo que cargar o descargar tu plugin en cualquier momento dispara una reconstrucción del registro y un aumento de revisión del manifiesto, y el sidecar compara el nuevo manifiesto y agrega / elimina las herramientas / prompts / recursos afectados automáticamente. Nunca empujas nada tú mismo.
Fusión determinista. Los proveedores se fusionan en orden ascendente de GetExtensionId(); dentro de un proveedor, las entradas se registran en orden de declaración. Tu GetExtensionId() se estampa en todo lo que contribuyes (no llames a .ExtensionId(...) tú mismo).
Aislamiento por extensión. Cada descriptor se valida (una herramienta / prompt necesita un nombre kebab-case + esquema bien formado + manejador vinculado; un recurso necesita un URI no vacío + manejador). Una entrada inválida o duplicada (nombre de herramienta / prompt duplicado, o URI de recurso duplicado) se descarta / rechaza y la razón se registra en el registro de tu extensión — tus otras entradas válidas, y cada otra extensión, no se ven afectadas. (UE se compila sin excepciones de C++, por lo que el aislamiento es a nivel de descriptor, no a nivel de cuerpo de manejador; valida entradas y falla con gracia con los helpers de resultado Error(...).)
Alternadores y habilitar / deshabilitar. Las herramientas contribuidas por extensiones se alternan en la ventana MCP Tools como las integradas; una extensión deshabilitada no contribuye nada a ningún manifiesto. (Las ventanas MCP Prompts / MCP Resources están conectadas pero aún se muestran vacías en esta versión — consulta Habilitar / deshabilitar por herramienta — por lo que alternar prompts / recursos desde la UI es un seguimiento; el registro y uso funcionan hoy.)

Aprende más:

Guía completa para autores: docs/EXTENSIONS.md — el contrato para herramientas, prompts y recursos, los constructores, ciclo de vida, ordenamiento, semántica de aislamiento y versionado.
Diseño: docs/ARCHITECTURE.md §5 (herramientas) + §A (la ruta de registro de prompts / recursos).
Ejemplos funcionales: samples/UnrealAITemplate/ — una extensión de editor completa y compilable con una herramienta hello-extension y un interruptor en tiempo de compilación (UNREAL_AI_TEMPLATE_INVALID_SCHEMA=1) que demuestra el comportamiento de aislamiento de primera mano; samples/UnrealAIRuntimeSample/ — la contraparte runtime (en juego), un plugin Type=Runtime cuya herramienta game-time-dilation lee / establece la dilatación del tiempo del mundo en vivo, invocable en un juego en ejecución a través de una conexión MCP runtime (docs/ARCHITECTURE.md §12.9; consulta EXTENSIONS.md "Runtime usage"). Para prompts y recursos, las familias centrales incluidas (UnrealMcpCorePrompts.cpp level-design-brief, UnrealMcpCoreResources.cpp unreal://project/levels + unreal://project/icon) son la referencia ejecutable.

AI Game Developer — Unreal MCP

Uso en runtime (en juego)

Todo lo anterior impulsa el editor. Unreal-MCP también puede ejecutarse dentro de un juego en ejecución — PIE, Standalone o una compilación Development empaquetada — para que un asistente de IA pueda impulsar tu juego en vivo. Esta es la contraparte de Unreal del soporte runtime (en juego) de Unity-MCP: el análogo de UE del UnityMcpPluginRuntime.Initialize().Build().Connect() de Unity y su muestra de bot de ajedrez [AiTool].

El punto de entrada runtime es un UGameInstanceSubsystem, UUnrealMcpRuntimeSubsystem (en el módulo runtime UnrealMcpRuntime del plugin). Se instancia automáticamente una vez por UGameInstance pero nunca se conecta automáticamente — una conexión siempre es una llamada explícita de opt-in (consulta el contrato de seguridad a continuación).

Conectar de tres maneras

Las tres llegan al mismo UUnrealMcpRuntimeSubsystem::Connect(Host, Token, Mode, bAllowRemoteHost); el modo de conexión predeterminado es Custom (un servidor loopback proporcionado por el desarrollador).

1. Desde C++ (por ejemplo, tu GameMode::BeginPlay):

#include "UnrealMcpRuntimeSubsystem.h"

void AMyGameMode::BeginPlay()
{
    Super::BeginPlay();

    if (UUnrealMcpRuntimeSubsystem* Mcp = UUnrealMcpRuntimeSubsystem::Get(this))
        Mcp->Connect(TEXT("http://localhost:8080"), TEXT("my-token")); // Custom mode, loopback
    // ... and, when you are done:
    //  Mcp->Disconnect();
}

Get(WorldContext) es un helper estático de BlueprintPure que devuelve el subsistema para la instancia de juego del contexto (o null). Connect devuelve false (y no conecta nada) si alguna puerta de seguridad rechaza — consulta a continuación.

2. Desde Blueprint — Get Unreal MCP Runtime Subsystem (el nodo Get, consciente de WorldContext) → Connect (un nodo BlueprintCallable bajo la categoría Unreal MCP; Token / Mode / bAllowRemoteHost son pines avanzados). Combínalo con el nodo Disconnect y el nodo puro Is Connected para el estado.

3. Desde la consola (conveniencia de QA, sin recompilar) — registrado mientras el subsistema está vivo:

UnrealMcp.Connect <host> [token]
UnrealMcp.Disconnect

La ruta de consola siempre usa loopback + modo Custom.

Tus propias herramientas, prompts y recursos en juego

Un juego incluye sus propias herramientas de gameplay (y, si es útil, prompts y recursos) y la IA las impulsa en vivo — el análogo de UE del bot de ajedrez WithToolsFromAssembly / [AiTool] de Unity. Autorizas los tres exactamente como para una extensión de editor (la sección Personalizar Herramientas, Prompts y Recursos anterior), con dos cambios para un módulo de juego: hazlo Type=Runtime y depende de UnrealMcpRuntime (no UnrealMcpEditor). Registra tus proveedores al inicio del módulo, o usa los wrappers descubribles del subsistema — un par de registro / anulación de registro por tipo:

if (UUnrealMcpRuntimeSubsystem* Mcp = UUnrealMcpRuntimeSubsystem::Get(this))
{
    Mcp->RegisterToolProvider(MyToolProvider);          // tools merge in; manifest re-pushed
    Mcp->RegisterPromptProvider(MyPromptProvider);      // prompts merge in; manifest re-pushed
    Mcp->RegisterResourceProvider(MyResourceProvider);  // resources merge in; manifest re-pushed
}
// ... before destroying the providers, call the matching Unregister*Provider(...) for each.

El ejemplo completo y compilable es samples/UnrealAIRuntimeSample/ — un plugin Type=Runtime cuya herramienta game-time-dilation lee / establece el AWorldSettings::TimeDilation del mundo en vivo (cámara lenta / avance rápido), invocable en un juego en ejecución a través de una conexión MCP runtime. (Demuestra la ruta de herramientas; los prompts y recursos se registran a través de la misma API de tres wrappers mostrada arriba y las familias centrales incluidas son la referencia ejecutable.) Los detalles del lado del autor (el contrato, ciclo de vida, ordenamiento, aislamiento) están en docs/EXTENSIONS.md → Runtime usage.

Conjunto de herramientas runtime vs solo editor

Una conexión runtime incluye exactamente una herramienta integrada: ping (una sonda de actividad). ping es una herramienta de sistema, por lo que responde en POST /api/system-tools/ping y no se anuncia a un agente de IA — lo que significa que un juego empaquetado que no registra nada propio presenta una lista de herramientas vacía, que es una descripción honesta de ello. Todo lo que un agente de IA runtime puede hacer es trae-lo-tuyo: registra tus propias herramientas a través del bus de extensiones anterior (RegisterToolProvider) y aparecen normalmente.

Todas las familias de desarrollo de motor — la familia de actores / componentes, object-get-data / object-modify, level-get-data, las herramientas de consola / reflexión, cada herramienta de captura de pantalla, más la autoría de Blueprint, operaciones de activos / Content-Browser, edición y compilación de C++, creación / apertura / guardado de niveles y estado de la aplicación del editor — son solo editor (las 61 herramientas de editor). Impulsan el editor y varias son de clase RCE (por ejemplo, reflection-method-call, console-run-command), por lo que no se compilan en un juego enviado por defecto. No hay editor en un juego empaquetado, por lo que la superficie integrada runtime es intencionalmente solo ping + cualquier herramienta que tu juego registre.

Solo editor — excluir Unreal-MCP de juegos empaquetados

Si solo quieres Unreal-MCP para herramientas de IA dentro del Unreal Editor y planeas enviar un juego empaquetado con cero huella de Unreal-MCP — sin módulo runtime, sin binario sidecar .NET incluido — fija el plugin al editor con un TargetDenyList en el .uproject propio de tu proyecto consumidor (no el .uplugin del plugin):

// <YourProject>.uproject — "Plugins" array
{
    "Name": "UnrealMCP",
    "Enabled": true,
    "TargetDenyList": [ "Game", "Client", "Server" ]
}

UE respeta TargetDenyList / TargetAllowList en una referencia de plugin (PluginReferenceDescriptor::IsEnabledForTarget): el plugin permanece activo en el objetivo Editor, pero se excluye de las compilaciones empaquetadas de Game / Client / Server — por lo que ni el módulo de infraestructura en tiempo de ejecución ni el sidecar unreal-mcp-bridge incluido se preparan o compilan en tu producto final. Los módulos de tipo Editor (UnrealMcpEditor) se eliminan de una compilación de juego de todos modos; la lista de denegación también elimina el módulo de infraestructura UnrealMcpRuntime y su sidecar RuntimeDependencies (§12.5), lo que te da una huella compilada cero.

Advertencia: no crees una dependencia directa de módulo. Un TargetDenyList solo excluye los módulos propios del plugin. Si uno de tus módulos de juego agrega UnrealMcpRuntime (o cualquier módulo UnrealMcp*) a su *.Build.cs PublicDependencyModuleNames / PrivateDependencyModuleNames, o incluye un encabezado UnrealMcp* mediante #include, esa dependencia directa anula la lista de denegación y UBT compila el módulo en tiempo de ejecución en tu juego de todos modos. Un proyecto solo de editor no referencia nada del plugin, por lo que se mantiene limpio por construcción — solo opta por una dependencia de módulo cuando realmente quieras uso en tiempo de ejecución (en juego).

Para uso en tiempo de ejecución (en juego) en su lugar, deja la lista de denegación desactivada: el módulo de infraestructura UnrealMcpRuntime + el ping integrado se incluyen en la compilación empaquetada (§12.5), y registras tus propias herramientas de juego mediante IUnrealMcpToolProvider — consulta Uso en tiempo de ejecución (en juego) y Personalizar herramientas, prompts y recursos. Los dos son mutuamente excluyentes: lista de denegación para un proyecto solo de editor, sin lista de denegación para un juego que aloja una conexión MCP en vivo.

Contrato de seguridad

Una conexión en tiempo de ejecución es control remoto de un juego en ejecución (actor-create, object-modify, CVars arbitrarios mediante console-run-command, UFunctions arbitrarios mediante reflection-method-call) — de clase RCE si fuera alcanzable en un producto enviado. La superficie en tiempo de ejecución está, por lo tanto, bloqueada por cinco mitigaciones en capas (docs/ARCHITECTURE.md §12.8), todas aplicadas dentro de Connect():

Solo con opt-in. El subsistema se autoinstancia pero nunca se autoconecta — no hay marcado automático al cargar ni autoconexión por activo de configuración. Una conexión solo ocurre mediante una llamada explícita a Connect().
Interruptor de seguridad, desactivado por defecto. UUnrealMcpRuntimeSettings::bRuntimeMcpEnabled (Configuración del proyecto → Plugins → Unreal MCP (Runtime)) tiene como valor predeterminado false. Mientras esté desactivado, cada Connect() se rechaza y no se genera ningún sidecar. Es una configuración de Juego (DefaultGame.ini, sección [/Script/UnrealMcpRuntime.UnrealMcpRuntimeSettings]), por lo que viaja a la compilación empaquetada donde la puerta debe tener efecto. Activarlo no autoconecta — aún se requiere un Connect() explícito.
Puerta de envío. El indicador bUnrealMcpAllowShipping *.Build.cs tiene como valor predeterminado false (→ UNREAL_MCP_ALLOW_SHIPPING=0); en una compilación Shipping, Connect() registra y devuelve false a menos que ese indicador se haya compilado deliberadamente. Las compilaciones de Desarrollo / PIE no se ven afectadas.
Host de bucle local por defecto. Connect() rechaza cualquier Host que no sea de bucle local a menos que el llamador pase explícitamente bAllowRemoteHost = true. El valor predeterminado mantiene la conexión en localhost / 127.0.0.0/8 / ::1.
IPC de bucle local + token de un solo uso por stdin. El IPC plugin ⇄ sidecar es solo de bucle local y se autentica con un token de un solo uso entregado por stdin, nunca argv, y nunca se registra (mismo modelo que el editor, ARQUITECTURA §1.4).

Además, la ruta en tiempo de ejecución es solo de escritorio (Win64 / Mac / Linux): generar el proceso sidecar .NET unreal-mcp-bridge no es posible en plataformas de consola o móviles, por lo que esas plataformas no tienen superficie MCP en tiempo de ejecución en absoluto.

Runbook de extremo a extremo. El recorrido completo del operador — habilitar el interruptor de seguridad, conectar desde PIE y una compilación empaquetada de Desarrollo, y ejercitar herramientas sobre la conexión en vivo — está en docs/RUNTIME-E2E.md. La mitad determinista (puertas de seguridad, cambio de resolvedor de mundo, seguridad de conexión/desconexión/órfanos) está bloqueada por especificaciones de Automatización sin cabeza.

AI Game Developer — Unreal MCP

Configuración y variables de entorno

El plugin lee la configuración con la precedencia env del proceso → <Project>/.env → archivo de configuración → valores predeterminados integrados. Las variables UNREAL_MCP_* reconocidas (definidas en UnrealMCP/Source/UnrealMcpEditor/Private/Config/UnrealMcpConfig.cpp):

Variable	Propósito
`UNREAL_MCP_CONNECTION_MODE`	`Cloud` o `Custom`. El valor predeterminado es `Cloud`.
`UNREAL_MCP_HOST`	URL del servidor (modo Personalizado), p. ej. `http://localhost:<port>`
`UNREAL_MCP_CLOUD_URL`	URL del backend en la nube (el valor predeterminado es ai-game.dev)
`UNREAL_MCP_TOKEN`	Token de autenticación (token IPC del sidecar / token del servidor). Secreto — nunca lo confirmes.
`UNREAL_MCP_AUTH_OPTION`	`none` o `oauth` (autenticación del servidor local)
`UNREAL_MCP_KEEP_CONNECTED`	Persistir/restaurar el estado conectado
`UNREAL_MCP_TOOLS`	Anulación de herramientas habilitadas (lista blanca; vacío = sin filtro)
`UNREAL_MCP_START_SERVER`	Se analiza y persiste como el indicador de configuración `startServer` (modo Personalizado); el auto-generado del `gamedev-mcp-server` local está planificado, aún no conectado — ningún código consume este indicador hoy, así que inicia el servidor tú mismo (p. ej. `unreal-mcp-cli`).
`UNREAL_MCP_TRANSPORT`	`stdio` o `http`
`UNREAL_MCP_LOG_LEVEL`	Verbosidad del registro
`UNREAL_MCP_BRIDGE_PATH`	Ruta a un binario sidecar — la anulación de dev/CI; gana sobre el binario incluido (§6). Una versión empaquetada resuelve automáticamente el sidecar incluido, por lo que los usuarios finales nunca lo configuran; las compilaciones desde el código fuente lo usan.
`UNREAL_MCP_SERVER_PATH`	Ruta a un binario local `gamedev-mcp-server` (leído por `unreal-mcp-cli`, no por el plugin) — omite la descarga del servidor + verificación de versión (§6).

Nunca confirmes .env. Un .env en la raíz del proyecto puede contener UNREAL_MCP_TOKEN, y las plantillas de proyecto de UE no incluyen ningún .gitignore. unreal-mcp-cli configure agrega .env al .gitignore del proyecto objetivo; el andamiaje de este repositorio ya lo ignora con git. El token IPC del sidecar viaja por stdin (nunca argv) y nunca se registra.

AI Game Developer — Unreal MCP

Solución de problemas

No connected clients. Retrying [1..10] y luego HTTP 500 desde un servidor local. El modo de conexión se estableció por defecto en Cloud, por lo que el sidecar marcó a ai-game.dev en lugar de tu servidor local. Configura UNREAL_MCP_CONNECTION_MODE=Custom (env, .env o el interruptor de la interfaz).
Sin línea [Unreal-MCP] plugin loaded al arrancar. El módulo del editor no se cargó — revisa el Registro de salida para ver un error StartupModule o un .uplugin mal formado.
Un cuerpo de herramienta devuelve 'x' is required. cuando se invoca a través del paso REST. Envía -H "Content-Type: application/json"; sin él, el servidor descarta el cuerpo JSON.
Las herramientas de captura de pantalla devuelven un error estructurado. La captura de píxeles necesita un editor respaldado por GPU — no pueden renderizar bajo -nullrhi sin cabeza.
Sin sidecar / el sidecar se reinicia constantemente. Verifica el estado del puente en la sección Conexión (Running (restarts: N) / Stopped). Si el registro muestra no sidecar binary resolved for rid <rid> …, ni un binario incluido ni UNREAL_MCP_BRIDGE_PATH se resolvieron — en una versión empaquetada esto significa que el plugin se empaquetó sin el puente de tu plataforma (reinstala la compilación correcta); en una compilación desde el código fuente, configura UNREAL_MCP_BRIDGE_PATH o ejecuta unreal-mcp-cli bootstrap-local para compilar uno desde el código fuente. (El sidecar está incluido en las versiones empaquetadas y se auto-genera, §6 — no hay descarga en el primer uso).
Puertos. El IPC usa un puerto determinista por proyecto en 30000–39999 y sondea hacia adelante (luego un puerto efímero) en caso de colisión; el servidor local usa un puerto hash determinista en 20000–29999 sin sondeo — el CLI deriva el mismo número sin leer ninguna configuración, y el servidor se vincula al puerto exacto solicitado. El número exacto es una conveniencia de depuración, no un requisito.
Registros. Usa la acción Abrir archivo de registro de la ventana principal, la herramienta console-get-logs o el Registro de salida del editor (categoría LogUnrealMcp).

AI Game Developer — Unreal MCP

Cómo funciona la arquitectura de Unreal MCP

Unreal-MCP es un puente entre LLMs y el Editor de Unreal. Expone y explica las herramientas de Unreal al LLM, que luego entiende la interfaz y usa las herramientas según tus solicitudes.

Debido a que el editor es C++, el host .NET McpPlugin no se ejecuta en proceso (como lo hace en Unity/Godot). En su lugar, el plugin escucha en un puerto TCP de localhost y genera un proceso sidecar auto-gestionado (unreal-mcp-bridge) que marca a él, autenticándose con un token de un solo uso entregado por stdin. El sidecar retransmite IPC ⇄ SignalR al servidor MCP (nube ai-game.dev por defecto, o un gamedev-mcp-server local). Las herramientas de IA que el plugin registra son entonces invocables por cualquier agente de IA compatible con MCP. El diseño autoritativo — protocolo IPC, registro dinámico de herramientas, generación de esquemas, el despachador del hilo del juego, extensiones, ciclo de vida del sidecar, interfaz y configuración — vive en docs/ARCHITECTURE.md (comienza en el diagrama de visión general del sistema §0).

Qué es `MCP`

MCP — Protocolo de Contexto de Modelo. En pocas palabras, es USB Type-C para IA, específicamente para LLMs (Modelos de Lenguaje Grande). Enseña al LLM cómo usar características externas — como el Motor de Unreal en este caso, o incluso tu propia herramienta C++ personalizada. Documentación oficial.

Qué es un `AI agent`

Es una aplicación con una ventana de chat. Puede tener agentes inteligentes para operar mejor y herramientas MCP avanzadas integradas. Un cliente MCP bien construido es el 50% del éxito de la IA en ejecutar una tarea — por eso es importante elegir uno bueno.

Qué es el `MCP Server`

Es el puente entre el MCP Client y "algo más" — en este caso el Editor de Unreal. En modo Nube, este es el backend alojado ai-game.dev; en modo Personalizado, es el host compartido GameDev-MCP-Server que ejecutas tú mismo.

Qué es un `MCP Tool`

Un MCP Tool es una función que el LLM puede llamar para interactuar con Unreal. Estas herramientas son el puente entre solicitudes en lenguaje natural y operaciones reales de Unreal. Cuando le pides a la IA que "genere un actor" o "compile este Blueprint", usa herramientas MCP para ejecutar la acción. Las herramientas tienen parámetros tipados y descritos; devuelven resultados estructurados; y se ejecutan en el hilo del juego del editor a través del despachador (el hilo lector de IPC nunca ejecuta cuerpos de herramientas).

AI Game Developer — Unreal MCP

Estructura del repositorio

Ruta	Qué es
`UnrealMCP/`	El plugin del editor de UE (C++, módulo `UnrealMcpEditor`, piso UE 5.5+, desarrollado contra 5.7, verificado en 5.8)
`bridge/`	El sidecar .NET 9 (`unreal-mcp-bridge`) — host McpPlugin, retransmisor IPC ⇄ SignalR
`cli/`	Paquete npm `unreal-mcp-cli` (TypeScript) — 16 comandos
`samples/UnrealAITemplate/`	Plantilla de plugin de extensión de editor (`hello-extension`)
`samples/UnrealAIRuntimeSample/`	Ejemplo de extensión en tiempo de ejecución (en juego) (`game-time-dilation`, `Type=Runtime`)
`docs/ARCHITECTURE.md`	El diseño de arquitectura autoritativo
`docs/EXTENSIONS.md`	Guía del autor de extensiones
`docs/RELEASING.md`	Runbook de CI/CD + versión del operador

Enlaces

Unity-MCP — el hermano de Unity
Godot-MCP — el hermano de Godot
GameDev-MCP-Server — el servidor MCP local compartido (gamedev-mcp-server)
MCP-Plugin-dotnet — el núcleo compartido del plugin/servidor MCP .NET (com.IvanMurzak.McpPlugin)
ReflectorNet — el núcleo compartido de reflexión/serialización
ai-game.dev — el backend en la nube
Protocolo de Contexto de Modelo

Unreal-MCP

Documentación

✨ AI Game Developer — Unreal MCP

Tabla de contenidos

Requisitos

Instalación

Opción A — Fab / Epic Marketplace (recomendado; próximamente)

Opción B — unreal-mcp-cli (actual / avanzado)

Opción C — manual

Actualizar el plugin

Primera ejecución

Tools

Habilitar / deshabilitar por herramienta

unreal-mcp-cli

Personalizar Herramientas, Prompts y Recursos

Herramientas

Prompts

Recursos

Uso en runtime (en juego)

Conectar de tres maneras

Tus propias herramientas, prompts y recursos en juego

Conjunto de herramientas runtime vs solo editor

Solo editor — excluir Unreal-MCP de juegos empaquetados

Contrato de seguridad

Configuración y variables de entorno

Solución de problemas

Cómo funciona la arquitectura de Unreal MCP

Qué es MCP

Qué es un AI agent

Qué es el MCP Server

Qué es un MCP Tool

Estructura del repositorio

Enlaces

Licencia

Opción B — `unreal-mcp-cli` (actual / avanzado)

`unreal-mcp-cli`

Qué es `MCP`

Qué es un `AI agent`

Qué es el `MCP Server`

Qué es un `MCP Tool`