Skip to content
Back to search

ide-mcp

IDE-free MCP servers: files and search, plus Gradle, detekt, ktlint and Kotlin/Java symbols

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 18 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/depeter/ide-mcp 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/depeter/ide-mcp'

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/depeter--ide-mcp/badge.svg)](/listings/depeter--ide-mcp)

HTML

<a href="/listings/depeter--ide-mcp"><img src="/api/listings/depeter--ide-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.

Requirements: [`uv`](https://docs.astral.sh/uv/) or Python 3.10+, `git`, and for the `kotlin` server a JDK (projects bring their own Gradle through `gradlew`).

Linux and macOS:

scripts/install.sh            # build .venv and register both servers with Codex
scripts/install.sh --claude   # ...and also with Claude Code

Windows (PowerShell; do not use `install.sh` from Git Bash):

powershell -ExecutionPolicy Bypass -File scripts\install.ps1           # Codex
powershell -ExecutionPolicy Bypass -File scripts\install.ps1 -Claude   # ...and Claude Code

On Windows the JDK is taken from `JAVA_HOME`, then `java` on `PATH`, then the one bundled with Android Studio. `run_command` runs PowerShell there instead of bash, and Gradle is started through `gradlew.bat`.

The script pins `JAVA_HOME` and `ANDROID_HOME` for the `kotlin` server, because agents launch MCP servers with a trimmed environment, and raises Codex's tool timeout for it to 30 minutes (the default of 60 seconds is shorter than most builds). Re-running is safe.

| Script | Purpose | | --- | --- | | `scripts/check.sh`, `scripts\check.ps1` | Show what each server sees: tools, JDK, Android SDK, lint CLIs | | `scripts/uninstall.sh [--purge]`, `scripts\uninstall.ps1 [-Purge]` | Unregister from Codex/Claude; also delete `.venv` |

Manual registration

# ~/.codex/config.toml
[mcp_servers.files]
command = "/absolute/path/to/ide-mcp/.venv/bin/files-mcp"

[mcp_servers.kotlin]
command = "/absolute/path/to/ide-mcp/.venv/bin/kotlin-mcp"   # Windows: '...\.venv\Scripts\kotlin-mcp.exe'
tool_timeout_sec = 1800
env = { JAVA_HOME = "/usr/lib/jvm/java-17-openjdk-amd64", ANDROID_HOME = "/home/you/Android/Sdk" }

The package is installed in editable mode, so edits under `src/` take effect the next time the agent starts a server.

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 · 213 lines
  1. # ide-mcp
  2. Two MCP servers that give coding agents (Codex, Claude Code, ...) what the JetBrains MCP server
  3. offers, without an IDE: nothing has to be opened in Android Studio or IntelliJ first, and no
  4. tool is scoped to a workspace. Every tool takes a path and works out the rest.
  5. | Server | Binary | What it does |
  6. | --- | --- | --- |
  7. | `files` | `files-mcp` | Read, create, edit, find and search files; directory trees; git status; shell commands |
  8. | `kotlin` | `kotlin-mcp` | Gradle builds, compile checks, unit tests, dependencies, detekt, ktlint, and code-aware find usages, rename and inspections |
  9. Both run locally as stdio processes; the agent starts them on demand. They are independent, so
  10. register only one if that is all you need.
  11. ## Install
  12. Requirements: [`uv`](https://docs.astral.sh/uv/) or Python 3.10+, `git`, and for the `kotlin`
  13. server a JDK (projects bring their own Gradle through `gradlew`).
  14. Linux and macOS:
  15. ```bash
  16. scripts/install.sh # build .venv and register both servers with Codex
  17. scripts/install.sh --claude # ...and also with Claude Code
  18. ```
  19. Windows (PowerShell; do not use `install.sh` from Git Bash):
  20. ```powershell
  21. powershell -ExecutionPolicy Bypass -File scripts\install.ps1 # Codex
  22. powershell -ExecutionPolicy Bypass -File scripts\install.ps1 -Claude # ...and Claude Code
  23. ```
  24. On Windows the JDK is taken from `JAVA_HOME`, then `java` on `PATH`, then the one bundled with
  25. Android Studio. `run_command` runs PowerShell there instead of bash, and Gradle is started
  26. through `gradlew.bat`.
  27. The script pins `JAVA_HOME` and `ANDROID_HOME` for the `kotlin` server, because agents launch
  28. MCP servers with a trimmed environment, and raises Codex's tool timeout for it to 30 minutes
  29. (the default of 60 seconds is shorter than most builds). Re-running is safe.
  30. | Script | Purpose |
  31. | --- | --- |
  32. | `scripts/check.sh`, `scripts\check.ps1` | Show what each server sees: tools, JDK, Android SDK, lint CLIs |
  33. | `scripts/uninstall.sh [--purge]`, `scripts\uninstall.ps1 [-Purge]` | Unregister from Codex/Claude; also delete `.venv` |
  34. ### Manual registration
  35. ```toml
  36. # ~/.codex/config.toml
  37. [mcp_servers.files]
  38. command = "/absolute/path/to/ide-mcp/.venv/bin/files-mcp"
  39. [mcp_servers.kotlin]
  40. command = "/absolute/path/to/ide-mcp/.venv/bin/kotlin-mcp" # Windows: '...\.venv\Scripts\kotlin-mcp.exe'
  41. tool_timeout_sec = 1800
  42. env = { JAVA_HOME = "/usr/lib/jvm/java-17-openjdk-amd64", ANDROID_HOME = "/home/you/Android/Sdk" }
  43. ```
  44. The package is installed in editable mode, so edits under `src/` take effect the next time the
  45. agent starts a server.
  46. ## How paths work
  47. - **File tools** take absolute paths (or `~/...`). Search and listing tools take a `root`
  48. directory. Inside a git repository they honour `.gitignore`; elsewhere they skip build and
  49. cache directories. `include_ignored=true` looks everywhere.
  50. - **Gradle tools** take `project_dir`: any path inside the project, a file included. The server
  51. walks up to the Gradle root (the nearest `settings.gradle[.kts]` with a `gradlew`), and if
  52. there is none above, looks below, which covers `<repo>/android` and `<repo>/app/android`
  53. layouts.
  54. - **Modules** are Gradle paths (`:app`, `:features:login`). Most tools also accept `file`
  55. instead and use the module that owns it.
  56. ## Tools
  57. ### files
  58. `read_file`, `list_directory_tree`, `find_files` (glob and/or name substring),
  59. `search_in_files` (text or regex, with context lines), `create_file`, `replace_text` (exact or
  60. regex; must match once unless `replace_all`), `move_path`, `delete_path`, `git_status`,
  61. `run_command`.
  62. ### kotlin
  63. | Tool | Purpose |
  64. | --- | --- |
  65. | `project_info` | Gradle root, versions, modules, configured tooling. Reads files only |
  66. | `gradle_tasks` | Tasks per module, filterable |
  67. | `gradle_run` | Any tasks and arguments, with a summarised result |
  68. | `compile` | Compile a file's module, a module, or everything; errors as `path:line:col` |
  69. | `run_tests` | Unit tests by file, `--tests` filter or module; failures with trimmed stack traces |
  70. | `detekt` | Findings as `path:line:col: message [Rule]`, optionally auto-corrected |
  71. | `ktlint` | Style check or `format=true`, via ktlint, kotlinter or spotless tasks |
  72. | `dependencies` | Resolved libraries and project dependencies of a module; filter or tree |
  73. | `find_symbol` | Where a class, function or property is declared, with signature and KDoc (text-based) |
  74. | `file_outline` | Declarations in a file with line numbers (text-based) |
  75. | `find_usages` | References to one symbol, labelled declaration / usage / import. Code-aware with the language server |
  76. | `rename_symbol` | The IDE's rename refactoring; dry run by default; renames `Name.kt` too. Code-aware with the language server |
  77. | `symbol_info` | What the symbol at a position resolves to: signature, docs, where it is declared. Needs the language server |
  78. | `file_problems` | IntelliJ inspections and compiler errors for one file, with available quick fixes, no build. Needs the language server |
  79. Gradle output is reduced to what matters: outcome, failed tasks, located errors, test results
  80. and Gradle's "What went wrong". The full log of every run is kept under
  81. `~/.cache/ide-mcp/logs/` (last 30) and its path is part of each result.
  82. `compile`, `run_tests`, `detekt` and `ktlint` pick the task for you (`compileDebugSources` on
  83. Android modules, `classes` on JVM ones, flavoured variants when present). To do that they read
  84. the build's task list once with `gradle tasks --all` and cache it for the life of the server,
  85. so the first call into a large project is slower. `gradle_tasks(refresh=true)` re-reads it
  86. after you change build scripts.
  87. `detekt` and `ktlint` use the project's own Gradle tasks, so its config, baselines and plugins
  88. apply. If a build has no such task they fall back to a `detekt` / `ktlint` binary on `PATH`.
  89. ## Code-aware tools (Kotlin language server)
  90. `find_usages`, `rename_symbol`, `symbol_info` and `file_problems` can use JetBrains'
  91. [Kotlin language server](https://github.com/Kotlin/kotlin-lsp), the IntelliJ engine running
  92. headless. With it they resolve symbols the way the IDE does: renaming the `scope` property of
  93. one class leaves every other `scope` alone, and `file_problems` reports inspections such as
  94. unused code or deprecated API, not only compiler errors.
  95. It is optional and not bundled. Install it once:
  96. ```bash
  97. .venv/bin/kotlin-mcp --install-lsp # Linux
  98. .venv\Scripts\kotlin-mcp.exe --install-lsp # Windows
  99. brew install JetBrains/utils/kotlin-lsp # macOS
  100. ```
  101. or pass `--with-lsp` / `-WithLsp` to the install script. The download is about 370 MB (1.2 GB
  102. unpacked, under `~/.local/share/ide-mcp` or `%LOCALAPPDATA%\ide-mcp`) and is verified against
  103. JetBrains' published SHA-256. It is JetBrains software under JetBrains' terms, currently Alpha.
  104. How it behaves:
  105. - One language server runs per project, started by the first code-aware call and stopped after
  106. 30 idle minutes (`KOTLIN_LSP_IDLE_MINUTES`). Nothing has to be opened by hand.
  107. - The first call imports and indexes the project: about 10 seconds for a small one, minutes for
  108. a large one. If that outlasts the tool call, the error says so and the import carries on in
  109. the background; call again.
  110. - It uses up to 2 GB of heap per project by default. Set `IJ_JAVA_OPTIONS=-Xmx4g` for the
  111. `kotlin` server to change that.
  112. - Files edited on disk between calls are picked up automatically.
  113. - When a name is declared more than once, the tool lists the candidates and asks for the `file`
  114. and `line` of the one you mean.
  115. - Without the language server, or with `engine="text"`, `find_usages` and `rename_symbol` use
  116. whole-word text matching and say so in their output.
  117. ### Android projects
  118. Android import in the language server is experimental, and one defect matters in practice:
  119. modules that enable `buildConfig`, `viewBinding` or `dataBinding` fail to import with AGP 8.13
  120. ([Kotlin/kotlin-lsp#253](https://github.com/Kotlin/kotlin-lsp/issues/253)). In a single-module
  121. app that takes the whole project with it.
  122. The tools detect a failed or partial import and never answer from an incomplete model:
  123. `find_usages` falls back to text matching with a note, `rename_symbol` shows the text-based
  124. preview and writes nothing unless you ask for `engine="text"`, and `symbol_info` and
  125. `file_problems` return the reason. `compile`, `detekt` and `ktlint` are unaffected. Once a
  126. language server release fixes the import, install it with
  127. `kotlin-mcp --install-lsp <version>` and the code-aware path takes over.
  128. ## Compared with the JetBrains MCP server
  129. | JetBrains tool | Here |
  130. | --- | --- |
  131. | `get_file_text_by_path`, `create_new_file`, `replace_text_in_file` | `read_file`, `create_file`, `replace_text` |
  132. | `list_directory_tree`, `find_files_by_glob`, `find_files_by_name_keyword` | `list_directory_tree`, `find_files` |
  133. | `search_in_files_by_text`, `search_in_files_by_regex` | `search_in_files` |
  134. | `execute_terminal_command`, `get_repositories` | `run_command`, `git_status` |
  135. | `get_project_modules`, `get_project_dependencies` | `project_info`, `dependencies` |
  136. | `get_run_configurations`, `execute_run_configuration` | `gradle_tasks`, `gradle_run`, `run_tests` |
  137. | `get_file_problems` | `file_problems` (inspections), `compile` with `file`, `detekt` / `ktlint` with `files` |
  138. | `reformat_file` | `ktlint` with `format=true` |
  139. | `get_symbol_info`, `rename_refactoring` | `symbol_info`, `find_symbol`, `find_usages`, `rename_symbol` |
  140. | `open_file_in_editor`, `get_all_open_file_paths` | not applicable without an editor |
  141. Where this differs from the IDE:
  142. - **Inspections and refactoring need the language server.** With it, `file_problems`,
  143. `find_usages` and `rename_symbol` use the same engine as the IDE. Without it, problems come
  144. from the compiler and detekt only, and usages and renames are whole-word text matches that
  145. cannot tell apart two symbols with the same name.
  146. - **Android projects may not import** in the language server yet (see above), in which case
  147. the text-based behaviour applies there.
  148. - **The language server covers Kotlin best.** Java files are analysed too, but its documented
  149. diagnostics and quick fixes are for Kotlin.
  150. - **Quick fixes are listed, not applied.** `file_problems` names the fixes the IDE would offer;
  151. apply them with an edit.
  152. - **Formatting is ktlint's**, not the IDE code style.
  153. ## Configuration
  154. | Env var | Server | Effect |
  155. | --- | --- | --- |
  156. | `IDE_MCP_ALLOWED_ROOTS` | files | Directories the file tools may touch, separated by `:` (`;` on Windows). Unset means anywhere |
  157. | `JAVA_HOME`, `ANDROID_HOME` | kotlin | Passed to Gradle. Pinned by `install.sh` |
  158. | `DETEKT_CLI`, `KTLINT_CLI` | kotlin | Explicit path to the fallback CLI binaries |
  159. | `KOTLIN_LSP_PATH` | kotlin | Use an existing Kotlin language server (its `intellij-server` launcher or install directory) |
  160. | `KOTLIN_LSP_IDLE_MINUTES` | kotlin | Stop a project's language server after this long unused. Default 30 |
  161. | `IJ_JAVA_OPTIONS` | kotlin | JVM options for the language server, e.g. `-Xmx4g` |
  162. `run_command`, `gradle_run`, `delete_path` and `rename_symbol` can change or remove things and
  163. are annotated as destructive, so rely on your agent's approval settings accordingly.
  164. ## Development
  165. ```bash
  166. uv run pytest # unit tests, no Gradle needed
  167. npx @modelcontextprotocol/inspector .venv/bin/kotlin-mcp # interactive tool browser
  168. ```

Ratings and comments

Sign in to rate this skill.

Sign in

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