Skip to main content
Glama

▎ Overview

ctxdebug is an MCP (Model Context Protocol) platform that connects WinDbg, IDA Pro 9.x, and x64dbg to AI coding assistants. Use it for crash dump analysis, static review in IDA, and live debugging in x64dbg — without copying output between windows.

One stdio interface. 160+ tools. Three debuggers, one client.

How it works. Each debugger is exposed as an MCP tool server. You talk to Claude, Kiro, or any MCP-compatible client; the client calls the debuggers. No copy-paste, no manual correlation between tools.

Example. You ask: "analyze this crash dump and find the root cause." ctxdebug opens the dump in WinDbg, runs !analyze -v, takes the faulting address, decompiles the function in IDA Pro, and returns a combined report with pseudocode and the caller chain.


Related MCP server: ida-pro-mcp-plus

▎ Demo


▎ Quick Start

Requirements

  • Python 3.11+

  • OS Windows 10 / 11

  • At least one debugger — WinDbg (Windows SDK) · IDA Pro 9.x · x64dbg

Install

git clone https://github.com/DdUdle/ctxdebug.git
cd ctxdebug
pip install -e .

Register servers

Individual servers:

claude mcp add windbg       -- python windbg_mcp.py
claude mcp add ida          -- python ida_mcp.py
claude mcp add x64dbg       -- python -m agent --mcp
claude mcp add mco          -- python mco_orchestrator.py
claude mcp add mco-sessions -- python mco_sessions.py

Or use the unified gateway — one server, every tool:

claude mcp add mco-gateway -- python mco_gateway.py

See mcp_config_example.json for full JSON configuration with environment variables.

Try it

Once a server is registered, ask your AI client:

Open C:\dumps\crash.dmp, run a full crash analysis,
and decompile the function at the fault address.

The orchestrator chains windbg_open_dump → windbg_analyze_crash → mco_pivot_to_ida and returns pseudocode with the caller chain.


▎ Features

Capability

What it does

Live debugger control

Run, pause, step, and inspect a process through x64dbg. Set breakpoints on API groups (memory, network, crypto) instead of one address at a time.

Cross-debugger pivot

Take an address from a WinDbg crash dump and open it in IDA Pro for decompilation, callers, and callees in one tool call.

Goal-driven analysis

The x64dbg server includes an optional ReAct agent (agent_analyze) that plans multi-step goals — for example finding an unpacking loop or listing anti-analysis checks — by chaining tool calls. Works with Claude, Groq, local Ollama, or heuristics only.

Persistent notes

The agent stores packer signatures, anti-analysis patterns, and notes from earlier sessions, and can recall them on new targets.

Session recording

Tool calls can be logged to SQLite with full-text search (FTS5). Replay a timeline, compare two sessions, or export a Markdown report.

Anti-analysis survey

Combines a static scan (IDA imports/patterns) and a dynamic scan (x64dbg PEB/RDTSC) into one report. Optional lab patches (PEB flags, instruction edits) for samples you are authorized to analyze.


▎ Architecture

  • Transport — stdio JSON-RPC (MCP 2024-11-05)

  • IDA — HTTP REST on localhost:2022, auto-discovers the endpoint from 6 candidates

  • x64dbg — binary framing over a named pipe (X64A magic + uint32 length + 8-byte padding + JSON)

  • Agent — ReAct loop with pluggable LLM backends (Claude, Groq, OpenRouter, local Ollama, or heuristics only)

  • Sessions — SQLite with FTS5, WAL mode, thread-safe

  • Gateway — starts sub-servers as child processes and proxies tool calls through one stdio connection


▎ Servers

Server

File

What it does

Tools

windbg

windbg_mcp.py

Crash dumps, heap analysis, shadow stack, kernel debugging

70+

ida

ida_mcp.py

Decompilation, xrefs, type recovery, binary patching

32+

x64dbg

agent/

Dynamic analysis, ReAct agent, memory inspection and patching

38+

mco

mco_orchestrator.py

Cross-debugger compound workflows

7

mco-sessions

mco_sessions.py

Session recording, FTS search, Markdown export

13

mco-gateway

mco_gateway.py

Unified proxy — all servers through one connection

all


▎ Debugger setup

Needs cdb.exe from the Windows SDK. Default path:

C:\Program Files (x86)\Windows Kits\10\Debuggers\x64\cdb.exe

Set WINDBG_MCP_CDB if your path differs. No pre-launch needed — tools open dumps or attach on demand.

  1. Open IDA Pro 9.x with a binary loaded.

  2. In the Python console, run:

    exec(open(r'path\to\ctxdebug\ida_server_plugin.py').read())
  3. HTTP server starts on port 2022.

  1. Build the C++ plugin:

    cd agent\plugins
    build_plugin.bat
  2. Copy mco_agent.dp64 to x64dbg's plugin directory.

  3. Restart x64dbg — the plugin exposes named pipe \\.\pipe\x64dbg_ai_agent.


