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 web client is served by a local FastAPI proxy (server.py) that runs on http://localhost:5000. The proxy handles CORS, flattens toolsets, translates MCP namespaces, and serves the static SPA files from the project root — all in a single process. Platform-specific convenience scripts are included in the project root so you never need to remember the Python invocation.

​
Starting the Server

chmod +x start.sh
./start.sh
When the script runs successfully it:
  1. Starts the FastAPI/Uvicorn server on port 5000 (0.0.0.0:5000) as a background process using the project’s bundled virtual environment (./venv/bin/python).
  2. Begins proxying all /mcp traffic to the Unreal Engine MCP server at http://localhost:8000/mcp.
  3. Opens your default browser automatically at http://localhost:5000.
Because the script runs the server in the background with output suppressed (> /dev/null 2>&1), no Uvicorn log appears in the terminal. Use the Manual Start approach if you need to see live server logs.

​
Stopping the Server

chmod +x stop.sh
./stop.sh
The macOS/Linux stop script (stop.sh) locates the process listening on port 5000 with lsof and sends it kill -9 (SIGKILL) to force-terminate it immediately. The Windows variant (stop.cmd) performs the equivalent via taskkill. If you started the server manually in a terminal, you can also stop it by pressing Ctrl+C in that terminal window.

​
Manual Start (Without Scripts)

If you prefer to start the server directly — or need to run it in a custom environment — invoke Python from the project root: 
python server.py
server.py changes its working directory to the project root at startup, so relative paths (static files, skill scripts, cache file) resolve correctly regardless of where the command is run from. The server imports the search engine from the bundled skill on startup: 
skills/dbv-unreal-python-api/scripts/search_engine.py
If the skill’s knowledge base has not been populated yet, the /api/docs/search, /api/docs/status, /api/guides/search, and /api/guides/status endpoints will respond with 503 — the rest of the proxy (MCP forwarding, static files) continues working normally.

​
Mounted Endpoints

Once running, the proxy exposes the following routes:
EndpointDescription
GET /Serves index.html (the SPA)
POST /mcpMCP proxy → Unreal Engine at :8000
GET /mcpPass-through (SSE keep-alive)
DELETE /mcpPass-through (session termination)
GET /api/docs/search?q=<query>Search the Unreal Python API knowledge base
GET /api/docs/statusStatus of the Python API knowledge base
GET /api/guides/search?q=<query>Search the conceptual dev-guides knowledge base
GET /api/guides/statusStatus of the guides knowledge base
Static files from the project root (CSS, JS, fonts, etc.) are served by StaticFiles(directory=".", html=True) mounted at /.

​
Proxy Interception Behaviour

The proxy is not a simple pass-through — it applies two layers of logic to every MCP request: tools/list interception — instead of forwarding the request verbatim, the proxy calls list_toolsets on Unreal, then calls describe_toolset on each registered toolset concurrently (asyncio.gather) and assembles a single flat list of all tools. This is what makes every individual tool visible as a first-class entry in the browser sidebar and available to the Gemini agent. tools/call namespace translation — when a tool name contains dots (e.g. editor_toolset.toolsets.scene.SceneTools.SpawnActor), the proxy splits it into toolset_name and tool_name and rewrites the request as a call_tool invocation. Ambiguous short names like EditorToolset.SceneTools are resolved to the fully-qualified registered name using the cache.

​
Tool Cache

The proxy automatically creates and maintains .mcp_tools_cache.json in the project root. The cache stores the flattened tool list keyed by an MD5 hash of the current list_toolsets response. Cache resolution order:
  1. Memory — if the toolsets hash matches the in-memory cache, the response is returned immediately (0 ms overhead).
  2. Disk — if the hash matches the on-disk .mcp_tools_cache.json, the file is read and the memory cache is primed.
  3. Rebuild — if neither matches (first run, or toolsets changed), all describe_toolset calls run concurrently and both the disk and memory caches are updated.
The tool cache persists across server restarts. If your toolsets appear stale (missing new tools or showing old ones), delete .mcp_tools_cache.json from the project root to force a full rebuild on the next tools/list call.

​
Requirements

Before starting, make sure the following are in place:
  • Python 3.x with fastapi, uvicorn, and httpx installed: 
    pip install fastapi uvicorn httpx
  • Unreal Engine 5.8 open with the ModelContextProtocol plugin enabled and the MCP server listening on http://localhost:8000.
  • A modern browser (Chrome, Edge, Firefox, Safari).

Build docs developers (and LLMs) love

Get started for freeTalk to us