An MCP (Model Context Protocol) server that gives AI agents live, programmatic access to any running RE Engine game -- Resident Evil, Monster Hunter, Devil May Cry, Dragon's Dogma, and more.

• Inspect everything. 100,000+ types, every singleton, every field, every method -- searchable and navigable from a running game. Call any method, chain multi-step queries across the object graph, batch operations in a single request.
• Read and write live state. Player health, enemy AI, inventory, position, equipment -- the agent sees what the game sees, in real time.
• Build mods in-conversation. Write C# plugins, hot-reload them into the running game, read compile errors, fix, redeploy -- full development loop, no human in the middle.
• Works across games. Same tools work on RE2, Monster Hunter Wilds, RE9, DMC5, DD2, and any other RE Engine title. Per-game endpoints (Mr. X tracker, monster HP, adaptive difficulty) light up automatically.

The web dashboard -- player stats, enemy lists, inventory, Mr. X real-time tracker -- was built entirely by AI agents using these MCP tools, in single conversations, without prior knowledge of each game's internals.

• REFramework nightly build installed for your game. You must use a nightly build -- stable releases do not include .NET support.
• csharp-api.zip from the same nightly releases page. Extract it into your game's reframework/ folder to get the .NET runtime and reference assemblies the plugin needs.
• .NET 10 runtime and SDK -- required by the C# API and the MCP server. Install the SDK if you want to build the MCP server from source, or just the runtime if using a pre-built release.

Copy the reframework/ folder into your game directory. It mirrors the exact folder structure REFramework expects:

<game>/reframework/plugins/source/TestWebAPI.cs
<game>/reframework/plugins/source/WebAPI/

REFramework will hot-compile the plugin on next game launch. You should see [WebAPI] Listening on http://localhost:8899/ in the REFramework log.

The repo root contains .mcp.json — agents that support workspace-level MCP config (Claude Code, Cursor, etc.) will detect it automatically when you open the project.

To register manually with any MCP client, add this to your MCP config:

{
  "mcpServers": {
    "reframework": {
      "command": "dotnet",
      "args": ["run", "--project", "/path/to/mcp-server"],
      "env": {
        "REFRAMEWORK_API_URL": "http://localhost:8899"
      }
    }
  }
}

Or use the helper scripts in mcp-server/ (install.cmd / install.sh) to register via the claude CLI.

Start the game with REFramework loaded. The plugin compiles automatically and starts the HTTP server. The MCP server connects to it on first tool call.

Open http://localhost:8899 in a browser while the game is running. The dashboard auto-detects which game is running and shows the relevant cards:

• Player -- HP bar with slider, position, status badges (poison, combat, etc.)
• Enemies -- Active enemy list with HP bars, distance, kill tracking
• Inventory -- Item pouch with weapon ammo/durability bars, equipped weapon, item counts
• Mr. X Tracker (RE2) -- Real-time AI state (Chasing/Searching/Stunned/Teleporting), distance proximity bar, location, kill/stun timers, on-screen detection
• Game Info -- Scenario, difficulty, adaptive difficulty rank with damage/break multipliers, save count
• Monsters (MH Wilds) -- Large monster HP, species, position, distance
• Weather (MH Wilds) -- Current/next weather, blend rates, in-game clock
• Equipment -- Weapon stats, armor pieces, decorations
• Object explorer -- Browse singletons, navigate object graphs, inspect fields and methods interactively

Cards that don't apply to the current game are hidden automatically. The same plugin binary, same dashboard code -- it just adapts.

The entire dashboard -- every card, every endpoint, every line of CSS -- was built by AI agents using the MCP tools in this repo. No human wrote the player HP bars, the enemy list, the inventory renderer, or the Mr. X tracker.

The process: an agent explored the live game's object graph to discover what data was available. It wrote API endpoints to expose that data, authored the HTML/JS/CSS to render it, tested against the running game, and iterated until it worked. The full RE2 dashboard -- player, enemies, inventory, game info, Mr. X tracker -- took about 30 minutes.

The per-game detection, the adaptive card visibility, the RE2-specific features -- all autonomously built through the same tools the repo ships. The dashboard is both a useful feature and a proof of what the MCP server makes possible.

The game plugin uses REFramework.NET to access the RE Engine's managed object system. Every game object, singleton, type, field, and method is reachable through the type database (TDB). The plugin exposes this as a REST API:

1. Type queries go straight to the TDB -- no live instance needed
2. Object inspection reads field values from live objects in the game's managed heap
3. Method invocation calls game methods through REFramework's managed interop layer
4. Chain queries walk the object graph server-side, expanding fields, calling methods, filtering, and collecting results in a single request

The MCP server is a thin translation layer. Each MCP tool maps to one HTTP endpoint. The named pipe channel provides a secondary communication path for compile/log operations that must work before the HTTP plugin is loaded.

Three components, each independently useful:

  AI Agent / MCP Client
        |
        | MCP protocol (stdio)
        v
  +-----------------+
  |   MCP Server    |  mcp-server/     .NET console app
  |  (stdio bridge) |  Translates MCP tool calls -> HTTP
  +-----------------+
        |
        | HTTP (localhost:8899)
        v
  +-----------------+
  |  Game Plugin    |  plugin/          C# REFramework.NET plugin
  |  (HTTP server)  |  Runs inside the game process
  +-----------------+
        |
        | REFramework.NET API
        v
  +-----------------+
  |   RE Engine     |  The actual game
  |   Game Process  |
  +-----------------+

