qwen-dap-mcp
This server provides an agent-oriented MCP interface to local GDB/LLDB/CodeLLDB DAP debugging for native crash, hang, dump, and runtime-evidence workflows.
Manage isolated DAP sessions: list, create, close, check status, and disconnect.
Launch/attach targets and run to a stop or exit with optional breakpoints and bounded timeouts.
Capture stopped-state evidence: threads, stack frames, scopes, locals, registers, modules, exceptions, disassembly, and symbol health.
Diagnose crashes with project-frame selection, fault classification, hypotheses, operand/source-disassembly correlation, and verification planning.
Run high-level crash workflows in current/live/CodeLLDB/lldb-dap/GDB/dump modes, including bounded autonomous diagnose/verify state.
Compare baseline vs candidate stopped sessions semantically while filtering unstable address-only changes.
Trace suspicious values via find-writer watchpoints, bounded write timelines, causal consumer-to-writer chains, and lifetime/UAF evidence.
Triage hangs/deadlocks/busy loops with all-thread stacks, wait/deadlock heuristics, and resume/pause progress sampling.
Produce runtime reports with crash fingerprints, sanitizer correlation, symbol-doctor status, memory-hazard hints, ABI/API analysis, and breakpoint plans.
Open core dumps/minidumps read-only for postmortem analysis without rerunning the crashed program.
Collect adaptive cheap/medium/full evidence to control token/DAP cost, while keeping destructive execution/attach actions distinct from read-only inspection.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@qwen-dap-mcp debug why app.exe crashes with --repro"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Qwen DAP MCP — Native Debugger MCP for Claude Code, Codex, Qwen and AI Coding Agents
Debug native C/C++ crashes, hangs, deadlocks, Windows minidumps and core dumps with Claude Code, OpenAI Codex CLI, Qwen Code, Gemini CLI and other local MCP-compatible coding agents. Connect a real GDB, LLDB or CodeLLDB debugger through the Debug Adapter Protocol (DAP) and Model Context Protocol (MCP).
qwen-dap-mcp is a local Debug Adapter Protocol (DAP) → Model Context Protocol (MCP) bridge for native crash debugging, hang/deadlock triage, crash dumps, differential runtime analysis, remote targets, and bounded fix/verify workflows.
Originally designed for Qwen Code, but usable from other local stdio MCP clients including Claude Code and Codex CLI. The AI model may run in the cloud; the debugger bridge and target binary still run where the MCP process is started.
Quick start · Capabilities · Debugger support · Safety · Docs · Contributing
Maintained Apache-2.0 fork of the original project by SLP-DEV1. The maintained source is spk-c/Qwen-dap-mcp; npm distributes
@slp-dev1/qwen-dap-mcp. GitHub'smainmay be ahead of the latest published npm version. See fork notes and TypeScript migration status.
See it in action: C++ crash → evidence → verification
Illustrated architecture/workflow, not a captured AI session or fabricated debugger transcript. Reproduce an actual intentional crash in the project's own C++ fixture, collect a GDB backtrace, apply an illustrative change only in a temporary copy, and rerun the same command:
bash scripts/demo-native-crash.shRequires Linux, g++ and gdb. CI also executes the demo with a real debugger. View step-by-step verified demo and Claude/Codex MCP setup.
Related MCP server: vibe-debug
Why this exists
Coding agents can read source and propose patches, but native failures often cannot be diagnosed reliably from source alone. The useful evidence lives at runtime: thread stacks, registers, locals, disassembly, exception state, modules, memory, wait states, symbols, and crash dumps.
qwen-dap-mcp makes that evidence available through MCP and adds agent-oriented workflows on top of raw debugger primitives:
Evidence first — inspect the actual failing process instead of guessing from source.
High-level workflows — crash, hang, differential, causal tracing, progress probing, runtime-report, dump, and verification tools are designed for agents rather than humans driving a debugger console.
Bounded automation — autonomous fix/verify state is explicit, serializable, iteration-limited, and re-checks the original reproduction.
Small default surface — 18 core agent tools stay visible by default; forensic workflows and raw DAP controls are separate opt-in tiers.
Local by default — the MCP server communicates over stdio and debugger adapters run locally unless you explicitly configure a validated remote target.
Quick start
Qwen Code
Install the current published npm version:
qwen extensions install @slp-dev1/qwen-dap-mcpOr install the newest code directly from the maintained GitHub repository (this can be ahead of npm):
qwen extensions install spk-c/Qwen-dap-mcpIn Qwen Code, run /mcp and /skills to check that the qwen-dap-mcp server and the native-runtime-debug skill were discovered.
Prerequisites: Node.js 20+, and a supported native DAP debugger installed separately (CodeLLDB, LLVM lldb-dap, or GNU GDB DAP). This package is a bridge, not a bundled debugger. See platform setup.
Claude Code
Use a local Claude Code CLI with Node.js 20+ and an installed native DAP debugger:
claude mcp add --transport stdio --scope user qwen-dap-mcp -- npx -y @slp-dev1/qwen-dap-mcp
claude mcp listSee Claude Code native debugging guide for a setup check, test prompt, Windows notes and safety boundaries.
OpenAI Codex CLI
codex mcp add qwen-dap-mcp -- npx -y @slp-dev1/qwen-dap-mcp
codex mcp listSee Codex CLI + IDE debugging guide and versioned Codex TOML configuration.
Gemini CLI, Cursor, VS Code Copilot and other clients
Use a local stdio MCP entry pointing to npx -y @slp-dev1/qwen-dap-mcp. These clients have different configuration schemas: Gemini CLI and Cursor use mcpServers, while VS Code's .vscode/mcp.json uses servers. See multi-client setup and compatibility matrix and the tested configuration examples.
Cloud execution boundary: Claude Code or Codex CLI may call a cloud AI model while the CLI and debugger remain on your desktop. A browser-only Claude.ai/ChatGPT session or a remote Codex task cannot automatically access your PC's local stdio MCP server or Windows processes. Remote debugging requires separately authorized local execution or a protected connection; never expose a raw debugger port to the public internet.
Other stdio MCP clients
Run the published package with npx:
npx -y @slp-dev1/qwen-dap-mcp --help
npx -y @slp-dev1/qwen-dap-mcp --versionConfigure a trusted local MCP client with:
{
"mcpServers": {
"qwen-dap-mcp": {
"command": "npx",
"args": ["-y", "@slp-dev1/qwen-dap-mcp"]
}
}
}When started without --help or --version, the CLI operates as a local stdio MCP server. Client configuration syntax may vary.
Update an existing installation
Update the npm-backed Qwen extension using the extension manager in your installed Qwen Code version, or reinstall the package with the command above. For npx, restart the MCP client to use newly resolved versions. npm releases are immutable: README changes appear on npmjs.com only after publishing a new package version, not when GitHub's README changes.
MCP client compatibility
Client | Local MCP setup | Verification |
Qwen Code | Qwen extension |
|
Claude Code | Local stdio |
|
OpenAI Codex CLI | Local stdio |
|
Gemini CLI |
|
|
Cursor | Desktop MCP settings | Connected tools in Cursor |
GitHub Copilot in VS Code |
| MCP tools in Agent mode |
Browser-only / cloud task | Not direct local stdio | Requires independent secure execution path |
The project includes automatic protocol-level stdio initialize + tools/list smoke tests with Claude Code, Codex CLI and Gemini client identities. These prove the shared MCP server protocol and example configuration consistency, not full end-to-end verification inside proprietary client applications. Native debugger E2E checks run separately. Run npm run test:clients from a built checkout.
30-second example
You: Debug why app.exe crashes with --repro
Coding agent
↓
qwen-dap-mcp starts a DAP debugger
↓
captures the native failure + project-controlled frame
↓
correlates stack + registers + locals + disassembly
↓
backtracks runtime evidence toward the likely producer
↓
agent applies a minimal source fix
↓
builds and repeats the original reproduction
↓
verifies whether the original crash fingerprint is goneThe MCP server supplies debugger evidence and bounded workflow state. Source editing, builds, tests, and source-control operations stay with the coding agent's normal authorized tools.
What it does
Problem | Agent-oriented capability |
Native crash | Diagnose a stopped process, identify project frames, collect runtime evidence, and drive bounded fix/verify loops |
Hang or deadlock | Observe, pause when needed, capture all-thread stacks, classify waits, and surface conservative deadlock candidates |
Good run vs bad run | Compare stopped sessions semantically while suppressing raw ASLR/address noise |
Suspicious value | Trace real writers with data breakpoints/watchpoints and bounded temporal tracing |
Runtime causality | Build a bounded suspicious-value consumer → writer/producer chain with |
Suspected busy loop | Resume/pause sample a live target with |
Record/replay target | Move backward with capability-gated |
Crash fleet triage | Build |
Child/fork signal | Inspect fail-closed adapter |
Crash dump | Inspect Windows minidumps and supported LLDB/GDB postmortem targets without launching the failed program |
Remote native target | Attach through validated |
Multiple targets | Keep isolated DAP sessions and route requests by |
Agent safety | Keep the default surface high-level and optionally gate executable/mutating DAP actions with HOL Guard |
Object lifetime / UAF | Correlate pointer writers, sanitizer evidence, reverse stepping, and allocation/free hints |
Symbol mismatch | Compare adapter symbol state with bounded local binary/PDB identity evidence |
Crash fleets | Batch postmortem analysis plus exact/semantic/family grouping |
Offline handoff | Export structured evidence and SARIF without keeping the target alive |
Tool surfaces
The default agent toolset intentionally exposes 18 core tools so coding models spend less context and selection effort on rarely needed forensic workflows.
Core tool | Purpose |
| High-level native crash diagnosis and bounded autonomous verification |
| High-level hang/deadlock triage |
| Semantic comparison of baseline and failing stopped sessions |
| Bounded temporal tracing of a suspicious value |
| Consumer-to-writer producer evidence for suspicious runtime state |
| Resume/pause sampling for no-progress and busy-loop triage |
| Fingerprints, symbols, sanitizer evidence, memory hazards, ABI/API analysis, hypotheses, and breakpoint planning |
| Object/pointer lifetime and writer provenance |
| Cheap → medium → full bounded evidence collection |
| Diagnose the current debugger stop |
| Correlate source with nearby native instructions |
| Stop at the code that writes a watched value |
| Continue/launch toward a bounded meaningful stop |
| Open supported postmortem dump/core targets |
| Capture structured runtime evidence |
| Inspect debugger/session state |
| Cleanly end a debugger session |
| Create, inspect, and remove isolated sessions |
Set QWEN_DAP_MCP_TOOLSET=forensics when deeper investigation is needed. It keeps the raw manual DAP surface hidden while adding:
Forensics-only tool | Purpose |
| Capability-gated reverseContinue / stepBack |
| Cluster normalized crash reports |
| Classify original/changed/inconclusive reproductions |
| Inspect fail-closed child/fork reverse requests |
| Explicitly adopt one reviewed |
| Bounded rr recording/replay planning and reverse workflows |
| Multi-thread progress and explicit-owner lock graph |
| Binary identity, local symbols, and PDB/DWARF mismatch diagnosis |
| Bounded crash-dump fleet analysis |
| Exact/semantic/family crash comparison |
| Read-only C++ object/vtable inspection |
| JSON/Markdown/SARIF evidence handoff |
| Adapter capability, rr, and security-profile audit |
Set QWEN_DAP_MCP_TOOLSET=full only when raw stacks/scopes/variables, manual breakpoints/watchpoints, evaluate, memory reads, stepping, or adapter-specific controls are intentionally required. See docs/toolsets.md.
Debugger support
Adapter / target | Supported use |
CodeLLDB | Local native launch/attach and Windows minidump workflows |
LLVM | Native launch/attach, core-file inspection, and |
GNU GDB 14+ DAP | Native launch/attach, core-file workflows, and hardened |
Adapter discovery, prerequisites, and platform-specific setup are documented in docs/README.md.
More than raw DAP
Raw DAP is intentionally low level. qwen-dap-mcp keeps raw debugger access available in the full toolset, but its default surface focuses on workflows an agent can reason about directly.
Source only | Raw DAP | qwen-dap-mcp agent tools | |
Runtime debugger evidence | — | ✓ | ✓ |
High-level crash diagnosis | — | — | ✓ |
All-thread hang triage | — | manual | ✓ |
Good-vs-bad semantic diff | — | manual | ✓ |
Explicit bounded fix/verify state | — | — | ✓ |
Verification fingerprinting | — | — | ✓ |
Causal writer chain | — | manual | ✓ |
Progress sampling / busy-loop triage | — | manual | ✓ |
Sanitizer + symbols + ABI report correlation | — | manual | ✓ |
Safety by design
A debugger can execute and mutate target state, so the bridge treats that power explicitly.
No arbitrary shell tool is exposed by the MCP server.
No source-writing primitive is exposed by the MCP server.
No general memory-write primitive is part of the default agent surface.
Remote endpoints are validated and non-loopback access requires explicit allowlisting.
Autonomous workflow state is explicit rather than hidden inside a background loop.
Optional HOL Guard 2.2+ integration can fail closed before protected adapter startup or executable/mutating DAP actions cross the debugger boundary.
Read the full policy and threat model in docs/hol-guard.md and SECURITY.md.
Development and reproducible verification
The repository includes native crash, hang, postmortem, Windows minidump, and remote-debugger fixtures. On a development checkout:
npm ci
npm run check
npm run check:packThe checks include source/build integrity, MCP tests, document consistency, and inspection of the actual npm tarball. Native adapter end-to-end tests run in dedicated CI jobs and require their debugger/toolchain prerequisites. See the integration tests and the benchmark harness; no performance claims are made without recorded, reproducible results.
Practical debugging tutorials
These focused tutorials describe setup, expected debugger evidence and limitations with real native targets; the MCP bridge does not bundle a debugger.
C/C++ crash debugging with Qwen Code — reproduce a native crash, capture stack/register/local evidence and verify a fix.
Windows minidump debugging with CodeLLDB — inspect a crash dump with matching executable and symbols, without rerunning the crashing process.
GDB/LLDB MCP setup and troubleshooting — install a DAP-capable adapter, discover MCP tools and resolve common adapter issues.
Reproducible native crash and fix-verification demo — build a real owned C++ test fixture, collect a GDB SIGSEGV backtrace, apply a temporary guard, and rerun the same argument.
MCP Registry discovery
The maintained package publishes its MCP metadata under io.github.spk-c/qwen-dap-mcp when a matching npm version and official registry publication succeed. This is separate from any historical registry listing for the original author. See publishing and registry verification; a listing is not proof of a particular feature until its exact package version is verified.
Discover the maintained fork: Official MCP Registry · npm · Source and checksums · Directory-ready listing and attribution.
Documentation
Start with the documentation index.
Topic | Guide |
macOS experimental support | |
CodeLLDB on Windows | |
LLVM | |
GNU GDB DAP | |
Remote debugging | |
Hang/deadlock analysis | |
Differential debugging | |
Runtime debugging v2 | |
Agent vs full toolsets | |
HOL Guard integration | |
Publishing / releases |
Contributing and source build
Requirements: Node.js 20+.
git clone https://github.com/spk-c/Qwen-dap-mcp.git
cd qwen-dap-mcp
npm ci
npm run checksrc/**/*.ts is the source of truth for 51 runtime modules; generated JavaScript mirrors and declarations are checked by CI. The full TypeScript strict: true migration is complete (issue #24, PRs #52–#56). CI enforces zero strict compiler diagnostics; native debugger support remains limited to the adapters and scenarios tested in CI.
See CONTRIBUTING.md before opening a pull request.
Distribution and release status
npm:
@slp-dev1/qwen-dap-mcp— installable published versions; verify the npm version before assuming a GitHub change is included.Maintained source and Qwen extension:
spk-c/Qwen-dap-mcp—qwen extensions install spk-c/Qwen-dap-mcp.Release archives and changelog: GitHub Releases and CHANGELOG.md.
Publishing: Releases are triggered by an intentional
vX.Y.Ztag on a verifiedmaincommit or by manual workflow dispatch; npm Trusted Publishing uses GitHub Actions OIDC without a long-lived npm publication token.
The npm listing is updated from the README inside the published tarball. The GitHub README and npm README can temporarily differ until the next release.
Contributing
Bug reports, reproducible native failure cases, adapter compatibility findings, documentation fixes, and focused feature proposals are welcome. Please keep additions evidence-driven and prefer high-level agent workflows over expanding the default surface with raw debugger commands.
If this project saves you a debugging session, consider starring the repository — it helps other MCP and coding-agent users discover it.
License
Available Tools
18 toolsdebug_adaptive_evidenceCollect Adaptive Runtime EvidenceARead-onlyIdempotent
Collect runtime evidence in progressively richer bounded phases instead of immediately requesting a maximal snapshot. Use it when token/DAP cost matters or the amount of evidence needed is unknown: it starts with stack and small locals, expands only when symbols, exception state, or variables are insufficient, and finishes with a full runtime report when needed. Do not use it to replace deliberate deep inspection when the required evidence is already known.
Inputs: forceFull, sessionId, maxVariables. Returns: report, snapshot, selectedPhase, evidenceBudget, +1 more
debug_causal_traceTrace Runtime CausalityADestructive
Build a bounded consumer-to-writer evidence chain for one suspicious debugger-visible value. Use it after crash or differential evidence identifies a value whose runtime producers matter. It combines the current stopped snapshot with repeated watchpoint writer tracing. Do not use it for frozen dumps or unsafe-to-resume targets, and do not treat an observed writer as automatic proof of root cause.
Inputs: name (required), maxDepth, maxStops, sessionId, +1 more. Returns: query, trace, consumer, conclusion, +2 more
debug_compare_runsARead-onlyIdempotent
Compare bounded runtime evidence from two existing stopped DAP sessions. Use this for baseline or known-good versus candidate or failing differential debugging after both sessions have reached comparable stops. It compares stack identities, locals, registers, exception state, symbol health, and modules semantically; non-null raw address-only changes are marked unstable rather than causal evidence. Do not use it to launch, resume, or alter either target; prepare both runtime states with the normal lifecycle tools first.
Inputs: baselineSessionId (required), candidateSessionId (required), snapshot, timeoutMs. Returns: diff, baseline, guidance, candidate, +3 more
debug_diagnose_stopDiagnose Current Debug StopARead-onlyIdempotent
Diagnose an already stopped live or postmortem debug session without changing execution state. Use this when a debugger has captured the failure and you want project-frame selection, crash classification, operand/register/variable bindings, call-chain provenance, ranked hypotheses, and a fix/rebuild/reproduce/verify plan; use debug_snapshot instead when only raw evidence is needed. The tool is read-only and returns both the bounded snapshot and the derived diagnosis, including collection limitations when optional debugger evidence is unavailable.
Inputs: analysis, threadId, sessionId, moduleCount, +7 more. Returns: snapshot, diagnosis
debug_disconnectDisconnect DebuggerADestructive
End the active DAP session and stop its local adapter process. Use this when debugging is finished or the session must be reset; do not call it when more runtime evidence is still needed. With terminateDebuggee=true it may also terminate a live target process, so this operation can destroy the current runtime state and cannot be treated as read-only.
Inputs: sessionId, terminateDebuggee. Returns: disconnected
debug_find_writerFind Runtime WriterADestructive
Temporarily watch a variable or debugger expression, resume an authorized live target, and capture the first resulting stop to identify the immediate writer candidate. Use this after a stopped-state diagnosis suggests a value was corrupted and runtime provenance is needed; do not use it for crash dumps or when resuming is unsafe. Adapters with DAP data-breakpoint support use that protocol directly; GDB 14/15 uses a bounded watch/rwatch/awatch command through DAP REPL because those releases do not advertise native data breakpoints. The tool removes only the temporary watch it created and never automatically continues through an unrelated stop.
Inputs: name (required), frameId, snapshot, threadId, +7 more. Returns: query, before, status, outcome, +11 more
debug_open_dumpOpen Native Crash DumpARead-onlyIdempotent
Open a local native core/minidump with CodeLLDB, upstream LLVM lldb-dap, or GNU GDB DAP and capture bounded postmortem evidence. Use this when the failure is already recorded and no target process should execute; use debug_run_to_stop or debug_this_crash for a live reproduction instead. The tool starts only the selected local debugger adapter, never launches or resumes the crashed program, treats the dump as read-only, and returns the initial stack/locals/registers plus optional modules and disassembly.
Inputs: dumpPath (required), cwd, adapter, program, +10 more. Returns: mode, attach, adapter, program, +6 more
debug_progress_probeProbe Runtime ProgressADestructive
Sample a live target across short resume/pause intervals to distinguish no observed progress, same-frame execution movement, and probable busy loops. Use it when a process appears hung but a single thread snapshot cannot distinguish blocking from spinning. Do not use it when resuming the target is unsafe; sampling perturbs scheduling and is not proof of application-level progress.
Inputs: samples, threadId, sessionId, intervalMs. Returns: status, samples, captures, evidence, +3 more
debug_runtime_reportBuild Runtime Debug ReportARead-onlyIdempotent
Create a shareable structured report from the current stopped target with normalized crash fingerprinting, Symbol Doctor status, sanitizer stderr correlation, poison-pattern memory hazard detection, ABI register-to-argument mapping, and recent debugger output. Use it only for evidence-driven triage and issue handoff. Do not treat heuristic poison patterns, ABI mappings, or sanitizer text correlation as standalone proof.
Inputs: abi, sessionId, redactPaths, includeOutputTail. Returns: abi, frameKey, snapshot, sanitizer, +12 more
debug_run_to_stopRun Until Debug Stop or ExitADestructive
Run one live launch or attach through an already initialized DAP adapter until the first stopped, exited, or terminated event. Use this when you need deterministic runtime evidence from a reproduction; do not use it for a postmortem dump or when executing/attaching to the local target is not authorized. Launch mode executes application code and attach mode changes debugger control of an existing process, so normal target side effects may occur before the stop. Returns the request result, terminal/stopped outcome, session status, and a bounded snapshot only when a stopped event is captured.
Inputs: configuration (required), request, snapshot, sessionId, +2 more. Returns: status, outcome, request, snapshot, +1 more
debug_sessionsManage Debug SessionsADestructive
Use this tool to list, create, or close isolated DAP sessions before routing other debugger tools with sessionId. Omit sessionId on normal debug tools only when the backward-compatible default session is intended; do not use a global session selector for concurrent work.
Inputs: action, sessionId, terminateDebuggee. Returns: action, removed, sessions, sessionId, +2 more
debug_snapshotCapture Runtime Debug SnapshotARead-onlyIdempotent
Capture bounded evidence from the current stopped debug state without resuming execution. Use this when an agent needs raw stack, locals, registers, exception details, modules, or nearby instructions; prefer debug_diagnose_stop when you also want ranked crash hypotheses and project-frame selection. This is read-only with respect to the debuggee and returns best-effort evidence plus collection errors for optional data that an adapter cannot provide.
Inputs: threadId, sessionId, moduleCount, stackLevels, +6 more. Returns: frame, stack, locals, scopes, +9 more
debug_source_disassemblyCorrelate Source and DisassemblyARead-onlyIdempotent
Correlate source locations, disassembly, registers, and pointer-like locals for the raw fault frame and the first likely project-controlled frame. Use this for low-level root-cause evidence when a crash is already stopped and instruction/operand provenance matters; prefer debug_diagnose_stop for a broader ranked diagnosis. This is read-only, does not resume the target, and returns frame-selection reasoning, both correlations, operand bindings, and any best-effort collection errors.
Inputs: analysis, threadId, sessionId, stackLevels, +2 more. Returns: projectFrame, frameSelection, operandAnalysis, collectionErrors, +2 more
debug_statusDebug Session StatusARead-onlyIdempotent
Inspect debugger lifecycle state, the selected stop, recent DAP events, and bounded adapter stderr without changing target execution. Use this to determine whether a session is initialized, running, stopped, postmortem, exited, or failed before choosing another debug tool; it is diagnostic only and does not resume, launch, attach, or terminate the debuggee.
Inputs: no named parameters. Returns: adapterId, adapterPid, configured, initialized, +5 more
debug_this_crashDebug This CrashADestructive
Preferred high-level native crash workflow. Use mode=current for an already stopped session, dump for read-only postmortem analysis, codelldb to discover CodeLLDB, lldb-dap to discover upstream LLVM lldb-dap, gdb to discover GNU GDB built-in DAP interpreter, or live with an already initialized generic DAP adapter. Do not use codelldb/lldb-dap/gdb/live when executing or attaching to the target is not authorized: those modes can run application code and cause its normal side effects, while current/dump only inspect stopped evidence. workflow.stage selects initial diagnosis, verification against a prior baseline, or the bounded autonomous cycle. Returns runtime evidence, diagnosis, verification/autonomous metadata, and debugger status with deterministic fixed/blocked/budget-exhausted outcomes where applicable.
Inputs: cwd, env, args, mode, +15 more. Returns: mode, status, workflow, diagnosis
debug_this_hangDebug This HangADestructive
High-level native hang workflow for all-thread triage. Use it when a live process appears stuck, deadlocked, waiting forever, or spinning and you need bounded stacks from every thread, wait-state/deadlock heuristics, and cross-thread Pointer-Provenance v2. In current mode it inspects an existing configured session and pauses a running live target when necessary; codelldb, lldb-dap, gdb, and live modes can launch or attach to an authorized local target, observe it for a bounded interval, then pause it for evidence. Do not use executable/attach modes when target execution or debugger control is not authorized, and do not treat a deadlock-candidate as a proven lock cycle because generic DAP does not expose portable lock ownership.
Inputs: cwd, env, pid, args, +16 more. Returns: mode, status, evidence, diagnosis, +1 more
debug_trace_lifetimeTrace Object LifetimeADestructive
Trace lifetime evidence for one debugger-visible pointer or object handle using the current snapshot, sanitizer/runtime output, bounded forward writer tracing, and optional reverse stepping when supported. Use this for suspected use-after-free, stale ownership, or unexpected pointer replacement. Do not use forward tracing on a frozen dump or when resuming the target is unsafe.
Inputs: name (required), maxStops, direction, sessionId, +2 more. Returns: query, initial, guidance, sanitizer, +4 more
debug_trace_valueTrace Runtime Value WritesADestructive
Build a bounded temporal write timeline for one debugger-visible variable or expression. Use this after differential or crash evidence identifies a suspicious value and repeated live-target resume is safe. The tool installs one temporary data breakpoint or watchpoint at a time, resumes to the next confirmed writer, captures bounded runtime evidence, removes only its own temporary watch, and repeats. Do not use it for crash dumps, unsafe-to-resume targets, or as proof that an observed writer is the root cause; it stops on unrelated debugger events rather than continuing through them.
Inputs: name (required), maxStops, snapshot, threadId, +4 more. Returns: query, events, status, guidance, +3 more
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 18 tools
The lifecycle tools are distinct, but the evidence tools overlap heavily: debug_snapshot, debug_diagnose_stop, debug_source_disassembly, debug_adaptive_evidence, and debug_runtime_report all inspect a stopped session with different levels of derivation. The descriptions help by stating when to prefer each, but an agent can still struggle to choose among them.
Every tool uses the same debug_ snake_case prefix with descriptive noun/verb phrases. The convention is highly predictable across lifecycle, evidence, tracing, and workflow tools.
Eighteen tools is heavy for an agent-facing server, and several evidence/reporting tools could plausibly be consolidated into fewer parameterized operations. The debugger domain is broad, so the count is not absurd, but it is borderline over-scoped.
The set covers crash, hang, postmortem, differential, and tracing workflows well, but it lacks explicit general breakpoint management, stepping operations, expression evaluation, and thread listing that agents often expect from a DAP debugger. These are notable gaps, though some workflows partially compensate through run-to-stop and temporary watchpoints.
Maintenance
Related MCP Connectors
Live browser debugging for AI assistants — DOM, console, network via MCP.
Enable secure connectivity between Sentry issues and debugging data, and LLM clients, using a Model Context Protocol (MCP) server.
Repository knowledge graph MCP server for codebase understanding and debugging.
MCP-Native LLM Orchestration Agent
Related MCP Servers
- AlicenseNot gradedqualityNot gradedmaintenanceEnables step-through debugging for C#, Node.js/TypeScript, Python, and Dart applications on Windows through a unified MCP interface. Acts as a bridge between MCP clients and various debug adapters, providing consistent debugging workflows with breakpoints, variable inspection, and process attachment capabilities.MIT
- AlicenseBqualityDmaintenanceEnables coding agents to use a real debugger (Python via debugpy) for launching, attaching, setting breakpoints, stepping through code, inspecting stack frames, and evaluating expressions through MCP tools.1227MIT
- AlicenseNot gradedqualityDmaintenanceEnables AI agents to inspect debug state, control execution, and set breakpoints in VS Code by exposing the Debug Adapter Protocol as an MCP server.1Apache 2.0
- AlicenseAqualityAmaintenanceEnables coding agents to connect to Debug Adapter Protocol debuggers over MCP, allowing them to launch or attach to native targets, control execution, set breakpoints and watchpoints, inspect stacks, variables, memory, and exceptions, and capture agent-friendly debugger snapshots.18263 npm3Apache 2.0