▎ Key Workflows

Crash dump → source (one command)

mco_crash_to_source(dump_path="C:\\dumps\\crash.dmp")

Opens the dump, runs !analyze -v, extracts the faulting address, decompiles the crashing function in IDA, and returns pseudocode with callers.

Anti-analysis report

mco_bossix_report()
bossix_hide()            # PEB flag adjustments (lab)
bossix_patch(address)    # NOP / flip JCC at a check (lab)

For authorized lab analysis of samples that implement anti-debug checks.

Pivot an address to pseudocode

mco_pivot_to_ida(address="0x7FF712340000")

Goal-driven analysis

agent_analyze(goal="Find the unpacking loop and identify the OEP")

The agent plans a sequence of tool calls, executes them, and reports findings — with or without an LLM backend.

Session recording

session_start(name="crash dump review")
# ... do your work ...
session_end(notes="null deref in CRenderObject::Destroy")
session_export_markdown(session_id=1)

▎ x64dbg Server Modes

Mode

Command

Tool-only (default)

python -m agent --mcp

Claude reasoning

python -m agent --mcp --llm claude --api-key sk-...

Local Ollama

python -m agent --mcp --llm local --llm-model deepseek-r1

Groq (free tier)

python -m agent --mcp --llm groq

OpenRouter

python -m agent --mcp --llm openrouter

Interactive CLI

python -m agent --cli


▎ Environment Variables

Variable

Server

Purpose

WINDBG_MCP_CDB

windbg

Path to cdb.exe

IDA_MCP_HOST

ida

IDA HTTP host (default: localhost)

IDA_MCP_PORT

ida

IDA HTTP port (default: 2022)

IDA_MCP_TOKEN

ida

Bearer token for the IDA HTTP server — required to bind it off loopback

IDA_SERVER_HOST

ida

Bind address of the in-IDA HTTP server (default: 127.0.0.1)

X64DBG_PATH

x64dbg

Path to x64dbg.exe

X64DBG_PIPE

x64dbg

Named pipe path

ANTHROPIC_API_KEY

x64dbg

Only needed with --llm claude

GROQ_API_KEY

x64dbg

Only needed with --llm groq

MCO_SESSIONS_DB

sessions

SQLite database path

MCO_SERVERS

gateway

Comma-separated subset of servers to enable


▎ Project Structure

ctxdebug/
├── windbg_mcp.py           # WinDbg MCP server
├── ida_mcp.py              # IDA Pro MCP server
├── ida_server_plugin.py    # IDA Python plugin (starts HTTP server)
├── mco_orchestrator.py     # Cross-debugger meta-tools
├── mco_sessions.py         # Session recording (SQLite + FTS5)
├── mco_gateway.py          # Unified gateway proxy
├── agent/
│   ├── __main__.py         # x64dbg MCP entry point + LLM backend selection
│   ├── core.py             # ReAct agent (Observe → Think → Act)
│   ├── memory.py           # Persistent memory store (~/.x64ai/)
│   ├── bridge.py           # Named-pipe IPC to x64dbg plugin
│   ├── mcp_server.py       # Tool definitions (38+)
│   ├── skills/             # Modular skill implementations
│   └── plugins/
│       ├── x64dbg_plugin.cpp
│       └── build_plugin.bat
├── mcp_config_example.json # Ready-to-use MCP client config
└── pyproject.toml

▎ Development

git clone https://github.com/DdUdle/ctxdebug.git
cd ctxdebug
pip install -e ".[dev]"
pytest

▎ Contributing

Contributions are welcome. Please open an issue before starting large changes so the approach can be discussed first.


▎ License

MIT — see LICENSE.

Available Tools

169 tools
agent_analyzeA

AUTONOMOUS ANALYSIS: Ask the AI agent to plan, execute, and report on a debugging goal. The agent runs a ReAct loop, calls multiple debugging skills, and returns findings. USE WHEN: open-ended exploration — 'find unpacking loop', 'identify anti-debug', 'trace execution from main'. DO NOT USE for single specific operations — call the dedicated tool instead.

Inputs: goal (required), max_steps. Returns: data, error, details, success, +2 more

agent_get_contextA

Get the agent's current debugging context: target process, current RIP, breakpoints, discovered functions, found patterns, current goal. USE WHEN: you need to know what the agent already knows before deciding next steps.

Inputs: no named parameters. Returns: data, error, details, success, +2 more

allocate_memoryA

Allocate memory in the target process. Returns the allocated address.

Inputs: size, protection. Returns: data, error, details, success, +2 more

analyze_functionA

Deep function analysis: disassembly, xrefs in/out, API calls, string refs, crypto indicators (xor/rol/ror/shl/shr).

Inputs: address. Returns: data, error, details, success, +2 more

