MCP-based DAP Server: Multi-language Debugging Integration

MCP Dap Server

The MCP DAP Server is a Debug Adapter Protocol (DAP) server based on the Model Context Protocol (MCP), providing AI assistants and other MCP clients with the ability to interact with debuggers for multiple programming languages, supporting debugging functions such as breakpoint setting, program control, and status check.

Developer tools Artificial intelligence chatbots #Debugging Tool #Protocol Adaptation #Programming Assistance .Go

rating : 2.5 points

downloads : 7.2K

update time : 2025-07-24

Open Site

What is the MCP DAP Server?

The MCP DAP Server is a bridge tool that connects MCP clients with DAP-compatible debuggers, enabling AI assistants and other MCP clients to control debugging sessions for multiple programming languages.

How to Use the MCP DAP Server?

The MCP DAP Server runs on port 8080 by default. You can use it by configuring the MCP client to connect to http://localhost:8080 and interact via the SSE (Server-Sent Events) transmission method.

Use Cases

Suitable for development environments that require debugging of various programming languages, especially providing powerful debugging capabilities in AI assistants or automated debugging processes.

Main Features

Debug Session Management

Supports starting, stopping, restarting, and terminating debug sessions.

Breakpoint Setting

Supports setting line-level and function-level breakpoints for convenient program debugging.

Execution Control

Supports operations such as continue, pause, and step execution to achieve fine-grained control of the program flow.

Status Check

Allows viewing information about threads, stack traces, variables, and scopes to help understand the program's running state.

Expression Evaluation

Allows evaluating expressions in the current debugging context for easy analysis of program behavior.

Process Attachment

Can attach to a running process to debug an existing program.

Advantages

Supports debugging of multiple programming languages and has good scalability.

Provides rich debugging functions such as breakpoints, execution control, and status check.

Easy to integrate into existing MCP clients to improve debugging efficiency.

Limitations

Depends on DAP-compatible debuggers. Ensure that the target language has corresponding debugger support.

Configuration and use may be complex for non-technical users.

Requires certain system environment requirements, such as the Go language version and related dependencies.

How to Use

Install Dependencies

Ensure that Go 1.24.4 or a higher version is installed and prepare a DAP-compatible debugger.

Build the Server

Clone the project from GitHub and compile it to generate an executable file.

Start the Server

Run the compiled executable file to start the MCP DAP Server.

Configure the MCP Client

Point the MCP client to the address of the MCP DAP Server, http://localhost:8080.

Usage Examples

Debug a Python Program

Use the MCP DAP Server to connect to a Python debugger, set breakpoints, and execute the code step by step.

Attach to a Running Java Process

Use the MCP DAP Server to attach to a running Java application and monitor its execution status in real-time.

Frequently Asked Questions

Which programming languages does the MCP DAP Server support?

How to solve the connection failure problem?

Does the MCP DAP Server support remote debugging?

Related Resources

Official Documentation

The GitHub repository of the MCP DAP Server, containing source code and detailed instructions.

Video Demonstration

A video demonstrating the basic use of the MCP DAP Server.

Google DAP Go Implementation

The Go language implementation of the DAP protocol provided by Google, used to support the functions of the MCP DAP Server.

🚀 MCP DAP Server

The MCP DAP Server is a Model Context Protocol (MCP) server that offers debugging capabilities via the Debug Adapter Protocol (DAP). It enables AI assistants and other MCP clients to interact with debuggers for different programming languages.

🚀 Quick Start

Starting the Server

The server listens on port 8080 by default:

./bin/mcp-dap-server

Connecting via MCP

Configure your MCP client to connect to the server at http://localhost:8080 using the SSE (Server - Sent Events) transport.

✨ Features

Core Debugging Operations

Session Management: Start, stop, restart, and terminate debugging sessions
Breakpoint Management: Set line and function breakpoints
Execution Control: Continue, pause, step operations (in/out/next)
State Inspection: View threads, stack traces, scopes, and variables
Expression Evaluation: Evaluate expressions in the current debugging context
Variable Modification: Change variable values during debugging

Advanced Features

Process Attachment: Attach to already running processes
Module Information: List loaded modules
Source Information: View loaded source files
Disassembly: View disassembled code
Exception Handling: Get information about exceptions

📦 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 Examples

Basic Usage

# Starting the server
./bin/mcp-dap-server

Advanced Usage

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

This configuration can be used for Agents such as (Gemini CLI)[https://developers.google.com/gemini-code-assist/docs/use-agentic-chat-pair-programmer#configure-mcp-servers].

claude mcp add --transport sse mcp-dap-server http://localhost:8080

This is an example configuration using Claude Code.

📚 Documentation

Available Tools

Session Management

API	Description	Parameters
`start_debugger`	Starts a new debugging session.	`port` (number): The port number for the DAP server
`stop_debugger`	Stops the current debugging session.	None
`restart_debugger`	Restarts the current debugging session.	None
`terminate_debugger`	Terminates the debugger and the debuggee process.	None

Program Control

API	Description	Parameters
`debug_program`	Launches a program in debug mode.	`path` (string): Path to the program to debug
`exec_program`	Executes a program without debugging.	`path` (string): Path to the program to execute
`attach_debugger`	Attaches to a running process.	`mode` (string): Attachment mode; `processId` (number, optional): Process ID to attach to

Breakpoints

API	Description	Parameters
`set_breakpoints`	Sets line breakpoints in a file.	`file` (string): Source file path; `lines` (array): Line numbers for breakpoints
`set_function_breakpoints`	Sets function breakpoints.	`functions` (array): Function names

Execution Control

API	Description	Parameters
`continue`	Continues program execution.	`threadId` (number, optional): Thread ID to continue
`next`	Steps over the current line.	`threadId` (number): Thread ID
`step_in`	Steps into function calls.	`threadId` (number): Thread ID
`step_out`	Steps out of the current function.	`threadId` (number): Thread ID
`pause`	Pauses program execution.	`threadId` (number): Thread ID

State Inspection

API	Description	Parameters
`threads`	Lists all threads in the debugged process.	None
`stack_trace`	Gets the stack trace for a thread.	`threadId` (number): Thread ID; `startFrame` (number, optional): Starting frame index; `levels` (number, optional): Number of frames to retrieve
`scopes`	Gets variable scopes for a stack frame and automatically fetches all variables within each scope.	`frameId` (number): Stack frame ID
`variables`	Gets variables in a scope.	`variablesReference` (number): Variables reference
`evaluate`	Evaluates an expression.	`expression` (string): Expression to evaluate; `frameId` (number, optional): Frame context; `context` (string, optional): Evaluation context
`set_variable`	Sets a variable value.	`variablesReference` (number): Variables reference; `name` (string): Variable name; `value` (string): New value

Additional Tools

API	Description	Parameters
`loaded_sources`	Lists all loaded source files.	None
`modules`	Lists loaded modules.	None
`disassemble`	Disassembles code at a memory location.	`memoryReference` (string): Memory address; `instructionOffset` (number, optional): Instruction offset; `instructionCount` (number): Number of instructions
`exception_info`	Gets exception information.	`threadId` (number): Thread ID
`disconnect`	Disconnects from the debugger.	`terminateDebuggee` (boolean, optional): Whether to terminate the debuggee
`configuration_done`	Signals that configuration is complete.	None