Skillget

mcp-dap-server

mcp
Security Audit
Pass
Health Pass
  • License — License: MIT
  • Description — Repository has a description
  • Active repo — Last push 0 days ago
  • Community trust — 81 GitHub stars
Code Pass
  • Code scan — Scanned 3 files during light audit, no dangerous patterns found
Permissions Pass
  • Permissions — No dangerous permissions requested
Purpose
This server acts as a bridge between AI assistants and Debug Adapter Protocol (DAP) debuggers. It enables AI agents to programmatically control debugging sessions, inspect variables, and evaluate expressions for live applications.

Security Assessment
Overall risk: Medium. The tool inherently requires the execution of local binaries and the ability to attach to running processes to function correctly. While the light code scan found no dangerous patterns or hardcoded secrets, and the tool requests no explicit dangerous permissions, granting an AI agent the ability to launch executables, attach to processes, and read program memory carries inherent local system risks. It uses stdio transport rather than exposing open network ports, which limits external attack surfaces, but users should be cautious about what code they allow the AI to execute and debug.

Quality Assessment
The project is in excellent health. It is freshly maintained, with its last push occurring today. The repository is well-documented and transparent about its capabilities, including providing video demonstrations. It has earned over 80 GitHub stars, indicating a good level of community trust and interest. Additionally, it uses the permissive MIT license, making it highly accessible for integration and broader use.

Verdict
Use with caution — the code itself is safe and well-maintained, but its core debugging functionality grants significant control over local processes and file execution.
SUMMARY

MCP server to communicate with DAP servers allowing AI Agents the ability to debug live programs.

README.md

MCP DAP Server

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

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.

Example MCP Client Configuration

This configuration works with Gemini CLI and similar MCP clients:

{
  "mcpServers": {
    "dap-debugger": {
      "command": "mcp-dap-server",
      "args": [],
      "env": {}
    }
  }
}

Claude Code Configuration

claude mcp add mcp-dap-server /path/to/mcp-dap-server

Available Tools

Session Management

debug

Start a debugging session. Supports three modes:

  • source: Compile and debug Go source code
  • binary: Debug a pre-compiled executable
  • attach: Attach to a running process

Parameters:

  • mode (string, required): One of 'source', 'binary', or 'attach'
  • path (string): Path to source file or binary (required for source/binary modes)
  • args (array): Arguments to pass to the program
  • processId (number): Process ID (required for attach mode)
  • breakpoints (array): Breakpoints to set before running (file:line or function name)
  • stopOnEntry (boolean): Stop at program entry point
  • port (number): DAP server port

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.

  • Parameters:
    • expression (string): Expression to evaluate
    • frameId (number, optional): Frame context
    • context (string, optional): Evaluation context ('watch', 'repl', 'hover')

set-variable

Modify a variable's value in the debugged program.

  • Parameters:
    • variablesReference (number): Variables reference from context
    • name (string): Variable name
    • value (string): New value

Program Information

info

Get program metadata.

  • Parameters:
    • type (string, required): One of 'sources' or 'modules'

disassemble

Disassemble code at a memory address.

  • Parameters:
    • memoryReference (string): Memory address
    • instructionOffset (number, optional): Offset from address
    • instructionCount (number): Number of instructions to disassemble

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

License

MIT

Acknowledgments

Reviews (0)

No results found