bossix_hideA

Hide debugger via PEB patches: zero BeingDebugged, clear NtGlobalFlag, x64dbg built-in hide.

Inputs: no named parameters. Returns: data, error, details, success, +2 more

bossix_patchA

Auto-patch a bossix check at an address. Picks the right patch based on instruction: flips conditional jumps, NOPs test/cmp, replaces CALL with xor eax,eax.

Inputs: address (required), technique. Returns: data, error, details, success, +2 more

bossix_scanA

COMPREHENSIVE bossix scan: PEB flags, API imports, byte patterns, RDTSC. Returns detected techniques + targeted bypass suggestions per finding.

Inputs: no named parameters. Returns: data, error, details, success, +2 more

breakpointA

Set, list, or delete a breakpoint. Supports software, hardware, memory, conditional, and API-by-name. USE 'set' WITH 'api' to break on an imported function by name (no need to resolve address). USE 'set_conditional' to break only when expression is true (e.g., 'rcx == 0x1000'). USE 'set_hw' for hardware breakpoints (no code modification, useful when scanning for INT3). USE 'list' to see all currently active breakpoints. For a single API, use action='set' + 'api'. For bulk API groups (all memory/network/etc.), use breakpoint_on_api_group instead.

Inputs: action (required), api, log, size, +4 more. Returns: data, error, details, success, +2 more

breakpoint_on_api_groupA

Set breakpoints on all APIs in a category at once. Saves many calls vs setting each manually.

Inputs: group (required). Returns: data, error, details, success, +2 more

disassembleA

Disassemble instructions with auto call/jump analysis. Returns instructions plus categorized lists of CALLs and JMPs.

Inputs: count, address. Returns: data, error, details, success, +2 more

dump_moduleA

Dump a loaded module to disk (post-unpacking, etc.).

Inputs: module (required), output. Returns: data, error, details, success, +2 more

evaluate_expressionA

Evaluate an x64dbg expression. Resolves API names, registers, arithmetic, pointer dereferences. TIP: Use [address] syntax to read a pointer value, e.g. '[rsp]' reads the QWORD at RSP. This is faster than read_memory for single values.

Inputs: expression (required). Returns: data, error, details, success, +2 more

execute_commandA

Execute a raw x64dbg command. ESCAPE HATCH for operations not covered by other tools. USE SPARINGLY — prefer the dedicated tool when one exists.

Inputs: command (required). Returns: data, error, details, success, +2 more

execution_controlA

Control execution: run, pause, single-step, run-to-address. TIP: Use 'run_to' instead of breakpoint(action='set')+run for one-shot stops (auto-cleans the BP).

Inputs: action (required), count, address, step_type. Returns: data, error, details, success, +2 more

get_call_stackB

Get the current thread's call stack with module + function names per frame.

Inputs: no named parameters. Returns: data, error, details, success, +2 more

get_handlesA

List process handles grouped by type (File, Mutant, Event, Thread, etc.).

Inputs: no named parameters. Returns: data, error, details, success, +2 more

get_pebA

Get FULL PEB (Process Environment Block) dump with anti-debug flag analysis. Returns ALL fields. Use process_info for a quick overview; use this for deep PEB inspection.

Inputs: no named parameters. Returns: data, error, details, success, +2 more

get_registersA

Get all CPU registers (GPRs + flags + RIP/RSP). Updates the agent's current_rip context.

Inputs: no named parameters. Returns: data, error, details, success, +2 more

get_threadsB

List threads with TID, entry, state, priority.

Inputs: no named parameters. Returns: data, error, details, success, +2 more

get_xrefsB

Get cross-references to or from an address (callers / callees).

Inputs: address (required), direction. Returns: data, error, details, success, +2 more

ida_analyze_functionA

Deep function analysis: calls, string refs, xrefs, decompile. Best starting point.

Inputs: address (required).

ida_apply_signatureA

Apply a FLIRT .sig signature file to auto-identify library functions.

Inputs: sig_file (required).

ida_call_treeA

Build a recursive call tree from a function up to depth levels. Returns a nested tree showing what functions are called. Useful for understanding w execution flow or finding the main logic.

Inputs: address (required), depth.

ida_commentC

Add a comment at an address. Kinds: regular, repeatable, anterior, posterior.

Inputs: text (required), address (required), kind.

ida_decompileB

Decompile function to pseudocode using Hex-Rays decompiler.

Inputs: address (required).

ida_diff_functionsA

Compare two functions side-by-side: disasm, instruction count, size delta. Useful for spotting obfuscation differences or comparing similar routines.

Inputs: addr1 (required), addr2 (required).

ida_disassembleA

Disassemble instructions at an address. Use function=true for entire function.

Inputs: address (required), count, function.

ida_entry_pointsA

List binary entry points (start address + DLL exports if applicable).

Inputs: no named parameters.

