MCPDebugger

MCPDebugger is a C# MCP server that exposes a lightweight C++ debugger backend via MCP tools. The server allows external clients to start and stop debugging sessions, control execution (continue, step into/over, continue to breakpoints), inspect memory and disassemble code, and query module information. Clients can leverage the provided MCP tools to drive debugging sessions, inspect disassembly with symbol information, read and write process memory, and resolve strings from the debuggee. The integration is designed for experimentation and static/dynamic analysis, using Zydis for instruction decoding to provide clear disassembly feedback during debugging sessions. To use, connect as an MCP client, start a Debugger_Start session with a target executable, and then invoke the lifecycle and execution-control tools to drive the debuggee through breakpoints and API interactions. The toolset includes memory and module inspection capabilities, which are essential for reverse engineering or in-depth static analysis workflows.

Prerequisites:

• Docker (for containerized deployment) or a Windows build environment with .NET SDK if you opt to run the MCP server directly.
• Access to the MCP client tooling (e.g., Gemini CLI) if you want to reproduce the quickstart demo.

Option A: Docker (recommended for quick startup)

1. Install Docker on your system.
2. Pull the MCPDebugger image: docker pull fatmike/mcpdebugger
3. Run the MCP server container: docker run -d --name mcpdebugger -i fatmike/mcpdebugger
4. Connect an MCP client to the running server using the appropriate endpoint (depending on your Docker networking configuration).

Option B: Native Windows deployment (requires .NET development environment)

1. Open the MCPDebugger project in Visual Studio.
2. Build the MCP.Server solution (MCPDebugger.sln).
3. Run the MCP.Server.exe from the build output (Release x64 or x86).
4. Ensure the server is listening for MCP client connections (configure endpoints as needed in your environment).

Prerequisites summary:

• Docker or .NET development environment
• MCP client tooling for testing (optional but recommended)
• Target executable for debugging if you plan to run a full session

Tips and notes:

• The MCP server exposes a set of tools under the Debugger, Execution, Code & Memory, Module, and Utilities categories. Use these to control the debuggee, inspect memory, and analyze modules.
• When running in containerized mode, ensure proper access to the host's target executable and any required symbol files.
• If the debuggee requires elevated privileges or special authentication, configure environment variables accordingly (for example, enabling verbose logging or providing target paths).
• Disabling heavy-state-transfer tools (as suggested in the README) can help manage token usage during long debugging sessions.
• For best results, provide realistic target executables and ensure symbol information is available to enrich disassembly output.