Skip to content
Back to search

ida-multi-mcp

Multi-instance IDA Pro MCP server — analyze multiple binaries simultaneously through a single MCP endpoint.

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/merozemory--ida-multi-mcp/badge.svg)](/listings/merozemory--ida-multi-mcp)

HTML

<a href="/listings/merozemory--ida-multi-mcp"><img src="/api/listings/merozemory--ida-multi-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.

**Ask your AI agent to install it.** Copy-paste one of these — it matches IDA's Python version, drops the plugin in place, and registers the MCP server with your client.

**Claude Code / Codex:** > Install and configure ida-multi-mcp by following the instructions here: https://raw.githubusercontent.com/MeroZemory/ida-multi-mcp/main/docs/installation.md

**Cursor:** > @Web fetch https://raw.githubusercontent.com/MeroZemory/ida-multi-mcp/main/docs/installation.md and follow the installation steps.

Then open your binaries in IDA Pro — instances register themselves — and talk to your agent. Prefer doing it by hand? See [Manual installation](#manual-installation). Removing it again is in [Troubleshooting](docs/troubleshooting.md#uninstallation).

---

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

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

  1. <h1 align="center">ida-multi-mcp</h1>
  2. <p align="center">
  3. <b>Reverse-engineer several binaries at once — dropper, payload, C2 — through a single MCP endpoint.</b><br>
  4. Each plugin-equipped IDA Pro database auto-registers when opened · headless idalib sessions · local, stripping-resistant function similarity across binaries.
  5. </p>
  6. <p align="center">
  7. <a href="https://github.com/MeroZemory/ida-multi-mcp/actions/workflows/ci.yml"><img src="https://github.com/MeroZemory/ida-multi-mcp/actions/workflows/ci.yml/badge.svg" alt="CI"></a>
  8. <a href="#license"><img src="https://img.shields.io/badge/license-MIT-blue.svg" alt="License"></a>
  9. <a href="#requirements"><img src="https://img.shields.io/badge/python-3.11%2B-blue.svg" alt="Python 3.11+"></a>
  10. <a href="#requirements"><img src="https://img.shields.io/badge/IDA%20Pro-8.5%E2%80%939.3-orange.svg" alt="IDA Pro 8.5-9.3"></a>
  11. <a href="#supported-mcp-clients"><img src="https://img.shields.io/badge/MCP-compatible-brightgreen.svg" alt="MCP compatible"></a>
  12. <a href="https://github.com/MeroZemory/ida-multi-mcp"><img src="https://img.shields.io/github/stars/MeroZemory/ida-multi-mcp?style=social" alt="GitHub stars"></a>
  13. </p>
  14. <p align="center">
  15. <a href="#install-in-one-prompt">Install</a> ·
  16. <a href="#see-it-in-action">In action</a> ·
  17. <a href="#why-ida-multi-mcp">Why</a> ·
  18. <a href="#built-on-ida-pro-mcp">Upstream</a> ·
  19. <a href="#architecture-at-a-glance">Architecture</a> ·
  20. <a href="#tool-surface">Tools</a> ·
  21. <a href="#learn-more">Docs</a>
  22. </p>
  23. ---
  24. ## Install in one prompt
  25. **Ask your AI agent to install it.** Copy-paste one of these — it matches IDA's Python version, drops the plugin in place, and registers the MCP server with your client.
  26. **Claude Code / Codex:**
  27. > Install and configure ida-multi-mcp by following the instructions here: https://raw.githubusercontent.com/MeroZemory/ida-multi-mcp/main/docs/installation.md
  28. **Cursor:**
  29. > @Web fetch https://raw.githubusercontent.com/MeroZemory/ida-multi-mcp/main/docs/installation.md and follow the installation steps.
  30. Then open your binaries in IDA Pro — instances register themselves — and talk to your agent.
  31. Prefer doing it by hand? See [Manual installation](#manual-installation). Removing it again is in [Troubleshooting](docs/troubleshooting.md#uninstallation).
  32. ---
  33. ## See it in action
  34. Two binaries open in two IDA windows. One MCP endpoint. No client config per binary.
  35. > *"Which function in dropper.dll is the same as `sub_140001000` in malware.exe?"*
  36. ```text
  37. → list_instances()
  38. k7m2 malware.exe x86_64 port 49152
  39. px3a dropper.dll x86_64 port 49153
  40. → analysis_wait(instance_id="px3a", timeout_sec=200)
  41. { "finished": true, "functions_added": 12884 } # 12,884 functions that did not exist a minute ago
  42. → index_functions(instance_id="k7m2") · index_functions(instance_id="px3a")
  43. { "indexed": 61044 } { "indexed": 73929 }
  44. → similar_functions(instance_id="k7m2", func="sub_140001000", scope="instances")
  45. 0.94 px3a sub_18000C120 high minhash 0.91 · anchors 0.97 · cfg 0.88
  46. 0.71 px3a sub_18000E440 medium minhash 0.68 · anchors 0.80 · cfg 0.64
  47. → decompile(instance_id="px3a", addr="sub_18000C120")
  48. ...
  49. ```
  50. Core instruction, anchor and CFG signals do not use function names, so stripping does not remove them. When both functions have meaningful symbols, pseudocode identifier tokens can also contribute. Scoring and inference run locally; no binary or IDB is uploaded.
  51. ---
  52. ## Why ida-multi-mcp
  53. <table>
  54. <tr>
  55. <td width="50%" valign="top">
  56. **Built for multi-binary work**
  57. - **Zero-configuration discovery** — every IDA Pro instance running the installed plugin registers into `~/.ida-mcp/instances.json` when a database opens; no per-binary client configuration
  58. - **Genuinely parallel across instances** — requests run on a worker pool. A call to instance B while instance A was busy: **3.41 s → 0.01 s** ([#27](https://github.com/MeroZemory/ida-multi-mcp/pull/27))
  59. - **Headless idalib sessions** — `idalib_open` analyses a binary with no GUI, one isolated subprocess per session
  60. - **Cross-binary similarity (BCSD)** — patch diffing, library-function ID and variant hunting, with local scoring and indexes
  61. - **Short, stable instance IDs** — `k7m2`, `px3a`, with automatic binary-change detection
  62. </td>
  63. <td width="50%" valign="top">
  64. **Built so the agent does not lie to you**
  65. - **Analysis gating** — `analysis_status` / `analysis_wait` tell an agent whether IDA has actually settled, and the router warns on results from analysis-dependent tools while it has not ([why this matters](#the-one-rule-wait-for-auto-analysis))
  66. - **Deadlines that reach into C** — a slow SDK call used to hold IDA's main thread past the tool timeout. The deadline now fires IDA's own `set_cancelled()`, and partial pages are labelled `cursor.cancelled` ([#28](https://github.com/MeroZemory/ida-multi-mcp/pull/28))
  67. - **Actionable failure** — binary changes, stale instances and crashes come back as errors an agent can act on, not silence
  68. - **Localhost only** — loopback-bound with Host/Origin validation; no remote surface
  69. - **IDA 8.5–9.3** — `compat.py` shims APIs that moved between releases and warns on the builds that shipped without them
  70. </td>
  71. </tr>
  72. </table>
  73. ---
  74. ## Built on ida-pro-mcp
  75. The IDA tool implementations here come from [ida-pro-mcp](https://github.com/mrexodia/ida-pro-mcp) by [Duncan Ogilvie (mrexodia)](https://github.com/mrexodia), bundled as a package, periodically compared and selectively synchronized. That project is the foundation this one stands on, and fixes flow both ways.
  76. What ida-multi-mcp adds on top:
  77. - a **router** that fronts N IDA processes behind one stdio endpoint, with `instance_id` routing and a worker pool
  78. - **discovery through a shared file registry** — the IDA plugin registers each GUI instance into `~/.ida-mcp/instances.json` when a database opens, so the client needs no per-binary configuration
  79. - **function similarity (BCSD)** and `compare_binaries` for cross-binary work
  80. - **auto-analysis gating** (`analysis_status` / `analysis_wait`) so an agent can tell a partial answer from a complete one
  81. Both projects now support working on several databases at once — upstream through its `idalib-mcp` supervisor, this one through registry-based discovery. Pick whichever fits your workflow. A running log of what has been adopted from upstream and what has been contributed back: [`docs/ida-pro-mcp/comparison.md`](docs/ida-pro-mcp/comparison.md).
  82. ---
  83. ## Architecture at a glance
  84. One stdio MCP server in front of N IDA processes. The router owns discovery, `instance_id` routing, health and the idalib lifecycle; the IDA tools themselves run inside each instance.
  85. ```mermaid
  86. flowchart TD
  87. C["MCP client<br/>Claude Code · Cursor · Codex …"]
  88. R["<b>ida-multi-mcp router</b><br/>dynamic tool discovery · instance_id routing<br/>worker pool · health · idalib lifecycle"]
  89. Reg[("~/.ida-mcp/instances.json<br/>shared registry")]
  90. G1["IDA #1 (GUI)<br/>malware.exe · k7m2"]
  91. G2["IDA #2 (GUI)<br/>dropper.dll · px3a"]
  92. H1["idalib #1 (headless)<br/>payload.bin · 9bf1"]
  93. C -- "stdio / MCP" --> R
  94. R -- "HTTP JSON-RPC" --> G1
  95. R -- "HTTP JSON-RPC" --> G2
  96. R -- "HTTP JSON-RPC" --> H1
  97. G1 -. "register after database opens" .-> Reg
  98. G2 -. "register after database opens" .-> Reg
  99. Reg -. "discovery" .-> R
  100. ```
  101. <details>
  102. <summary>Plain-text version</summary>
  103. ```
  104. MCP Client (Claude, Cursor, etc.)
  105. │ stdio (MCP Protocol)
  106. ▼
  107. ┌──────────────────────────────────────┐
  108. │ ida-multi-mcp Server (Router) │
  109. │ - Dynamic tool discovery │
  110. │ - instance_id routing │
  111. │ - Management + idalib lifecycle │
  112. └───┬──────┬──────┬──────┬─────────────┘
  113. │ │ │ │ HTTP JSON-RPC
  114. ▼ ▼ ▼ ▼
  115. IDA #1 IDA #2 IDA #3 idalib #1
  116. (GUI) (GUI) (GUI) (headless)
  117. ```
  118. </details>
  119. Registry layout, request routing, health monitoring and the design trade-offs behind them: [`docs/architecture.md`](docs/architecture.md).
  120. ---
  121. ## The one rule: wait for auto-analysis
  122. On a freshly opened binary IDA analyses in the background, and **function lists, xrefs and decompilation are incomplete until it settles**. On an 8.5 MB DLL the function count went from 9,580 to 13,252 — 28% of the functions did not exist yet. On a 23 MB DLL it was 12,885.
  123. ```text
  124. analysis_status() -> {"queue_empty": false, "function_count": 61044}
  125. analysis_wait(timeout_sec=200) -> {"finished": true, "functions_added": 12884}
  126. ```
  127. - **`analysis_status()`** — non-blocking snapshot: queue state, current phase, function count so far.
  128. - **`analysis_wait(timeout_sec=120)`** — drives analysis to completion and returns. `finished: false` means the wait timed out, not that it failed; call it again.
  129. If you only do one thing, call `analysis_wait` once after opening a binary. The router also attaches a warning to results from analysis-dependent tools while an instance is still analysing, so a partial answer is not silently mistaken for a complete one.
  130. <details>
  131. <summary>Why <code>finished</code> is a snapshot, not a latch</summary>
  132. `finished` / `queue_empty` come from IDA's `auto_is_ok()`, which answers *"are the analysis queues empty right now"*. IDA re-queues work as it goes, so the flag can read `true` and then `false` again moments later — observed directly on a 23 MB DLL, where `analysis_wait` returned `finished: true` and the very next `analysis_status` reported `false` on the same idle instance.
  133. Read it as: **`false` means definitely not done**. `true` means nothing is queued at that instant. The durable signal is `functions_added` reaching 0 across successive calls.
  134. Three phases are involved, which is why this is fiddly. IDA's background analysis does the bulk on its own and then plateaus without ever flipping the flag; `auto_make_step()` drains the residual queue; and a final `auto_wait()` pass — 34.5 s on that DLL, adding zero functions — is the only thing that clears the queues. `analysis_wait` handles all three, in bounded slices, so the instance stays responsive throughout.
  135. </details>
  136. ---
  137. ## Tool surface
  138. **Up to 76 tools through one router.** The router combines a 61-tool static fallback with live schema refresh, plus 11 local tools and 4 more when idalib is available.
  139. | Area | Tools |
  140. |---|---|
  141. | Triage | `survey_binary` · `binary_fingerprint` · `classify_functions` · `func_profile` · `analyze_function` · `analyze_component` · `analyze_batch` |
  142. | Navigation & listing | `list_funcs` · `lookup_funcs` · `func_query` · `list_globals` · `imports` · `imports_query` · `export_funcs` |
  143. | Decompile & disassemble | `decompile` · `decompile_to_file` · `disasm` · `basic_blocks` |
  144. | Cross-references | `xrefs_to` · `xrefs_from` · `xrefs_to_field` · `xref_query` · `callgraph` · `callees` · `trace_data_flow` |
  145. | Search | `find` · `find_bytes` · `find_regex` · `insn_query` · `search_structs` |
  146. | Types & stack | `declare_type` · `set_type` · `infer_types` · `enum_upsert` · `read_struct` · `stack_frame` · `declare_stack` · `delete_stack` |
  147. | Modify | `rename` · `set_comments` · `append_comments` · `define_func` · `define_code` · `undefine` · `patch` · `patch_asm` · `idb_save` |
  148. | Memory | `get_bytes` · `get_int` · `put_int` · `get_string` · `get_global_value` · `int_convert` |
  149. | Similarity (BCSD) | `index_functions` · `index_status` · `similar_functions` · `compare_functions` |
  150. | Multi-instance | `list_instances` · `server_health` · `server_warmup` · `refresh_tools` · `refresh_caches` · `compare_binaries` · `diff_before_after` |
  151. | Analysis gating | `analysis_status` · `analysis_wait` · `analysis_step` |
  152. | Headless (idalib) | `idalib_open` · `idalib_close` · `idalib_list` · `idalib_status` |
  153. | Escape hatch | `py_eval` — arbitrary IDAPython, in-process |
  154. Renames, retypes and comments live in memory until `idb_save()`. Full signatures and parameters: [`docs/tools.md`](docs/tools.md).
  155. The bundled IDA-side server also defines 16 debugger tools behind its direct-endpoint `?ext=dbg` gate; the central router does not advertise them.
  156. ---
  157. ## Function similarity (BCSD)
  158. Find the same or a similar function *within a binary or across instances* — patch diffing, library-function ID, variant hunting. The core signals are **name-independent**, so they survive stripping. When both functions have meaningful symbols, a conditional pseudocode identifier-token signal can also contribute:
  159. - instruction-shingle **MinHash**
  160. - IDF-weighted **imported-API / string / constant anchors**
  161. - **CFG** structure and shape
  162. - symbol-gated pseudocode tokens
  163. - optional **local neural recall** — on-demand jTrans embeddings for anchor-less cross-compiler twins
  164. Scoring, indexes and neural inference stay local; no binary or IDB is uploaded. Neural mode downloads its model checkpoint on demand as described below.
  165. ```text
  166. index_functions(instance_id, rebuild=False) # content-hash keyed, persisted to ~/.ida-mcp/index/, incremental
  167. index_status(instance_id) # readiness, function count, staleness, background progress
  168. similar_functions(instance_id, func, top_k=20, scope="binary"|"instances"|"all")
  169. compare_functions(a, b) # direct pairwise, optionally across instances
  170. ```
  171. Neural recall is opt-in: `pip install ida-multi-mcp[neural]` and `IDA_MCP_SIM_NEURAL=1` (the model auto-downloads to `~/.ida-mcp/models/`).
  172. Worked examples against stripped binaries: [`docs/function-similarity-usage.md`](docs/function-similarity-usage.md).
  173. ---
  174. ## Requirements
  175. - Python 3.11 or later
  176. - IDA Pro 8.5+ (9.1 or later recommended)
  177. > **IDA 9.0 SP0 (build 240925) is not supported.** That build shipped without `func_t.get_name`, `func_t.get_prototype` and `tinfo_t.get_udm`, which several tools call directly. Use IDA 9.0 SP1 (build 241217) or later.
  178. ---
  179. ## Manual installation
  180. > Already used the prompt in [Install in one prompt](#install-in-one-prompt)? Skip this section.
  181. <details>
  182. <summary><b>Windows</b></summary>
  183. ```bash
  184. # 0. (Recommended) Clean previous install to avoid stale scripts/config
  185. ida-multi-mcp --uninstall
  186. python -m pip uninstall -y ida-multi-mcp
  187. # 1. Install ida-multi-mcp
  188. python -m pip install git+https://github.com/MeroZemory/ida-multi-mcp.git
  189. # 2. Install IDA plugin + configure all MCP clients
  190. ida-multi-mcp --install
  191. ```
  192. > If IDA uses a different Python version than your default, use `py -3.12` (replace with IDA's version) instead of `python`.
  193. > If you manually edit `%USERPROFILE%\.codex\config.toml`, use literal TOML quoting for Windows paths (e.g. `[projects.'\\?\C:\path\to\repo']`, `command = 'C:\...\python.exe'`).
  194. </details>
  195. <details>
  196. <summary><b>macOS</b> — requires matching IDA's Python version</summary>
  197. > **Important:** IDA Pro typically uses a different Python version than your system default (e.g. IDA uses Python 3.11 while macOS ships 3.14). Install the package for **both** your terminal Python and IDA's Python.
  198. **Step 1 — check IDA's Python version.** In the IDA console:
  199. ```
  200. Python> import sys; print(sys.version)
  201. ```
  202. **Step 2 — install** (replace `3.11` with IDA's version):
  203. ```bash
  204. # 1. CLI tool via pipx (for terminal commands)
  205. pipx install git+https://github.com/MeroZemory/ida-multi-mcp.git
  206. # 2. Package for IDA's Python
  207. python3.11 -m pip install --user git+https://github.com/MeroZemory/ida-multi-mcp.git
  208. # 3. IDA plugin + MCP client configuration
  209. ida-multi-mcp --install
  210. # 4. Claude Code — configure manually (recommended over --install)
  211. claude mcp add ida-multi-mcp -s user -- ida-multi-mcp
  212. ```
  213. > `ida-multi-mcp --install` registers MCP servers using `python3 -m ida_multi_mcp`, which may point at the wrong Python on macOS. For Claude Code, `claude mcp add` pins the pipx-managed CLI directly.
  214. </details>
  215. <details>
  216. <summary><b>Linux</b></summary>
  217. ```bash
  218. # 1. Install ida-multi-mcp
  219. pip install --user git+https://github.com/MeroZemory/ida-multi-mcp.git
  220. # 2. Install IDA plugin + configure MCP clients
  221. ida-multi-mcp --install
  222. ```
  223. </details>
  224. The canonical guide an AI agent should follow is [`docs/installation.md`](https://raw.githubusercontent.com/MeroZemory/ida-multi-mcp/main/docs/installation.md) — platform packages, IDA Python matching, plugin setup, verification.
  225. ### Supported MCP clients
  226. Works with stdio-capable MCP clients. `ida-multi-mcp --install` configures every supported client it finds on your machine:
  227. - **CLI** — Claude Code, Codex, Gemini CLI, Copilot CLI, Amazon Q Developer CLI, Qwen Coder, Opencode, Crush, Factory Droid
  228. - **IDE** — Cursor, VS Code (Copilot), Windsurf, Zed, Kiro, Trae, Antigravity, Augment Code
  229. - **Desktop** — Claude Desktop, LM Studio, BoltAI, Perplexity
  230. - **Editor extension** — Cline, Roo Code, Kilo Code, Qodo Gen
  231. - **Terminal** — Warp
  232. For anything not auto-detected, `ida-multi-mcp --config` prints the raw configuration JSON to paste in yourself.
  233. ---
  234. ## Usage
  235. ### Opening several binaries (GUI)
  236. Open each binary in its own IDA Pro window. The plugin auto-loads (`PLUGIN_FIX`) and registers a 4-character instance ID — `k7m2`, `px3a`, `9bf1`. That is the whole setup.
  237. **Skipping the load dialog.** A new binary normally pops IDA's "Load a new file" dialog, which blocks *before* the plugin is running — nothing on the MCP side can dismiss it. Launch IDA in autonomous mode to accept the defaults:
  238. ```bash
  239. ida -A path/to/binary.exe
  240. ```
  241. ### Targeting an instance
  242. `instance_id` is **required whenever two or more instances are registered**, so concurrent agents cannot collide. With exactly one registered it may be omitted and that instance is selected automatically.
  243. ```text
  244. Decompile the main function in malware.exe (k7m2)
  245. Decompile main in malware.exe (k7m2) and compare it with the entry point in dropper.dll (px3a)
  246. Index malware.exe (k7m2) and dropper.dll (px3a), then find the function in dropper.dll
  247. most similar to sub_140001000 in malware.exe
  248. ```
  249. ### Headless analysis (IDA Pro only)
  250. > **Requires an IDA Pro license.** IDA Home and IDA Free do not ship `idalib`.
  251. ```text
  252. Use idalib_open to analyze /path/to/malware.exe headlessly
  253. ```
  254. `idalib_open(input_path=...)` spawns a headless idalib process, waits for auto-analysis and returns an `instance_id`. From there analysis tools use the same routed interface; GUI- and debugger-dependent operations remain subject to headless IDA limitations. To pin a specific Python that has `idapro` installed:
  255. ```bash
  256. ida-multi-mcp --idalib-python /path/to/python3.11
  257. ```
  258. ### Listing registered instances
  259. ```console
  260. $ ida-multi-mcp --list
  261. Registered IDA instances (3):
  262. k7m2
  263. Binary: malware.exe
  264. Path: C:/samples/malware.exe
  265. Arch: x86_64
  266. Port: 49152
  267. PID: 12345
  268. px3a
  269. Binary: dropper.dll
  270. Path: C:/samples/dropper.dll
  271. Arch: x86_64
  272. Port: 49153
  273. PID: 12346
  274. 9bf1
  275. Binary: payload.exe
  276. Path: C:/samples/payload.exe
  277. Arch: x86
  278. Port: 49154
  279. PID: 12347
  280. ```
  281. ---
  282. ## Learn more
  283. | I want to… | Read |
  284. |---|---|
  285. | Install it properly, on any platform | [`docs/installation.md`](docs/installation.md) |
  286. | Look up a tool's parameters | [`docs/tools.md`](docs/tools.md) |
  287. | Use the CLI (`--list`, `--install`, `--uninstall`, `--config`) | [`docs/cli.md`](docs/cli.md) |
  288. | Understand routing, the registry and health monitoring | [`docs/architecture.md`](docs/architecture.md) |
  289. | Know what it costs on a huge binary | [`docs/performance.md`](docs/performance.md) · [`docs/benchmark-report.md`](docs/benchmark-report.md) |
  290. | Fix a plugin that will not load, or a Python mismatch | [`docs/troubleshooting.md`](docs/troubleshooting.md) |
  291. | See similarity search used on stripped binaries | [`docs/function-similarity-usage.md`](docs/function-similarity-usage.md) |
  292. | Know how this relates to upstream ida-pro-mcp | [`docs/ida-pro-mcp/comparison.md`](docs/ida-pro-mcp/comparison.md) |
  293. ---
  294. ## Limitations
  295. - **Localhost only.** The router binds loopback and refuses non-loopback instances; remote IDA instances are not supported.
  296. - **stdio transport only.** There is no HTTP/SSE endpoint for remote or containerized clients.
  297. - **Headless (idalib) requires IDA Pro.** IDA Home and IDA Free do not ship `idalib`.
  298. - **Concurrency is *across* instances, not within one.** IDA executes on a single main thread, so two calls to the *same* instance still queue.
  299. - **Cancellation is not forwarded to IDA.** `notifications/cancelled` reaches the router, but the router→IDA hop is a blocking HTTP request; the per-tool deadline is what bounds a runaway call.
  300. - **Resources (as opposed to tools) require manual routing.**
  301. ---
  302. ## Changelog highlights
  303. <details>
  304. <summary>Recent work, newest first</summary>
  305. - **⏳ Auto-analysis gating** — `analysis_status()` and `analysis_wait()` let an agent find out whether IDA has actually settled before it draws conclusions, and the router attaches a warning to results from analysis-dependent tools while an instance is still analysing. `server_health`'s `auto_analysis_ready` flag was **inverted**, reporting "ready" exactly when analysis was still running. Waiting properly is worth **12,885 functions** on a 23 MB DLL (61,044 → 73,929) that an unwaiting agent would never see — [why the flag is a snapshot, not a latch](#the-one-rule-wait-for-auto-analysis). `idb_save` also no longer takes the save-as path in the GUI.
  306. - **⚡ Genuinely parallel instances** — the router used to dispatch one request at a time, so a slow call on one binary stalled every other binary behind it. Requests now run on a worker pool with only the stdout writes serialized. Measured against two live instances: a call to instance B while instance A was busy went from **3.41 s → 0.01 s**. ([#27](https://github.com/MeroZemory/ida-multi-mcp/pull/27))
  307. - **⏱️ Slow scans no longer freeze an instance** — a long C-level SDK call (`find_bytes`, `decompile`, string building) could hold IDA's main thread far past the tool timeout, because a Python-level timeout cannot preempt C. The deadline now fires IDA's own `set_cancelled()`, which those calls poll and honour; `find` / `find_bytes` report `cursor.cancelled` so a partial page is distinguishable from a finished one. ([#28](https://github.com/MeroZemory/ida-multi-mcp/pull/28))
  308. - **🔎 Function similarity search (BCSD)** — locate the same or similar function within a binary or across instances, with stripping-resistant core signals, a conditional pseudocode-token signal and optional local neural recall. → [details](#function-similarity-bcsd)
  309. </details>
  310. ---
  311. ## Contributing
  312. Contributions welcome. Please keep changes:
  313. - Python 3.11+ compatible
  314. - cross-platform (Windows, macOS, Linux)
  315. - covered by tests for new behaviour
  316. CI runs lint (`F821`/`F811` — IDA modules cannot be imported in CI, so undefined names are otherwise invisible to pytest) and the test suite on Ubuntu, Windows and macOS against Python 3.11 and 3.12.
  317. ## License
  318. MIT
  319. ## Acknowledgments
  320. This project exists because of [ida-pro-mcp](https://github.com/mrexodia/ida-pro-mcp) by [Duncan Ogilvie (mrexodia)](https://github.com/mrexodia) — the IDA tool implementations are its work, and the multi-instance layer here is built on that foundation. See [Built on ida-pro-mcp](#built-on-ida-pro-mcp) for the details, and [`docs/ida-pro-mcp/comparison.md`](docs/ida-pro-mcp/comparison.md) for what has been adopted from upstream and what has been contributed back.
  321. ## Related projects
  322. - **[ida-pro-mcp](https://github.com/mrexodia/ida-pro-mcp)** — the upstream IDA MCP plugin this project forked its tool implementations from; now also ships a multi-session `idalib-mcp` supervisor (MIT)
  323. - **[Model Context Protocol](https://modelcontextprotocol.io)** — the protocol every client listed above speaks
  324. ## Support
  325. Open an [issue](https://github.com/MeroZemory/ida-multi-mcp/issues) — but check [`docs/troubleshooting.md`](docs/troubleshooting.md) first; plugin-not-loading and Python-version mismatch are common failure modes.

Ratings and comments

Sign in to rate this skill.

Sign in

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