ida_export_idb_infoA

Export a comprehensive IDA database summary: input file path, MD5, SHA256, image base, entry point count, function count, segment count, string count, import module count, and patch count. Good for a session overview.

Inputs: no named parameters.

ida_exportsA

Get the export table (for DLLs/EXEs with exports).

Inputs: no named parameters.

ida_find_cryptoA

Scan for cryptographic algorithm indicators (constants, XOR patterns, S-boxes).

Inputs: no named parameters.

ida_find_string_refsA

Find all strings matching a regex pattern, then for each string list every function that references it. Great for finding where 'admin', 'password', 'cmd.exe', or C2 URLs are used.

Inputs: pattern (required).

ida_functionsA

List functions in the binary. Supports pagination and name filtering.

Inputs: limit, offset, pattern.

ida_get_pseudocode_all_functionsA

Decompile up to limit functions using Hex-Rays and return their pseudocode. Starts from the first function in the binary. Useful for bulk analysis.

Inputs: limit.

ida_get_typeB

Get the type signature of a function or variable.

Inputs: address (required).

ida_importsA

Get the import table, optionally filtered by DLL name.

Inputs: module.

ida_infoA

Get detailed binary info: path, arch, image base, entry point, size.

Inputs: no named parameters.

ida_list_patchesA

List all patches applied to the IDA database. Shows address, original byte value, and patched byte value for each changed byte.

Inputs: no named parameters.

ida_make_functionA

Force-create a function at an address (useful for undefined code regions).

Inputs: address (required).

ida_namesA

List all named addresses (functions, globals, labels) with optional pattern filter.

Inputs: limit, pattern.

ida_patch_bytesA

Write bytes to the IDA database at an address using idc.patch_byte(). Does NOT modify the original file — only the IDA database. Useful for NOP-ing bossix checks found by ida_scan_bossix.

Inputs: address (required), hex_bytes (required).

ida_read_bytesA

Read raw bytes at an address and show a hex+ASCII dump.

Inputs: address (required), size.

ida_renameB

Rename a function, label, or global variable at an address.

Inputs: name (required), address (required).

ida_run_scriptA

Execute raw IDAPython code inside IDA Pro. Escape hatch for any operation not covered by other tools.

Inputs: code (required).

ida_scan_bossixA

Scan the binary for bossix imports, string indicators, and techniques.

Inputs: no named parameters.

ida_segmentsA

List all binary segments (.text, .data, .rdata, etc.) with addresses and permissions.

Inputs: no named parameters.

ida_set_typeB

Set the type signature for a function or variable (C declaration syntax).

Inputs: address (required), type_str (required).

ida_statusA

Check if IDA Pro is connected and get binary info. Always call first.

Inputs: no named parameters.

ida_stringsB

Find all strings in the binary. Useful for IOC extraction.

Inputs: limit, min_len.

ida_structA

Get struct definition from IDA's type library (name, members, offsets, sizes).

Inputs: name (required).

ida_xrefs_fromA

Get all cross-references FROM an address (what this calls/references).

Inputs: address (required), limit.

ida_xrefs_toA

Get all cross-references TO an address (who calls/references this).

Inputs: address (required), limit.

list_exportsB

Get the export table of a module — exported function names + addresses + ordinals.

Inputs: module. Returns: data, error, details, success, +2 more

list_importsB

Get import table grouped by DLL. Network imports → C2; crypto imports → ransomware; anti-debug imports → evasion.

Inputs: module. Returns: data, error, details, success, +2 more

list_known_patternsA

List the agent's known binary patterns: packer signatures, anti-debug checks, crypto routines, syscall stubs, Heaven's Gate, etc. USE WHEN: deciding what to search for, or to understand what the agent recognizes.

Inputs: category. Returns: data, error, details, success, +2 more

list_modulesA

List all loaded modules (DLLs/EXE) with bases, sizes, entry points.

Inputs: no named parameters. Returns: data, error, details, success, +2 more

mco_bossix_reportA

Cross-debugger bossix detection: IDA Pro static scan for IsDebuggerPresent/NtQueryInformationProcess/etc. + x64dbg dynamic PEB check. Returns combined findings.

Inputs: no named parameters.

mco_compare_functionsA

Binary diff two functions in IDA Pro. Compare instruction sequences, calculate similarity percentage, show added/removed operations. Useful for patch diffing between clean and infected binaries.

Inputs: address_a (required), address_b (required).

mco_crash_to_sourceA

Full crash analysis pipeline: open a .dmp in WinDbg, extract the crashing address, then pivot to IDA Pro to decompile the crashing function and show callers. Returns a combined report with WinDbg !analyze output + IDA pseudocode.

Inputs: dump_path (required).

mco_gateway_statusA

Show status of all MCO sub-servers: running/stopped, PID, tool count, uptime.

Inputs: no named parameters.

