# IntelliJ IDEA MCP Server The MCP Server is a [[Model Context Protocol (MCP)]] server bundled with [[IntelliJ IDEA]] since version 2025.2. It exposes the IDE itself as a toolbox that external agents can call: [[Claude Code]], [[OpenAI Codex|Codex]], [[Visual Studio Code (VSCode)|VS Code]], [[GitHub Copilot CLI]], **Junie**, [[JetBrains Air|Air]], and anything else that speaks MCP. The point is not remote control of an editor. It's that the agent stops guessing. ## Why it matters Coding agents are text tools. They grep, they read files, they pattern-match, and they hope. Meanwhile, [[IntelliJ IDEA]] has already indexed the whole project, resolved every symbol, built the call graph, and run its inspections. That knowledge sat locked inside the IDE, unavailable to the agent typing next to it. The MCP server hands it over. Instead of a regex search for `createUser`, the agent asks for the symbol and gets the declaration, the documentation, and every caller. Instead of running the build and parsing raw compiler noise, it calls `build_project` and gets structured errors. Instead of `console.log` archaeology, it drives the real debugger. This is the same bet as [[JetBrains Context]], one layer lower: the IDE already did the expensive work, so stop making the agent redo it on every task. ## Setup - Bundled and enabled as a plugin by default; can be disabled in **Plugins** - Turn it on under **Settings | Tools | MCP Server** → *Enable MCP Server*, review the third-party access permissions, then *Apply* - Detected clients are configured automatically; anything else gets a config snippet to paste - **Global setup** registers the server across all projects, **project-level setup** writes the connection into the project config so it's only live for that codebase - Transports: **stdio**, **SSE**, and **HTTP Stream** ## The toolset Around 100 tools, grouped by what the IDE is actually good at: - **Analysis** — `analyze_calls` (call hierarchy), `build_project`, `get_file_problems`, `lint_files` - **Code insight** — `get_symbol_info` for declarations and docs - **Search** — `search_symbol` (semantic), `search_regex`, `search_text`, `search_file` - **Files** — `read_file` (including decompiled classes), `create_new_file`, `open_file_in_editor`, `list_directory_tree` - **Refactoring** — `rename_refactoring`, AST-aware rather than find-and-replace - **Execution** — `get_run_configurations`, `execute_run_configuration`, `execute_terminal_command` - **Debugger** — `xdebug_start_debugger_session`, `xdebug_set_breakpoint`, `xdebug_control_session`, `xdebug_get_stack`, `xdebug_get_frame_values`, `xdebug_evaluate_expression`, `xdebug_set_variable` - **Database** — query execution, connections, schema introspection, table preview - **VCS** — `git_status`, `get_repositories` - **Patches and inspections** — apply unified diffs, write custom inspections in a Kotlin DSL `get_symbol_info`, `analyze_calls`, and `rename_refactoring` are the ones no CLI agent can replicate on its own. Everything else it could do the slow way. ## Brave mode Terminal commands and run configurations ask for confirmation by default. **Brave mode** (Settings | Tools | MCP Server, under *Command execution*) removes the prompts and lets clients execute freely. Convenient, and exactly as dangerous as it sounds. An MCP client with brave mode enabled has unconfirmed shell access on your machine, through your IDE, with your credentials. Enable it per project when you trust the agent and the codebase. Not globally, and not by default. ## Limits worth knowing - Database tools require the **Database Tools and SQL** plugin; debugger tools require the bundled **Debugger MCP toolset** plugin - Debugger event reporting is JVM-only (Java, Kotlin) - File analysis tools only see files inside the project directory - Line and column numbers are 1-based across the whole API, which will bite anyone assuming 0-based - The IDE has to be running with the project open. This is a live-session integration, not a headless service ## My take This is JetBrains playing to its actual strength. They can't out-model [[Anthropic]] or [[OpenAI]], and they know it. What they own is 25 years of static analysis that nobody else can rebuild in a weekend. Exposing it over MCP turns the IDE into infrastructure for whichever agent wins. It also quietly answers the "will agents kill the IDE?" question. If the agent needs the IDE's index to do good work, the IDE isn't the thing being replaced. It's the thing being called. ## References - IntelliJ IDEA MCP Server documentation: https://www.jetbrains.com/help/idea/mcp-server.html - MCP Server plugin on JetBrains Marketplace: https://plugins.jetbrains.com/plugin/26071-mcp-server - Model Context Protocol: https://modelcontextprotocol.io/introduction - AI Assistant in JetBrains IDEs: https://www.jetbrains.com/help/idea/ai-assistant.html - IntelliJ IDEA documentation: https://www.jetbrains.com/help/idea/ ## Related - [[IntelliJ IDEA]] - [[JetBrains]] - [[JetBrains Context]] - [[JetBrains Air]] - [[Junie (JetBrains)]] - [[Model Context Protocol (MCP)]] - [[Claude Code MCP Integration]] - [[Claude Code IDE Integration]] - [[Agent Client Protocol (ACP)]] - [[Agentic Engineering]] - [[GitHub Copilot CLI]] - [[OpenAI Codex]] - [[Visual Studio Code (VSCode)]] - [[2026-08-21 IntelliJ IDEA's MCP server gives agents the index and the debugger]]