← Back to directory
M

MCP Server for WinDbg Crash Analysis

Community
Drive WinDbg with natural language for Windows crash dump analysis
Category
Dev Tools #26 of 438
Stars
★ 1.6k Very popular
Transport
stdio (local process) · Streamable HTTP
Runtime
Python 3.10+ · Prebuilt binary
Credentials
No credential needed
License
MIT
Last commit
Tools
10
67FMRS · C

Maintained by an individual developer (repository svnscha/mcp-windbg, MIT license); it is not an official Microsoft or MCP protocol project. It wraps cdb.exe / kd.exe behind ten MCP tools covering dump analysis, user-mode remote debugging, kernel debugging, bulk triage, and output filtering, with stdio and streamable-HTTP transports plus a Claude Code plugin and VS Code client config. It suits Windows developers doing crash and driver triage who already use an MCP client; it is not for non-Windows environments or users expecting automatic fixes. Before use, confirm the debugging tools are installed, understand that live and kernel sessions interrupt targets, and use a filter script to control sensitive data exposure.

Strongest · Documentation 17/20 Weakest · Reliability 11/20

Reliability
11/20
Security and permissions
12/20
Maintenance
13/20
Documentation
17/20
Setup experience
14/20
Why each score
Reliability 11/20
Evidence: server.json declares io.github.svnscha/mcp-windbg 1.3.0 with two transports (stdio, streamable-http), a PyPI package (mcp-windbg) run via uvx, and two optional non-secret env vars (CDB_PATH, _NT_SYMBOL_PATH). The README lists ten tools (list_dumps, open_cdb_dump, open_cdb_remote, open_kd_session, run_cdb_command, run_kd_command, close_cdb_session, close_kd_session, send_ctrl_break, wait_for_break), describes an opaque session_id model, per-call timeouts, and CTRL+BREAK resynchronization for slow live commands; declared tools and described behavior are consistent, with no visible contradictions. Deductions: this is a static, unexecuted review; the only execution-related artifacts are CI/docs badges pointing at ci.yml and GitHub Pages, and no committed test files or CI step contents are present in the supplied material, so the MCP init handshake, actual tool-list responses, error paths, and dependency control (e.g. cdb.exe/kd.exe auto-detection failure) cannot be verified. All reliability claims (timeouts, CTRL+BREAK, live-session resync) rest on README prose only. Static calibration caps this at 12; scored 11.
Security and permissions 12/20
Evidence: the server is essentially a local Windows debugger wrapper, running over stdio locally or streamable-http at http://localhost:{port}/mcp; its privilege surface is local cdb.exe/kd.exe processes and sessions, and the only env vars are two optional non-secret values (CDB_PATH, _NT_SYMBOL_PATH). No hardcoded tokens or secrets appear in the install examples. The README documents a --filter-script hook to redact PII/secrets from tool arguments and output before they leave the machine, plus a dedicated redaction scenario and a note that closing a kernel session resumes the target machine, so data boundaries and side effects get some disclosure. Deductions: the HTTP transport listens on a port and the README explicitly promotes driving it from another machine, yet the material shows no authentication, bind-address restriction, or TLS guidance, so default deployment can be exposed; attaching to kernel/remote targets and tools like send_ctrl_break, close_kd_session (resumes the target), and run_*_command are high-impact actions on real systems with no visible default confirmation or scoping (e.g. read-only command allowlist). This is 'main risks visible but permissions/confirmation/scoping incomplete' rather than a red line — no malware, credential theft, covert exfiltration, or irreversible destructive defaults — so it is not scored 0-4.
Maintenance 13/20
Evidence: server.json version 1.3.0 matches the PyPI identifier/version; the repo carries mcp-server topics; MIT license is consistent across the README and repository metadata; the README shows CI and docs-deployment badges, a dedicated documentation site, a plugin marketplace entry, a blog post and community discussion links, indicating ongoing maintenance with clear ownership (svnscha). Open issues 0 and 1564 stars are treated only as discovery signals, not points. Deductions: the supplied material contains no commit history, release cadence, dependency-update policy, or security-response channel (no SECURITY.md or vulnerability-reporting guidance), and versioning/governance is asserted but lacks verifiable update-path evidence. This reads as 'active but with governance/versioning gaps'; scored 13.
Documentation 17/20
Evidence: documentation is layered — the README provides overview, features, a use-case table, a tool table, three install routes (Claude Code plugin, self-registration, other clients), a VS Code/Copilot JSON config example, and natural-language debugging prompts, all linked to a standalone docs site covering getting-started, crash-dump, remote-debugging, kernel-debugging, triage, http-service, redaction, reference, troubleshooting, and development, plus a tools reference and CLI reference. Prerequisites are explicit (Windows with Debugging Tools for Windows or Store WinDbg supplying cdb.exe/kd.exe with auto-detection; Python 3.10+ or uv). Limitations are disclosed ('not a magical auto-fix', enterprise-policy caveat, Windows-only platform). Deductions: evidence here is limited to the README and manifest, so the docs site contents cannot be checked for consistency with tool parameters, timeouts, and prompts, and key limitations (HTTP auth, confirmation flow, port exposure) are not expanded in the README.
Setup experience 14/20
Evidence: the install path is clear and tiered — a two-line plugin install (/plugin marketplace add, /plugin install) needing uv/uvx, or pip install mcp-windbg followed by a single claude mcp add command, or pointing any other client at python -m mcp_windbg with a complete VS Code JSON example; server.json also declares a uvx runtimeHint and both stdio and streamable-http transports with a port argument, enabling one-command fetching. Deductions: it is hard-bound to Windows and an additional debugger toolchain (Debugging Tools for Windows / WinDbg), so it cannot run in mainstream Linux/macOS environments; the HTTP route leaves port choice, network reachability, and the missing authentication to the user; the plugin route adds a uv and marketplace dependency. Because the source files contain no verifiable execution evidence (real CI workflows plus committed tests covering the server's key paths), the static calibration caps this at 15; scored 14.

Static review · not runListed 2026-09-10

Read the FMRS scoring method →

Fit and risk

What it can accessReads local filesRuns commands or codeUses the network

Best for

  • Developers and support engineers doing Windows crash dump and driver/kernel triage
  • Users of MCP clients (Claude Code, GitHub Copilot, Claude Desktop, Cursor, Windsurf, Cline) who want natural-language control of WinDbg
  • Teams that need to manage and automate multiple cdb/kd sessions (dumps, remote, kernel) in parallel
  • Environments that must filter sensitive data before debugging output leaves the machine

Not for

  • Non-Windows platforms: dump analysis needs cdb.exe and kernel debugging needs kd.exe
  • Users expecting an automatic fix: it runs real debugger commands and lets the model reason about output
  • Users without organizational permission to use AI tools in a managed enterprise environment
  • Users who have not installed the debugging tools (cdb.exe / kd.exe)

Required permissions

  • Execute local processes on the Windows host (cdb.exe / kd.exe and the Python package)
  • Read local dump files (.dmp/.mdmp/.hdmp) and target directories
  • Open TCP, named-pipe, or COM connections for user-mode remote debugging
  • Open KDNET, named-pipe, or serial connections for kernel debugging (waits for and breaks into the target machine)
  • Optional: filter tool arguments and output via --filter-script; configure a custom CDB_PATH and symbol path via _NT_SYMBOL_PATH

Risks and side effects

  • Closing a kernel session resumes the target machine, which may affect it if it is processing critical state
  • Attaching to live (remote or kernel) sessions interrupts the target and may affect production or shared environments
  • Without --filter-script, sensitive data in dumps may leave the machine as part of tool output
  • Using MCP and AI tools in enterprise environments may be restricted by organizational policy; confirm permissions first
  • The default symbol path uses the Microsoft symbol server, so debugging may access external networks

Setup

Before you start

Runtime:Python 3.10+ · Prebuilt binary

Other optional settings (1)
CDB_PATH optional Optional custom path to cdb.exe for when Debugging Tools for Windows is not installed in the default location; no credentials needed.
  1. Prerequisites: Windows with Debugging Tools for Windows or WinDbg from the Microsoft Store, which ship cdb.exe and kd.exe (auto-detected).
  2. In Claude Code you can use the plugin: /plugin marketplace add svnscha/mcp-windbg then /plugin install mcp-windbg-uvx@mcp-windbg; this needs uv (winget install astral-sh.uv) which supplies uvx.
  3. Or register manually: pip install mcp-windbg (Python 3.10+ required), then run claude mcp add mcp-windbg -s user -e _NT_SYMBOL_PATH="SRV*C:\Symbols*https://msdl.microsoft.com/download/symbols" -- python -m mcp_windbg.
  4. Other clients: after installing, point the client at python -m mcp_windbg; in VS Code (GitHub Copilot) press F1 and select MCP: Open User Configuration, then use the servers config shown in the README.
  5. Restart your client and ask in natural language, e.g. 'Analyze the crash dump at C:\dumps\app.dmp'. Server options include --cdb-path, --kd-path, --symbols-path, --filter-script, --transport.
.mcp.json
{
  "servers": {
    "mcp_windbg": {
      "type": "stdio",
      "command": "python",
      "args": ["-m", "mcp_windbg"],
      "env": {
        "_NT_SYMBOL_PATH": "SRV*C:\\Symbols*https://msdl.microsoft.com/download/symbols"
      }
    }
  }
}

Shown for Claude Code. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "mcp_windbg": {
      "type": "stdio",
      "command": "python",
      "args": [
        "-m",
        "mcp_windbg"
      ],
      "env": {
        "_NT_SYMBOL_PATH": "SRV*C:\\Symbols*https://msdl.microsoft.com/download/symbols"
      }
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add mcp_windbg -e '_NT_SYMBOL_PATH=SRV*C:\Symbols*https://msdl.microsoft.com/download/symbols' -- python -m mcp_windbg

Run it in a terminal; replace any <…> placeholders with your own values first.

Check that it works

After restarting the client, the tool list should show the ten tools such as open_cdb_dump and run_cdb_command; then ask it to analyze C:\dumps\app.dmp — if it returns the !analyze -v triage output, the connection works.

Troubleshooting

  1. If cdb.exe/kd.exe is not found, confirm the debugging tools are installed or set CDB_PATH, --cdb-path, --kd-path explicitly
  2. If symbols fail to resolve, check _NT_SYMBOL_PATH / --symbols-path (defaults to the Microsoft symbol server)
  3. A slow live command is broken into with CTRL+BREAK and the session resynchronized; if still unresponsive, use send_ctrl_break manually
  4. Kernel sessions require a reachable target over KDNET / named pipe / serial; verify connection parameters and target state
  5. If remote debugging fails to connect, check the TCP, named-pipe, or COM connection string and reachability
  6. If the HTTP transport does not respond, confirm --transport streamable-http and the right --port (default 8000) and call http://localhost:{port}/mcp

Things to try

Once connected, you can ask your AI assistant things like:

  • Analyze the crash dump at C:\dumps\app.dmp and explain the exception and faulting frame
  • Connect to tcp:Port=5005,Server=192.168.0.100 and show me the current thread state
  • Open a kernel session on net:port=50000,key=1.2.3.4, run !analyze -v, and tell me which driver bugchecked
  • List the crash dump files in C:\dumps

Tools 10

list_dumps read-only
List crash dump files in a directory
open_cdb_dump read-only
Open and triage a crash dump
open_cdb_remote writes
Attach to a user-mode remote debug server (-remote)
open_kd_session writes
Attach to a kernel target (-k, KDNET / named pipe / serial)
run_cdb_command writes
Run a command on a user-mode session
run_kd_command writes
Run a command on a kernel session
close_cdb_session writes
Close a user-mode session
close_kd_session writes
Close a kernel session (resumes the target machine)
Show 2 more tools
send_ctrl_break writes
Break into a running live session
wait_for_break read-only
Wait for a target you resumed with g to stop again

Use cases

Analyze a .dmp from a crash and root-cause it: exception, faulting frame, why it happened
Break into a live user-mode process (via cdb -server) and inspect a hang or live state
Debug drivers, bugchecks, and boot-time issues on a KD-enabled machine or VM
Triage a folder full of dumps and find the common signature
Run the server over HTTP on a debugging host and drive it from another machine
Scrub secrets or PII from tool output before it leaves the box

Supported clients

Claude Code
VS Code
Claude Desktop
Cursor
Windsurf
Cline

Listed from the project's documentation, not tested by this site.

Overview

A Model Context Protocol server that bridges AI models with WinDbg for Windows crash dump analysis, user-mode remote debugging, and kernel debugging. Under the hood it drives the Windows debuggers: CDB for user mode (dumps and -remote) and KD for kernel targets (-k). It is not a magical auto-fix, but a Python wrapper around cdb.exe / kd.exe that lets an LLM run real debugger commands and reason about the output. Every open_* call returns a session_id so several sessions (dumps, remote, kernel) can be open at once and addressed independently; per-call timeouts break into slow live commands with CTRL+BREAK and resynchronize the session. It runs locally over stdio or as a streamable-HTTP service you can drive from another machine, and a --filter-script can redact PII/secrets from tool arguments and output before they leave the machine.

Similar servers

Context7 80 · B

Upstash's official server providing up-to-date third-party library docs for AI coding assistants

★ 63.3k · Tools 2 Compare with this →

Source revision 48e4350d57c4 Data synced 2026-10-19 Read the FMRS scoring method