mco_heap_spray_analysisA

Detect heap spray attacks: WinDbg !heap -s summary + IDA Pro heap allocation site mapping. Identifies suspicious allocation patterns and size anomalies.

Inputs: no named parameters.

mco_list_serversA

List all configured MCO sub-servers with description and tool counts.

Inputs: no named parameters.

mco_pivot_to_idaA

Take an address from WinDbg or x64dbg and analyze it in IDA Pro. Returns: function name, decompiled pseudocode, callers, callees. Use when you have a suspicious address from dynamic analysis.

Inputs: address (required), context.

mco_restart_serverA

Restart a crashed MCO sub-server by name (windbg / ida / x64dbg / orchestrator / sessions).

Inputs: server_name (required).

mco_statusA

Check which debuggers (WinDbg, IDA Pro, x64dbg) are currently available and connected.

Inputs: no named parameters.

mco_w_auditA

Quick w audit using all available debuggers: IDA static analysis (suspicious APIs, strings, crypto) + x64dbg runtime state (modules, threads). Returns a unified threat intelligence report with severity ratings.

Inputs: no named parameters.

memory_mapA

Get the process virtual memory map. AUTOMATICALLY FLAGS RWX regions (unpacking indicator).

Inputs: no named parameters. Returns: data, error, details, success, +2 more

memory_recallA

Recall insights from past debugging sessions. Searches the agent's persistent memory (~/.x64ai/) for matching patterns and insights. USE WHEN: starting analysis on a new binary — past insights may apply.

Inputs: query (required). Returns: data, error, details, success, +2 more

process_infoA

Get comprehensive process info: main module, base address, entry point, threads, PEB. USE WHEN: starting analysis — typically the first call to orient yourself.

Inputs: no named parameters. Returns: data, error, details, success, +2 more

read_memoryB

Read memory and return as hex+ASCII dump.

Inputs: address (required), size. Returns: data, error, details, success, +2 more

read_stringB

Read a null-terminated string from memory (ASCII).

Inputs: address (required), max_len. Returns: data, error, details, success, +2 more

run_scriptA

Execute a multi-line x64dbg script (commands run atomically). One command per line. Example: 'bp VirtualAlloc\nrun\nlog "hit VirtualAlloc"'.

Inputs: script (required). Returns: data, error, details, success, +2 more

search_patternA

Search memory for a byte pattern with ?? wildcards. Examples: 'CC' (INT3), '0F 31' (RDTSC), 'E9 ?? ?? ?? ??' (JMP rel32).

Inputs: pattern (required), module. Returns: data, error, details, success, +2 more

search_stringsA

Find readable strings in ALL loaded modules, AUTO-CATEGORIZED into urls/paths/registry/apis/other. Great for IOCs and hardcoded URLs/paths. May be slow on large processes.

Inputs: min_length. Returns: data, error, details, success, +2 more

session_deleteA

Permanently delete a session and all its recorded events.

Inputs: session_id (required).

session_diffA

Compare two sessions: which tools were used in one but not the other, call count differences, similarity %.

Inputs: session_id_a (required), session_id_b (required).

session_endA

End the current (or specified) session and save notes.

Inputs: notes, session_id.

session_export_markdownA

Export a full Markdown report of a session — timeline of tool calls, key addresses, tools table. Ready to share.

Inputs: session_id (required).

session_find_addressA

Find all sessions that mention a specific hex address in any tool output.

Inputs: address (required).

session_find_functionA

Find all sessions that mention a specific function name (e.g. 'NtUserSetWindowPos' or 'win32k!NtUser').

Inputs: name (required).

session_listA

List recent debug sessions with stats (duration, tool calls, debugger).

Inputs: limit.

session_recordA

Record a tool call into the current session. Call this after every MCP tool call you want to track.

Inputs: result (required), tool_name (required), args, session_id, +1 more.

session_replayB

Return all tool calls from a session in chronological order with timestamps.

Inputs: session_id (required).

session_startA

Start a new named debug session. Sets it as the current active session for recording.

Inputs: name (required), target, debugger.

session_statsA

Global MCO stats: total sessions, total tool calls, most used tools, most analyzed targets.

Inputs: no named parameters.

session_summaryB

Get an AI-readable summary of a session: top tools, key addresses found, critical findings.

Inputs: session_id (required).

set_registerA

Set a CPU register to a specific value. Useful for bypassing checks (set RAX=0 after IsDebuggerPresent), redirecting execution (change RIP), or modifying function arguments.

Inputs: value (required), register (required). Returns: data, error, details, success, +2 more

windbg_addressB

Describe a virtual address with !address. Filters noisy 'Building memory map' progress lines and can cap output.

Inputs: address, timeout, max_lines.

windbg_address_to_symbolB

Find the nearest symbol to an address (cdb 'ln').

Inputs: address (required).

windbg_analyze_crashA

