Skip to main content

Documentation Index

Fetch the complete documentation index at: https://mintlify.com/davidbuenov/dbv-mcp-server/llms.txt

Use this file to discover all available pages before exploring further.

The Unreal MCP Web Client is a single-page application (SPA) served by a local FastAPI proxy at http://localhost:5000. It gives you a graphical control panel for interacting with the Model Context Protocol (MCP) server built into Unreal Engine 5.8 — no extra tooling required beyond a modern browser and Python. The interface is organised into five tabs in the center panel, plus a persistent streaming terminal at the bottom of every view.

​
Interface Layout

┌──────────────── App Header (connection bar + Gemini settings) ────────────────┐
│                                                                                 │
│  ┌─── Left Sidebar ────┐  ┌──────────────── Center Panel ──────────────────┐  │
│  │  Tool search        │  │  [Chat] [Manual] [Blueprints] [Tests] [Spawner] │  │
│  │  Meta tools list    │  │                                                  │  │
│  │  Toolsets list      │  │         Active tab content                       │  │
│  │  Guides search      │  │                                                  │  │
│  └─────────────────────┘  └──────────────────────────────────────────────────┘  │
│                                                                                 │
├──────────────── Bottom Terminal (SSE log, resizable) ───────────────────────────┤
The left sidebar lists all discovered meta-tools and registered toolsets after connecting. A built-in search box lets you filter tools by name or description in real time. A second search box below queries the Conceptual Dev Guides knowledge base and renders matching recipe snippets in the sidebar. The bottom terminal streams every JSON-RPC request and SSE response. All panels share this terminal so you always have a live trace of what is being sent to and received from Unreal.
Resizable terminal: Drag the horizontal divider bar between the center panel and the terminal to resize the output area. The terminal height can range from a compact strip up to 80 % of the viewport height. Touch dragging is also supported on mobile/tablet browsers.

​
Panels

The connection bar lives in the app header and is always visible regardless of which tab is active.What it does:
  • Sends an MCP initialize handshake (POST /mcp, method: "initialize") to the Unreal Engine server at http://localhost:8000/mcp (proxied transparently through localhost:5000).
  • Extracts the Mcp-Session-Id response header and stores it in memory for every subsequent request.
  • Sends the notifications/initialized confirmation to complete the two-step MCP handshake.
  • Triggers an automatic tools/list + list_toolsets refresh to populate the sidebar.
Key features:
  • Status LED — real-time indicator: grey (disconnected), amber (connecting), green (connected).
  • Auto-URL detection — when the page is served from http://localhost:5000, the server URL defaults to window.location.origin + "/mcp" so the proxy is used automatically.
  • Disconnect — clicking the button a second time clears the session ID, resets the sidebar, and restores the chat welcome dashboard.
  • Warnings are logged to the terminal if an HTTPS endpoint is entered (Unreal’s MCP server runs plain HTTP only).
Accessed via the ⚙️ Ejecución Manual tab.What it does:Displays all available MCP tools in a flattened list — including the three meta-tools (list_toolsets, describe_toolset, call_tool) and every individual tool from every registered toolset. The proxy server intercepts tools/list and dynamically expands all toolsets into a single flat list, caching the result in .mcp_tools_cache.json.Key features:
  • Sidebar tool list — click any item to pre-populate the execution console. Tools are badged as meta or tool.
  • Sidebar search — filter the full tool list by name or description. Click ✕ to clear.
  • Dynamic argument form — selecting a tool from the dropdown populates a JSON textarea with a template. For call_tool, companion dropdowns appear to pick toolset and tool name.
  • Real-time SSE terminal — execution results stream back as Server-Sent Events (text/event-stream) and are rendered live in the bottom terminal with pretty-printed JSON where applicable.
  • Quick Actions bar — two one-click shortcuts: Count SM_Cube in Scene and List Agent Skills.
