Recafmcp

🚀 Recaf MCP Plugin

Enable AI assistants to control Recaf 4.x through the Model Context Protocol (MCP) — decompile, search, analyze, edit bytecode, compile Java, assemble/disassemble JASM, diff classes, patch workspaces, and export Java bytecode directly from your AI workflow.

Chinese Documentation

🚀 Quick Start

Run Recaf with the plugin and configure your AI client to use the MCP Server. Then you can interact with Recaf through the AI client.

Prerequisites

• JDK 22+ — Required by Recaf 4.x. Make sure java on your PATH points to JDK 22 or higher.
• Recaf 4.x — This plugin is built against snapshot d07958a5c7. The build system will download it automatically.

Build

git clone https://github.com/your-repo/recaf-mcp-plugin.git
cd recaf-mcp-plugin
./gradlew build

Setup & Usage

Step 1: Start Recaf with the Plugin

Option A: Run directly from the project (recommended for development)

./gradlew runRecaf

This builds the plugin and launches Recaf with it auto-loaded.

Option B: Manual installation Copy build/libs/recaf-mcp-plugin-1.2.0.jar to Recaf's plugin directory:

Then start Recaf normally.

Verify: Look for this in Recaf's Logging panel:

========================================
  Recaf MCP Plugin enabled
  Bridge Server running on port 9847
========================================

Step 2: Configure Your AI Client

Claude Code

Add to ~/.claude.json:

{
  "mcpServers": {
    "recaf": {
      "command": "java",
      "args": ["-jar", "/absolute/path/to/build/mcp/recaf-mcp-server-1.2.0.jar"]
    }
  }
}

Then restart Claude Code. The recaf tools will appear in your tool list.

Cursor

Add to your MCP configuration (Settings → MCP):

{
  "mcpServers": {
    "recaf": {
      "command": "java",
      "args": ["-jar", "/absolute/path/to/build/mcp/recaf-mcp-server-1.2.0.jar"]
    }
  }
}

Other MCP-Compatible Clients

Any client that supports the MCP protocol can use this plugin. Configure it to spawn the MCP Server JAR via java -jar over STDIO.

Step 3: Start Using

Once both Recaf and your AI client are running, you can interact naturally:

Open /path/to/target.jar and list all classes
Decompile the com/example/Main class
Search for all strings containing "password"
Show me the call graph for com/example/Main
Rename com/example/a to com/example/LoginManager
Compare com/example/A with com/example/B
Remove the method "unused" from com/example/Foo
Show me the bytecode instructions for com/example/Main.main
Disassemble com/example/Crypto into JASM
Compile this modified Java source back into the workspace
Read the META-INF/MANIFEST.MF file
Create a patch of all my changes
Export the modified JAR to /tmp/output.jar

✨ Features

• Dual-process architecture: Bridge AI assistants with Recaf's bytecode analysis engine.
• 25 MCP tools: Support various operations such as workspace management, analysis, compilation, modification, and export.
• Structured error responses: Provide detailed error information for better troubleshooting.

📦 Installation

git clone https://github.com/your-repo/recaf-mcp-plugin.git
cd recaf-mcp-plugin
./gradlew build

This produces two JARs:

💻 Usage Examples

Reverse Engineering an Obfuscated JAR

1. "Open /path/to/obfuscated.jar"
2. "List all classes" — get an overview of the package structure
3. "Decompile com/a/b/c" — read the decompiled source
4. "Search for strings containing 'http'" — find network endpoints
5. "Get the call graph for com/a/b/c method d" — understand control flow
6. "Rename com/a/b/c to com/app/NetworkManager" — give it a meaningful name
7. "Export mappings as TinyV1 to ./mappings.tiny" — save your work
8. "Export the modified JAR to ./cleaned.jar" — save the result

Multi-JAR Comparison

1. "Open /path/to/v1.jar" — opens first JAR, returns workspaceId
2. "Open /path/to/v2.jar" — opens second JAR, returns workspaceId
3. "List workspaces" — see both workspaces
4. "Switch to workspace v1-1" — switch to first JAR
5. "Decompile com/example/Main" — get v1 source
6. "Switch to workspace v2-2" — switch to second JAR
7. "Diff com/example/Main against the v1 source" — compare versions

Bytecode Editing

1. "Open /path/to/target.jar"
2. "Remove the method 'checkLicense' from com/app/Main"
3. "Add a public field 'debug' of type boolean to com/app/Config"
4. "Export the modified JAR to /tmp/patched.jar"

Compile & Assemble Round-Trip

1. "Open /path/to/target.jar"
2. "Decompile com/app/Main" — get the Java source
3. (modify the source) → "Compile this Java source for com.app.Main" — compile & apply
4. "Decompile com/app/Main" — verify the changes took effect
5. "Disassemble com/app/Crypto" — get JASM assembly text
6. "Show me the bytecode for com/app/Crypto.encrypt" — inspect method instructions
7. "Create a patch" — save all modifications as JSON
8. "Export the modified JAR to /tmp/patched.jar"

📚 Documentation

Available MCP Tools (25)

Workspace Management

Analysis

Compilation & Assembly

Modification

Export

MCP Resources

Bridge HTTP API Reference

All endpoints accept POST with JSON body and return JSON responses.

🔧 Technical Details

📄 License

MIT