Run !analyze on the current state. Best after windbg_open_dump or on an unhandled exception.

Inputs: verbose.

windbg_asan_parseA

Parse ASAN crash context: exception record + context record + call stack at exception. Use when debugging ASAN-instrumented binaries.

Inputs: no named parameters.

windbg_attachA

Attach cdb to a running process by PID. The process is paused on attach.

Inputs: pid (required).

windbg_bp_templateA

Set a breakpoint from an AI-friendly template: log this/args, log expression, stop on signed-negative, pointer range, or stack log.

Inputs: location (required), expr, stack, stop_if, +1 more.

windbg_break_inA

Break into a running target (Ctrl+Break). Use this when the program is executing and you need to pause it.

Inputs: no named parameters.

windbg_call_stackA

Show the call stack of the current thread.

Inputs: mode, count.

windbg_clear_breakpointA

Delete one or all breakpoints (cdb 'bc').

Inputs: spec.

windbg_continueA

Resume execution (cdb 'g'). Returns when the target hits a breakpoint, exception, or exits. On timeout the server auto-breaks the target so you can recover.

Inputs: timeout.

windbg_continue_asyncA

Resume execution with cdb 'g' and return immediately. Does not install a timeout and never sends break-in by itself.

Inputs: no named parameters.

windbg_crash_triageA

Full crash triage in one call: !analyze -v + registers + call stack + exception record + fault address context. Best first tool after hitting a crash.

Inputs: no named parameters.

windbg_decode_spansA

Decode VRle::Span entries from memory. Layout assumed: {x:i16, y:i16, len:u16, cov:u8, raw7:u8}.

Inputs: address (required), count.

windbg_disable_breakpointA

Disable a breakpoint without deleting it (cdb 'bd').

Inputs: spec (required).

windbg_disassembleA

Disassemble code forward. By default shows N instructions at an address; with function=true disassembles the whole function (cdb 'uf').

Inputs: count, address, function.

windbg_disassemble_backA

Disassemble N instructions BEFORE an address (cdb 'ub'). Useful for seeing what led to the current IP.

Inputs: count, address.

windbg_dtB

Dump a structure type with cdb 'dt'. Optionally apply to an address.

Inputs: type_name (required), address.

windbg_enable_breakpointA

Re-enable a previously disabled breakpoint (cdb 'be').

Inputs: spec (required).

windbg_evaluateA

Evaluate a cdb expression (cdb '?'). Useful for arithmetic, symbol lookup, and casting.

Inputs: expression (required).

windbg_exception_chainA

Show full exception chain: last event + exception record + context + stack at exception + SEH chain.

Inputs: no named parameters.

windbg_find_symbolsA

Search symbols by pattern across modules (cdb 'x'). Pattern: 'mod!func'.

Inputs: pattern (required).

windbg_find_vtableA

Check if an address contains a vtable pointer and resolve it to a symbol + disassembly. Useful for type confusion / UAF analysis.

Inputs: address (required).

windbg_find_vtable_ownerA

Find heap object candidates whose first qword equals a vtable pointer. With heap_start+heap_length searches that range; otherwise parses heap ranges from !address -f:Heap and searches each range.

Inputs: vtable_addr (required), max_hits, heap_start, heap_length, +3 more.

windbg_goA

Recommended safe continue: send cdb 'g', then wait for event/output without ever sending break-in on timeout.

Inputs: timeout, max_lines, tail_lines, ignore_case, +7 more.

windbg_handleA

Run !handle to inspect kernel handles in the target. Empty args lists all handles.

Inputs: args.

windbg_heapB

Run !heap with optional arguments (e.g. '-s' for summary, '-p -a ' to inspect a block).

Inputs: args.

windbg_heap_block_infoA

Inspect a specific heap block: size, flags, neighbors, memory before/after. Use with ASAN crash addresses to understand overflow context.

Inputs: address (required).

windbg_heap_neighborsA

Inspect a heap block plus bytes and pointer/symbol view before and after it.

Inputs: address (required), after, before.

windbg_helpA

Show a quick orientation cheatsheet for this MCP: typical workflow, key concepts, address forms, and timeout semantics. Call this first if you are unsure how to drive the debugger.

Inputs: no named parameters.

windbg_io_statusA

Show MCP-side debugger I/O state: active cdb PID, buffered output lines, async command, and async age.

Inputs: no named parameters.

windbg_list_breakpointsA

List all configured breakpoints (cdb 'bl').

Inputs: no named parameters.

windbg_list_modulesA

List loaded modules. Optional name filter (cdb 'lm m ').

Inputs: filter.

windbg_list_processesA

List processes in the current debugger session (cdb '|').

Inputs: no named parameters.

windbg_list_threadsA

List all threads in the current process.

Inputs: no named parameters.

windbg_load_breakpointsA

Restore a previously saved breakpoint set. Optionally clears existing breakpoints first.

