Skip to content
Back to search

lldb-mcp

LLDB MCP server

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/stass--lldb-mcp/badge.svg)](/listings/stass--lldb-mcp)

HTML

<a href="/listings/stass--lldb-mcp"><img src="/api/listings/stass--lldb-mcp/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

1. Clone the repository:

   git clone https://github.com/stass/lldb-mcp.git
   cd lldb-mcp

2. Install dependencies:

   pip install mcp

3. Configure Claude to use the LLDB-MCP server: - Open the Claude desktop app configuration - Add the following to your MCP configuration:

   "mcpServers": {
     "lldb-mcp": {
       "command": "python3",
       "args": ["/path/to/lldb-mcp/lldb_mcp.py"],
       "disabled": false
     }
   }

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 161 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # LLDB-MCP
  2. ![Screenshot](screenshot.png)
  3. See it in acton here, automatically debugging a buffer overflow: https://x.com/full_duplex/status/1904770477698277847
  4. ## Overview
  5. LLDB-MCP is a tool that integrates the LLDB debugger with Claude's Model Context Protocol (MCP). This integration allows Claude to start, control, and interact with LLDB debugging sessions directly, enabling AI-assisted debugging workflows.
  6. The tool provides a comprehensive set of commands for working with LLDB, including:
  7. - Starting and managing LLDB sessions
  8. - Loading programs for debugging
  9. - Setting breakpoints and watchpoints
  10. - Controlling program execution
  11. - Examining memory, registers, and variables
  12. - Analyzing stack traces and program state
  13. ## Features
  14. - Create and manage multiple LLDB debugging sessions
  15. - Load executables and attach to running processes
  16. - Load core dump files for post-mortem analysis
  17. - Execute arbitrary LLDB commands
  18. - Fine-grained control over program execution
  19. - Memory examination and disassembly
  20. - Thread and stack frame inspection
  21. ## Installation
  22. 1. Clone the repository:
  23. ```
  24. git clone https://github.com/stass/lldb-mcp.git
  25. cd lldb-mcp
  26. ```
  27. 2. Install dependencies:
  28. ```
  29. pip install mcp
  30. ```
  31. 3. Configure Claude to use the LLDB-MCP server:
  32. - Open the Claude desktop app configuration
  33. - Add the following to your MCP configuration:
  34. ```json
  35. "mcpServers": {
  36. "lldb-mcp": {
  37. "command": "python3",
  38. "args": ["/path/to/lldb-mcp/lldb_mcp.py"],
  39. "disabled": false
  40. }
  41. }
  42. ```
  43. ## Usage
  44. Once installed and configured, you can interact with LLDB through Claude using natural language.
  45. ### Basic Workflow
  46. 1. Start a new LLDB session
  47. 2. Load a program
  48. 3. Set breakpoints
  49. 4. Run the program
  50. 5. Inspect variables and memory
  51. 6. Control execution (continue, step, next, etc.)
  52. 7. Terminate the session when done
  53. ### Example Commands
  54. Here are some examples of how to interact with LLDB-MCP through Claude:
  55. - "Start a new LLDB session"
  56. - "Load the program '/path/to/executable'"
  57. - "Set a breakpoint at main"
  58. - "Run the program"
  59. - "Show backtrace"
  60. - "Print the value of variable 'count'"
  61. - "Step over the next line"
  62. - "Examine memory at address 0x1000"
  63. - "Show register values"
  64. - "Continue execution"
  65. - "Kill the process"
  66. - "Terminate the LLDB session"
  67. ## Supported Commands
  68. ### Session Management
  69. - `lldb_start`: Start a new LLDB session
  70. - `lldb_terminate`: Terminate an LLDB session
  71. - `lldb_list_sessions`: List all active LLDB sessions
  72. ### Program Loading
  73. - `lldb_load`: Load a program into LLDB
  74. - `lldb_attach`: Attach to a running process
  75. - `lldb_load_core`: Load a core dump file
  76. ### Execution Control
  77. - `lldb_run`: Run the loaded program
  78. - `lldb_continue`: Continue program execution
  79. - `lldb_step`: Step to next line or instruction
  80. - `lldb_next`: Step over function calls
  81. - `lldb_finish`: Execute until the current function returns
  82. - `lldb_kill`: Kill the running process
  83. ### Breakpoints and Watchpoints
  84. - `lldb_set_breakpoint`: Set a breakpoint
  85. - `lldb_breakpoint_list`: List all breakpoints
  86. - `lldb_breakpoint_delete`: Delete a breakpoint
  87. - `lldb_watchpoint`: Set a watchpoint on a variable or memory address
  88. ### Inspection
  89. - `lldb_backtrace`: Show call stack
  90. - `lldb_print`: Print value of expression
  91. - `lldb_examine`: Examine memory
  92. - `lldb_info_registers`: Display registers
  93. - `lldb_frame_info`: Get detailed information about a stack frame
  94. - `lldb_disassemble`: Disassemble code
  95. - `lldb_process_info`: Get information about the current process
  96. ### Thread Management
  97. - `lldb_thread_list`: List all threads in the current process
  98. - `lldb_thread_select`: Select a specific thread
  99. ### Miscellaneous
  100. - `lldb_command`: Execute an arbitrary LLDB command
  101. - `lldb_expression`: Evaluate an expression in the current frame
  102. - `lldb_help`: Get help for LLDB commands
  103. ## Example program
  104. `example/overflow.c` contains an example C program that causes buffer overflow with certain arguments.
  105. Compile it using `cc overflow.c` and ask Claude to debug the issue with the resulting program:
  106. ```
  107. I'm trying to debug my program a.out that is crashing with certain arguments, e.g. when I pass "hello".
  108. Can you help me debug it?
  109. ```
  110. ## Debugging Tips
  111. - Use `lldb_command` when you need to execute LLDB commands that don't have a dedicated function
  112. - Enable debug mode with `--debug` flag when starting the server for detailed logging
  113. - Sessions are automatically cleaned up when the server shuts down
  114. - Each session has a unique ID - make sure to use the correct ID when executing commands
  115. ## Requirements
  116. - Python 3.7+
  117. - LLDB installed on the system
  118. - Claude desktop app with MCP support
  119. ## Troubleshooting
  120. - If LLDB commands are timing out, check that LLDB is installed correctly
  121. - Verify the path to LLDB when starting a new session
  122. - Check for permission issues when attaching to processes
  123. - Review debug logs if commands aren't executing correctly
  124. ## License
  125. BSD 2-clause

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.