go-delve/mcp-dap-server is an AI-powered project on GitHub with 106 stars, written primarily in Go. MCP server to communicate with DAP servers allowing AI Agents the ability to debug live programs.
Snapshot summary built from the project's own GitHub metadata — there's no written TopGit review yet. The page will update automatically when a full review is published.
WHY NO REVIEW YET
TopGit writes full reviews for the most-starred, most-requested repositories. This page is a snapshot until then — see the READ ME tab for the original README in full.
A Model Context Protocol (MCP) server that provides debugging capabilities through the Debug Adapter Protocol (DAP). This server enables AI assistants and other MCP clients to interact with debuggers for various programming languages.
Overview
The MCP DAP Server acts as a bridge between MCP clients and DAP-compatible debuggers, allowing programmatic control of debugging sessions. It provides a comprehensive set of debugging tools that can be used to:
Start and stop debugging sessions
Set breakpoints (line-based and function-based)
Control program execution (continue, step in/out/over, pause)
Inspect program state (threads, stack traces, variables, scopes)
Evaluate expressions
Attach to running processes
Handle exceptions
Demos
Basic demo with multiple prompts
Autonomous agentic debugging pt.1
Autonomous agentic debugging pt.2
Features
Unified Debug Launch: Single debug tool handles source, binary, and attach modes
Automatic Context: Execution control tools return full state (location, stack, variables)
Streamlined API: 13 tools cover all debugging operations
Breakpoint Management: Set line and function breakpoints, run-to-cursor
Full State Inspection: Stack traces, scopes, and variables in one call
Expression Evaluation: Evaluate and modify variables in context
Process Attachment: Attach to running processes
Disassembly Support: View disassembled code at memory addresses
Installation
Prerequisites
Go 1.24.4 or later
A DAP-compatible debugger for your target language
Building from Source
git clone https://github.com/go-delve/mcp-dap-server
cd mcp-dap-server
go build -o bin/mcp-dap-server
Usage
Connecting via MCP
The server uses stdio transport, allowing AI agents to spawn it on-demand. Configure your MCP client with the path to the binary.
[!IMPORTANT]
A debugger can launch programs, attach to processes, evaluate target code,
inspect secrets, and alter or terminate a debuggee. Run this server only for a
trusted, single-user MCP client under a least-privileged OS account. The stdio
server has no HTTP listener or multi-tenant authorization layer. Delve's
internal DAP socket is always bound to loopback.
Persistent server logging is disabled by default. Set MCP_DAP_LOG=1 to create
a unique private log in the OS temporary directory. It is capped at 8 MiB and
retained until manually deleted. Explicit protocol and GDB tool logs reject
existing files; treat them as sensitive. GDB tool logs are written directly by
GDB and are not size-capped.
Example MCP Client Configuration
This configuration works with Gemini CLI and similar MCP clients:
claude mcp add mcp-dap-server /path/to/mcp-dap-server
Available Tools
Session Management
debug
Start a debugging session. Supports four modes:
source: Compile and debug Go source code
binary: Debug a pre-compiled executable
core: Debug a core dump file
attach: Attach to a running process
Parameters:
mode (string, required): One of 'source', 'binary', 'core', or 'attach'
path (string): Path to source file or binary (required for source/binary modes; optional for core mode with GDB, which can auto-detect it)
In attach mode, path optionally names the target's executable, as seen
from the debugger (for example /proc/PID/exe, or an unstripped copy of a
stripped binary); without it the debugger discovers the executable from the
process. With Delve, path must be a Go executable, and is used only by
Delve versions that support the attach program field
(go-delve/delve#4462);
older releases ignore it.
args (array): Arguments to pass to the program
coreFilePath (string): Path to core dump file (required for core mode)
processId (number): Process ID (required for attach mode). In core mode
with GDB, optionally the PID of the live process the core was taken from.
On Linux, GDB then reads the target's executable and shared libraries
through /proc/PID/root, so a sidecar or toolbox container that shares the
target's PID namespace finds the target's own files.
breakpoints (array): Breakpoints to set before running (file:line or function name)
stopOnEntry (boolean): Stop at program entry point. In attach mode, keep the
process stopped where it was attached instead of resuming it. Defaults to
true when no breakpoints are given, for every mode.
port (number): optional numeric Delve port (0 chooses an ephemeral
loopback port; external bind addresses are not accepted)
Returns full context (location, stack trace, variables) when stopped.
stop
End the debugging session. Terminates the debuggee and stops the debugger.
restart
Restart the debugging session with optional new arguments.
Parameters:
arguments (array, optional): New program arguments
Breakpoints
breakpoint
Set a breakpoint at a file:line location or on a function.
Parameters (one of):
file (string) + line (number): Source file and line number
function (string): Function name
clear-breakpoints
Remove breakpoints from a file or clear all breakpoints.
Parameters:
file (string, optional): Clear breakpoints in this file
all (boolean, optional): Clear all breakpoints
Execution Control
continue
Continue program execution. Optionally run to a specific location.
Parameters:
to (object, optional): Run-to-cursor target (file+line or function)
Returns full context when stopped.
step
Step through code execution.
Parameters:
mode (string, required): One of 'over', 'in', or 'out'
Returns full context at new location.
pause
Pause program execution.
Parameters:
threadId (number): Thread ID to pause
State Inspection
context
Get full debugging context including current location, stack trace, and all variables.
Parameters:
threadId (number, optional): Thread ID
frameId (number, optional): Stack frame ID
evaluate
Evaluate an expression in the current debugging context.
How does go-delve/mcp-dap-server compare to other AI Tools projects?
go-delve/mcp-dap-server is tracked by TopGit in the AI Tools category, with 106 GitHub stars and written in Go. Browse the AI Tools topic page on TopGit to compare it against similar projects by stars and activity.
Is go-delve/mcp-dap-server open source?
Yes — go-delve/mcp-dap-server ships under the MIT license, which makes its source code freely readable (and, depending on license terms, forkable and reusable). Source: github.com/go-delve/mcp-dap-server.
What else is in the AI Tools space?
go-delve/mcp-dap-server is tracked by TopGit under the AI Tools category, alongside 8 GitHub-tagged topics. Trending and Topics pages list peer repositories of comparable stars and language.
What is go-delve/mcp-dap-server?
go-delve/mcp-dap-server (go-delve/mcp-dap-server) is a Go project on GitHub. From the project's own README: MCP server to communicate with DAP servers allowing AI Agents the ability to debug live programs.
Where do I read more about go-delve/mcp-dap-server?
This TopGit page is a snapshot — the READ ME tab shows the project's own README content (links stripped, images preserved). The GitHub repository at github.com/go-delve/mcp-dap-server is the definitive source.
Why is go-delve/mcp-dap-server categorized under AI Tools?
TopGit places go-delve/mcp-dap-server in the AI Tools category based on its GitHub topics and description (tagged: "agentic-ai", "agents", "ai"). Categories are assigned from real repository metadata, not editorial guesswork.
Read full README in the tab above.
Want a second opinion on mcp-dap-server?
Ask an AI that can read this page — one click and you get its take on mcp-dap-server.