Inputs: name (required), clear_existing.

windbg_localsA

Show local variables of the current frame (requires private symbols).

Inputs: no named parameters.

windbg_module_infoA

Show detailed info for one module (paths, version, symbols).

Inputs: name (required).

windbg_object_contextA

One-call object/heap context: address eval, symbol, !address, !heap, qwords, bytes/pointers around, potential vtable, optional VRle::Span decode.

Inputs: address (required), after, before, span_count, +1 more.

windbg_open_dumpA

Open a Windows crash dump (.dmp) for post-mortem analysis. Combine with windbg_analyze_crash.

Inputs: path (required).

windbg_pebA

Dump the Process Environment Block of the current process (cdb '!peb').

Inputs: no named parameters.

windbg_read_memoryA

Read memory in a chosen format (byte/word/dword/qword/ascii/unicode/pointer).

Inputs: address (required), fmt, count.

windbg_read_outputA

Drain currently buffered cdb output without blocking and without sending break-in.

Inputs: lines, tail_lines, ignore_case, invert_match, +4 more.

windbg_registersA

Read the CPU registers. Output is parsed into a clean key=value table plus the raw cdb output.

Inputs: group.

windbg_reload_symbolsA

Reload symbols (cdb '.reload'). Use force=true to discard cached symbols.

Inputs: force.

windbg_run_commandA

Run an arbitrary cdb/WinDbg command verbatim. Optional regex filter keeps only matching lines; max_lines caps noisy output.

Inputs: command (required), timeout, max_lines, tail_lines, +8 more.

windbg_run_command_asyncA

Send a raw cdb command and return immediately without waiting for a prompt and without break-in. Use windbg_wait_for_event/read_output afterward.

Inputs: command (required).

windbg_run_toA

Run until execution reaches a given address or symbol (cdb 'g ').

Inputs: address (required), timeout.

windbg_run_to_shadow_returnB

Run to poi(@ssp+index*8). Async by default so long waits do not force break-in.

Inputs: index, timeout, async_run.

windbg_save_breakpointsA

Persist current breakpoints using cdb .bpcmds into .windbg_mcp_breakpoints/.cmd.

Inputs: name (required).

windbg_search_memoryA

Search a memory range for a byte/string/dword/qword pattern.

Inputs: start (required), length (required), pattern (required), kind.

windbg_set_breakpointC

Set a software breakpoint at an address or symbol. Optional cdb-expression condition.

Inputs: location (required), condition.

windbg_set_conditional_bpA

Build and set a conditional cdb breakpoint safely, including optional .printf logging and false-branch gc.

Inputs: location (required), stop_if, condition, print_expr, +1 more.

windbg_set_data_breakpointA

Set a hardware data breakpoint (cdb 'ba'). Triggers on read/write/execute access.

Inputs: size (required), access (required), address (required).

windbg_set_registerB

Modify a CPU register, e.g. name='rax', value='0x42'.

Inputs: name (required), value (required).

windbg_set_source_pathA

Set the source code search path (cdb '.srcpath').

Inputs: path (required).

windbg_set_symbol_pathA

Set the symbol search path (cdb '.sympath') and reload symbols. Use 'srvc:\symhttps://msdl.microsoft.com/download/symbols' for the public store.

Inputs: path (required).

windbg_shadow_stackA

Dump the CET hardware shadow stack using dps @ssp. Useful when HW-enforced stack protection is enabled.

Inputs: count, address.

windbg_shadow_stack_compareA

Dump normal stack and shadow stack side by side for quick return-address divergence checks.

Inputs: count.

windbg_shadow_stack_returnA

Resolve one shadow stack return slot: dps slot, nearest symbol, and disassembly at poi(slot).

Inputs: index, disasm_count.

windbg_source_linesA

Show source code lines around an address (requires source path).

Inputs: address.

windbg_stack_find_threadA

Search all thread stacks for a regex/module/SP/address and optionally switch to the matching thread.

Inputs: sp, mode, count, switch, +3 more.

windbg_start_executableA

Launch a Windows executable under cdb. The target starts SUSPENDED at the initial breakpoint — use windbg_continue to run it.

Inputs: exe (required), args.

windbg_statusA

Show whether a session is active, current target, RIP, nearest symbol, current process and thread.

Inputs: no named parameters.

windbg_step_inA

Single-step one instruction, stepping INTO calls (cdb 't').

Inputs: no named parameters.

windbg_step_outA

Run until the current function returns (cdb 'gu').

Inputs: no named parameters.

windbg_step_overA

Single-step one instruction, stepping OVER calls (cdb 'p').

Inputs: no named parameters.

windbg_stopA

Quit the cdb session and release the target.

Inputs: no named parameters.

windbg_switch_threadA

Switch debugger context to a specific thread index.

Inputs: index (required).

windbg_switch_thread_by_tidA

