SuperAPI AI Directory
Partner with us中文AI newsFavorites
All toolsAI codingjetbrains-index-mcp-plugin

jetbrains-index-mcp-plugin

JetBrains IDE plugin exposing indexing and refactoring features: rename, safe delete, find references, call and type hierarchy, diagnostics and more.

Open website

About this tool

IDE Index MCP Server is a JetBrains IDE plugin that exposes an MCP (Model Context Protocol) server, enabling AI coding assistants such as Claude, Codex, Cursor, and Windsurf to leverage the IDE's powerful indexing and refactoring capabilities.

Purpose

Enable AI coding assistants to access the IDE's code intelligence features through MCP, gaining true semantic understanding, cross-project reference resolution, multi-language support, and safe refactoring operations, suitable for AI-assisted development workflows that demand accuracy and safety.

Key Capabilities

General Tools (all supported JetBrains IDEs)

  • Find References: Locate all usages of any symbol in the project
  • Go to Definition: Jump to a symbol's declaration
  • Code Diagnostics: Access errors, warnings, and quick fixes
  • Index Status: Check whether code intelligence is ready
  • Sync Files: Force synchronization of VFS/PSI caches after external file changes
  • Reload Project: Refresh the associated Maven/Gradle build model after dependency or build file changes (disabled by default)
  • Import Modules: Import external Maven project directories as modules to enable cross-project code intelligence and refactoring (disabled by default)
  • Open Workspace: Scan for Maven projects in the root directory, or provide a list of Maven project paths, open them in one IntelliJ window and enable full cross-project code intelligence (disabled by default)
  • Build Project: Trigger an IDE build and output structured errors/warnings (disabled by default)
  • Find Class: Quickly search for classes/interfaces by name, with camel case matching support
  • Find File: Quickly search for files by name using the IDE file index
  • Symbol Search: Find code symbols by name, matching IntelliJ's Go to Symbol (disabled by default)
  • Search Text: Perform text search using IntelliJ's Find in Files (substring and regex matching)
  • Read File: Read file contents by path or qualified name, including library sources (disabled by default)
  • Open File: Open a file in the editor with optional navigation (disabled by default)
  • Get Active File: Get the current active editor file and cursor position (disabled by default)

Extended Tools (language-aware)

Activated based on installed language plugins:

  • Type Hierarchy: Explore class inheritance chains
  • Call Hierarchy: Trace method/function call relationships
  • Find Implementations: Discover interface/abstract implementations
  • Find Super Methods: Navigate method override hierarchies
  • File Structure: View hierarchical file structure similar to the IDE Structure view, including the PHP Structure View tree and Markdown heading outline, showing the start and end line of each element (disabled by default)

Refactoring Tools

  • Rename Refactoring: Safely rename and automatically rename related elements (getters/setters, overriding methods), applicable to all languages, fully headless
  • Move File: Move files where supported and update references and packages
  • Reformat Code: Reform at according to the project code style and optimize imports (disabled by default)
  • Optimize Imports: Remove unused imports and organize imports without reformatting (disabled by default)
  • Edit Member: Replace an entire member declaration (signature + body) with new content (Java/Kotlin, disabled by default)
  • Insert Member: Insert a new member at a structural location (Java/Kotlin, disabled by default)
  • Replace Member: Replace only a method body or field initializer, preserving the signature (Java/Kotlin, disabled by default)
  • Safe Delete: Delete code after checking usages (Java/Kotlin only)
  • Java to Kotlin Conversion: Convert Java to Kotlin using IntelliJ's built-in converter (Java only)

Project Lifecycle Management

When handling multiple projects at the same time, idle projects consume memory and keep editors open. Lifecycle management puts projects to sleep and wakes them based on window focus and MCP activity; disabled by default and must be enabled in Settings → Tools → Index MCP Server.The auto-sleep/wake states are active → background (power saving enabled) → dormant (editor tabs closed, PSI cache released) → closed (fully unloaded), and the next MCP call automatically reopens transparently. Related tools:

  • ide_project_status: a combined snapshot of all open and managed projects
  • ide_set_project_mode / ide_get_project_modes: explicit mode control
  • ide_release_project: removes a project from lifecycle management
  • ide_lifecycle_log: a timestamped event log with trigger reasons, used to diagnose unexpected behavior

