Skip to content
Back to search

ghidra-mcp

Ghidra MCP Server — 200+ MCP tools for AI-powered reverse engineering. GUI plugin + headless server, lazy tool loading, convention enforcement, batch operations, Ghidra Server integration, and Docker deployment.

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 11 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/bethington/ghidra-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/bethington/ghidra-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/bethington--ghidra-mcp/badge.svg)](/listings/bethington--ghidra-mcp)

HTML

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

Prerequisites

- **Java 21 LTS** (OpenJDK recommended) - **Apache Maven 3.9+** - **Ghidra 12.1.3** (or compatible version) - **Python 3.10+** with [uv](https://docs.astral.sh/uv/) (recommended) or pip + venv

> Shared Ghidra Server users: Ghidra 12.1.3 clients require a Ghidra > Server at 12.1, 12.0.5, or a newer compatible version. Upgrade the > server before using this plugin from a 12.1 client. > > Ghidra 12.1.3 ships Jython as an optional extension. Java scripts work > by default, but `.py` scripts in `ghidra_scripts/` require installing > the Jython extension from **File > Install Extensions** and restarting > Ghidra.

Installation

> Recommended for all platforms: use `python -m tools.setup` directly. > > `ensure-prereqs` installs runtime Python requirements plus the Ghidra JARs needed in the local Maven repository. > `deploy` copies the build output, installs the user-profile extension, and patches Ghidra user config.

1. **Clone the repository:**

   git clone https://github.com/bethington/ghidra-mcp.git
   cd ghidra-mcp

2. **Recommended: run environment preflight first:**

   python -m tools.setup preflight --ghidra-path "F:\ghidra_12.1.3_PUBLIC"

3. **Build and deploy to Ghidra:**

   python -m tools.setup ensure-prereqs --ghidra-path "F:\ghidra_12.1.3_PUBLIC"
   python -m tools.setup build
   python -m tools.setup deploy --ghidra-path "F:\ghidra_12.1.3_PUBLIC"

`deploy` saves/closes an already-running matching Ghidra instance when needed, installs the extension, starts Ghidra, waits for MCP health, and runs schema smoke checks.

Prefer to click through Ghidra's own dialogs, or installing a release zip on a machine without the repo? Follow the illustrated [manual GUI install guide](docs/INSTALL_GUI.md).

4. **Optional strict/manual mode** (advanced):

   # Skip automatic prerequisite setup
   python -m tools.setup build
   python -m tools.setup deploy --ghidra-path "F:\ghidra_12.1.3_PUBLIC"

5. **Show command help**:

   python -m tools.setup --help

6. **Optional build-only mode** (advanced/troubleshooting):

   python -m tools.setup build

Two Java backends are supported. **Gradle is the default for local work** — it reads Ghidra's jars straight out of the installation, so there is no `install-file` step and nothing to install beyond a JDK. **CI builds and gates with Maven**, so Maven is a maintained peer rather than a fallback.

   # Gradle (default) -- the wrapper is committed, so no Gradle install is needed.
   # -PGHIDRA_INSTALL_DIR or the GHIDRA_INSTALL_DIR env var both work.
   # In Git Bash use forward slashes; a backslash path is mangled before Gradle sees it.
   ./gradlew buildExtension -PGHIDRA_INSTALL_DIR=/path/to/ghidra
   # Maven (peer backend; what CI uses). Needs Ghidra's jars in the local .m2 first:
   #   python -m tools.setup ensure-prereqs --ghidra-path /path/to/ghidra
   mvn clean package assembly:single -DskipTests

`python -m tools.setup build` routes to Maven by default; set `TOOLS_SETUP_BACKEND=gradle` to route it to Gradle instead.

Installation (Linux — Ubuntu/Debian)

1. **Clone the repository:**

   git clone https://github.com/bethington/ghidra-mcp.git
   cd ghidra-mcp

2. **Install system prerequisites** (if not already installed):

   sudo apt update && sudo apt install -y openjdk-21-jdk maven python3 python3-pip python3-venv curl jq unzip

> **Debian/Kali/Ubuntu 23.04+ note (PEP 668):** these distros mark the system > Python as *externally managed*, so a bare `pip install` fails with > `error: externally-managed-environment`. Don't work around it with > `--break-system-packages` — it can corrupt apt-managed tooling. Instead use > [uv](https://docs.astral.sh/uv/) (recommended — it creates and manages a

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 · 1,656 lines

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

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. # Ghidra MCP Server
  2. [![MCP Toplist](https://mcptoplist.com/badge/glama%2Fbethington%2Fghidra-mcp.svg)](https://mcptoplist.com/server/glama%2Fbethington%2Fghidra-mcp)
  3. [![Tests](https://img.shields.io/github/actions/workflow/status/bethington/ghidra-mcp/tests.yml?branch=main&style=for-the-badge&label=Tests&logo=github-actions&logoColor=white)](https://github.com/bethington/ghidra-mcp/actions/workflows/tests.yml)
  4. [![Release](https://img.shields.io/github/v/release/bethington/ghidra-mcp?style=for-the-badge&logo=github&logoColor=white&color=blue)](https://github.com/bethington/ghidra-mcp/releases/latest)
  5. [![License](https://img.shields.io/github/license/bethington/ghidra-mcp?style=for-the-badge&color=green)](LICENSE)
  6. [![GitHub Sponsors](https://img.shields.io/github/sponsors/bethington?style=for-the-badge&logo=githubsponsors&logoColor=white&label=Sponsors&labelColor=ea4aaa&color=ea4aaa)](https://github.com/sponsors/bethington)
  7. [![Python](https://img.shields.io/badge/python-3.10%20%7C%203.11%20%7C%203.12%20%7C%203.13-3776AB?style=for-the-badge&logo=python&logoColor=white)](https://www.python.org/)
  8. [![Java](https://img.shields.io/badge/Java-21-ED8B00?style=for-the-badge&logo=openjdk&logoColor=white)](https://openjdk.org/projects/jdk/21/)
  9. [![Ghidra](https://img.shields.io/badge/Ghidra-12.2-brightgreen?style=for-the-badge&logoColor=white)](https://ghidra-sre.org/)
  10. [![MCP](https://img.shields.io/badge/MCP-Model%20Context%20Protocol-6C5CE7?style=for-the-badge&logoColor=white)](https://modelcontextprotocol.io/)
  11. [![Stars](https://img.shields.io/github/stars/bethington/ghidra-mcp?style=for-the-badge&logo=github&logoColor=white&color=yellow)](https://github.com/bethington/ghidra-mcp/stargazers)
  12. [![Last commit](https://img.shields.io/github/last-commit/bethington/ghidra-mcp?style=for-the-badge&logo=git&logoColor=white)](https://github.com/bethington/ghidra-mcp/commits/main)
  13. [![Discussions](https://img.shields.io/badge/discussions-join-7B68EE?style=for-the-badge&logo=github&logoColor=white)](https://github.com/bethington/ghidra-mcp/discussions)
  14. [![Issues](https://img.shields.io/github/issues/bethington/ghidra-mcp?style=for-the-badge&logo=github&logoColor=white&color=orange)](https://github.com/bethington/ghidra-mcp/issues)
  15. [![OpenSSF Scorecard](https://img.shields.io/ossf-scorecard/github.com/bethington/ghidra-mcp?style=for-the-badge&logo=securityscorecard&logoColor=white&label=OpenSSF%20Scorecard)](https://scorecard.dev/viewer/?uri=github.com/bethington/ghidra-mcp)
  16. > If you find this useful, please ⭐ star the repo — it helps others discover it!
  17. >
  18. > If Ghidra MCP saves you time, consider [sponsoring the project](https://github.com/sponsors/bethington). One-time and recurring support both help fund compatibility updates, production hardening, docs, and new tooling.
  19. A production-ready Model Context Protocol (MCP) server that bridges Ghidra's powerful reverse engineering capabilities with modern AI tools and automation frameworks. **219 MCP tools**, battle-tested AI workflows, and the most comprehensive Ghidra-MCP integration available — now including P-code emulation, live debugger integration, and PCode-graph data flow analysis.
  20. ## Quickstart: install a release (no clone, no build)
  21. Every [release](https://github.com/bethington/ghidra-mcp/releases) ships the two
  22. pieces you need: the Ghidra extension (`GhidraMCP-<version>.zip`) and the MCP
  23. bridge (`ghidra_mcp_bridge-<version>-py3-none-any.whl`).
  24. 1. **Install the prerequisites:** [Ghidra 12.2](https://github.com/NationalSecurityAgency/ghidra/releases),
  25. Java 25 and [uv](https://docs.astral.sh/uv/getting-started/installation/).
  26. The extension only loads in the exact Ghidra version it was built for.
  27. 2. **Install the extension:** in Ghidra's project window, **File > Install
  28. Extensions**, click **+**, pick the `GhidraMCP-<version>.zip` you downloaded,
  29. and restart Ghidra.
  30. 3. **Enable the plugin:** in the project window, **File > Configure >
  31. Utility > Configure**, tick **GhidraMCPPlugin**. Check it answers:
  32. ```bash
  33. curl http://127.0.0.1:8089/check_connection
  34. # {"status": "ok", "server_kind": "gui", "version": "7.0.0"}
  35. ```
  36. 4. **Install the bridge** (copy the wheel's link from the same release page):
  37. ```bash
  38. uv tool install https://github.com/bethington/ghidra-mcp/releases/download/v7.0.0/ghidra_mcp_bridge-7.0.0-py3-none-any.whl
  39. ```
  40. 5. **Point your MCP client at it**, using the absolute path (`which
  41. bridge-mcp-ghidra`, or `where.exe bridge-mcp-ghidra` on Windows):
  42. ```json
  43. {
  44. "mcpServers": {
  45. "ghidra-mcp": { "command": "/home/<you>/.local/bin/bridge-mcp-ghidra" }
  46. }
  47. }
  48. ```
  49. On Windows: `"command": "C:\\Users\\<you>\\.local\\bin\\bridge-mcp-ghidra.exe"`.
  50. A client launched from a GUI or a service does not see your shell's PATH,
  51. so a bare `bridge-mcp-ghidra` fails with `spawn ENOENT`.
  52. Open a program in Ghidra and ask your AI tool to list its functions. Screenshots
  53. of steps 2-3: [docs/INSTALL_GUI.md](docs/INSTALL_GUI.md). Building from source,
  54. Docker, the HTTP transports and every bridge flag are further down.
  55. **Which version should I run?** Tagged releases (7.0.0, 7.1.0, ...) are
  56. stable. Release candidates and `main` are beta: feature-complete and
  57. live-tested, but shapes can still change before final. `dev` is experimental:
  58. tools are merged, renamed and refactored there freely, so build nothing on its
  59. API.
  60. ## Why Ghidra MCP?
  61. Most Ghidra MCP implementations give you a handful of read-only tools and call it a day. This project is different — it was built by a reverse engineer who uses it daily on real binaries, not as a demo.
  62. - **219 MCP tools** — 3x more than any competing implementation. Not just read operations — full write access for renaming, typing, commenting, structure creation, script execution, P-code emulation, and live debugging.
  63. - **Battle-tested AI workflows** — Proven documentation workflows (V5) refined across hundreds of functions. Includes step-by-step prompts, Hungarian notation reference, batch processing guides, and orphaned code discovery.
  64. - **Production-grade reliability** — Atomic transactions, batch operations (93% API call reduction), configurable timeouts, and graceful error handling. No silent failures.
  65. - **Cross-binary documentation transfer** — SHA-256 function hash matching propagates documentation across binary versions automatically. Document once, apply everywhere.
  66. - **Full Ghidra Server integration** — Connect to shared Ghidra servers, manage repositories, version control, checkout/checkin workflows, and multi-user collaboration.
  67. - **Headless and GUI modes** — Run with or without the Ghidra GUI. Docker-ready for CI/CD pipelines and automated analysis at scale.
  68. - **Opinionated by design** — v5.0 moves naming conventions, type safety, and documentation standards into the tool layer. AI agents and human engineers produce consistent output without style guides in every prompt.
  69. ## Convention Enforcement
  70. You've been there: six months into a project you find `ProcessItem`, `process_items`, `handleItem`, and `ItemProc` in the same codebase — four functions doing the same thing, named by four different sessions or engineers with no shared contract. Fixing it takes longer than it should, and the problem will happen again.
  71. v5.0 moves conventions from "things to remember" into the tool layer, where they can actually be enforced.
  72. | Tier | Behavior | Example |
  73. | ------ | ---------- | --------- |
  74. | **Auto-fix** | Applied silently | `count` field on a `uint32` → auto-prefixed `dwCount` on save |
  75. | **Warn** | Change goes through, warning returned | `processData` → "name should be PascalCase with a verb: `ProcessData`" |
  76. | **Reject** | Change blocked with explanation | `undefined → undefined` type change → "no-op rejected, type unchanged" |
  77. **For AI agents**, this means consistent output across every session, every model, every run — without pasting a style guide into every prompt. The tool knows the rules; the model just needs to make the call.
  78. **For teams**, it eliminates the entire class of review comment that says "that's not our naming convention." Convention arbitration stays in the tool, not in code review.
  79. **For solo work at scale**, `analyze_function_completeness` gives you a 0–100% score that measures honestly: structural deductions (unfixable compiler artifacts) are forgiven in your effective score, log-scaling prevents one bad category from burying everything else, and tiered plate comment quality means you know exactly what's missing and why.
  80. ## 🌟 Features
  81. ### Core MCP Integration
  82. - **Full MCP Compatibility** — Complete implementation of Model Context Protocol
  83. - **219 MCP tools** — Comprehensive API surface covering every aspect of binary analysis
  84. - **Production-Ready Reliability** — Atomic transactions, batch operations, configurable timeouts
  85. - **Real-time Analysis** — Live integration with Ghidra's analysis engine
  86. > **Compatibility note:** MCP tool names are normalized for GitHub Copilot CLI
  87. > and CAPI validation. Exposed tool names use lowercase letters, digits,
  88. > underscores, and hyphens only; nested HTTP paths such as `/debugger/status`
  89. > are advertised as names like `debugger_status_2` when needed to avoid
  90. > collisions with static bridge tools.
  91. ### Binary Analysis Capabilities
  92. - **Function Analysis** — Decompilation, call graphs, cross-references, completeness scoring
  93. - **Data Flow Analysis** — PCode-graph value propagation (forward / backward) from any variable or register
  94. - **Data Structure Discovery** — Struct/union/enum creation with field analysis and naming suggestions
  95. - **String Extraction** — Regex search, quality filtering, and string-anchored function discovery
  96. - **Import/Export Analysis** — Symbol tables, external locations, ordinal import resolution
  97. - **Memory & Data Inspection** — Raw memory reads, byte pattern search, array boundary detection
  98. - **Cross-Binary Documentation** — Function hash matching and documentation propagation across versions
  99. ### Dynamic Analysis (v5.4.0)
  100. - **P-code Emulation** — Run any function in isolation via Ghidra's `EmulatorHelper`; brute-force API hash resolution in milliseconds
  101. - **Live Debugger Integration** — 16 `/debugger/*` endpoints over Ghidra's TraceRmi framework (GUI plugin only; dbgeng on Windows PE, gdb/lldb otherwise): launch, interrupt/resume, step into/over/out, breakpoints, registers, memory reads, stack traces, ASLR-aware static↔dynamic address translation. The bridge can also proxy 22 `debugger_*` tools to an external debugger server; they are opt-in (see [below](#optional-connect-an-external-debugger-server))
  102. ### AI-Powered Reverse Engineering Workflows
  103. - **Function Documentation Workflow V5** — 7-step process for complete function documentation with Hungarian notation, type auditing, and automated verification scoring
  104. - **Batch Documentation** — Parallel subagent dispatch for documenting multiple functions simultaneously
  105. - **Orphaned Code Discovery** — Automated scanner finds undiscovered functions in gaps between known code
  106. - **Data Type Investigation** — Systematic workflows for structure discovery and field analysis
  107. - **Cross-Version Matching** — Hash-based function matching across different binary versions
  108. ### Development & Automation
  109. - **Ghidra Script Execution** — List and run Ghidra scripts, or run inline script code, via MCP (running them is opt-in: `GHIDRA_MCP_ALLOW_SCRIPTS=1`)
  110. - **Multi-Program Support** — Switch between and compare multiple open programs
  111. - **Batch Operations** — Bulk renaming, commenting, typing, and label management (93% fewer API calls)
  112. - **Headless Server** — Full analysis without Ghidra GUI — Docker and CI/CD ready
  113. - **Project & Version Control** — Create projects, manage files, Ghidra Server integration
  114. - **Analysis Control** — List, configure, and trigger Ghidra analyzers programmatically
  115. ## 🚀 Install from source
  116. The [Quickstart](#quickstart-install-a-release-no-clone-no-build) above needs
  117. none of this. Build from source to run `dev`, to contribute, or to use
  118. `python -m tools.setup deploy`, which installs, configures and restarts Ghidra
  119. for you.
  120. ### Prerequisites
  121. - **Java 25 LTS** (OpenJDK recommended)
  122. - **Apache Maven 3.9+** for the `python -m tools.setup` commands below (Maven is their default backend). Not needed if you build with the committed Gradle wrapper instead — see step 6
  123. - **Ghidra 12.2** (or compatible version)
  124. - **Python 3.10+** with [uv](https://docs.astral.sh/uv/) (recommended) or pip + venv
  125. > Shared Ghidra Server users: Ghidra 12.2 clients enforce TLS server
  126. > authentication on every connection, loopback included, so the server's
  127. > certificate must be trusted (**Edit > Manage Certificates...** on Windows
  128. > and macOS). A server previously refused on the Server Allow List stays
  129. > refused, including for headless `ghidra://` runs, until it is changed with
  130. > `support/updateServerAllowList`. See Ghidra's `WhatsNew` before upgrading a
  131. > shared deployment.
  132. >
  133. > Programs saved by 12.2 may not open in an earlier Ghidra. Programs from an
  134. > earlier Ghidra open read-only until upgraded, because 12.2 raises the program
  135. > database version. With Ghidra closed and a backup taken, upgrade a project with
  136. > `support/analyzeHeadless <project_dir> <project_name> -process '*' -recursive -noanalysis`.
  137. > Add `-connect <user> -p` for a shared project. Without `-commit`, nothing is
  138. > committed to the server, but unmodified checkouts become modified.
  139. >
  140. > Ghidra 12.2 ships Jython as an optional extension. Java scripts work
  141. > by default, but `.py` scripts in `ghidra_scripts/` require installing
  142. > the Jython extension from **File > Install Extensions** and restarting
  143. > Ghidra.
  144. ### Installation
  145. > Recommended for all platforms: use `python -m tools.setup` directly.
  146. >
  147. > `ensure-prereqs` installs runtime Python requirements plus the Ghidra JARs needed in the local Maven repository.
  148. > `deploy` copies the build output, installs the user-profile extension, and patches Ghidra user config.
  149. 1. **Clone the repository:**
  150. ```bash
  151. git clone https://github.com/bethington/ghidra-mcp.git
  152. cd ghidra-mcp
  153. ```
  154. 2. **Recommended: run environment preflight first:**
  155. ```text
  156. python -m tools.setup preflight --ghidra-path "F:\ghidra_12.2_PUBLIC"
  157. ```
  158. 3. **Build and deploy to Ghidra:**
  159. ```text
  160. python -m tools.setup ensure-prereqs --ghidra-path "F:\ghidra_12.2_PUBLIC"
  161. python -m tools.setup build
  162. python -m tools.setup deploy --ghidra-path "F:\ghidra_12.2_PUBLIC"
  163. ```
  164. `deploy` saves/closes an already-running matching Ghidra instance when
  165. needed, installs the extension, starts Ghidra, waits for MCP health, and runs
  166. schema smoke checks.
  167. Prefer to click through Ghidra's own dialogs, or installing a release zip on
  168. a machine without the repo? Follow the illustrated
  169. [manual GUI install guide](docs/INSTALL_GUI.md).
  170. 4. **Optional strict/manual mode** (advanced):
  171. ```text
  172. # Skip automatic prerequisite setup
  173. python -m tools.setup build
  174. python -m tools.setup deploy --ghidra-path "F:\ghidra_12.2_PUBLIC"
  175. ```
  176. 5. **Show command help**:
  177. ```text
  178. python -m tools.setup --help
  179. ```
  180. 6. **Optional build-only mode** (advanced/troubleshooting):
  181. ```text
  182. python -m tools.setup build
  183. ```
  184. Two Java backends are supported. **Gradle is the default for local work** — it reads Ghidra's jars straight out of the installation, so there is no `install-file` step and nothing to install beyond a JDK. **CI builds and gates with Maven**, so Maven is a maintained peer rather than a fallback.
  185. ```bash
  186. # Gradle (default) -- the wrapper is committed, so no Gradle install is needed.
  187. # -PGHIDRA_INSTALL_DIR or the GHIDRA_INSTALL_DIR env var both work.
  188. # In Git Bash use forward slashes; a backslash path is mangled before Gradle sees it.
  189. ./gradlew buildExtension -PGHIDRA_INSTALL_DIR=/path/to/ghidra
  190. ```
  191. ```bash
  192. # Maven (peer backend; what CI uses). Needs Ghidra's jars in the local .m2 first:
  193. # python -m tools.setup ensure-prereqs --ghidra-path /path/to/ghidra
  194. mvn clean package assembly:single -DskipTests
  195. ```
  196. `python -m tools.setup build` routes to Maven by default; set `TOOLS_SETUP_BACKEND=gradle` to route it to Gradle instead.
  197. ### Installation (Linux — Ubuntu/Debian)
  198. 1. **Clone the repository:**
  199. ```bash
  200. git clone https://github.com/bethington/ghidra-mcp.git
  201. cd ghidra-mcp
  202. ```
  203. 2. **Install system prerequisites** (if not already installed):
  204. ```bash
  205. sudo apt update && sudo apt install -y openjdk-21-jdk maven python3 python3-pip python3-venv curl jq unzip
  206. ```
  207. > **Debian/Kali/Ubuntu 23.04+ note (PEP 668):** these distros mark the system
  208. > Python as *externally managed*, so a bare `pip install` fails with
  209. > `error: externally-managed-environment`. Don't work around it with
  210. > `--break-system-packages` — it can corrupt apt-managed tooling. Instead use
  211. > [uv](https://docs.astral.sh/uv/) (recommended — it creates and manages a
  212. > project-local `.venv` automatically, and is what this repo's commands use):
  213. >
  214. > ```bash
  215. > curl -LsSf https://astral.sh/uv/install.sh | sh
  216. > uv run bridge-mcp-ghidra # resolves deps into .venv and starts the bridge
  217. > ```
  218. >
  219. > or a classic virtual environment:
  220. >
  221. > ```bash
  222. > python3 -m venv .venv && source .venv/bin/activate
  223. > pip install -e .
  224. > bridge-mcp-ghidra
  225. > ```
  226. 3. **Run environment preflight:**
  227. ```bash
  228. python -m tools.setup preflight --ghidra-path ~/ghidra_12.2_PUBLIC
  229. ```
  230. 4. **Build and deploy to Ghidra (single command):**
  231. ```bash
  232. python -m tools.setup ensure-prereqs --ghidra-path ~/ghidra_12.2_PUBLIC
  233. python -m tools.setup build
  234. python -m tools.setup deploy --ghidra-path ~/ghidra_12.2_PUBLIC
  235. ```
  236. This will:
  237. - Install Ghidra JAR dependencies into your local `~/.m2/repository`
  238. - Build `GhidraMCP-<version>.zip` with Maven
  239. - Extract the extension to `~/.config/ghidra/ghidra_<version>_PUBLIC/Extensions/`
  240. - Update `preferences` with `LastExtensionImportDirectory`
  241. - Install Python requirements
  242. 5. **Optional: setup only Maven dependencies:**
  243. ```bash
  244. python -m tools.setup install-ghidra-deps --ghidra-path ~/ghidra_12.2_PUBLIC
  245. ```
  246. 6. **Show command help:**
  247. ```bash
  248. python -m tools.setup --help
  249. ```
  250. > **Linux paths:** The extension is installed to `$HOME/.config/ghidra/ghidra_<version>_PUBLIC/Extensions/GhidraMCP/`.
  251. > Ghidra config files are in `$HOME/.config/ghidra/ghidra_<version>_PUBLIC/`.
  252. ### Installation (macOS — Homebrew)
  253. 1. **Install prerequisites:**
  254. ```bash
  255. brew install openjdk@21 maven python ghidra
  256. ```
  257. 2. **Clone the repository:**
  258. ```bash
  259. git clone https://github.com/bethington/ghidra-mcp.git
  260. cd ghidra-mcp
  261. ```
  262. 3. **Install Ghidra JARs into local Maven:**
  263. ```bash
  264. python -m tools.setup install-ghidra-deps \
  265. --ghidra-path /opt/homebrew/opt/ghidra/libexec
  266. ```
  267. 4. **Build and deploy:**
  268. ```bash
  269. python -m tools.setup ensure-prereqs \
  270. --ghidra-path /opt/homebrew/opt/ghidra/libexec
  271. python -m tools.setup build
  272. python -m tools.setup deploy \
  273. --ghidra-path /opt/homebrew/opt/ghidra/libexec
  274. ```
  275. The extension is installed to `~/Library/ghidra/ghidra_12.2_PUBLIC/Extensions/GhidraMCP/`.
  276. > **Note:** the Homebrew path contains no version string, so `tools.setup` reads the Ghidra version from `Ghidra/application.properties` inside the installation instead.
  277. 5. **Start Ghidra and enable the plugin:**
  278. ```bash
  279. /opt/homebrew/opt/ghidra/libexec/ghidraRun
  280. ```
  281. The server starts with the plugin. Check it from the project window:
  282. **Tools > GhidraMCP > Server Status**
  283. 6. **Configure Cursor/Claude MCP** (`~/.cursor/mcp.json`) — use the **absolute
  284. path** to `uv` (`which uv`), not the bare name; GUI-launched clients do not
  285. inherit your shell's PATH ([#441](https://github.com/bethington/ghidra-mcp/issues/441)):
  286. ```json
  287. {
  288. "mcpServers": {
  289. "ghidra": {
  290. "command": "/opt/homebrew/bin/uv",
  291. "args": ["run", "--directory", "/path/to/ghidra-mcp", "bridge-mcp-ghidra"]
  292. }
  293. }
  294. }
  295. ```
  296. macOS is the sharpest case: apps launched from Finder/Dock get `launchd`'s
  297. PATH, which never contains `~/.local/bin` or `/opt/homebrew/bin`.
  298. ### Installation (Arch Linux — AUR)
  299. [@Pandoriaantje](https://github.com/Pandoriaantje) maintains community AUR packages:
  300. - [`ghidra-mcp-git`](https://aur.archlinux.org/packages/ghidra-mcp-git) — tracks `main`
  301. - [`ghidra-mcp`](https://aur.archlinux.org/packages/ghidra-mcp) — tracks tagged releases
  302. Install with your AUR helper of choice, e.g.:
  303. ```bash
  304. yay -S ghidra-mcp # or ghidra-mcp-git
  305. ```
  306. ### Basic Usage
  307. #### Option 1: Stdio Transport (Recommended for AI tools)
  308. ```bash
  309. uv run bridge-mcp-ghidra # or: python -m bridge_mcp_ghidra
  310. ```
  311. MCP client config (`.mcp.json`, `~/.cursor/mcp.json`, Claude Desktop config, …).
  312. **Use the absolute path to `uv`** — see the note below for why:
  313. ```json
  314. {
  315. "mcpServers": {
  316. "ghidra-mcp": {
  317. "command": "/home/<you>/.local/bin/uv",
  318. "args": ["run", "--directory", "/path/to/ghidra-mcp", "bridge-mcp-ghidra", "--transport", "stdio"],
  319. "env": { "GHIDRA_MCP_URL": "http://127.0.0.1:8089" }
  320. }
  321. }
  322. }
  323. ```
  324. On Windows the same config points at `uv.exe`, e.g.
  325. `"command": "C:\\Users\\<you>\\.local\\bin\\uv.exe"`. Find your own path with
  326. `which uv` (POSIX) or `where.exe uv` (Windows), or just run
  327. `python -m tools.setup preflight`, which prints the resolved absolute path and a
  328. ready-to-paste snippet.
  329. > **Why absolute? `"command": "uv"` fails under service and GUI launchers.**
  330. > The MCP client resolves `command` with **its own** PATH, not your shell's. A
  331. > client started from a **systemd user service**, a `.desktop` entry, or any
  332. > other GUI session inherits that launcher's environment, which routinely lacks
  333. > `~/.local/bin` and `~/.cargo/bin` — the very directories `uv` installs into.
  334. > The failure lands at process-spawn time as `spawn uv ENOENT`, before any
  335. > bridge code runs, so there is nothing in any log to read. An absolute path
  336. > makes the client's PATH irrelevant and works on the first try. The same
  337. > applies to `python`, `python3`, and the `bridge-mcp-ghidra` console script.
  338. > ([#441](https://github.com/bethington/ghidra-mcp/issues/441))
  339. To add the bridge to [Autohand Code](https://github.com/autohandai/code-cli/) from a cloned checkout:
  340. ```bash
  341. autohand mcp add ghidra /home/<you>/.local/bin/uv run --directory /path/to/ghidra-mcp bridge-mcp-ghidra
  342. ```
  343. Add `--scope project` before `ghidra` to save the server in the current project's `.autohand` configuration instead of your user configuration.
  344. #### Option 2: Streamable HTTP Transport (Recommended for web/HTTP clients)
  345. ```bash
  346. uv run bridge-mcp-ghidra --transport streamable-http --mcp-host 127.0.0.1 --mcp-port 8081
  347. ```
  348. MCP client config for the HTTP transport (add to your client's MCP config file):
  349. ```json
  350. {
  351. "mcpServers": {
  352. "ghidra-mcp-http": {
  353. "url": "http://127.0.0.1:8081/mcp"
  354. }
  355. }
  356. }
  357. ```
  358. Browser-based clients (e.g. [MCP Inspector](https://github.com/modelcontextprotocol/inspector))
  359. work out of the box: the HTTP transports answer CORS preflight (`OPTIONS`) requests and expose
  360. the `mcp-session-id` / `mcp-protocol-version` headers to scripts. Allowed origins mirror the
  361. Host-header policy — loopback on any port is always permitted, plus the bind host and any
  362. hosts listed in `GHIDRA_MCP_ALLOWED_HOSTS`.
  363. `GHIDRA_MCP_ALLOWED_HOSTS` also supports clients that route a loopback-bound
  364. bridge through another network namespace. For example, a container can address
  365. the host as `host.containers.internal` without exposing the bridge on a LAN
  366. interface:
  367. ```bash
  368. GHIDRA_MCP_ALLOWED_HOSTS=host.containers.internal \
  369. uv run bridge-mcp-ghidra --transport streamable-http \
  370. --mcp-host 127.0.0.1 --mcp-port 8081
  371. ```
  372. The setting extends DNS-rebinding Host/Origin validation only; it does not
  373. change the bind address or make the listener reachable on additional interfaces.
  374. #### Option 3: SSE Transport (Deprecated — use streamable-http instead)
  375. ```bash
  376. uv run bridge-mcp-ghidra --transport sse --mcp-host 127.0.0.1 --mcp-port 8081
  377. ```
  378. #### Bridge advanced flags
  379. | Flag | Default | Description |
  380. | ------ | --------- | ------------- |
  381. | `--transport` | `stdio` | `stdio` (AI tools), `streamable-http` (web clients), `sse` (deprecated) |
  382. | `--mcp-host` | `127.0.0.1` | Bind host for HTTP transports |
  383. | `--mcp-port` | — | Port for HTTP transports |
  384. | `--lazy` | (default) | Load only the default tool groups on connect, and let the model pull in the rest with `search_tools`/`load_tool_group`. |
  385. | `--project` | unset | Exact project name to select at startup, including when multiple instances are running. Overrides `GHIDRA_MCP_PROJECT`. |
  386. | `--no-lazy` | off | Load all tool groups immediately on connect. Needed only by MCP clients that ignore `tools/list_changed`; **rejected outright by the Gemini API** (see below). |
  387. | `--default-groups` | `listing,function,program` | Comma-separated groups loaded on connect under `--lazy`. |
  388. | `--tools-page-size` | `0` | Serve `tools/list` in pages of this size (`0` = one page). Only for a client that cannot take one large response; a client that ignores `nextCursor` sees only the first page. |
  389. | `--json-response` | off | streamable-http: answer POSTs with plain JSON instead of an SSE stream. Server-initiated messages such as `tools/list_changed` are then not delivered. |
  390. | `--stateless-http` | off | streamable-http: no session id and no server-initiated notifications, for running several bridge workers behind a load balancer. Pair it with `--no-lazy`, since a group loaded later can never be announced. |
  391. To require a token from MCP clients of an HTTP transport, set
  392. `GHIDRA_MCP_INBOUND_TOKEN=<secret>`; clients must then send
  393. `Authorization: Bearer <secret>`. The bridge logs a warning when it binds a
  394. non-loopback `--mcp-host` without one. Separately, when `GHIDRA_MCP_AUTH_TOKEN`
  395. (the token the bridge sends to Ghidra) is set and the bridge binds a
  396. non-loopback host, clients must present that same token, so the bridge cannot
  397. be used to relay it.
  398. #### Lazy tool loading is the default (issue #440)
  399. Advertising all 220 endpoints in a single `tools/list` is over a hard limit for
  400. at least one major provider. Gemini compiles function declarations into a
  401. constrained-decoding state machine and rejects the whole request before any tool
  402. is ever called:
  403. ```text
  404. 400 INVALID_ARGUMENT
  405. The specified schema produces a constraint that has too many states for serving
  406. ```
  407. That is not a degradation, it is an outright break, and no client-side setting
  408. could work around a server that only ever offered the full set. So the bridge
  409. now loads `listing,function,program` (70 endpoints plus the 8 static tools) on
  410. connect and registers the rest on demand.
  411. **If your client ignores `tools/list_changed`** it will not notice tools that
  412. are registered later, and should turn lazy loading off:
  413. ```bash
  414. uv run bridge-mcp-ghidra --no-lazy # when you control the command line
  415. export GHIDRA_MCP_LAZY=0 # when you don't (Docker, uvx, some client configs)
  416. ```
  417. `GHIDRA_MCP_LAZY` accepts `0/false/no/off` and `1/true/yes/on`; an explicit
  418. `--lazy`/`--no-lazy` on the command line wins over it. Startup logs which mode
  419. is in effect.
  420. #### Strict program routing (multi-program safety)
  421. Set `GHIDRA_MCP_REQUIRE_PROGRAM_SELECTORS=1` to make the bridge refuse any program-scoped
  422. call that omits a program selector, returning a clear error instead of letting the call
  423. ride the server's shared "current program" (the one `switch_program` and the
  424. active GUI tab move).
  425. ```bash
  426. export GHIDRA_MCP_REQUIRE_PROGRAM_SELECTORS=1
  427. uv run bridge-mcp-ghidra
  428. ```
  429. Without this, a call that leaves `program=` out runs against whichever program
  430. is current, which is fine for a single-program workflow but a hazard once
  431. several programs are open: the call can read or edit the wrong binary with no
  432. error. The hazard is worse when more than one client shares a server, since
  433. each one moves that current-program global out from under the others.
  434. With strict mode on, every program-scoped call must name its target. This
  435. covers every selector that picks an open program: plain `program=` and the
  436. cross-program tools' `source_program`/`target_program` or `program_a`/`program_b`
  437. (declared required, but the server still falls back to the current program when
  438. one arrives empty). A forgotten selector surfaces as a loud error on the first
  439. bad call instead of a silent write to the wrong binary. Tools with no program
  440. selector (`open_program` and `close_program` take `path`/`name`) are unaffected.
  441. Off by default: with the variable unset the bridge sends calls unchanged.
  442. #### Reducing tool-context overhead
  443. The bridge exposes a large catalog, so it loads only `listing,function,program`
  444. on connect (see above) and lets the model **discover** the rest on demand
  445. instead of registering everything:
  446. - `search_tools("rename function")` — keyword-search the **entire** catalog,
  447. including tools whose group isn't loaded. Each result says whether it's
  448. callable now and, if not, the exact `load_tool_group(...)` call to enable it.
  449. - `list_tool_groups()` — list all categories and their load state.
  450. - `load_tool_group("datatype")` / `unload_tool_group("datatype")` — load or
  451. drop a category at runtime.
  452. - `check_tools("rename_symbol,batch_set_comments")` — confirm specific tools
  453. are callable right now.
  454. To select a project before the client discovers tools, use
  455. `bridge-mcp-ghidra --project MyProject --no-lazy`, or set
  456. `GHIDRA_MCP_PROJECT=MyProject` and `GHIDRA_MCP_LAZY=0` in the client's environment.
  457. Project names are matched exactly. A missing or ambiguous match leaves the bridge
  458. disconnected; background retries retain the selector. Blank environment values mean
  459. unset, and a blank `--project` is rejected. Without a selector, auto-connect behavior
  460. is unchanged. For TCP-only servers, `GHIDRA_MCP_URL` limits project discovery to that
  461. listener; otherwise the usual local TCP discovery range is searched.
  462. `search_tools` works in both lazy and `--no-lazy` modes, so agents that honor
  463. `tools/list_changed` get full discovery without the upfront context cost.
  464. #### Minimal read-only allowlist
  465. Some MCP clients gate tools through an explicit allowlist. Cut it too far and
  466. the agent loses **discovery** — it cannot find entry points or enumerate
  467. functions through MCP, so it works around the allowlist by `curl`-ing the HTTP
  468. API on `127.0.0.1:8089` directly, which defeats the point of having one. The
  469. allowlist has to be small *and* self-sufficient.
  470. **Minimum viable read-only set (4 tools):**
  471. | Tool | Group | What it buys you |
  472. | --- | --- | --- |
  473. | `get_metadata` | `program` | Which binary is loaded — name, architecture, image base, function count. Orientation, and it confirms the bridge reached Ghidra at all. |
  474. | `find_functions` | `listing` | Paginated function enumeration (`offset`, `limit`); with no filter it lists the whole program, and `name_pattern`/`regex` turn it into a name search. **This is the discovery tool** — without it the agent cannot answer "what is in this binary". |
  475. | `get_entry_points` | `listing` | Where execution starts, so analysis has a root to work down from. |
  476. | `get_functions` | `function` | The payload. Takes `function=` (name or address) **or** `functions=` (comma-separated names *or* addresses, up to 20), and `fields=` to pick what comes back: `decompiled_code`, `signature`, `callers`, `callees`, `xrefs`, `comments`, and more. |
  477. That set is genuinely closed: `get_entry_points` and `find_functions` supply the
  478. addresses and names that `get_functions` consumes, and its `callees` field names
  479. the next functions to feed straight back into it.
  480. The three tools suggested in [#441](https://github.com/bethington/ghidra-mcp/issues/441)
  481. were `get_metadata`, `get_entry_points` and `decompile_function`. The first two
  482. still exist under those names; `decompile_function` was folded into
  483. `get_functions` in 7.0.0 (`fields=decompiled_code`), and
  484. [the migration guide](docs/project-management/MIGRATION_7.0.0_TOOL_CONSOLIDATION.md)
  485. maps every other removed name. `find_functions` is the one addition worth
  486. making: without it the agent can only reach code that is reachable by name from
  487. something it already decompiled, so anything not referenced from an entry point
  488. is invisible.
  489. **Useful next additions, in order:**
  490. | Tool | Group | Why |
  491. | --- | --- | --- |
  492. | `get_function_call_graph` | `xref` | A multi-level call graph (`depth`, `direction`) in one call. One level of callers and callees already comes from `get_functions`. |
  493. | `get_xrefs_to` | `xref` | Who touches this address — the standard question about a global. Takes `addresses=` for several at once. |
  494. | `list_strings` | `listing` | Strings are the cheapest orientation signal in an unknown binary. |
  495. | `list_program_items` | `listing` | `kind=imports` / `kind=exports`: the binary's external surface. Other kinds list segments, classes, namespaces, data items and external locations. |
  496. Every tool above is a `GET`; none of them writes to the Ghidra database.
  497. **Two things to check when your allowlist is narrow:**
  498. - **Groups, not just names.** The bridge registers tools by *group*, and the
  499. group is the `category` on the Java `@McpTool` annotation (which the running
  500. server publishes at `/mcp/schema`) — not the `category` field in
  501. `tests/endpoints.json`, which is a separate hand-maintained column and does
  502. not always agree. All four tools in the minimum set fall inside the default
  503. `listing,function,program` groups, so they are registered even under `--lazy`.
  504. Of the additions above, only the `xref` ones fall outside: under `--lazy` you
  505. must either allow `load_tool_group` as well, or start the bridge with
  506. `--default-groups listing,function,program,xref`.
  507. - **A narrow allowlist plus `--lazy` needs the group tools.** If you allowlist
  508. only leaf tools and run lazily, the agent has no way to load anything else.
  509. Either run eagerly (`--no-lazy`; lazy is the default) or add `search_tools`,
  510. `list_tool_groups`, `load_tool_group`, and `check_tools` to the allowlist.
  511. Verify any allowlist against the running server rather than against this table:
  512. `curl http://127.0.0.1:8089/mcp/schema` lists every tool with the `category`
  513. the bridge groups it by.
  514. #### Optional: Connect an external debugger server
  515. The bridge can proxy 22 `debugger_*` tools to an external dbgeng/WinDbg
  516. debugger server speaking the bridge's debugger HTTP API. That server is **not
  517. part of this repository**; this repo ships only the proxies. They are **off by
  518. default** and register only when you opt in:
  519. ```bash
  520. # point the bridge at your debugger server (loopback only)
  521. export GHIDRA_DEBUGGER_URL=http://127.0.0.1:8099
  522. # or force registration against the default URL (http://127.0.0.1:8099)
  523. export GHIDRA_DEBUGGER_TOOLS=1
  524. ```
  525. `GHIDRA_DEBUGGER_TOOLS` decides outright when set: `1`/`true`/`yes`/`on`
  526. registers the tools, anything else (`0`, `false`, ...) keeps them off even with
  527. a URL configured. With neither variable set the tools simply do not appear,
  528. rather than appearing and failing. The host platform plays no part.
  529. Ghidra's own TraceRmi debugger endpoints (`debugger_status`, `debugger_launch`,
  530. ...) are separate: they live in the GUI plugin and need no extra server.
  531. Calls are only ever proxied to a loopback URL (`127.0.0.1`, `localhost` or
  532. `::1`), so a non-loopback `GHIDRA_DEBUGGER_URL` does not register the tools. To
  533. reach a debugger server on another machine, forward its port to loopback (for
  534. example an SSH tunnel) and point `GHIDRA_DEBUGGER_URL` there.
  535. The bridge reads these from its own process environment (the MCP client's
  536. `env` block, or your shell); it does not read a `.env` file.
  537. #### In Ghidra
  538. 1. Start Ghidra and open your project
  539. 2. In the **project window**, enable the plugin via **File > Configure > Utility > Configure > GhidraMCPPlugin** (this is what `deploy` does; enabling it in CodeBrowser also works, but then the server runs only while CodeBrowser is open)
  540. 3. Optional: configure a custom port via **Edit > Tool Options > GhidraMCP HTTP Server** in the same window
  541. 4. The server starts with the plugin; check it via **Tools > GhidraMCP > Server Status**
  542. 5. The server runs on `http://127.0.0.1:8089/` by default
  543. Screenshots of every step: [docs/INSTALL_GUI.md](docs/INSTALL_GUI.md).
  544. #### Verify It's Working
  545. ```bash
  546. # Quick health check
  547. curl http://127.0.0.1:8089/check_connection
  548. # Expected: {"status": "ok", "server_kind": "gui", "version": "7.0.0", "program": "<name>"}
  549. # ("program" appears only while a program is current)
  550. # Fuller health: build details, uptime, open program count, HTTP pool, memory
  551. curl http://127.0.0.1:8089/mcp/health
  552. # Every tool the server advertises
  553. curl -s http://127.0.0.1:8089/mcp/schema | jq '.tools | length'
  554. ```
  555. ## Support This Project
  556. If Ghidra MCP saves you engineering or reverse-engineering time, consider [sponsoring the project](https://github.com/sponsors/bethington).
  557. - One-time sponsorship helps fund fixes, compatibility updates, and release work.
  558. - Recurring sponsorship helps keep maintenance, docs, and production hardening moving.
  559. - Company support helps prioritize long-term reliability for the bridge, headless server, debugger integration, and workflow tooling.
  560. ## 🔒 Security
  561. GhidraMCP is designed for **localhost-only development**. The default configuration — HTTP server bound to `127.0.0.1`, no authentication — is safe on a trusted single-user workstation and matches pre-v5.4.1 behavior.
  562. **If you expose the server beyond loopback, configure these three environment variables first.** The server refuses to start on a non-loopback bind without a token.
  563. | Env var | Effect |
  564. | --- | --- |
  565. | `GHIDRA_MCP_AUTH_TOKEN` | When set, every HTTP request must carry `Authorization: Bearer <token>`. Timing-safe comparison. `/mcp/health` and `/check_connection` are exempt. |
  566. | `GHIDRA_MCP_ALLOW_SCRIPTS` | Set to `1`, `true`, or `yes` to enable `/run_script_inline` and `/run_ghidra_script`. **Off by default as of v5.4.1** — these endpoints execute arbitrary Java against the Ghidra process. In headless mode this also triggers OSGi `BundleHost` initialization at server startup (Felix framework, ~hundreds of ms); leave it off if you don't need script execution. |
  567. | `GHIDRA_MCP_FILE_ROOT` | When set to a directory path, filesystem-path endpoints (`/import_file`, `/open_project`, `/delete_file`, etc.) canonicalize the input and require it to fall under this root. Prevents path-traversal. |
  568. Name-quality enforcement is separate from security. By default,
  569. `rename_function` and global write endpoints reject names that fail
  570. the built-in quality gates, and struct field writes apply the built-in field
  571. prefix convention. Disable the built-in convention layer with **Edit > Tool
  572. Options > GhidraMCP HTTP Server > Strict Naming Enforcement**. The same Tool
  573. Options checkbox covers `rename_symbol` (all symbol kinds),
  574. `set_global`, the `apply_data_type` prefix/type guard, and struct-field
  575. Hungarian prefix auto-fixes in `create_struct`, `add_struct_field`, and
  576. `modify_struct_field`. The setting is read when the MCP server starts or
  577. restarts. Function/global convention warnings are still returned when
  578. enforcement is disabled.
  579. ### Example: exposing to a private LAN with auth
  580. ```bash
  581. export GHIDRA_MCP_AUTH_TOKEN=$(openssl rand -hex 32)
  582. export GHIDRA_MCP_ALLOW_SCRIPTS=1 # only if your workflow needs it
  583. export GHIDRA_MCP_FILE_ROOT=/srv/ghidra/inputs
  584. # Headless server (`mvn clean package -P headless -DskipTests`). The jar does not
  585. # bundle Ghidra, so Ghidra's Framework/Features/Processors jars go on the
  586. # classpath too -- docker/entrypoint.sh builds exactly that command.
  587. java -cp "target/GhidraMCP-<version>.jar:<ghidra jars>" \
  588. com.xebyte.headless.GhidraMCPHeadlessServer --bind 0.0.0.0 --port 8089
  589. ```
  590. The headless server serves only its Unix domain socket unless `--port` or
  591. `--bind` is given; either one adds the TCP listener.
  592. ### Ghidra Server authentication
  593. When connecting to a shared Ghidra Server, GhidraMCP can suppress the password dialog automatically. It resolves credentials in this order (first non-empty value wins):
  594. Compatibility note: Ghidra 12.2 clients require Ghidra Server 12.1, 12.0.5,
  595. or a newer compatible server, and refuse a server whose TLS certificate they
  596. do not trust. Import a self-signed server's certificate on each client with
  597. **Edit > Manage Certificates...**, and on the server side note that a 12.2
  598. server with no `ghidra.keystore` listens on loopback only.
  599. 1. `GHIDRA_SERVER_PASSWORD` environment variable (or `.env` file in the Ghidra install directory or `~`)
  600. 2. `~/.ghidra-cred` — single-line password file in your home directory
  601. 3. `<ghidra-install-dir>/.ghidra-cred`
  602. Username resolves similarly: `GHIDRA_SERVER_USER` env var → `user.name` system property.
  603. If no password is found, Ghidra shows its normal GUI prompt. Set these in `.env` (see `.env.template` for the full block) to enable silent auth.
  604. ### Migration from v5.4.0 → v5.4.1
  605. - **Script endpoints now default-off.** If you relied on `/run_script_inline` or `/run_ghidra_script`, export `GHIDRA_MCP_ALLOW_SCRIPTS=1`. This is a deliberate breaking change; the prior default was unsafe.
  606. - **Localhost-only deployments need no changes.** Auth, bind refusal, and path-root checks are all opt-in.
  607. ## ❓ Troubleshooting
  608. ### `spawn uv ENOENT` / `spawn python ENOENT` when the client starts the server
  609. **Cause:** the MCP client could not find the `command` on **its own** PATH. This
  610. happens before any bridge code runs, so there is nothing in the Ghidra log or
  611. the bridge log to look at — the process was never created.
  612. It shows up when the client is launched by something other than a login shell:
  613. - a **systemd user service** (`systemctl --user`), whose PATH is
  614. `/usr/local/bin:/usr/bin:/bin` unless you extend it;
  615. - a desktop `.desktop` entry, dock icon, or app launcher;
  616. - macOS apps started from Finder, which inherit `launchd`'s PATH.
  617. None of those contain `~/.local/bin` (uv's default install location) or
  618. `~/.cargo/bin`, so `"command": "uv"` cannot resolve even though `uv` works
  619. perfectly in your terminal.
  620. **Solution:** use an absolute path in the client config.
  621. ```jsonc
  622. // before — resolves against the client's PATH, fails under a service/GUI launcher
  623. "command": "uv"
  624. // after — no PATH lookup at all
  625. "command": "/home/<you>/.local/bin/uv"
  626. ```
  627. Find yours with `which uv` (POSIX) or `where.exe uv` (Windows). Or run:
  628. ```bash
  629. python -m tools.setup preflight
  630. ```
  631. which prints the resolved absolute path, the PATH entries it searched when a
  632. launcher is missing, and a ready-to-paste config snippet. Note what that check
  633. can and cannot tell you: it resolves against **your shell's** PATH, not the
  634. client's, so a pass there is evidence, not proof — the absolute path is what
  635. actually removes the failure mode. ([#441](https://github.com/bethington/ghidra-mcp/issues/441))
  636. If you must keep a bare command name, give the service manager the PATH instead
  637. — e.g. `Environment="PATH=%h/.local/bin:/usr/local/bin:/usr/bin:/bin"` in the
  638. unit file, or `systemctl --user import-environment PATH` — but the absolute
  639. path is the smaller and more portable fix.
  640. ### "GhidraMCP" menu not appearing in Tools
  641. **Cause:** Plugin not enabled or installed incorrectly.
  642. **Solution:**
  643. 1. Verify extension is installed: **File > Install Extensions** — GhidraMCP should be listed
  644. 2. Enable the plugin: **File > Configure > Utility > Configure > GhidraMCPPlugin** (check the box)
  645. 3. **Restart Ghidra** after installation/enabling
  646. Illustrated walkthrough: [docs/INSTALL_GUI.md](docs/INSTALL_GUI.md).
  647. ### Server not responding / Connection refused
  648. **Cause:** Server not started or wrong port.
  649. **Solution:**
  650. 1. Check the server state: **Tools > GhidraMCP > Server Status** (it starts with the plugin; use **Restart Server** if it is stopped)
  651. 2. Check configured port: **Edit > Tool Options > GhidraMCP HTTP Server**
  652. 3. Check if port is in use:
  653. ```bash
  654. # Linux/macOS
  655. lsof -i :8089
  656. # Windows
  657. netstat -ano | findstr :8089
  658. ```
  659. 4. Look for errors in Ghidra console: **Window > Console**
  660. ### `pip install` fails with `error: externally-managed-environment`
  661. **Cause:** PEP 668. Debian-family distros (Debian 12+, Kali, Ubuntu 23.04+)
  662. mark the system Python as externally managed, so global `pip install` is
  663. blocked to protect apt-managed packages.
  664. **Solution:** Use a virtual environment — never `--break-system-packages`.
  665. The recommended path is [uv](https://docs.astral.sh/uv/), which manages a
  666. project-local `.venv` automatically:
  667. ```bash
  668. curl -LsSf https://astral.sh/uv/install.sh | sh
  669. cd ghidra-mcp
  670. uv run bridge-mcp-ghidra
  671. ```
  672. Or a classic venv:
  673. ```bash
  674. python3 -m venv .venv && source .venv/bin/activate
  675. pip install -e .
  676. bridge-mcp-ghidra
  677. ```
  678. ### The `debugger_*` tools do not appear
  679. **Cause:** The 22 bridge-side debugger proxies are off by default. They register
  680. only when `GHIDRA_DEBUGGER_URL` is set or `GHIDRA_DEBUGGER_TOOLS=1`, and they
  681. forward to an external debugger server that is not part of this repository.
  682. **Solution:** start your debugger server, then set the URL before launching the
  683. bridge:
  684. ```text
  685. export GHIDRA_DEBUGGER_URL=http://127.0.0.1:8099
  686. ```
  687. If the tools appear but every call reports that the server is not running,
  688. the URL is wrong or the server is down. `GHIDRA_DEBUGGER_TOOLS=0` turns them off
  689. again even with a URL configured.
  690. ### 500 Internal Server Errors
  691. **Cause:** Server-side exception, often due to missing program data.
  692. **Solution:**
  693. 1. Ensure a binary is loaded in CodeBrowser
  694. 2. Run auto-analysis first: **Analysis > Auto Analyze**
  695. 3. Check Ghidra console (**Window > Console**) for Java exceptions
  696. 4. Some operations require fully analyzed binaries
  697. ### 404 Not Found Errors
  698. **Cause:** Endpoint doesn't exist or wrong URL.
  699. **Solution:**
  700. 1. Verify the endpoint exists: `curl -s http://127.0.0.1:8089/mcp/schema` lists every tool the server advertises
  701. 2. Check for typos in endpoint name
  702. 3. Ensure you're using correct HTTP method (GET vs POST)
  703. 4. If a script or prompt calls a tool that worked before 7.0.0 (`decompile_function`, `list_functions`, `search_functions`, `get_function_callers`, `list_imports`, ...), it was consolidated: the [7.0.0 migration guide](docs/project-management/MIGRATION_7.0.0_TOOL_CONSOLIDATION.md) names the replacement for every removed tool
  704. 5. Some routes exist on only one server: `/debugger/*` and `/tool/*` are GUI-only, and `/create_project`, `/close_project`, `/delete_project` and `/list_projects` are headless-only (see the API Reference)
  705. ### Python Ghidra scripts fail with "No script provider found"
  706. **Cause:** In Ghidra 12.2, Jython support is no longer enabled by
  707. default. `.py` scripts need the bundled Jython extension; Python 3
  708. scripts should use PyGhidra instead of the Ghidra Script Manager.
  709. **Solution:**
  710. 1. In the Ghidra Front End, open **File > Install Extensions**.
  711. 2. Check **Jython**, restart Ghidra, then refresh Script Manager.
  712. 3. For new automation, prefer Java Ghidra scripts or PyGhidra.
  713. ### Extension not appearing in Install Extensions
  714. **Cause:** JAR file in wrong location.
  715. **Solution:**
  716. 1. Manual install location: `~/.config/ghidra/ghidra_12.2_PUBLIC/Extensions/GhidraMCP/lib/GhidraMCP.jar`
  717. (`%APPDATA%\ghidra\...` on Windows, `~/Library/ghidra/...` on macOS)
  718. 2. Or use: **File > Install Extensions > Add** and select the ZIP file — see the
  719. [illustrated guide](docs/INSTALL_GUI.md)
  720. 3. Ensure JAR/ZIP was built for your Ghidra version
  721. ### Build fails with "Ghidra dependencies not found"
  722. **Cause:** Ghidra JARs not installed in local Maven repository (Maven backend only; Gradle reads them straight from the installation).
  723. **Solution:**
  724. ```text
  725. # Windows (recommended)
  726. python -m tools.setup install-ghidra-deps --ghidra-path "C:\ghidra_12.2_PUBLIC"
  727. ```
  728. Under Gradle, a wall of `package ghidra.program.model.address does not exist`
  729. errors instead means `-PGHIDRA_INSTALL_DIR` resolved to nothing — in Git Bash,
  730. write the path with forward slashes.
  731. ## 📊 Production Performance
  732. - **MCP Tools**: 219 tools fully implemented (the whole catalog; the GUI plugin serves 216 of them and the headless server 201)
  733. - **Speed**: Sub-second response for most operations
  734. - **Efficiency**: 93% reduction in API calls via batch operations
  735. - **Reliability**: Atomic transactions with all-or-nothing semantics
  736. - **AI Workflows**: Proven documentation prompts refined across hundreds of real functions
  737. - **Deployment**: Automated version-aware deployment script
  738. ## 🛠️ API Reference
  739. <!-- BEGIN GENERATED API REFERENCE (tools/gen_readme_api_reference.py) -->
  740. 219 MCP tools backed by HTTP endpoints, grouped by catalog category. Generated from [tests/endpoints.json](tests/endpoints.json) by `python -m tools.gen_readme_api_reference --write`; the live schema at `/mcp/schema` is authoritative at runtime. Usage patterns: [docs/prompts/TOOL_USAGE_GUIDE.md](docs/prompts/TOOL_USAGE_GUIDE.md).
  741. 196 of these are served by both the GUI plugin and the standalone headless server. The rest are marked **(GUI only)** (19) or **(headless only)** (4) — calling one against the other server returns a 404, not an error message. See `python -m tools.audit_server_scope` for how the split is derived.
  742. ### Program & Session Management
  743. - `analysis_status` - Get auto-analysis status for open programs
  744. - `close_program` - Close an open program by project path or name
  745. - `create_memory_block` - Create memory block, optionally initialized with byte contents (hex or base64)
  746. - `create_property_map` - Create a user property map to store typed values keyed by address
  747. - `delete_bookmark` - Delete bookmark
  748. - `delete_property_map` - Delete a user property map and all values it holds
  749. - `exit_ghidra` - Save and exit Ghidra
  750. - `get_address_spaces` - List all physical and overlay address spaces in the program (overlays include is_overlay flag and overlayed_space name)
  751. - `get_change_token` - Return the program's change token: '<saved time>:<open epoch>:<modification number>'
  752. - `get_language_metadata` - Dump the program's language description: address spaces, registers, default symbols, endianness, pointer size (issue #192)
  753. - `get_metadata` - Get program metadata
  754. - `get_program_options` - Read all options in a program option group with types, current values, defaults, and descriptions
  755. - `get_property` - Read the value stored at an address in a property map
  756. - `import_file` - Import a binary file from disk into the current Ghidra project and open it
  757. - `list_bookmarks` - List bookmarks
  758. - `list_open_programs` - List open programs
  759. - `list_project_files` - List project files
  760. - `list_properties` - List (address, value) entries stored in a property map, with pagination
  761. - `list_scripts` - List available Ghidra scripts
  762. - `open_program` - Open program from project
  763. - `read_memory` - Read raw memory
  764. - `reanalyze` - Trigger full auto-analysis on a program
  765. - `remove_program_option` - Remove an option from a program option group
  766. - `remove_property` - Remove the value stored at a single address in a property map
  767. - `run_ghidra_script` - Run script with output capture
  768. - `run_script_inline` - Run inline script code
  769. - `save_all_programs` - Save all open programs
  770. - `save_program` - Save current program
  771. - `set_bookmark` - Set bookmark
  772. - `set_image_base` - Set the base address of the program (rebases all addresses)
  773. - `set_memory_block` - Change an existing memory block's permissions or volatility
  774. - `set_program_option` - Set a typed program option
  775. - `set_property` - Set a value at an address in a property map
  776. - `switch_program` - Switch current program
  777. ### Project Organization
  778. - `archive_project` - Archive the currently open project to a Ghidra-native .gar file
  779. - `create_folder` - Create a folder in the project
  780. - `delete_file` - Delete a file from the project
  781. - `delete_project` - Delete a Ghidra project **(headless only)**
  782. - `export_program` - Export an open or project-resident program to a Ghidra Zip File (.gzf)
  783. - `get_project_info` - Get info about the currently open project
  784. - `import_program` - Import a Ghidra Zip File (.gzf) into the currently open project as a new DomainFile under target_folder (default '/')
  785. - `list_projects` - List available Ghidra projects **(headless only)**
  786. - `move_file` - Move a program file to a different folder in the project, preserving analysis and documentation
  787. - `move_folder` - Move a project folder and everything under it into another folder
  788. - `restore_project` - Restore a Ghidra .gar archive into a fresh on-disk project at `parent_dir/project_name`
  789. ### Headless Project & Program Lifecycle
  790. Available on the standalone headless server (`GhidraMCPHeadlessServer`).
  791. - `close_project` - Close the currently open project **(headless only)**
  792. - `create_project` - Create a new Ghidra project **(headless only)**
  793. - `open_project` - Open an existing Ghidra project (.gpr file or directory)
  794. ### Listing & Enumeration
  795. - `convert_number` - Convert number between bases
  796. - `find_functions` - Find functions: every filter is optional, so with none it lists the whole program a page at a time
  797. - `get_entry_points` - Get program entry points
  798. - `get_external_location` - Get external location details
  799. - `get_function_count` - Return the number of functions in the loaded program
  800. - `list_calling_conventions` - List available calling conventions
  801. - `list_data_items_by_xrefs` - List data sorted by xref count
  802. - `list_globals` - List global variables
  803. - `list_program_items` - List one kind of program inventory with pagination
  804. - `list_shadowed_globals` - List named global DATA symbols that have NO type of their own because a larger data unit starting at an earlier address covers them
  805. - `list_strings` - List defined strings
  806. - `search_strings` - Search defined strings by a regex/substring pattern
  807. - `set_equate` - Apply, remove or rename equates
  808. ### Current GUI Context
  809. - `get_ui_cursor` - What the analyst is looking at right now: cursor address, the function under it, the listing selection, and the focused program — one call instead of four
  810. ### Functions: Decompile, Rename, Prototypes & Variables
  811. - `add_function_tag` - Attach tags to ONE function (function + tags) OR MANY in one transaction (assignments=[{function,tags}, ...])
  812. - `batch_rename_function_components` - Batch rename function components
  813. - `clear_flow_and_repair` - Run Ghidra's GUI 'Clear Flow and Repair' action on a seed range: clears instruction flow reachable from the seed, then repairs function bodies and re-disassembles retained flow (ClearFlowAndRepairCmd with clear_data=false, clear_labels=false, repair=true)
  814. - `clear_instruction_flow_override` - Clear flow override
  815. - `create_function` - Create function at address
  816. - `delete_function` - Delete function at address
  817. - `delete_function_tag` - Delete a program-wide function tag definition
  818. - `disassemble_bytes` - Disassemble byte range
  819. - `disassemble_function` - Disassemble function
  820. - `force_decompile` - Force fresh decompilation (output stamped with language_id + variant; optional variant= is checked against the loaded one)
  821. - `get_functions` - Everything about one or many functions in a single call
  822. - `list_class_members` - List the member functions of a C++ class
  823. - `list_function_tags` - List all program-wide function tag definitions with their use counts
  824. - `remove_function_tag` - Detach one or more tags from a function
  825. - `rename_function` - Rename function by name
  826. - `rename_variables` - Batch rename variables
  827. - `set_function_no_return` - Set no-return attribute
  828. - `set_function_prototype` - Set function prototype (return type, param types, calling convention)
  829. - `set_function_tag_comment` - Update the comment/description on an existing program-wide function tag
  830. - `set_function_this_type` - Set the decompiler/database type of the implicit 'this' pointer (ECX on x86 __thiscall/__fastcall)
  831. - `set_variable_storage` - Set variable storage
  832. - `set_variable_type` - Set the data type of a function variable (local OR parameter) by name at the decompiler (high-level) layer
  833. - `set_variables` - Set types and names for multiple variables in a single transaction
  834. ### Symbols, Labels & Globals
  835. - `can_rename_at_address` - Check if address can be renamed
  836. - `create_label` - Create label
  837. - `delete_label` - Delete label at address
  838. - `rename_symbol` - Rename a symbol of any kind
  839. ### Cross-References & Call Graphs
  840. - `add_memory_reference` - Create a user-defined cross-reference between two memory addresses that the auto-analyzer can't infer (runtime-populated pointer tables, vtables, late-bound function pointers, missed jump/switch tables)
  841. - `analyze_call_graph` - Analyze function call graph patterns
  842. - `get_assembly_context` - Get assembly context
  843. - `get_full_call_graph` - Get full call graph
  844. - `get_function_call_graph` - Get call graph
  845. - `get_xrefs_from` - Get references from address
  846. - `get_xrefs_to` - Get references to address
  847. - `remove_reference` - Remove memory cross-reference(s) from one address to another — the inverse of add_memory_reference
  848. ### Data Types & Structures
  849. - `add_struct_field` - Add struct field
  850. - `analyze_global_completeness` - Score a global variable's documentation completeness on a budgeted 0-100 scale — the data-address analog of analyze_function_completeness
  851. - `analyze_struct_field_usage` - Analyze struct field usage
  852. - `apply_data_classification` - Apply data classification
  853. - `apply_data_type` - Apply data type
  854. - `audit_global` - Audit a global variable's documentation state
  855. - `audit_globals_in_function` - Audit every global variable referenced from within a function in one call
  856. - `clone_data_type` - Clone data type
  857. - `create_data_type_category` - Create data type category
  858. - `create_derived_type` - Create a type built on another: a typedef alias, an array or a pointer
  859. - `create_enum` - Create enumeration
  860. - `create_function_signature` - Create function signature type
  861. - `create_struct` - Create structure
  862. - `create_union` - Create union
  863. - `delete_data_type` - Delete data type
  864. - `find_data_types` - Find data types by name or path pattern, category and kind, one record per type (name, kind, category, size, path)
  865. - `find_type_users` - Functions whose decompilation references a data type (or one of its fields)
  866. - `get_enum_values` - Get enumeration values
  867. - `get_struct_layout` - Get structure layout
  868. - `get_type_size` - Get data type size and info
  869. - `get_valid_data_types` - Get valid data type names
  870. - `import_data_types` - Import data types from GDT
  871. - `modify_struct_field` - Modify a field in a structure: retype it (new_type, which also embeds a struct by value, e.g
  872. - `move_data_type_to_category` - Move data type to category
  873. - `recreate_struct` - Replace a structure in one step: optionally remove an existing same-named type, then create with fields JSON (same shape as create_struct)
  874. - `remove_struct_field` - Remove struct field
  875. - `rename_data_type` - Rename a data type (struct, union, enum, typedef) in place, preserving existing applications of it
  876. - `resize_struct` - Grow or shrink an existing structure by total byte size
  877. - `resolve_duplicate_type` - Find duplicate data types by simple name; delete unused /Demangler size-1 stubs when a larger canonical type exists
  878. - `set_global` - Atomically apply name + type + plate-comment + array length to a global variable
  879. - `suggest_field_names` - Suggest field names
  880. - `validate_data_type` - Validate data type syntax
  881. - `validate_function_prototype` - Validate function prototype
  882. ### Comments
  883. - `batch_set_comments` - Set multiple comments
  884. - `clear_function_comments` - Clear all comments for a function
  885. - `get_comment` - Get listing comments (plate/pre/eol/post/repeatable) at ANY address, including data addresses (works on functions and data globals alike), for ONE address (address=) or MANY in one call (addresses=a,b,c)
  886. - `set_comment` - Set a listing comment of a given kind (plate/pre/eol/post/repeatable) at ANY address, including data addresses
  887. ### Analysis
  888. - `analyze_control_flow` - Analyze control flow
  889. - `analyze_data_region` - Analyze data region
  890. - `analyze_dataflow` - Trace value propagation through a function (PCode graph, forward/backward)
  891. - `analyze_for_documentation` - Composite RE documentation analysis (decompile + classify + variables + completeness); decompiled_code is stamped with language_id + variant, and withheld if a supplied variant= contradicts the program
  892. - `analyze_function_complete` - Comprehensive single-call function analysis
  893. - `analyze_function_completeness` - Analyze documentation completeness
  894. - `apply_documentation` - Apply documentation to ONE function (fields at the top level) OR MANY (entries=[{address, ...}, ...])
  895. - `configure_analyzer` - Configure an analysis plugin
  896. - `detect_array_bounds` - Detect array bounds
  897. - `find_code_gaps` - Find gaps of undefined bytes between functions in executable memory
  898. - `find_dead_code` - Find dead code
  899. - `find_next_undefined_function` - Find next undefined function
  900. - `find_similar_functions` - Find similar functions
  901. - `get_field_access_context` - Get field access context
  902. - `get_function_pcode` - Dump raw P-code for a function (issue #192)
  903. - `inspect_memory_content` - Inspect memory bytes
  904. - `list_analyzers` - List available analysis plugins
  905. - `partition_program` - Group a program's functions into compartments so you can decide which regions to ignore before reading any of them — on a driver DLL the two library compartments were 42% of the binary and identifiable from their referenced strings alone
  906. - `run_analysis` - Run auto-analysis on the current program
  907. - `search_byte_patterns` - Search for byte patterns
  908. - `search_instructions` - Search for instructions by mnemonic and/or operand substring
  909. ### Malware & Anti-Analysis
  910. - `analyze_api_call_chains` - Analyze API call chains
  911. - `detect_crypto_constants` - Detect crypto constants
  912. - `detect_malware_behaviors` - Detect malware behaviors
  913. - `extract_iocs_with_context` - Extract IOCs with context
  914. - `find_anti_analysis_techniques` - Find anti-analysis techniques
  915. ### Cross-Binary Documentation & Archive
  916. - `archive_ingest_function` - Ingest a single function's documentation into the cross-version archive (the doc archive service configured via GHIDRA_MCP_ARCHIVE_URL)
  917. - `archive_ingest_program` - Bulk-ingest every function in a program into the cross-version documentation archive
  918. - `batch_string_anchor_report` - Report of source file strings and their FUN_* functions
  919. - `bulk_fuzzy_match` - Bulk cross-binary function matching
  920. - `compare_programs_documentation` - Compare documentation across programs
  921. - `diff_functions` - Diff two functions
  922. - `find_similar_functions_fuzzy` - Cross-binary fuzzy function matching
  923. - `find_undocumented_by_string` - Find undocumented functions referencing string
  924. - `get_function_documentation` - Export function documentation
  925. - `get_function_hash` - Compute the normalized opcode hash of ONE function (function=), or of MANY in one call by omitting it: every function, paged, optionally only the documented or undocumented ones (filter=)
  926. - `merge_program_documentation` - Bulk merge: copy all RE documentation (function names, signatures, plate comments, instruction comments at EOL/PRE/POST, non-default labels & global symbols) from one program to another at matching addresses
  927. ### Health, Schema & Tool Control
  928. - `check_connection` - Liveness probe: {status, server_kind (gui/headless), version, program when one is current}
  929. - `mcp_health` - Server health: kind (gui/headless), build, current program, uptime, HTTP pool, memory, endpoint count
  930. - `mcp_schema` - Machine-readable API schema with endpoint metadata
  931. - `tool_goto_address` - Navigate CodeBrowser listing and decompiler to a specific address **(GUI only)**
  932. - `tool_running_tools` - List all running Ghidra tool windows **(GUI only)**
  933. ### Emulation
  934. - `emulate_function` - Emulate a single function with controlled register/memory inputs
  935. - `emulate_hash_batch` - Brute-force API hash resolution
  936. ### Ghidra Server & Version Control
  937. - `checkin_program` - Check an open program back in to the shared Ghidra Server as a new version
  938. - `server_admin_set_permissions` - Set user permissions on a repository
  939. - `server_admin_terminate_all_checkouts` - Terminate all checkouts in a folder recursively
  940. - `server_admin_terminate_checkout` - Terminate all checkouts on a single file
  941. - `server_admin_users` - List all users on the server
  942. - `server_authenticate` - Register server credentials for programmatic authentication
  943. - `server_checkouts` - List all checked-out files in a folder, including server-side checkouts
  944. - `server_connect` - Report/establish the Ghidra server connection
  945. - `server_disconnect` - Disconnect from the Ghidra server
  946. - `server_repositories` - List repositories on the connected server
  947. - `server_repository_create` - Create a new repository on the server
  948. - `server_repository_file` - Get file info from a server repository
  949. - `server_repository_files` - List files in a server repository folder
  950. - `server_status` - Check headless server connection status
  951. - `server_version_control_add` - Add a file to version control
  952. - `server_version_control_checkout` - Check out a version-controlled file
  953. - `server_version_control_undo_checkout` - Undo a file checkout
  954. - `server_version_history` - Get version history for a file
  955. ### Debugger (Ghidra TraceRmi)
  956. When the bridge's opt-in WinDbg debugger proxies are enabled (`GHIDRA_DEBUGGER_URL` or `GHIDRA_DEBUGGER_TOOLS=1`), a TraceRmi tool below that shares a proxy's name gets a `_2` suffix (e.g. `debugger_status_2`), so both stay reachable.
  957. - `debugger_dynamic_to_static` - Translate a runtime dynamic address from the current trace back to a static Ghidra program address **(GUI only)**
  958. - `debugger_interrupt` - Interrupt (break into) the running target **(GUI only)**
  959. - `debugger_launch` - Launch an executable through Ghidra's Trace RMI debugger launcher **(GUI only)**
  960. - `debugger_launch_offers` - List available debugger launch/attach options for the current program **(GUI only)**
  961. - `debugger_list_breakpoints` - List all breakpoints in the current trace **(GUI only)**
  962. - `debugger_modules` - List modules (DLLs/EXEs) loaded in the debugged process **(GUI only)**
  963. - `debugger_read_memory` - Read memory from the debugged process **(GUI only)**
  964. - `debugger_registers` - Read CPU registers from the current debug trace snapshot **(GUI only)**
  965. - `debugger_remove_breakpoint` - Remove a breakpoint at an address **(GUI only)**
  966. - `debugger_resume` - Resume execution of the debugged process **(GUI only)**
  967. - `debugger_set_breakpoint` - Set a software execution breakpoint at an address in the trace **(GUI only)**
  968. - `debugger_stack_trace` - Get the call stack backtrace for the current thread **(GUI only)**
  969. - `debugger_static_to_dynamic` - Translate a static Ghidra program address to a runtime dynamic address in the current trace **(GUI only)**
  970. - `debugger_status` - Get debugger status: active trace, thread, execution state, module count **(GUI only)**
  971. - `debugger_step` - Single-step the debugged process: into the next instruction (follows calls), over it (does not follow calls), or out of the current function (run to return) **(GUI only)**
  972. - `debugger_traces` - List all open debug traces **(GUI only)**
  973. ### System
  974. - `prompt_policy` - Temporarily enable, disable, or query scoped automation prompt handling **(GUI only)**
  975. ### Decompile-Tree (uncategorized)
  976. - `decompile_tree_configure` - Change a tree's configuration: exclusions (tag: / partition: / range:), enabled strategies, band size, max file bytes, throttle
  977. - `decompile_tree_create` - Create a decompilation tree: a program's decompiled C materialised as a file tree you can Grep and Glob
  978. - `decompile_tree_delete` - Deregister a tree; with delete_files=true also remove the files it recorded writing, then the directories that leaves empty
  979. - `decompile_tree_pin_module` - Pin a function to a tree compartment forever
  980. - `decompile_tree_run` - Start or stop the sweep that fills a tree
  981. - `decompile_tree_status` - Status, config and root path of a decompilation tree — poll this after decompile_tree_run(action=start), then Grep the reported root
  982. ### Bridge Static Tools
  983. Defined in the Python bridge itself (instance discovery, tool-group management); always available even before a Ghidra connection. The bridge can also proxy 22 `debugger_*` WinDbg tools to an external debugger server; they are off by default and register only when `GHIDRA_DEBUGGER_URL` is set or `GHIDRA_DEBUGGER_TOOLS=1`.
  984. - `check_tools` - Report which tools are currently registered and callable
  985. - `connect_instance` - Connect the bridge to a specific Ghidra instance
  986. - `import_file` - Import a binary from disk into the current project and open it
  987. - `list_instances` - Discover running Ghidra MCP instances (UDS + TCP port scan)
  988. - `list_tool_groups` - List tool groups and their load state
  989. - `load_tool_group` - Register a tool group's dynamic tools with the MCP client
  990. - `search_tools` - Search the full tool catalog by keyword
  991. - `unload_tool_group` - Unregister a tool group's dynamic tools
  992. <!-- END GENERATED API REFERENCE -->
  993. See [CHANGELOG.md](CHANGELOG.md) for version history.
  994. ## 🏗️ Architecture
  995. ```text
  996. ┌─────────────────┐ ┌─────────────────┐ ┌─────────────────┐
  997. │ AI/Automation │◄──►│ MCP Bridge │◄──►│ Ghidra Plugin │
  998. │ Tools │ │ (bridge_mcp_ │ │ (GhidraMCP.jar) │
  999. │ (Claude, etc.) │ │ ghidra/) │ │ │
  1000. └─────────────────┘ └─────────────────┘ └─────────────────┘
  1001. │ │ │
  1002. MCP Protocol HTTP REST Ghidra API
  1003. (stdio/streamable-http) (localhost:8089) (Program, Listing)
  1004. ```
  1005. ### Components
  1006. - **python/bridge_mcp_ghidra/** — Python MCP server package (ships as the `ghidra-mcp-bridge` wheel; `bridge-mcp-ghidra` console script) that translates MCP protocol to HTTP calls (220 catalog entries)
  1007. - **GhidraMCP.jar** — Ghidra plugin that exposes analysis capabilities via HTTP (216 endpoints)
  1008. - **GhidraMCPHeadlessServer** — Standalone headless server — 201 endpoints, no GUI required
  1009. - **python/bridge_mcp_ghidra/** — Python MCP server package (ships as the `ghidra-mcp-bridge` wheel; `bridge-mcp-ghidra` console script) that translates MCP protocol to HTTP calls (220 catalog entries)
  1010. - **GhidraMCP.jar** — Ghidra plugin that exposes analysis capabilities via HTTP (216 endpoints)
  1011. - **GhidraMCPHeadlessServer** — Standalone headless server — 201 endpoints, no GUI required
  1012. - **ghidra_scripts/** — Collection of automation scripts for common tasks
  1013. ## 🔧 Development
  1014. ### Building from Source
  1015. ```bash
  1016. # Recommended: direct Python-first workflow
  1017. python -m tools.setup ensure-prereqs --ghidra-path "C:\ghidra_12.2_PUBLIC"
  1018. python -m tools.setup build
  1019. python -m tools.setup deploy --ghidra-path "C:\ghidra_12.2_PUBLIC"
  1020. # Version bump (updates all maintained version references atomically)
  1021. python -m tools.setup bump-version --new X.Y.Z
  1022. ```
  1023. Both Java backends are maintained. Gradle (`./gradlew`, wrapper committed) is the default for local work and writes to `build/`; CI builds and gates with Maven, which writes to `target/`. `tools.setup` routes through Maven unless `TOOLS_SETUP_BACKEND=gradle`. Three things exist only under Maven: regenerating `tests/endpoints.json` (`mvn test -Dtest=RegenerateEndpointsJson -Dregenerate=true`), the JaCoCo coverage gate, and the `headless`/`docker` build profiles.
  1024. ### Command Reference
  1025. | Command | What it does |
  1026. | --------- | ------------- |
  1027. | `ensure-prereqs` | Install Python deps + Ghidra Maven JARs in one shot. Start here on a new machine. |
  1028. | `preflight` | Validate Python, build tool, Ghidra path, and JAR availability without making changes. Add `--strict` to also check network reachability. |
  1029. | `build` | Build the plugin JAR and extension ZIP via Maven (or Gradle when `TOOLS_SETUP_BACKEND=gradle`). |
  1030. | `deploy` | Copy the built extension into the Ghidra profile and patch `FrontEndTool.xml` for auto-activation. |
  1031. | `start-ghidra` | Launch the configured Ghidra installation. |
  1032. | `clean` | Remove the selected backend's build output (`target/`, or `build/` under Gradle). |
  1033. | `clean-all` | Remove build outputs plus local cache artifacts (`.m2` Ghidra JARs, etc.). |
  1034. | `install-ghidra-deps` | Install only the Ghidra JARs into `~/.m2`. Useful when the build environment changes. |
  1035. | `install-python-deps` | Install the Python dependency groups via `uv sync`. |
  1036. | `run-tests` | Run the backend's whole Java `test` task (`mvn test`, or `gradlew test` under Gradle). The integration classes in it need a live Ghidra on port 8089. |
  1037. | `verify-version` | Check `pom.xml`'s Ghidra version against the `--ghidra-path` installation (same major.minor series passes). |
  1038. | `bump-version --new X.Y.Z` | Atomically update all version references. Pass `--tag` to create a git tag. |
  1039. Common flags accepted by most commands:
  1040. | Flag | Description |
  1041. | ------ | ------------- |
  1042. | `--ghidra-path PATH` | Ghidra installation directory. Defaults to `GHIDRA_PATH` from `.env`. |
  1043. | `--dry-run` | Print actions without executing them. |
  1044. | `--force` | Reinstall Ghidra JARs even if already present (`install-ghidra-deps`, `ensure-prereqs`). |
  1045. | `--with-debugger` | Force-install debugger Python requirements (Windows only). |
  1046. | `--use-debugger-toggle` | Read `INSTALL_DEBUGGER_DEPS` from `.env` to decide whether to install debugger deps. |
  1047. | `--test TIER` | (`deploy` only) Opt into live deploy regression tiers such as `release` or `debugger-live`. |
  1048. | `--strict` | (`preflight` only) Also check network reachability for Maven Central and PyPI. |
  1049. Deploy test tiers are opt-in because benchmark tiers can import/reset
  1050. `Benchmark.dll` and `BenchmarkDebug.exe` in the active Ghidra project. Use
  1051. `--test release` before cutting releases, or set
  1052. `GHIDRA_MCP_DEPLOY_TESTS=release` in a local `.env` when you want every deploy
  1053. on your machine to run the live benchmark regression. The value is validated
  1054. against the same tier list `--test` accepts, and an unknown tier is refused
  1055. rather than skipped. See [Testing and Release Regression](docs/TESTING.md).
  1056. ```text
  1057. # Standard first-time setup and deploy
  1058. python -m tools.setup ensure-prereqs --ghidra-path "C:\ghidra_12.2_PUBLIC"
  1059. python -m tools.setup build
  1060. python -m tools.setup deploy --ghidra-path "C:\ghidra_12.2_PUBLIC"
  1061. # Preflight check before deploying
  1062. python -m tools.setup preflight --strict --ghidra-path "C:\ghidra_12.2_PUBLIC"
  1063. # Version bump and tag
  1064. python -m tools.setup bump-version --new X.Y.Z --tag
  1065. # Run the Java test suite (integration classes need a live Ghidra)
  1066. python -m tools.setup run-tests
  1067. # Show full help
  1068. python -m tools.setup --help
  1069. ```
  1070. ### Project Structure
  1071. ```text
  1072. ghidra-mcp/
  1073. ├── pyproject.toml # uv project (ghidra-mcp-bridge wheel + dependency groups)
  1074. ├── python/bridge_mcp_ghidra/ # MCP server package (Python, 220 catalog entries)
  1075. ├── src/main/java/ # Ghidra plugin + headless server (Java)
  1076. │ └── com/xebyte/
  1077. │ ├── GhidraMCPPlugin.java # GUI plugin (216 endpoints)
  1078. │ ├── headless/ # Headless server (201 endpoints)
  1079. ├── python/bridge_mcp_ghidra/ # MCP server package (Python, 220 catalog entries)
  1080. ├── src/main/java/ # Ghidra plugin + headless server (Java)
  1081. │ └── com/xebyte/
  1082. │ ├── GhidraMCPPlugin.java # GUI plugin (216 endpoints)
  1083. │ ├── headless/ # Headless server (201 endpoints)
  1084. │ └── core/ # Shared service layer (`*Service.java`, `@McpTool`-annotated)
  1085. ├── ghidra_scripts/ # Automation scripts for batch workflows
  1086. ├── tests/ # Python unit tests + endpoint catalog
  1087. │ ├── unit/ # Catalog consistency, schema, tool function tests
  1088. │ └── endpoints.json # Endpoint catalog (the authoritative tool list)
  1089. ├── docs/ # Documentation
  1090. │ ├── prompts/ # AI workflow prompts (V5 documentation workflows)
  1091. │ ├── releases/ # Version release notes
  1092. │ └── project-management/ # Contributor planning docs (Gradle migration, etc.)
  1093. ├── tools/setup/ # Build and deployment CLI (python -m tools.setup)
  1094. ├── docker/ # Headless server + bridge containers
  1095. └── .github/workflows/ # CI/CD pipelines
  1096. ```
  1097. ### Library Dependencies
  1098. Under the Maven backend, Ghidra JARs must be installed into your local Maven repository (`~/.m2/repository`) before compilation.
  1099. This is a one-time setup per machine, and again when your Ghidra version changes.
  1100. `ensure-prereqs` does it for you; Gradle needs no such step, because it reads the jars from the installation.
  1101. The tool enforces version consistency between:
  1102. - `pom.xml` (`ghidra.version`)
  1103. - `--ghidra-path` version segment (e.g., `ghidra_12.2_PUBLIC`)
  1104. If they are not in the same major.minor series, deployment fails fast with a clear error (a different patch release of the same series is accepted).
  1105. ### Troubleshooting: Version Mismatch
  1106. If you see a version mismatch error, align both values:
  1107. 1. `pom.xml` → `ghidra.version`
  1108. 2. `--ghidra-path` version segment (`ghidra_X.Y.Z_PUBLIC`)
  1109. Then rerun:
  1110. ```text
  1111. python -m tools.setup preflight --ghidra-path "C:\ghidra_12.2_PUBLIC"
  1112. ```
  1113. ```text
  1114. # Windows
  1115. python -m tools.setup install-ghidra-deps --ghidra-path "C:\path\to\ghidra_12.2_PUBLIC"
  1116. ```
  1117. **Required Libraries (18 JARs, as listed in `tools/setup/ghidra.py`):**
  1118. | Library | Source Path | Purpose |
  1119. | --------- | ------------ | --------- |
  1120. | **Base.jar** | `Features/Base/lib/` | Core Ghidra functionality |
  1121. | **Decompiler.jar** | `Features/Decompiler/lib/` | Decompilation engine |
  1122. | **PDB.jar** | `Features/PDB/lib/` | Microsoft PDB symbol support |
  1123. | **FunctionID.jar** | `Features/FunctionID/lib/` | Function identification |
  1124. | **SoftwareModeling.jar** | `Framework/SoftwareModeling/lib/` | Program model API |
  1125. | **Project.jar** | `Framework/Project/lib/` | Project management |
  1126. | **Docking.jar** | `Framework/Docking/lib/` | UI docking framework |
  1127. | **Generic.jar** | `Framework/Generic/lib/` | Generic utilities |
  1128. | **Utility.jar** | `Framework/Utility/lib/` | Core utilities |
  1129. | **Gui.jar** | `Framework/Gui/lib/` | GUI components |
  1130. | **FileSystem.jar** | `Framework/FileSystem/lib/` | File system support |
  1131. | **Graph.jar** | `Framework/Graph/lib/` | Graph/call graph analysis |
  1132. | **DB.jar** | `Framework/DB/lib/` | Database operations |
  1133. | **Emulation.jar** | `Framework/Emulation/lib/` | P-code emulation |
  1134. | **Help.jar** | `Framework/Help/lib/` | Help system |
  1135. | **Debugger-api.jar** | `Debug/Debugger-api/lib/` | Debugger service API |
  1136. | **Framework-TraceModeling.jar** | `Debug/Framework-TraceModeling/lib/` | Debug trace model |
  1137. | **Debugger-rmi-trace.jar** | `Debug/Debugger-rmi-trace/lib/` | Trace RMI debugger connection |
  1138. > **Note**: Libraries are NOT included in the repository (see `.gitignore`). You must install them from your Ghidra installation before building.
  1139. <!-- two separate call-outs, not one blockquote (MD028) -->
  1140. > **Automation entry point**:
  1141. >
  1142. > - `python -m tools.setup` is the supported setup/build/deploy/versioning interface
  1143. > - use `ensure-prereqs`, `build`, `deploy`, `preflight`, `clean-all`, and `bump-version` directly
  1144. > - these commands use Maven unless `TOOLS_SETUP_BACKEND=gradle` is set
  1145. ### Development Features
  1146. - **Automated Deployment**: Version-aware deployment script
  1147. - **Batch Operations**: Reduces API calls by 93%
  1148. - **Atomic Transactions**: All-or-nothing semantics
  1149. - **Comprehensive Logging**: Debug and trace capabilities
  1150. ## 📚 Documentation
  1151. ### Core Documentation
  1152. - [Documentation Index](docs/README.md) - Complete documentation navigation
  1153. - [Project Structure](docs/PROJECT_STRUCTURE.md) - Project organization guide
  1154. - [Testing and Release Regression](docs/TESTING.md) - Local tests, CI, live Ghidra regression, and release gates
  1155. - [Naming Conventions](docs/NAMING_CONVENTIONS.md) - Code naming standards
  1156. - [Hungarian Notation](docs/HUNGARIAN_NOTATION.md) - Variable naming guide
  1157. ### AI Workflow Prompts
  1158. - [Function Documentation V5](docs/prompts/FUNCTION_DOC_WORKFLOW_V5.md) — Primary workflow: 7-step process with Hungarian notation, type auditing, and verification scoring
  1159. - [Batch Documentation V5](docs/prompts/FUNCTION_DOC_WORKFLOW_V5_BATCH.md) — Parallel subagent dispatch for multi-function processing
  1160. - [Orphaned Code Discovery](docs/prompts/ORPHANED_CODE_DISCOVERY_WORKFLOW.md) — Automated scanner for undiscovered functions
  1161. - [Data Type Investigation](docs/prompts/DATA_TYPE_INVESTIGATION_QUICK.md) — Structure discovery and field analysis
  1162. - [Global Data Analysis](docs/prompts/GLOBAL_DATA_ANALYSIS_WORKFLOW.md) — Global naming and analysis
  1163. - [Quick Start Prompt](docs/prompts/QUICK_START_PROMPT.md) — Simplified beginner workflow
  1164. - [All Prompts](docs/prompts/README.md) — Complete prompt index
  1165. ### Release History
  1166. - [Complete Changelog](CHANGELOG.md) - All version release notes
  1167. - [Release Notes](docs/releases/) - Detailed release documentation
  1168. ## 🐳 Headless Server (Docker)
  1169. GhidraMCP includes a headless server mode for automated analysis without the Ghidra GUI.
  1170. ### Quick Start with Docker
  1171. ```bash
  1172. # Build and run (the compose files live in docker/). The token is required:
  1173. # the container binds 0.0.0.0, and the server refuses a non-loopback bind
  1174. # without one.
  1175. cd docker
  1176. export GHIDRA_MCP_AUTH_TOKEN=$(openssl rand -hex 32)
  1177. docker compose up -d --build
  1178. # Test connection (/check_connection and /mcp/health need no token)
  1179. curl http://localhost:8089/check_connection
  1180. # {"status": "ok", "server_kind": "headless", "version": "7.0.0"}
  1181. ```
  1182. This starts the headless server on `:8089` and the MCP bridge on `:8081`
  1183. (streamable-http at `/mcp`). See [docker/README.md](docker/README.md) for the
  1184. full deployment guide.
  1185. ### Headless API Workflow
  1186. ```bash
  1187. AUTH="Authorization: Bearer $GHIDRA_MCP_AUTH_TOKEN"
  1188. # 1. Import a binary into the open project (auto-analysis runs by default)
  1189. curl -X POST -H "$AUTH" -H 'Content-Type: application/json' \
  1190. -d '{"file_path": "/data/program.exe"}' http://localhost:8089/import_file
  1191. # 2. Re-run auto-analysis later if needed
  1192. curl -X POST -H "$AUTH" http://localhost:8089/run_analysis
  1193. # 3. List discovered functions
  1194. curl -H "$AUTH" "http://localhost:8089/find_functions?limit=20"
  1195. # 4. Decompile a function
  1196. curl -H "$AUTH" "http://localhost:8089/get_functions?function=0x401000&fields=decompiled_code"
  1197. # 5. Get metadata
  1198. curl -H "$AUTH" http://localhost:8089/get_metadata
  1199. ```
  1200. ### Key Headless Endpoints
  1201. | Endpoint | Method | Description |
  1202. | ---------- | -------- | ------------- |
  1203. | `/import_file` | POST | Import a binary into the project and open it |
  1204. | `/open_program` | POST | Open a program already in the project (any `program=` also opens on demand) |
  1205. | `/run_analysis` | POST | Run Ghidra auto-analysis |
  1206. | `/find_functions` | GET | List or filter discovered functions |
  1207. | `/list_program_items` | GET | `kind=imports`, `exports`, `segments`, `classes`, `namespaces`, `data_items` or `external_locations` |
  1208. | `/get_functions` | GET | Decompiled code, signature, callers, callees and more for one or many functions (`fields=` picks) |
  1209. | `/create_function` | POST | Create function at address |
  1210. | `/get_metadata` | GET | Get program metadata |
  1211. | `/create_project` | POST | Create a Ghidra project (headless only) |
  1212. | `/list_analyzers` | GET | List available analyzers |
  1213. | `/server/status` | GET | Check Ghidra Server connection |
  1214. ### Configuration
  1215. Environment variables for Docker:
  1216. - `GHIDRA_MCP_AUTH_TOKEN` - Bearer token, **required** by the compose files (see above)
  1217. - `GHIDRA_MCP_PORT` - Server port (default: 8089)
  1218. - `GHIDRA_MCP_BIND_ADDRESS` - Bind address (default: 0.0.0.0 in Docker)
  1219. - `JAVA_OPTS` - JVM options (default: -Xmx4g -XX:+UseG1GC)
  1220. ## 🤝 Contributing
  1221. See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed contribution guidelines.
  1222. ### Quick Start
  1223. 1. Fork the repository
  1224. 2. Create a feature branch (`git checkout -b feature/amazing-feature`)
  1225. 3. Build and test your changes (`./gradlew buildExtension -PGHIDRA_INSTALL_DIR=/path/to/ghidra`, or `mvn clean package assembly:single -DskipTests` under the Maven backend)
  1226. 4. Update documentation as needed
  1227. 5. Commit your changes (`git commit -m 'Add amazing feature'`)
  1228. 6. Push to the branch (`git push origin feature/amazing-feature`)
  1229. 7. Open a Pull Request
  1230. ## 📄 License
  1231. This project is licensed under the Apache License 2.0 - see the [LICENSE](LICENSE) file for details.
  1232. ## 🏆 Production Status
  1233. | Metric | Value |
  1234. | -------- | ------- |
  1235. | **Version** | 7.0.0 |
  1236. | **MCP Tools** | 220 catalog entries (219 agent-visible tools) |
  1237. | **GUI Endpoints** | 216 (GhidraMCPPlugin) |
  1238. | **Headless Endpoints** | 201 (GhidraMCPHeadlessServer) |
  1239. | **Compilation** | ✅ 100% success |
  1240. | **Batch Efficiency** | 93% API call reduction |
  1241. | **AI Workflows** | 7 proven documentation workflows |
  1242. | **Ghidra Scripts** | Automation scripts included |
  1243. | **Documentation** | Comprehensive with AI prompts |
  1244. See [CHANGELOG.md](CHANGELOG.md) for version history and release notes.
  1245. ## 🙏 Acknowledgments
  1246. This project was originally derived from [LaurieWired/GhidraMCP](https://github.com/LaurieWired/GhidraMCP) in August 2025 and has since been substantially rewritten and extended. We acknowledge LaurieWired's original work as the starting point. See [NOTICE](NOTICE) for license attribution.
  1247. ### Powered by
  1248. [![JetBrains logo.](https://resources.jetbrains.com/storage/products/company/brand/logos/jetbrains.svg)](https://jb.gg/OpenSource)
  1249. Tooling provided by JetBrains through their [Open Source Support Program](https://jb.gg/OpenSource).
  1250. ## 👥 Contributors
  1251. This project has benefited from the work of dedicated contributors:
  1252. ### Core Contributors
  1253. **[@heeen](https://github.com/heeen)** — Significant contributions including:
  1254. - Fuzzy function matching and structured diff for cross-binary comparison (#13)
  1255. - Script execution improvements and bug fixes (#12)
  1256. - New API endpoints: `save_program`, `exit_ghidra`, `delete_function`, `create_memory_block`, `run_script_inline` (#11)
  1257. - Architectural vision: annotation-driven design, UDS transport, Python bridge optimization proposals
  1258. **[@huehuehuehueing](https://github.com/huehuehuehueing)** — Significant contributions including:
  1259. - Address-space prefix support — added `<space>:<hex>` syntax (e.g., `mem:1000`, `code:ff00`) to address parsing across the entire endpoint surface, unlocking multi-space targets like embedded firmware (#84, closes #65)
  1260. - Optional `program` parameter + required-param schema fixes — made `program` optional on every endpoint with a sane currentProgram fallback, and fixed several required-vs-optional schema bugs the catalog had inherited (#92)
  1261. - Seeded #44 (data-type / enum tools) — the issue that motivated the v5.0 enum + struct enforcement layer
  1262. - **Ghidra Team** - For the incredible reverse engineering platform
  1263. - **Model Context Protocol** - For the standardized AI integration framework
  1264. - **Contributors** - For testing, feedback, and improvements
  1265. ---
  1266. ## 🔗 Related Projects
  1267. - [re-universe](https://github.com/bethington/re-universe) — Ghidra BSim PostgreSQL platform for large-scale binary similarity analysis. Pairs perfectly with GhidraMCP for AI-driven reverse engineering workflows.
  1268. - [cheat-engine-server-python](https://github.com/bethington/cheat-engine-server-python) — MCP server for dynamic memory analysis and debugging.
  1269. ---
  1270. **Ready for production deployment with enterprise-grade reliability and comprehensive binary analysis capabilities.**

Ratings and comments

Sign in to rate this skill.

Sign in

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