Switch debugger context by OS thread id using cdb ~~[tid]s. Accepts values like '43110', '0x43110', or 'pid.tid'.

Inputs: tid (required).

windbg_tebA

Dump the Thread Environment Block of the current thread (cdb '!teb').

Inputs: no named parameters.

windbg_thread_stacksA

Show call stacks for ALL threads simultaneously (cdb '~* kP'). Essential for race condition / UAF analysis.

Inputs: no named parameters.

windbg_wait_exception_profileA

Wait for exception/crash output using a preset filter profile (default/tg/asan). Does not send break-in on timeout.

Inputs: profile, timeout, max_lines, tail_lines.

windbg_wait_for_eventA

Wait for output/prompt from an async command without sending break-in on timeout. Use after windbg_continue_async.

Inputs: timeout, max_lines, tail_lines, ignore_case, +7 more.

windbg_watch_memoryA

Set a hardware data breakpoint that logs IP, watched value, optional stack, then continues. Avoids hand-written ba/.printf escaping.

Inputs: address (required), size, access, log_stack.

windbg_write_memoryA

Write memory in a chosen format (byte/word/dword/qword/ascii/unicode).

Inputs: values (required), address (required), fmt.

write_memoryB

Write hex bytes to memory. ⚠ Modifies process state.

Inputs: data (required), address (required). Returns: data, error, details, success, +2 more

x64dbg_connectA

Attempt to (re)connect to a running x64dbg instance. USE WHEN: x64dbg is already running but Claude is not connected.

Inputs: no named parameters. Returns: data, error, details, success, +2 more

x64dbg_eval_expressionA

Evaluate a debugger expression and return the numeric result. Sends the eval_expression command directly to the x64dbg plugin for extended expression support. Resolves register names, API addresses, arithmetic, pointer dereferences. USE WHEN: you need to resolve a symbol address or compute a pointer value. Examples: 'kernel32.VirtualAlloc', 'rax+8', '[rsp+0x28]', 'ntdll.NtQueryInformationProcess'.

Inputs: expression (required). Returns: data, error, details, success, +2 more

x64dbg_launchA

Launch x64dbg debugger (with optional target EXE). USE WHEN: x64dbg is not yet running and you need to start a debug session. Waits for the AI Agent plugin to become connectable after launch.

Inputs: target_exe, wait_seconds. Returns: data, error, details, success, +2 more

x64dbg_statusA

Get x64dbg connection status, process state, and bridge info.

Inputs: no named parameters. Returns: data, error, details, success, +2 more

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    B3.1/5.0

    Scored across 169 tools

    Disambiguation2/5

    While tools are prefixed by backend (ida_, windbg_, x64dbg_), there are multiple near-duplicates across backends (evaluate_expression vs x64dbg_eval_expression, read_memory vs windbg_read_memory vs ida_read_bytes) and unprefixed tools lack clear backend identification. The sheer 169-tool volume makes it easy to select the wrong tool, especially for similar operations like continue, step, and breakpoint across three debuggers.

    Naming Consistency2/5

    Naming mixes verb_noun, noun_verb, bare verbs, and nouns (disassemble, breakpoint, process_info, memory_recall). Each backend prefix has its own internal inconsistency (e.g., ida_functions vs ida_decompile, windbg_status vs windbg_start_executable). The unprefixed tools are particularly inconsistent, mixing styles and using generic names.

    Tool Count1/5

    With 169 tools, the server far exceeds reasonable scoping even for a multi-debugger orchestration layer. Many tools duplicate similar functionality across backends, and there are multiple escape-hatch raw command tools that add to the bloat.

    Completeness5/5

    The tool set is extremely comprehensive, covering process/execution control, memory/breakpoints, disassembly/decompilation, symbol/string/xref analysis, session lifecycle, and cross-debugger composite pipelines. Raw command escape hatches for all three backends fill any residual gaps, so agents are unlikely to hit dead ends.

    Maintenance

    ActivityNo data
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      B
      quality
      F
      maintenance
      MCP server for reverse engineering that enables interaction with IDA Pro for analysis tasks such as decompilation, disassembly, and memory engagement reports.
      24
      46
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      An enhanced MCP server for IDA Pro that integrates bulk binary export, multi-instance management via Broker mode, and 80+ analysis tools for AI-assisted reverse engineering.
      6
      MIT
    • F
      license
      Not graded
      quality
      D
      maintenance
      A local, privacy-first MCP server that orchestrates Ghidra, Binary Ninja, x64dbg, and system tools to provide AI assistants with powerful binary analysis capabilities.
      -
    • A
      license
      Not graded
      quality
      F
      maintenance
      MCP server for reverse engineering Windows executables and related binary formats, offering static analysis, Ghidra-assisted function recovery, plugin-driven tooling, and optional isolated Windows runtime execution.
      238
      MIT