Skip to content
Back to search

jetbrains-debugger-mcp-plugin

A JetBrains IDE plugin that exposes an MCP (Model Context Protocol) server, giving AI coding assistants full programmatic control over the debugger. Set breakpoints, step through code, inspect…

Safety scan

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

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/hechtcarmel/jetbrains-debugger-mcp-plugin with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/hechtcarmel/jetbrains-debugger-mcp-plugin'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/hechtcarmel--jetbrains-debugger-mcp-plugin/badge.svg)](/listings/hechtcarmel--jetbrains-debugger-mcp-plugin)

HTML

<a href="/listings/hechtcarmel--jetbrains-debugger-mcp-plugin"><img src="/api/listings/hechtcarmel--jetbrains-debugger-mcp-plugin/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. **Install the plugin** and restart your JetBrains IDE 2. **Open a project** - the MCP server starts automatically on an IDE-specific port 3. **Find your IDE port**: <kbd>Settings</kbd> > <kbd>Tools</kbd> > <kbd>Debugger MCP Server</kbd> (each IDE has a unique default port, e.g., 29190 for IntelliJ IDEA) 4. **Configure your AI assistant** with the server URL: `http://127.0.0.1:{PORT}/debugger-mcp/streamable-http` 5. **Use the tool window** (bottom panel: "Debugger MCP Server") to copy configuration or monitor commands

Using the "Install on Coding Agents" Button

