ReClass.NET MCP Plugin

A plugin that turns ReClass.NET into a Model Context Protocol (MCP) server, so an agentic LLM (Claude, etc.) can drive ReClass.NET directly — attach to a process, read and write its memory, and build up class/struct layouts node-by-node while you watch it happen in the UI.

Think of it as giving the model the same buttons you have: enumerate processes, walk modules and sections, resolve address formulas, read typed values, define fields, create enums, and generate C++/C# code from the result.

🤖 Authorship

This project — every line of code, every test, this README, and the CI workflows — was written entirely by an AI agent (Anthropic's Claude), not by a human. It was produced through an agentic workflow (design → spec → plan → test-driven implementation with automated code review → live end-to-end testing). A human directed what to build and reviewed the result, but did not write the implementation.

---

Why?

Reverse engineering an unknown object in memory is a loop: read some bytes, guess a field, type it, check whether the neighbouring values now make sense, repeat. That loop is exactly the kind of thing an LLM is good at — if it can actually see and manipulate the target. This plugin exposes ReClass.NET's engine over MCP so the model can run that loop itself, turning "here's a pointer, figure out the struct" into something you can simply ask for.

How it works

┌────────────┐   HTTP + JSON-RPC (MCP)    ┌──────────────────────────────────────┐
│ MCP client │ ─────────────────────────► │ ReClass.NET (this plugin)            │
│ (Claude)   │   127.0.0.1:6464/mcp       │  HttpListener → dispatcher → tools    │
└────────────┘   Bearer <token>           │   • memory  → RemoteProcess          │
                                           │   • classes → project (UI thread)    │
                                           └──────────────────────────────────────┘

On load, the plugin starts an in-process HTTP server bound to loopback only (127.0.0.1) that speaks the MCP wire protocol (JSON-RPC 2.0). Tool calls arrive on background threads; anything that touches the ReClass project tree or the UI is marshaled onto the WinForms UI thread, while raw memory reads/writes go straight to the attached process. Every request must carry a bearer token.

Requirements

• Windows (x86 or x64 — must match the ReClass.NET build you run)
• ReClass.NET (.NET 9 build)
• An MCP-capable client (e.g. Claude Code)

Installation

From a release

1. Download the archive for your architecture from the Releases page (ReClassMcpPlugin-x64.zip or ReClassMcpPlugin-x86.zip).
2. Extract ReClassMcpPlugin.dll into the Plugins folder next to ReClass.NET.exe.
3. Start ReClass.NET (matching x86/x64). The server auto-starts and an MCP Server menu appears in the menu bar.

⚠️ Keep the file named exactly ReClassMcpPlugin.dll — ReClass.NET's loader derives the plugin entry type from the file name.

From source

git clone --recursive https://github.com/RequiDev/reclass-mcp-plugin.git
cd reclass-mcp-plugin
dotnet build ReClassMcpPlugin/ReClassMcpPlugin.csproj -c Release -p:Platform=x64

--recursive matters: ReClass.NET is included as a git submodule and the plugin compiles against it. The output lands in build/Release/x64/ReClassMcpPlugin.dll; copy it into your ReClass.NET Plugins folder. (If you already cloned without --recursive, run git submodule update --init --recursive.)

Connecting an MCP client

The server listens on http://127.0.0.1:6464/mcp and requires a bearer token. Find the token via the MCP Server → Copy Token menu item, or read it from:

%APPDATA%\ReClass.NET\mcp-server.json

Add it to Claude Code:

claude mcp add --transport http reclass http://127.0.0.1:6464/mcp \
  --header "Authorization: Bearer <YOUR_TOKEN>"

Then claude mcp list (terminal) or /mcp (inside a session) should show reclass connected.

The port, auto-start behaviour, and token live in mcp-server.json and can be edited; the MCP Server menu also lets you start/stop the server and copy the token.

⚠️ Security

This server gives its client the ability to read and write the memory of — and suspend, resume, or terminate — whatever process ReClass.NET is attached to. Protections:

• It binds to loopback only (127.0.0.1); it is not reachable from the network.
• Every request requires a bearer token (32 random bytes, generated on first run).
• All memory writes and process-control actions are written to the ReClass.NET log.

Treat the token like a password, and stop the server from the menu when you are not using it.

Tools

Group	Tools
Process	list_processes, attach_process, get_status, control_process (suspend/resume/terminate)
Modules	list_modules, get_module, list_sections
Memory	resolve_address, read_memory, read_typed, read_string, read_pointer, get_rtti, write_memory, write_typed
Classes	list_classes, get_class, create_class, rename_class, set_class_address, delete_class
Nodes	list_node_types, append_node, set_field, add_bytes, insert_bytes, set_node_name, set_node_comment, remove_node
Enums	list_enums, get_enum, create_enum, delete_enum
Code generation	generate_code (C++ / C#)
Project	get_project_info, new_project, open_project, save_project

Node types available to append_node / set_field (via list_node_types): the hex blocks, all integer widths (Int8–Int64, UInt8–UInt64, NInt/NUInt), Bool, BitField, Float, Double, Vector2/3/4, Matrix3x3/3x4/4x4, UTF-8/16/32 text and text pointers, Enum, and the wrappers Pointer, Array, and ClassInstance.

Example: build a class

A typical agent flow, all over MCP:

1. attach_process { "name": "game.exe" }
2. create_class { "name": "Player", "addressFormula": "<game.exe>+0x1000" } → returns a uuid
3. append_node { "classUuid": "<uuid>", "type": "Int32", "name": "health" }
4. append_node { "classUuid": "<uuid>", "type": "Vector3", "name": "position" }
5. append_node { "classUuid": "<uuid>", "type": "Pointer", "name": "weapon", "targetClassUuid": "<Weapon uuid>" }
6. generate_code { "language": "cpp" }

class Player {
public:
    int32_t health;            //0x0000
    Vector3 position;          //0x0004
    class Weapon *weapon;      //0x0010
};

Building & testing

dotnet build ReClassMcpPlugin.sln -c Release -p:Platform=x64
dotnet test  ReClassMcpPlugin.Tests/ReClassMcpPlugin.Tests.csproj -c Release -p:Platform=x64

The unit tests cover the protocol layer (JSON-RPC, dispatcher, argument parsing), the node factory/serializer, and configuration. The live memory/UI tools are exercised manually against a running ReClass.NET.

Project layout

reclass-mcp-plugin/
├─ ReClass.NET/              # git submodule → RequiDev/ReClass.NET (build dependency)
├─ ReClassMcpPlugin/         # the plugin
│  ├─ Protocol/              #   JSON-RPC + MCP dispatcher
│  ├─ Transport/             #   HttpListener server
│  ├─ Tools/                 #   tool modules + node factory/serializer
│  └─ Config/                #   server config + token
├─ ReClassMcpPlugin.Tests/   # xUnit tests
├─ docs/                     # design doc & implementation plan
└─ .github/workflows/        # CI: build + release

Acknowledgements

• ReClass.NET by KN4CK3R and contributors — the engine this plugin exposes.
• README structure inspired by ida-pro-mcp.

License

MIT. ReClass.NET is also MIT-licensed.