Usage

Installation

  1. Via the IDE's built-in plugin system: Settings/Preferences > Plugins > Marketplace > search for "IDE Index MCP Server" > Install
  2. Via JetBrains Marketplace: click the Install to ... button to install
  3. Manual installation: download the latest version, Settings/Preferences > Plugins > ⚙️ > Install plugin from disk... After installation, restart the IDE, open a project, and the MCP server starts automatically, using IDE-specific defaults: intellij-index port 29170 for IntelliJ IDEA, pycharm-index port 29172 for PyCharm, and webstorm-index port 29173 for WebStorm.

Configuring AI assistants

The easiest way is to use the "Install on Coding Agents" button in the tool window, but manual configuration is also possible. The tool window is located in the bottom panel "Index MCP Server", where you can copy the configuration or monitor commands. "Install on Coding Agents" button: clicking it opens two areas—Install Now (for Claude Code CLI and Codex CLI, automatically runs the installation command) and Copy Configuration (for other clients,copies the JSON configuration to the clipboard). Client configuration examples:

  • Claude Code CLI: use the button or run the command (adjust the name and port as needed), --scope user is global, --scope project is current project only; removal command claude mcp remove <server-name>.
  • Codex CLI: removal command codex mcp remove <server-name>.
  • Cursor: add the configuration to .cursor/mcp.json in the project root or to the global ~/.cursor/mcp.json.
  • Windsurf: add the configuration to ~/.codeium/windsurf/mcp_config.json.
  • VS Code (Generic MCP): be sure to replace the server name and port. Each JetBrains IDE has a unique default port and server name, so multiple IDEs can run simultaneously without conflicts.

Support

  • Fully tested: IntelliJ IDEA, PyCharm, WebStorm, GoLand, RustRover, Android Studio, PhpStorm
  • May work (untested): RubyMine, CLion, DataGrip
  • Not supported: Rider (its ReSharper backend does not expose the IntelliJ PSI API that this plugin depends on) Multilingual support: Java & Kotlin (IntelliJ IDEA, Android Studio), Python (all versions of PyCharm, IntelliJ with the Python plugin, including symbol-based definition/reference lookup), JavaScript & TypeScript (WebStorm, IntelliJ Ultimate, PhpStorm), Go (GoLand, IntelliJ IDEA Ultimate with the Go plugin), PHP (PhpStorm, IntelliJ Ultimate with the PHP plugin), Rust (RustRover, IntelliJ IDEA Ultimate with the Rust plugin, CLion), Scala (with Scala The IntelliJ IDEA plugin, Scala 2 sources), Markdown (heading outline provided in IDEs with the bundled Markdown plugin).

Limitations

  • The server binds to 127.0.0.1 and has no authentication, so any local process can call its tools with your IDE's file access permissions. On a single-user development machine, this is the same trust boundary that the shell already has; on a shared machine, it is worth weighing before enabling write tools.
  • Some tools are disabled by default and must be enabled in Settings > Tools > Index MCP Server > Exposed Tools.
  • Go and Rust do not expose ide_find_super_methods because of language semantics.
  • Applying refactorings modifies source files and supports undo via Ctrl/Cmd+Z; a dryRun: true preview does not modify files or create an undo command.
  • Symbol handles and navigation: class, symbol, reference, implementation, and parent method searches return opaque symbolId handles; cached search pages are still marked stale: true after PSI edits; deleted declarations and handles from other projects or server sessions are rejected.
  • ide_file_structure preserves the legacy structure response by default; use includeNodes=true to get structured declarations, and includeSymbolIds=true to get precise handles (which implies includeNodes). Handle allocation is optional, capped at 100 per response, and can be lowered via maxSymbolIds (1–100); large responses report symbolIdsTruncated and symbolIdsOmitted.
  • Hierarchical pagination: when maxNodes or cursor is not provided, call/type hierarchies preserve the nested tree and legacy limits; explicit pagination returns a bounded breadth-first page.
  • The third-party integration opencode-jetbrains-index is maintained by a third party; for related support, please use its own issue tracker.
  • Other details (such as the full tool list, the default port table for each IDE, etc.) are not fully expanded in the materials and are not provided for now.

Related tools

Browse category