The proxy translates dotted tool names (e.g. editor_toolset.toolsets.scene.SceneTools.SpawnActor) to the correct call_tool(toolset_name, tool_name, arguments) triple before forwarding to Unreal, so what you see in the browser matches the real registered namespace.
Accessed via the 📦 Spawner tab.What it does:Provides a visual form to spawn actors into the currently open Unreal level without writing any JSON by hand.Key features:
  • Class-based spawning — choose from StaticMeshActor, PointLight, DirectionalLight, or CameraActor. The UI maps the friendly name to its fully-qualified refPath format (e.g. { "refPath": "/Script/Engine.PointLight" }) as required by the UE5.8 EditorToolset Python tools.
  • Blueprint spawning — select Blueprint in the class dropdown to reveal a path input. Enter a full asset path such as /Game/Blueprints/BP_MyActor.BP_MyActor_C to spawn a Blueprint instance.
  • XYZ transform input — separate X, Y, Z number fields control the spawn location. Rotation defaults to { pitch:0, yaw:0, roll:0 } and scale to { x:1, y:1, z:1 } (the ToolsetTransform format).
  • Actor label — a name field sets the display label of the spawned actor in the Outliner.
  • Component manager — a second column lets you add components (PointLightComponent, StaticMeshComponent, AudioComponent, BoxComponent) to an existing actor or Blueprint CDO by specifying its refPath.
Internally, spawning calls editor_toolset.toolsets.scene.SceneTools.add_to_scene_from_class (for native classes) or editor_toolset.toolsets.scene.SceneTools.add_to_scene_from_asset (for Blueprints).
Accessed via the 📐 Blueprints tab.What it does:Exposes the BlueprintTools toolset from the EditorToolset Python plugin so you can create, inspect, modify, and compile Blueprints directly from the browser.Key features:
  • Create Blueprint — specify a content folder path (e.g. /Game/Blueprints/), an asset name, and a parent class (Actor, Character, Pawn, ActorComponent, SceneComponent). The panel auto-fills the edit path on success and loads the new Blueprint’s metadata immediately.
  • Load Blueprint info — enter any fully-qualified asset path (e.g. /Game/Blueprints/BP_MyActor.BP_MyActor) and click Load. The panel fetches and renders:
    • Graphs (EdGraph nodes) — listed by name.
    • Functions — listed with an Implemented / Inherited badge.
    • Variables — listed by member name.
  • Compile Blueprint — triggers BlueprintTools.compile_blueprint with a { refPath: "..." } argument. Compilation errors are surfaced in the terminal.
  • Add Function Graph — type a function name and click Add Function to call BlueprintTools.add_function_graph, then reloads the metadata grid automatically.
All Blueprint asset paths are sent as { refPath: "..." } objects, matching the UE5.8 tool schema requirement.
Accessed via the 🧪 Pruebas tab.What it does:Connects to the AutomationTestToolset to discover and execute Unreal’s built-in automation tests from the browser.Key features:
  • Discover & List — clicking List Tests first calls AutomationTestToolset.DiscoverTests (which may take 3–5 seconds while the editor scans for tests), then calls AutomationTestToolset.ListTests with optional nameFilter, tagFilter, and a limit of 200 tests.
  • Checklist UI — each discovered test is rendered as a checkbox row. You can tick individual tests or leave all unchecked to run the entire set.
  • Per-test run — each row has an individual Run button that calls AutomationTestToolset.RunTests for just that test.
  • Run All — the Run All button runs every checked test, or every loaded test if nothing is checked.
  • Results detail — after running, the panel calls AutomationTestToolset.GetTestResults and streams the detailed output to the terminal.
Accessed via the 💬 Agente Inteligente (Chat) tab (active by default on load).What it does:Embeds a multi-turn Gemini AI agent that can issue Unreal Engine tool calls in natural language. See Gemini Agent for full documentation.Key features:
  • Powered by the Google Gemini API (generateContent) with tool-calling enabled.
  • Has access to all flattened Unreal toolsets plus two virtual search tools (dbv_python_unreal_api and dbv_unreal_dev_guide).
  • Runs up to 20 agentic iterations per message before producing a final summary.
  • Markdown-rendered responses (via marked.js), with syntax-highlighted code blocks.
  • Suggestion chips on the welcome dashboard let you one-click common tasks (count cubes, list tools, spawn a light, run a Python test script).
  • A Cancel button interrupts the agent loop at any point via AbortController.

Build docs developers (and LLMs) love

Get started for freeTalk to us