pe-mcp cover: four tool names, headers, imports, strings and xrefs, with xrefs in orange

pe-mcp logope-mcp

MCP server for static analysis of PE files
Price
Free
Version
1.0.0
Platform
Windows
License
MIT
Free & Open Source MCP Server Static Analysis PE Files C++20
An AI agent can read a game’s file on disk before it touches the running program. pe-mcp is a small Model Context Protocol server that reads an .exe, .dll or .sys file and answers the agent’s questions about it. It lists headers, sections, imports, exports, strings, TLS callbacks and resources. It disassembles x86 and x64 code, finds every instruction that refers to an address, and tests byte signatures against the file. Every answer is compact JSON, paged, and never larger than 24 KB, because it lands in a model’s context window. It never opens a process, attaches a debugger or writes a byte. It is the static half of Pointer Lab’s MCP server: Pointer Lab works on the running program, and pe-mcp reads the file first.
Free
One pe-mcp.exe in an x64 or x86 zip. Nothing else to install
↓ Download from GitHub View Source on GitHub
Developer
Game Reversal Club
Open Source Software

See all software from this developer

What You Get

A small scripted MCP client spoke to pe-mcp.exe over stdio, the way Claude Code does, and asked three questions about a local build of the tutorial that ships with Pointer Lab. This is real output. The client printed one row per line, and the rows are as the server sent them.

# server pe-mcp 1.0.0, 17 tools
> strings {"filter":"Health: %.3f"}
{
  "total": 1,
  "items": [
    {"rva":"0x1B518","enc":"utf16","text":"Health: %.3f     Ammo: %.4f"}
  ],
  "next": null
}
> xrefs_to {"rva":"0x1B518"}
{
  "target": "0x1B518",
  "note": "L\"Health: %.3f     Ammo: %.4f\"",
  "total": 1,
  "items": [
    {"rva":"0x1B4B","kind":"rip","text":"lea r8, [0x14001B518]","function":"0x1B40"}
  ],
  "next": null
}
> disassemble {"rva":"0x1B4B","function":true}
{
  "function": {"begin":"0x1B40","end":"0x1B79"},
  "items": [
    {"rva":"0x1B40","bytes":"4883EC38","text":"sub rsp, 0x38"},
    {"rva":"0x1B44","bytes":"488B057DC00200","text":"mov rax, [0x14002DBC8]","ref":"0x2DBC8"},
    {"rva":"0x1B4B","bytes":"4C8D05C6990100","text":"lea r8, [0x14001B518]","ref":"0x1B518","note":"L\"Health: %.3f     Ammo: %.4f\""},
    {"rva":"0x1B52","bytes":"F30F1000","text":"movss xmm0, dword ptr [rax]"},
    {"rva":"0x1B56","bytes":"488B0573C00200","text":"mov rax, [0x14002DBD0]","ref":"0x2DBD0"},
    {"rva":"0x1B5D","bytes":"0F5AD8","text":"cvtps2pd xmm3, xmm0"},
    {"rva":"0x1B60","bytes":"F20F1008","text":"movsd xmm1, qword ptr [rax]"},
    {"rva":"0x1B64","bytes":"66490F7ED9","text":"movq r9, xmm3"},
    {"rva":"0x1B69","bytes":"F20F114C2420","text":"movsd [rsp+0x20], xmm1"},
    {"rva":"0x1B6F","bytes":"E83C1F0000","text":"call 0x140003AB0","ref":"0x3AB0"},
    {"rva":"0x1B74","bytes":"4883C438","text":"add rsp, 0x38"},
    {"rva":"0x1B78","bytes":"C3","text":"ret"}
  ],
  "next": null
}

The string led to the one instruction that uses it, and that instruction named its function. The function reads the float health and the double ammo through the two globals in orange.

How It Works

Reads files, nothing else
pe-mcp opens files from disk and never a process. Every tool is marked read-only in tools/list. For a running program, use Pointer Lab’s MCP server.
Sized for a context window
A list comes back as total, items and next. Pass next back as cursor for the next page. No result is larger than 24 KB of JSON, whatever the limit.
Disassembly with notes
An instruction that points into the image carries the target RVA and a note naming the import, export or string there. On x64, function: true uses .pdata to disassemble the whole function around an address.
Cross-references by sweep
Every executable section is decoded, and each relative call or jump, RIP-relative operand and absolute address that points at the target is reported. On x64 each hit names its function. Pointers in data sections, such as vtable entries, are optional.
Signatures checked on disk
find_pattern is sigscan, so it reads x64dbg, IDA, code and mask, C++ array and aobscanmodule forms. It returns every match and the total, so a Signature Lab signature can be checked before the program runs.
Errors a model can use
A bad argument comes back as a tool result with isError set and a sentence saying what was wrong. A misspelled argument name is refused with the names the tool takes. A corrupt file is refused with the reason, or read in part with warnings.

Item Specifics

Name
pe-mcp
Author
Heath Howren (“Cyborg Elf”)
Version
1.0.0 (2026)
Type
MCP server: static analysis of PE files
Platform
Windows; x64 and x86 builds, each reads PE32 and PE32+ files
License
MIT License
Price
Free
Language
C++20
Disassembler
Zydis 4.1.1
Protocol
MCP over stdio, JSON-RPC 2.0; revisions 2025-06-18, 2025-03-26 and 2024-11-05
Dependencies
Zydis, Zycore, nlohmann/json and sigscan, all MIT and all built in
Distribution
pe-mcp-v1.0.0-windows-x64.zip and pe-mcp-v1.0.0-windows-x86.zip, each with pe-mcp.exe
Requirements
An MCP client that can launch a stdio server, such as Claude Code. Nothing else: the C runtime is linked statically
Tests
54 Catch2 test cases, with golden output for every tool, run in CI for x64 and x86
Source Code

Features

17 read-only MCP tools
MCP over stdio, no port or token
One-line setup with claude mcp add
PE32 and PE32+ files
ASLR, DEP and CFG in the headers
PDB path and overlay
Sections with entropy
Imports with IAT slots, delay-loaded too
Exports with forwarders
ASCII and UTF-16LE strings
x86 and x64 disassembly (Zydis)
Whole-function disassembly on x64
Cross-references to an address or range
Data pointers such as vtable entries
Signature search through sigscan
SHA-256 per file and section, and imphash
TLS callbacks and resources
RVA and file offset conversion
Several files open to compare builds
Paged JSON, 24 KB cap per result
Damaged files reported, not crashed on
54 test cases, run in CI

Before You Download

Intended use. pe-mcp is for studying software you own or are authorized to analyze: your own programs, single-player games, CTF binaries, and the lab targets from The Game Hacker’s Handbook. It reads files and changes nothing, but what you do with what it finds is your decision. Modifying software you do not have permission to modify may be illegal where you live. This is a research tool.

What it does not read. It does not load PDB symbols, parse .NET metadata or disassemble ARM64 code, though the headers and tables of an ARM64 file still read. Function bounds come from .pdata, so they exist only on x64. Files are read whole into memory, up to 1 GiB each and 16 at once.

Cross-references come from a linear sweep. Data inside a code section can hide the instruction after it. A call through a register or a computed address is not a reference it can see.

The binary is unsigned. pe-mcp only reads files, but build it from source if you would rather not take a binary on trust.