The easiest way to configure your AI assistant: 1. Open the "Debugger MCP Server" tool window (bottom panel) 2. Click the prominent **"Install on Coding Agents"** button on the right side of the toolbar 3. A popup appears with three sections: - **Install Now** - For Claude Code CLI and Codex CLI: Runs the installation command automatically - **Copy Configuration** - For other clients (Gemini CLI, Cursor, etc.): Copies the JSON config to your clipboard - **Generic MCP Config** - Streamable HTTP or Legacy SSE configuration for any MCP client 4. For "Copy Configuration" clients, paste the config into the appropriate config file

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 · 535 lines

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

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Debugger MCP Server
  2. [![Build](https://github.com/hechtcarmel/jetbrains-debugger-mcp-plugin/actions/workflows/build.yml/badge.svg)](https://github.com/hechtcarmel/jetbrains-debugger-mcp-plugin/actions/workflows/build.yml)
  3. [![codecov](https://codecov.io/gh/hechtcarmel/jetbrains-debugger-mcp-plugin/branch/main/graph/badge.svg)](https://codecov.io/gh/hechtcarmel/jetbrains-debugger-mcp-plugin)
  4. [![Version](https://img.shields.io/jetbrains/plugin/v/29233.svg)](https://plugins.jetbrains.com/plugin/29233)
  5. [![Downloads](https://img.shields.io/jetbrains/plugin/d/29233.svg)](https://plugins.jetbrains.com/plugin/29233)
  6. A JetBrains IDE plugin that exposes an **MCP (Model Context Protocol) server**, giving AI coding assistants full programmatic control over the debugger. Set breakpoints, step through code, inspect variables, and evaluate expressions—all driven autonomously by your AI assistant.
  7. **Verified in CI** (IntelliJ Plugin Verifier): IntelliJ IDEA, PyCharm, WebStorm, GoLand. **Community-tested**: RustRover, Android Studio, PhpStorm
  8. **May work** (untested): RubyMine, CLion, DataGrip
  9. [!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/hechtcarmel)
  10. <!-- Plugin description -->
  11. **Debugger MCP Server** gives AI coding assistants complete control over the IDE's debugger through the Model Context Protocol (MCP). Let your AI assistant debug code autonomously—from setting breakpoints to inspecting variables to stepping through execution.
  12. ### Features
  13. **Debug Session Management**
  14. - **Start/Stop Sessions** - Launch run configurations in debug mode
  15. - **Android Process Attachment** - Discover and attach to running Android apps (optional Android plugin)
  16. - **Rich Status** - Get comprehensive state in a single call (variables, stack, source context)
  17. - **Multi-Session Support** - Manage multiple concurrent debug sessions
  18. **Breakpoint Management**
  19. - **Line Breakpoints** - Set breakpoints at any valid location
  20. - **Conditional Breakpoints** - Add conditions that must be true to pause
  21. - **Tracepoints** - Log messages without pausing execution
  22. - **Run Lifecycle** - Discover ordinary Run sessions, retain startup/exit diagnostics, and stop the exact requested process
  23. - **Console Output** - Read logpoint results and retained Run/Debug console text with bounded pagination and exact session selection
  24. **Execution Control**
  25. - **Step Over/Into/Out** - Navigate through code line by line
  26. - **Resume & Pause** - Control execution flow
  27. - **Run to Line** - Continue execution until a specific line
  28. - **Jump to Line** - Move the execution point without running the code in between (Python/pydevd)
  29. **Variable Inspection**
  30. - **View Variables** - Inspect local variables, arguments, and object fields
  31. - **Modify Values** - Change variable values during debugging
  32. **Expression Evaluation**
  33. - **Evaluate Expressions** - Run arbitrary expressions in the current context
  34. - **Code Fragments** - Execute multi-line code snippets
  35. - **Safety Controls** - Choose unrestricted evaluation, a default risky-operation blocklist, or conservative read-only checks with optional custom regex block rules
  36. **Stack & Thread Navigation**
  37. - **Stack Traces** - View the complete call stack with source locations
  38. - **Frame Selection** - Switch context to any stack frame
  39. - **Thread Listing** - See all threads and their states
  40. **Companion Skill**
  41. - **AI Debugging Guidance** - Bundled companion skill teaches AI agents optimal debugger tool usage
  42. - **One-Click Install** - Install to `.claude/skills/` or export as `.skill`/`.zip`
  43. ### Why Use This Plugin?
  44. Unlike manual debugging, this plugin enables:
  45. - **Autonomous AI Debugging** - Your AI assistant can debug code without human intervention
  46. - **Rich Context in Single Calls** - Get variables, stack, and source in one request
  47. - **Programmatic Breakpoint Control** - Set conditional breakpoints with complex expressions
  48. - **Cross-IDE Compatibility** - Works with any JetBrains IDE that supports XDebugger
  49. - **30 Comprehensive Tools** - Full debugging capability through MCP
  50. - **Configurable Server** - IDE-specific ports with customizable host binding
  51. Perfect for AI-assisted development workflows where you want your assistant to investigate bugs, validate fixes, or explore code behavior autonomously.
  52. <!-- Plugin description end -->
  53. ## Table of Contents
  54. - [Installation](#installation)
  55. - [Quick Start](#quick-start)
  56. - [Client Configuration](#client-configuration)
  57. - [Available Tools](#available-tools)
  58. - [Multi-Project Support](#multi-project-support)
  59. - [Tool Window](#tool-window)
  60. - [Error Codes](#error-codes)
  61. - [Settings](#settings)
  62. - [Requirements](#requirements)
  63. - [Contributing](#contributing)
  64. ## Installation
  65. ### Using the IDE built-in plugin system
  66. <kbd>Settings/Preferences</kbd> > <kbd>Plugins</kbd> > <kbd>Marketplace</kbd> > <kbd>Search for "Debugger MCP Server"</kbd> > <kbd>Install</kbd>
  67. ### Using JetBrains Marketplace
  68. Go to [JetBrains Marketplace](https://plugins.jetbrains.com/plugin/29233) and install it by clicking the <kbd>Install to ...</kbd> button.
  69. ### Manual Installation
  70. Download the latest version from the [JetBrains Marketplace versions page](https://plugins.jetbrains.com/plugin/29233/versions) and install it manually:
  71. <kbd>Settings/Preferences</kbd> > <kbd>Plugins</kbd> > <kbd>⚙️</kbd> > <kbd>Install plugin from disk...</kbd>
  72. ## Quick Start
  73. 1. **Install the plugin** and restart your JetBrains IDE
  74. 2. **Open a project** - the MCP server starts automatically on an IDE-specific port
  75. 3. **Find your IDE port**: <kbd>Settings</kbd> > <kbd>Tools</kbd> > <kbd>Debugger MCP Server</kbd> (each IDE has a unique default port, e.g., 29190 for IntelliJ IDEA)
  76. 4. **Configure your AI assistant** with the server URL: `http://127.0.0.1:{PORT}/debugger-mcp/streamable-http`
  77. 5. **Use the tool window** (bottom panel: "Debugger MCP Server") to copy configuration or monitor commands
  78. ### Using the "Install on Coding Agents" Button
  79. The easiest way to configure your AI assistant:
  80. 1. Open the "Debugger MCP Server" tool window (bottom panel)
  81. 2. Click the prominent **"Install on Coding Agents"** button on the right side of the toolbar
  82. 3. A popup appears with three sections:
  83. - **Install Now** - For Claude Code CLI and Codex CLI: Runs the installation command automatically
  84. - **Copy Configuration** - For other clients (Gemini CLI, Cursor, etc.): Copies the JSON config to your clipboard
  85. - **Generic MCP Config** - Streamable HTTP or Legacy SSE configuration for any MCP client
  86. 4. For "Copy Configuration" clients, paste the config into the appropriate config file
  87. ## Example Workflow
  88. Just tell your AI assistant:
  89. > "Debug the calculateTotal function—set a breakpoint at line 42, run the tests in debug mode, and show me the variable values when it pauses."
  90. Or for more complex debugging:
  91. > "There's a bug in UserService. Set a breakpoint at line 42, run the tests in debug mode, and when it breaks, show me the stack trace and all local variables."
  92. ## Client Configuration
  93. ### Claude Code (CLI)
  94. The easiest way is to use the **"Install on Coding Agents"** button in the IDE's tool window—it generates the correct command with your IDE-specific server name and port.
  95. Or run this command manually in your terminal (replace `<ide>-debugger` and port with your IDE's values):
  96. ```bash
  97. claude mcp add --transport http intellij-debugger http://127.0.0.1:29190/debugger-mcp/streamable-http --scope user
  98. ```
  99. **IDE-specific server names and default ports:**
  100. | IDE | Server Name | Default Port |
  101. |-----|-------------|-------------|
  102. | IntelliJ IDEA | `intellij-debugger` | 29190 |
  103. | Android Studio | `android-studio-debugger` | 29191 |
  104. | PyCharm | `pycharm-debugger` | 29192 |
  105. | WebStorm | `webstorm-debugger` | 29193 |
  106. | GoLand | `goland-debugger` | 29194 |
  107. | PhpStorm | `phpstorm-debugger` | 29195 |
  108. | RubyMine | `rubymine-debugger` | 29196 |
  109. | CLion | `clion-debugger` | 29197 |
  110. | RustRover | `rustrover-debugger` | 29198 |
  111. | DataGrip | `datagrip-debugger` | 29199 |
  112. | Aqua | `aqua-debugger` | 29200 |
  113. | DataSpell | `dataspell-debugger` | 29201 |
  114. | Rider | `rider-debugger` | 29202 |
  115. Options:
  116. - `--scope user` - Adds globally for all projects
  117. - `--scope project` - Adds to current project only
  118. To remove: `claude mcp remove intellij-debugger` (use your IDE's name)
  119. ### Codex CLI
  120. The easiest way is to use the **"Install on Coding Agents"** button in the IDE's tool window—it generates the correct command with your IDE-specific server name and port.
  121. Or run this command manually in your terminal (replace `<ide>-debugger` and port with your IDE's values):
  122. ```bash
  123. codex mcp add intellij-debugger --url http://127.0.0.1:29190/debugger-mcp/streamable-http
  124. ```
  125. To remove: `codex mcp remove intellij-debugger` (use your IDE's name)
  126. ### Gemini CLI
  127. Add to `~/.gemini/settings.json`:
  128. ```json
  129. {
  130. "mcpServers": {
  131. "intellij-debugger": {
  132. "httpUrl": "http://127.0.0.1:29190/debugger-mcp/streamable-http"
  133. }
  134. }
  135. }
  136. ```
  137. ### Cursor
  138. Add to `.cursor/mcp.json` in your project root or `~/.cursor/mcp.json` globally:
  139. ```json
  140. {
  141. "mcpServers": {
  142. "intellij-debugger": {
  143. "url": "http://127.0.0.1:29190/debugger-mcp/streamable-http"
  144. }
  145. }
  146. }
  147. ```
  148. ### Windsurf
  149. Add to `~/.codeium/windsurf/mcp_config.json`:
  150. ```json
  151. {
  152. "mcpServers": {
  153. "intellij-debugger": {
  154. "serverUrl": "http://127.0.0.1:29190/debugger-mcp/streamable-http"
  155. }
  156. }
  157. }
  158. ```
  159. ### VS Code (Generic MCP)
  160. ```json
  161. {
  162. "mcp.servers": {
  163. "intellij-debugger": {
  164. "url": "http://127.0.0.1:29190/debugger-mcp/streamable-http"
  165. }
  166. }
  167. }
  168. ```
  169. > **Note**: Replace `intellij-debugger` and the port with your IDE's server name and default port (see table above).
  170. > **Note**: The port can be changed in <kbd>Settings</kbd> > <kbd>Tools</kbd> > <kbd>Debugger MCP Server</kbd>.
  171. ## Available Tools
  172. The plugin provides **30 MCP tools** organized by category:
  173. ### Run Configuration Tools
  174. | Tool | Description |
  175. |------|-------------|
  176. | `list_run_configurations` | List all available run configurations in the project |
  177. | `execute_run_configuration` | Execute a run configuration in debug or run mode |
  178. | `list_run_sessions` | List tracked ordinary Run sessions and their lifecycle status |
  179. | `stop_run_session` | Stop only the process owned by the selected Run session |
  180. | `get_run_console_output` | Read a bounded page from the selected Run session’s retained console |
  181. ### Debug Session Tools
  182. | Tool | Description |
  183. |------|-------------|
  184. | `list_debug_sessions` | List all active debug sessions with state and metadata |
  185. | `list_android_processes` | List running Android processes with device serial, PID and process name |
  186. | `attach_android_debugger` | Attach the Android debugger to a running Android app process without a chooser |
  187. | `start_debug_session` | Start a new debug session for a run configuration |
  188. | `stop_debug_session` | Stop/terminate a debug session |
  189. | `get_debug_session_status` | Get comprehensive status (variables, stack, source) in one call |
  190. | `get_console_output` | Read retained console output, including logpoints, while running or paused |
  191. For an already running Android app, call `list_android_processes`, then call
  192. `attach_android_debugger` with `process_name` or `process_id` and, when needed, `device_serial`:
  193. ```json
  194. {"process_name": "com.example.app", "device_serial": "emulator-5554"}
  195. ```
  196. This uses the Android debugger directly without
  197. installing or launching the app. Names match exactly, including `:subprocess` suffixes. Multiple
  198. matches return an error with candidate processes. Attachment requires the Android plugin and
  199. defaults to its Java/Kotlin debugger. Android support is optional: a missing or incompatible Android
  200. plugin returns a tool error while other tools remain available. If automatic attachment is
  201. unavailable, attach through the IDE's **Attach Debugger to Android Process** action and use
  202. `list_debug_sessions` to discover the session. Process attachment on other platforms is not
  203. currently supported.
  204. New attachments use default debugger state and do not inherit a run configuration's LLDB startup
  205. commands or symbol directories. An existing matching debug session in the same project may be
  206. reused. To apply native debugger settings from a run configuration, use the IDE's
  207. [Attach Debugger to Android Process](https://developer.android.com/studio/debug#attach-debugger)
  208. workflow and select the option to reuse that configuration.
  209. ### Breakpoint Tools
  210. | Tool | Description |
  211. |------|-------------|
  212. | `list_breakpoints` | List all breakpoints with optional filtering |
  213. | `set_breakpoint` | Set a line breakpoint with condition, log message, suspend policy |
  214. | `remove_breakpoint` | Remove a breakpoint by ID or location |
  215. ### Execution Control Tools
  216. | Tool | Description |
  217. |------|-------------|
  218. | `resume_execution` | Resume paused execution |
  219. | `pause_execution` | Pause running execution |
  220. | `step_over` | Step over to next line (without entering methods) |
  221. | `step_into` | Step into method calls |
  222. | `step_out` | Step out of current method |
  223. | `run_to_line` | Continue execution until a specific line |
  224. | `jump_to_line` | Move the paused execution point to another line without running the code in between (Python/pydevd) |
  225. | `wait_for_pause` | Block until the session pauses (breakpoint, step, manual) and return full status |
  226. ### Stack & Thread Tools
  227. | Tool | Description |
  228. |------|-------------|
  229. | `get_stack_trace` | Get current call stack with file/line/method info |
  230. | `select_stack_frame` | Change debugger context to a different stack frame |
  231. | `list_threads` | List all threads with state information |
  232. ### Variable Tools
  233. | Tool | Description |
  234. |------|-------------|
  235. | `get_variables` | Get all variables visible in current stack frame |
  236. | `set_variable` | Modify a variable's value during debugging |
  237. ### Navigation Tools
  238. | Tool | Description |
  239. |------|-------------|
  240. | `get_source_context` | Get source code around current execution point |
  241. ### Evaluation Tools
  242. | Tool | Description |
  243. |------|-------------|
  244. | `evaluate_expression` | Evaluate an expression or code fragment in debug context |
  245. Read tracepoint results with `get_console_output` after setting `log_message` and `suspend_policy: "none"`. It returns the newest 100 retained lines by default; `offset` pages backward, and `max_chars` bounds large lines. If `hasDeferredOutput` is true, read again after the IDE renders the queued text. Output is limited to the IDE console buffer; this tool does not retain cleared/evicted output or read plain Run configurations and terminals.
  246. > **Note**: For detailed tool documentation with parameters, examples, and response formats, see [USAGE.md](USAGE.md).
  247. ## Multi-Project Support
  248. When multiple projects are open in a single IDE window, you must specify which project to use with the `project_path` parameter:
  249. ```json
  250. {
  251. "name": "set_breakpoint",
  252. "arguments": {
  253. "project_path": "/Users/dev/myproject",
  254. "file_path": "/Users/dev/myproject/src/Main.java",
  255. "line": 42
  256. }
  257. }
  258. ```
  259. If `project_path` is omitted:
  260. - **Single project open**: That project is used automatically
  261. - **Multiple projects open**: An error is returned with the list of available projects
  262. ## Tool Window
  263. The plugin adds a "Debugger MCP Server" tool window (bottom panel) that shows:
  264. - **Server Status**: Running indicator with server URL and port
  265. - **Agent Rule Tip**: Copy a rule for your AI agent's config to prefer debugger MCP tools
  266. - **Project Name**: Currently active project
  267. - **Command History**: Log of all MCP tool calls with:
  268. - Timestamp
  269. - Tool name
  270. - Status (Success/Error/Pending)
  271. - Parameters and results (expandable)
  272. - Execution duration
  273. - **Filters**: Filter history by tool name, status, or search text
  274. ### Tool Window Actions
  275. | Action | Description |
  276. |------------------------------|--------------------------------------------------------------------------|
  277. | Refresh | Refresh server status and command history |
  278. | Copy URL | Copy the MCP server URL to clipboard |
  279. | Clear History | Clear the command history |
  280. | Export History | Export history to JSON file |
  281. | Settings | Open settings |
  282. | Star/Report Issues | Link to GitHub repository |
  283. | Try IDE Index MCP Server | Link to companion plugin |
  284. | Buy Me a Coffee | Support the developer |
  285. | **Get Companion Skill** | Install or export the companion AI skill for enhanced debugging guidance |
  286. | **Install on Coding Agents** | Install MCP server on AI assistants (prominent button on right) |
  287. ## Error Codes
  288. ### JSON-RPC Standard Errors
  289. | Code | Name | Description |
  290. |------|------|-------------|
  291. | -32700 | Parse Error | Failed to parse JSON-RPC request |
  292. | -32600 | Invalid Request | Invalid JSON-RPC request format |
  293. | -32601 | Method Not Found | Unknown method name |
  294. | -32602 | Invalid Params | Invalid or missing parameters |
  295. | -32603 | Internal Error | Unexpected internal error |
  296. ### Tool Failures
  297. Tool failures are **not** JSON-RPC errors. A tool that fails returns a successful result whose
  298. payload carries `isError: true` and a human-readable message in `content[0].text`, so the model
  299. can read what went wrong and retry:
  300. ```json
  301. {
  302. "jsonrpc": "2.0",
  303. "id": 1,
  304. "result": {
  305. "content": [{ "type": "text", "text": "Session must be paused to get variables" }],
  306. "isError": true
  307. }
  308. }
  309. ```
  310. The JSON-RPC `error` channel is reserved for protocol-level problems — malformed JSON, an
  311. unparseable message, an unknown *method* (not an unknown tool).
  312. Project resolution is the one failure that returns structured JSON in `content[0].text`, because
  313. an agent that picked the wrong project needs the list of real ones to retry with:
  314. ```json
  315. { "error": "multiple_projects_open", "message": "...", "available_projects": [ ... ] }
  316. ```
  317. `error` is one of `no_project_open`, `project_not_found` or `multiple_projects_open`.
  318. ## Settings
  319. Configure the plugin at <kbd>Settings</kbd> > <kbd>Tools</kbd> > <kbd>Debugger MCP Server</kbd>:
  320. | Setting | Default | Description |
  321. |---------|---------|-------------|
  322. | Server Host | 127.0.0.1 | Bind address for the MCP server. Use `127.0.0.1` for localhost only, `0.0.0.0` for all interfaces, or a custom IP |
  323. | Server Port | IDE-specific | Each IDE has a unique default port (e.g., 29190 for IntelliJ, 29192 for PyCharm). Range: 1024-65535 |
  324. | Exposed tools | All enabled | Choose individual tools to expose. Changes apply to existing connections; clients that cache tools may need to refresh or reconnect. Calls already in progress continue. |
  325. | Max History Size | 1000 | Maximum number of commands to keep in history |
  326. | Evaluate Expression Safety Mode | Unrestricted | Controls plugin-side filtering before `evaluate_expression` reaches the debugger evaluator. `Unrestricted` preserves previous behavior. `Default blocklist` blocks built-in risky categories. `Read-only` also rejects mutation syntax and method calls that cannot be proven read-only |
  327. | Additional blocked regex patterns | None | Optional custom deny rules for `evaluate_expression`. They apply in `Default blocklist` and `Read-only`, never in `Unrestricted`, and match expression text after comments and string literals are removed |
  328. ### Evaluate Expression Safety
  329. `evaluate_expression` is powerful because IDE debuggers can call methods and run code in the debugged process. The safety setting is a best-effort guardrail, not a sandbox.
  330. - **Unrestricted** - No plugin-side filtering. Expressions may call methods, mutate state, access files/network, or run any operation accepted by the debugger.
  331. - **Default blocklist** - Blocks common high-risk categories: process execution, JVM termination, filesystem access, network access, reflection/access bypass, native code loading, and environment/system property access. Custom regex rules also apply.
  332. - **Read-only** - Includes the default blocklist and custom regex rules, then rejects assignments, increment/decrement operations, code fragments, constructors, and method calls that cannot be proven read-only.
  333. Custom regex rules are additional blocked patterns. They do not replace the built-in restrictions.
  334. ## Requirements
  335. - **JetBrains IDE** 2025.2 or later (any IDE based on IntelliJ Platform)
  336. - **JVM** 21 or later
  337. - **MCP Protocol** negotiated per client, from 2024-11-05 up to 2025-11-25, over the official MCP Kotlin SDK
  338. ### Supported IDEs
  339. **Verified in CI** (IntelliJ Plugin Verifier): IntelliJ IDEA, PyCharm, WebStorm, GoLand. **Community-tested**: RustRover, Android Studio, PhpStorm
  340. **May work** (untested): RubyMine, CLion, DataGrip, Aqua, DataSpell, Rider
  341. ## Architecture
  342. The plugin runs an embedded Ktor CIO server on an IDE-specific port and supports **three MCP transports**.
  343. The protocol itself — JSON-RPC framing, the `initialize` handshake, version negotiation, session
  344. lifecycle and batching — is handled by the official
  345. [MCP Kotlin SDK](https://github.com/modelcontextprotocol/kotlin-sdk); the plugin owns only the
  346. routes, the loopback-Origin guard, and the debugger tools themselves.
  347. ### Streamable HTTP Transport (Primary)
  348. ```
  349. AI Assistant ──────► POST /debugger-mcp/streamable-http (JSON-RPC with Mcp-Session-Id header)
  350. ◄── JSON-RPC response (immediate HTTP response)
  351. ──────► GET /debugger-mcp/streamable-http (server → client event stream)
  352. ◄── event: message (notifications, progress)
  353. ──────► DELETE /debugger-mcp/streamable-http (session termination)
  354. ```
  355. ### Legacy HTTP+SSE Transport
  356. ```
  357. AI Assistant ──────► GET /debugger-mcp/sse (establish SSE stream)
  358. ◄── event: endpoint (receive POST URL with sessionId)
  359. ──────► POST /debugger-mcp?sessionId=x (JSON-RPC requests)
  360. ◄── HTTP 202 Accepted
  361. ◄── event: message (JSON-RPC response via SSE)
  362. ```
  363. ### Stateless HTTP (Convenience)
  364. ```
  365. AI Assistant ──────► POST /debugger-mcp (JSON-RPC requests, no session)
  366. ◄── JSON-RPC response (immediate HTTP response)
  367. ```
  368. This approach:
  369. - **Modern clients** - Streamable HTTP with session management and a server → client event stream
  370. - **Legacy clients** - Full HTTP+SSE transport for pre-2025 clients
  371. - **Protocol version** is negotiated per client, from `2024-11-05` up to `2025-11-25`
  372. - **Simple clients** - Stateless HTTP for quick request/response without sessions
  373. - Each IDE gets a unique default port to avoid conflicts when multiple IDEs run simultaneously
  374. - Works with any MCP-compatible client
  375. - Supports CORS for browser-based clients
  376. ## Contributing
  377. Contributions are welcome! See [CONTRIBUTING.md](CONTRIBUTING.md) for the build/test quickstart
  378. and the project-specific tripwires (JDK 21, `pumpingEdt`, golden-contract regeneration). For
  379. security concerns, see [SECURITY.md](SECURITY.md). In short:
  380. 1. Fork the repository
  381. 2. Create a feature branch
  382. 3. Make your changes
  383. 4. Run tests: `./gradlew test`
  384. 5. Submit a pull request
  385. ### Development Setup
  386. ```bash
  387. # Build the plugin
  388. ./gradlew build
  389. # Run IDE with plugin installed
  390. ./gradlew runIde
  391. # Run tests
  392. ./gradlew test
  393. # Run plugin verification
  394. ./gradlew runPluginVerifier
  395. ```
  396. ## License
  397. This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
  398. ---
  399. Plugin based on the [IntelliJ Platform Plugin Template](https://github.com/JetBrains/intellij-platform-plugin-template).

Ratings and comments

Sign in to rate this skill.

Sign in

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