reframework/plugins/source/TestWebAPI.cs -- A C# plugin loaded by REFramework inside the game. It starts an HTTP server on localhost:8899, exposes /api/* endpoints that call into the game engine via REFramework.NET's managed API, and serves the web dashboard from the WebAPI/ folder.

reframework/plugins/source/WebAPI/ -- A static web frontend with a live object explorer and player dashboard. Open http://localhost:8899 in a browser while the game is running.

mcp-server/ -- A standalone .NET 10 console app that speaks MCP over stdio. It translates MCP tool calls into HTTP requests to the game plugin. Also has a named-pipe channel for out-of-band operations (compile status, logs, errors) that work even before the HTTP plugin loads.

Any RE Engine title that REFramework supports:

The plugin has per-game convenience endpoints gated behind preprocessor symbols (#if MHWILDS, #elif RE9, #elif RE2). The core explorer endpoints -- type search, object inspection, field read/write, method invocation -- work on any RE Engine game without modification.

Once connected, you can ask your agent things like:

• "What's my current health and position?"
• "Find the type that manages weather and show me its fields."
• "Set my health to max."

But the real power is in open-ended requests. You don't need to know the game's internals -- the agent will figure it out:

• "Figure out how the save system works and write a mod that expands it to 90 save slots."
• "Find out what controls item drop rates and make a plugin that doubles them."
• "Reverse-engineer how the damage formula works, then write a C# plugin that adds a damage log overlay."
• "I want to change the weather to always be sunny. Find the right singleton, figure out the fields, and make it happen."

A user asked: "What large monsters are currently loaded? Give me each one's species, HP, max HP, position, and distance from my character."

The agent had zero prior context about the game's enemy system. It found the enemy manager singleton, navigated a multi-step object graph through chain queries, and filtered down to boss-type enemies. It resolved monster names via GUID localization, read HP and positions, and computed 3D distances. Along the way it discovered and corrected a non-obvious enum offset bug between SPECIES_Fixed and SPECIES variants. 15-word question in, formatted table out.

A user asked: "Add a Mr. X tracker to the dashboard."

The agent had never seen RE2's enemy system. It explored EnemyManager, discovered the Em6200ChaserController list (count=1 when Mr. X is spawned), and navigated to the Em6200Think AI brain with its state flags and timers.

From there it wrote the full feature: API endpoint with graceful absent-case handling, dashboard card with color-coded status badges and a distance proximity bar, CSS, and MCP tool registration. All deployed via hot-reload and tested against the running game.

{
  "active": true,
  "status": "Chasing (Aggressive)",
  "state": "Move",
  "location": "RPD",
  "playerDistance": 3.19,
  "ai": { "isSleeping": false, "isEncounting": true, "isKillingMode": true, "isGhostMode": false },
  "timers": { "killingTimer": 19.8, "sleepTimer": 0 }
}

The agent doesn't just read game state -- it can run a full development loop against the live game:

1. Discover. Search the type database for relevant singletons. Inspect their fields and methods, probe live objects to understand data layouts. The agent fans out parallel queries to find populated collections of the right shape.
2. Write. Author a C# plugin (or modify an existing one) and save it to the game's reframework/plugins/source/ directory.
3. Build. The plugin hot-compiles automatically. The agent reads compile status and errors through the MCP server -- no manual checking needed.
4. Test. Deploy test plugins that exercise specific behaviors, read the results from the game log, and verify correctness. If something fails, the agent reads the error, fixes the code, and recompiles -- all without human intervention.
5. Iterate. Repeat until the tests pass. The agent can locate candidate objects, write targeted tests, fix field names or type mismatches from error output, and converge on working code autonomously.

For example: given a C++ API with broken collection iteration, the agent probed live Dictionary, HashSet, List, and Array objects across multiple game singletons to characterize the failures. It read the C++ source to identify the root cause, wrote a fix, and built it.

Then it needed test data. It queried the type database and inspected live singletons to find populated collections of each type -- a Dictionary<String, GameSlotSaveHandler> with 37 entries, a HashSet<ItemID> with 113 entries, a Dictionary<SaveSlotAddress, SaveSlotInfo> with struct keys for diversity. It assembled a 22-test regression suite, deployed it as a hot-compiled plugin, read back the log, fixed wrong field names from the error output, redeployed, and converged to 22 PASS, 0 FAIL. No human touched the keyboard between "fix the broken enumerator" and the final results.

Tip: Pair with IDA Pro MCP, Binary Ninja MCP, or Ghidra MCP for even deeper reverse engineering. If your disassembler has RE Engine method addresses mapped to names (REFramework ships a Python script for this), the agent can read decompiled function bodies alongside live object inspection. Not required, but powerful when you need to understand what a function actually does rather than just what it's called.

The agent guide (help tool) provides detailed navigation paths, chain examples, and tips -- call it first in any new session.

MIT