IDA-MCP

# IDA-MCP  [](https://lobehub.com/mcp/captain-ai-hub-ida-mcp) [wiki](https://github.com/jelasin/IDA-MCP/wiki) [deepwiki](https://deepwiki.com/jelasin/IDA-MCP) ## IDA-MCP (FastMCP + Multi-instance Coordinator) * Each IDA instance starts a **FastMCP** server (`/mcp`) * The first instance occupies `127.0.0.1:11337` as the **coordinator**, maintaining a memory registry and supporting tool forwarding * Subsequent instances automatically register with the coordinator; no need to share files or manually configure ports * Unified access / aggregation of instance tools via a modular **proxy** (MCP clients can start it via command/args) ## Architecture The project uses a modular architecture: ### Core Infrastructure * `rpc.py` - `@tool` / `@resource` / `@unsafe` decorators and registration * `sync.py` - `@idaread` / `@idawrite` IDA thread synchronization decorators * `utils.py` - Address parsing, pagination, pattern filtering utilities * `compat.py` - IDA 8.x/9.x compatibility layer ### API Modules (IDA Backend) * `api_core.py` - IDB metadata, function/string/global lists * `api_analysis.py` - Decompilation, disassembly, cross-references * `api_memory.py` - Memory reading operations * `api_types.py` - Type operations (prototypes, local types) * `api_modify.py` - Comments, renaming * `api_stack.py` - Stack frame operations * `api_debug.py` - Debugger control (marked unsafe) * `api_resources.py` - MCP Resources (`ida://` URI patterns) ### Key Features * **Decorator Chain Pattern**: `@tool` + `@idaread`/`@idawrite` for clean API definitions * **Batch Operations**: Most tools accept lists for batch processing * **MCP Resources**: REST-like `ida://` URI patterns for read-only data access * **Multi-instance Support**: Coordinator on port 11337 manages multiple IDA instances * **IDA 8.x/9.x Compatible**: Compatibility layer handles API differences ## Current Tools ### Core Tools (`api_core.py`) * `check_connection` – Health check (ok/count) * `list_instances` – List all registered IDA instances * `get_metadata` – IDB metadata (hash/arch/bits/endian) * `list_functions` – Paginated function list with optional pattern filter * `get_function` – Find function by name or address * `list_globals` – Global symbols (non-functions) * `list_strings` – Extracted strings * `list_local_types` – Local type definitions * `get_entry_points` – Program entry points * `convert_number` – Number format conversion * `list_imports` – List imported functions with module names * `list_exports` – List exported functions/symbols * `list_segments` – List memory segments with permissions * `get_cursor` – Get current cursor position and context ### Analysis Tools (`api_analysis.py`) * `decompile` – Batch decompile functions (Hex-Rays) * `disasm` – Batch disassemble functions * `linear_disassemble` – Linear disassembly from arbitrary address * `xrefs_to` – Batch cross-references to addresses * `xrefs_from` – Batch cross-references from addresses * `xrefs_to_field` – Heuristic struct field references * `find_bytes` – Search for byte patterns with wildcards * `get_basic_blocks` – Get basic blocks with control flow ### Memory Tools (`api_memory.py`) * `get_bytes` – Read raw bytes * `get_u8` / `get_u16` / `get_u32` / `get_u64` – Read integers * `get_string` – Read null-terminated strings ### Type Tools (`api_types.py`) * `declare_type` – Create/update local types * `set_function_prototype` – Set function signature * `set_local_variable_type` – Set local variable type (Hex-Rays) * `set_global_variable_type` – Set global variable type * `list_structs` – List all structures/unions * `get_struct_info` – Get structure definition with fields ### Modify Tools (`api_modify.py`) * `set_comment` – Batch set comments * `rename_function` – Rename function * `rename_local_variable` – Rename local variable (Hex-Rays) * `rename_global_variable` – Rename global symbol * `patch_bytes` – Patch bytes at addresses ### Stack Tools (`api_stack.py`) * `stack_frame` – Get stack frame variables * `declare_stack` – Create stack variables * `delete_stack` – Delete stack variables ### Debug Tools (`api_debug.py`) - Unsafe * `dbg_regs` – Get all registers * `dbg_callstack` – Get call stack * `dbg_list_bps` – List breakpoints * `dbg_start` – Start debugging * `dbg_exit` – Terminate debug * `dbg_continue` – Continue execution * `dbg_run_to` – Run to address * `dbg_add_bp` – Add breakpoint * `dbg_delete_bp` – Delete breakpoint * `dbg_enable_bp` – Enable/disable breakpoint * `dbg_step_into` – Step into instruction * `dbg_step_over` – Step over instruction * `dbg_read_mem` – Read debugger memory * `dbg_write_mem` – Write debugger memory ### MCP Resources (`api_resources.py`) * `ida://idb/metadata` – IDB metadata * `ida://functions` / `ida://functions/{pattern}` – Functions * `ida://function/{addr}` – Single function details * `ida://strings` / `ida://strings/{pattern}` – Strings * `ida://globals` / `ida://globals/{pattern}` – Global symbols * `ida://types` / `ida://types/{pattern}` – Local types * `ida://segments` – Segment list * `ida://imports` – Import list * `ida://exports` – Export list * `ida://xrefs/to/{addr}` – Cross-references to address * `ida://xrefs/from/{addr}` – Cross-references from address * `ida://memory/{addr}?size=N` – Read memory ## Directory Structure ```text IDA-MCP/ ida_mcp.py # Plugin entry: start/stop SSE server + register coordinator ida_mcp/ __init__.py # Package initialization, auto-discovery, exports config.py # Configuration loader (config.conf parser) config.conf # User configuration file rpc.py # @tool/@resource/@unsafe decorators sync.py # @idaread/@idawrite thread sync utils.py # Utility functions compat.py # IDA 8.x/9.x compatibility layer api_core.py # Core API (metadata, lists) api_analysis.py # Analysis API (decompile, disasm, xrefs) api_memory.py # Memory API api_types.py # Type API api_modify.py # Modification API api_stack.py # Stack frame API api_debug.py # Debugger API (unsafe) api_resources.py # MCP Resources registry.py # Coordinator / multi-instance registration proxy/ # stdio-based MCP proxy __init__.py # Proxy module exports ida_mcp_proxy.py # Main entry point (stdio MCP server) _http.py # HTTP helpers for coordinator communication _state.py # State management and port validation proxy_core.py # Core forwarding tools proxy_analysis.py # Analysis forwarding tools proxy_memory.py # Memory forwarding tools proxy_types.py # Type forwarding tools proxy_modify.py # Modification forwarding tools proxy_stack.py # Stack frame forwarding tools proxy_debug.py # Debug forwarding tools http/ # HTTP-based MCP proxy (auto-started, reuses stdio proxy) __init__.py # HTTP module exports http_server.py # HTTP transport wrapper (reuses ida_mcp_proxy.server) mcp.json # MCP client configuration (both modes) README.md # README requirements.txt # fastmcp dependencies ``` ## Startup Steps 1. Copy `ida_mcp.py` + `ida_mcp` folder to IDA's `plugins/`. 2. Open target binary, wait for analysis to complete. 3. Trigger plugin via menu / shortcut: First launch will: * Select free port (starting from 10000) to run SSE service `http://127.0.0.1:<port>/mcp/` * If 11337 is free → start coordinator; otherwise register with existing coordinator 4. Trigger plugin again = stop and unregister instance. ## Proxy Usage The proxy **simultaneously supports both transport modes** - choose whichever works best for your MCP client: ### Transport Modes | Mode | Description | Configuration | |------|-------------|---------------| | **HTTP** (recommended) | Auto-started by coordinator, no subprocess needed | Only requires `url` | | **stdio** | MCP client launches subprocess | Requires `command` and `args` | Both modes are always available when the IDA plugin is running. **Proxy Tools:** | Category | Tools | |----------|-------| | Management | `check_connection`, `list_instances`, `select_instance` | | Core | `list_functions`, `get_metadata`, `list_strings`, `list_globals`, `list_local_types`, `get_entry_points`, `get_function` | | Analysis | `decompile`, `disasm`, `linear_disassemble`, `xrefs_to`, `xrefs_from`, `find_bytes`, `get_basic_blocks` | | Modify | `set_comment`, `rename_function`, `rename_global_variable`, `rename_local_variable` | | Memory | `get_bytes`, `get_u8`, `get_u16`, `get_u32`, `get_u64`, `get_string` | | Types | `set_function_prototype`, `set_local_variable_type`, `set_global_variable_type`, `declare_type` | | Debug | `dbg_start`, `dbg_continue`, `dbg_step_into`, `dbg_step_over`, `dbg_regs`, `dbg_add_bp`, `dbg_delete_bp`, ... | You can use it on Codex / Claude Code / LangChain / Cursor / VSCode / etc - any MCP client. ### Configuration File Edit `ida_mcp/config.conf` to customize settings: ```ini # Coordinator settings # coordinator_host = "127.0.0.1" # coordinator_port = 11337 # HTTP proxy settings # http_host = "127.0.0.1" # Use 0.0.0.0 for remote access # http_port = 11338 # http_path = "/mcp" # IDA instance settings # ida_default_port = 10000 # General settings # request_timeout = 30 # debug = false ``` ### Method 1: HTTP Mode (Recommended) HTTP proxy auto-starts when IDA plugin loads. Client only needs URL - no subprocess required. **Claude / Cherry Studio / Cursor example:** ```json { "mcpServers": { "ida-mcp": { "url": "http://127.0.0.1:11338/mcp" } } } ``` **LangChain example:** ```json { "mcpServers": { "ida-mcp": { "transport": "streamable-http", "url": "http://127.0.0.1:11338/mcp" } } } ``` **VSCode example:** ```json { "servers": { "ida-mcp": { "url": "http://127.0.0.1:11338/mcp" } } } ``` ### Method 2: stdio Mode Client launches proxy as subprocess. Useful when HTTP is not available. **Claude / Cherry Studio / Cursor example:** ```json { "mcpServers": { "ida-mcp-proxy": { "command": "path of python (IDA's python)", "args": ["path of ida_mcp/proxy/ida_mcp_proxy.py"] } } } ``` **VSCode example:** ```json { "servers": { "ida-mcp-proxy": { "command": "path of python (IDA's python)", "args": ["path of ida_mcp/proxy/ida_mcp_proxy.py"] } } } ``` ⚠️ Note: Using VSCode Copilot may result in your account being banned. ## Dependencies Need to install using IDA's Python environment: ```bash python -m pip install -r requirements.txt ``` ## Development It's not about having many tools, but about having precise ones; the power of the API is what truly matters. Additionally, the tools should be comprehensive, and the more tools there are, the more obstacles there are for the model to call them. If certain tools can be achieved through existing ones, then those tools are unnecessary. What I need are the missing tools—the ones that existing tools cannot accomplish. ## Future Plans Add UI interface, support internal model calls, add multi-agent A2A automated reverse engineering functionality after langchain officially updates to 1.0.0.