JADX-AI-MCP

JADX-AI-MCP is a plugin for the JADX decompiler that integrates with the Model Context Protocol (MCP). It enables LLMs (like Claude) to perform live reverse engineering, static code analysis, and real-time code review of Android APKs.

It works in conjunction with the JADX MCP Server, which acts as the communication bridge between the LLM client and the JADX plugin.

When using JADX-AI-MCP, be aware of the following security behaviors:

• Localhost Binding: By default, the server binds to 127.0.0.1.
• Remote Access Warning: If you use --host 0.0.0.0 to allow remote access, the MCP server becomes accessible to anyone on your network over unencrypted, unauthenticated plain HTTP. Use a firewall or SSH tunnel for remote access.
• Proxy Isolation: Internal HTTP requests use trust_env=False to prevent proxy interception.
• Data Privacy: The project does not collect telemetry or usage data.

The system implements several security layers:

• Network Security: The plugin binds strictly to 127.0.0.1 (localhost), preventing remote access. It relies on OS-level user isolation for authentication.
• Input Validation:
  • Resource paths are validated against the APK root to prevent Path Traversal.
  • Refactoring inputs are validated against Java naming rules to prevent Code Injection.
• Transport Security:
  • Proxy Isolation: The Python httpx client uses trust_env=False to ensure local 127.0.0.1 traffic is not intercepted or routed through OS-level HTTP/HTTPS proxies.
  • Stdio Integrity: When running as an MCP stdio server, stdout is reserved exclusively for JSON-RPC communication. All logging, health checks, and banners are directed to stderr to prevent protocol corruption.

The plugin is built on top of the JADX plugin system and exposes its functionality through an embedded Javalin HTTP server.

Key architectural components:

• JadxAIMCP: The main entry point implementing JadxPlugin.
• PluginServer: Manages an embedded Jetty server using the Javalin framework.
• Route Handlers: Specialized classes (e.g., ClassRoutes, SearchRoutes) that handle specific HTTP endpoints.
• Lifecycle: The plugin uses a delayed initialization pattern to ensure the server only starts after JADX has fully loaded the APK content.

// Delayed initialization pattern
private void startDelayedInitialization() {
    scheduler.scheduleAtFixedRate(() -> {
        if (isJadxFullyLoaded()) {
            startServer();
            scheduler.shutdown();
        }
    }, 2, 1, TimeUnit.SECONDS);
}

The JADX Plugin uses a multi-threaded model where the HTTP server (Jetty/Javalin) runs on a worker thread pool. Because JADX is a GUI-based application, any JADX API calls that access UI components or shared data must be executed on the Event Dispatch Thread (EDT) to avoid ConcurrentModificationException or other threading issues.

To safely access data from a worker thread, wrap the call in SwingUtilities.invokeLater.

// Wrong: Direct access from worker thread
String code = javaClass.getCode(); // ConcurrentModificationException

// Correct: Wrap in invokeLater
SwingUtilities.invokeLater(() -> {
    String code = javaClass.getCode(); // Safe
});

JADX-AI-MCP is a reverse engineering toolkit that connects the JADX decompiler to Large Language Models (LLMs) using the Model Context Protocol (MCP). It consists of two main components:

1. JADX-AI-MCP Plugin (Java): A plugin for JADX-GUI that exposes decompiler data (code, resources, debug info) via a local HTTP API.
2. JADX-MCP-Server (Python): An MCP server that acts as a bridge, translating MCP tool calls from an AI assistant (like Claude) into HTTP requests for the JADX plugin.

Network Architecture

The system maintains two distinct connections:

• Client ↔ MCP Server: The LLM client connects to the MCP server (configured via --host and --port).
• MCP Server ↔ JADX Plugin: The MCP server connects to the JADX plugin (configured via --jadx-host and --jadx-port).

JADX-AI-MCP operates using a three-tier architecture to bridge LLM clients with JADX decompilation capabilities:

1. Presentation Tier: The LLM Client (e.g., Claude, Cherry Studio) that interacts with the user.
2. Application Tier: The MCP Server (written in Python) which acts as the intermediary using the FastMCP library.
3. Data Tier: The JADX Plugin (Java) and JADX Core, which handle the actual decompilation and APK analysis.

The flow of communication is: LLM Client $\rightarrow$ MCP Server (Python) $\rightarrow$ Javalin Server (Java Plugin) $\rightarrow$ JADX API $\rightarrow$ JADX GUI.

The project is split into two main components:

• JADX-AI-MCP (Plugin): The Java-based plugin files are located within this repository.
• jadx-mcp-server (MCP Server): The Python-based server files are located in a separate repository: https://github.com/zinja-coder/jadx-mcp-server.

To prevent JSON serialization overhead, network latency, and LLM client timeouts (which typically occur after 60s), all list endpoints implement a pagination strategy. This is essential when dealing with large APKs containing thousands of classes.

• Mechanism: Use offset and count parameters.
• Default page size: 100 items.
• Maximum page size: 10,000 items.

If your JADX-GUI plugin is running on a custom port or a different machine, you must configure the MCP server to find it using --jadx-host and --jadx-port.

Example: Connecting to a remote JADX host

uv run jadx_mcp_server.py --jadx-host 192.168.1.100 --jadx-port 8650

Example: Claude Desktop config for custom JADX port

If the JADX plugin is on port 8652, update your claude_desktop_config.json arguments:

{
  "mcpServers": {
    "jadx-mcp-server": {
      "command": "/path/to/uv",
      "args": [
        "--directory",
        "/path/to/jadx-mcp-server/",
        "run",
        "jadx_mcp_server.py",
        "--jadx-port",
        "8652"
      ]
    }
  }
}