JADX-MCP-SERVER
Provides tools for analyzing Android APKs through JADX, enabling inspection of decompiled classes, methods, fields, smali, main activity, manifest/resources, and code search for reverse engineering and vulnerability discovery.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@JADX-MCP-SERVER Find hardcoded API keys in the decompiled Android app"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
JADX-MCP-SERVER (Part of Zin's Reverse Engineering MCP Suite)
⚡ Fully automated MCP server built to communicate with JADX-AI-MCP Plugin to analyze Android APKs using LLMs like Claude — uncover vulnerabilities, parse manifests, and reverse engineer effortlessly.
⭐ Contributors
Thanks to these wonderful people for their contributions ⭐
ReadTheDocs:
We are now live at Read The Docs:
Download now: https://github.com/zinja-coder/jadx-ai-mcp/releases
🤖 What is JADX-MCP-SERVER?
JADX MCP Server is a standalone Python server that interacts with a modified version of jadx-gui (see: jadx-ai-mcp) via MCP (Model Context Protocol). It lets LLMs communicate with the decompiled Android app context live.
Related MCP server: jadx-rpc
🤖 What is JADX-AI-MCP?
JADX-AI-MCP is a plugin for the JADX decompiler that integrates directly with Model Context Protocol (MCP) to provide live reverse engineering support with LLMs like Claude.
Think: "Decompile → Context-Aware Code Review → AI Recommendations" — all in real time.
High Level Sequence Diagram
sequenceDiagram
LLM CLIENT->>JADX MCP SERVER: INVOKE MCP TOOL
JADX MCP SERVER->>JADX AI MCP PLUGIN: INVOKE HTTP REQUEST
JADX AI MCP PLUGIN->>REQUEST HANDLERS: INVOKE HTTP REQUEST HANDLER
REQUEST HANDLERS->>JADX GUI: PERFORM ACTION/GATHER DATA
JADX GUI->>REQUEST HANDLERS: ACTION PERFORMED/DATA GATHERED
REQUEST HANDLERS->>JADX AI MCP PLUGIN: CRAFT HTTP RESPONSE
JADX AI MCP PLUGIN->>JADX MCP SERVER:HTTP RESPONSE
JADX MCP SERVER->>LLM CLIENT: MCP TOOL RESULTWatch the demos!
Perform quick analysis
https://github.com/user-attachments/assets/b65c3041-fde3-4803-8d99-45ca77dbe30a
Quickly find vulnerabilities
https://github.com/user-attachments/assets/c184afae-3713-4bc0-a1d0-546c1f4eb57f
Multiple AI Agents Support
https://github.com/user-attachments/assets/6342ea0f-fa8f-44e6-9b3a-4ceb8919a5b0
Analyze The APK Resources
https://github.com/user-attachments/assets/f42d8072-0e3e-4f03-93ea-121af4e66eb1
Your AI Assistant during debugging of APK using JADX
https://github.com/user-attachments/assets/2b0bd9b1-95c1-4f32-9b0c-38b864dd6aec
It is combination of two tools:
JADX MCP SERVER
Zin MCP Suite
Current MCP Tools
The following MCP tools are available:
Tools that return decompiled source strip Kotlin compiler metadata (@Metadata /
@DebugMetadata, often 25-50% of a Kotlin dump) by default; pass slim=False for a
raw dump. Stripping never changes line numbers, so with_line_numbers=True and
add_comment(line=...) keep working.
fetch_current_class(slim=True)— Get the class name and full source of selected classget_selected_text()— Get currently selected textget_all_classes()— List all classes in the projectget_class_source(slim=True)— Get full source of a given class (with_line_numbers=Trueto number the lines foradd_comment(line=...))get_method_by_name(slim=True)— Fetch a method’s sourcesearch_method_by_name()— Search method across classessearch_classes_by_keyword()— Search for classes whose source code contains a specific keyword (supports pagination)get_methods_of_class()— List methods in a classget_fields_of_class()— List fields in a classget_smali_of_class()— Fetch smali of classget_main_activity_class(slim=True)— Fetch main activity from jadx mentioned in AndroidManifest.xml file.get_main_application_classes_code(slim=True)— Fetch all the main application classes' code based on the package name defined in the AndroidManifest.xml.get_main_application_classes_names()— Fetch all the main application classes' names based on the package name defined in the AndroidManifest.xml.get_android_manifest()— Retrieve and return the AndroidManifest.xml content.get_manifest_component- Retrieve specific manifest component instead of whole manifest fileget_strings(): Fetches the strings.xml fileget_all_resource_file_names(): Retrieve all resource files names that exists in applicationget_resource_file(): Retrieve resource file contentrename_variable(): Renames the variable within a methodadd_comment(): Adds a comment to a class, method, field or a single code line (line=), shown in JADX-GUI and saved with the project (re-commenting the same target updates it, an empty comment removes it)list_comments(): Lists the comments stored in the project, optionally filtered to one classdebug_get_stack_frames(): Get the stack frames from jadx debuggerdebug_get_threads(): Get the insights of threads from jadx debuggerdebug_get_variables(): Get the variables from jadx debuggerxrefs_to_class(): Find all references to a class (returns method-level and class-level references, supports pagination)xrefs_to_method(): Find all references to a method (includes override-related methods, supports pagination)xrefs_to_field(): Find all references to a field (returns methods that access the field, supports pagination)
Note: Tested on Claude Desktop. Support for other LLMs might be tested in future.
🗒️ Sample Prompts
🔍 Basic Code Understanding
"Explain what this class does in one paragraph."
"Summarize the responsibilities of this method."
"Is there any obfuscation in this class?"
"List all Android permissions this class might require."🛡️ Vulnerability Detection
"Are there any insecure API usages in this method?"
"Check this class for hardcoded secrets or credentials."
"Does this method sanitize user input before using it?"
"What security vulnerabilities might be introduced by this code?"🛠️ Reverse Engineering Helpers
"Deobfuscate and rename the classes and methods to something readable."
"Can you infer the original purpose of this smali method?"
"What libraries or SDKs does this class appear to be part of?"📦 Static Analysis
"List all network-related API calls in this class."
"Identify file I/O operations and their potential risks."
"Does this method leak device info or PII?"🤖 AI Code Modification
"Refactor this method to improve readability."
"Add comments to this code explaining each step."
"Rewrite this Java method in Python for analysis."📄 Documentation & Metadata
"Generate Javadoc-style comments for all methods."
"What package or app component does this class likely belong to?"
"Can you identify the Android component type (Activity, Service, etc.)?"🐞 Debugger Assistant
"Fetch stack frames, varirables and threads from debugger and provide summary"
"Based the stack frames from debugger, explain the execution flow of the application"
"Based on the state of variables, is there security threat?"🛠️ Getting Started
Demo: Perform Code Review to Find Vulnerabilities locally
https://github.com/user-attachments/assets/4cd26715-b5e6-4b4b-95e4-054de6789f42
Advanced CLI Options — Understanding the Flags
There are two separate connections and each has its own host/port:
┌─────────────┐ --host / --port ┌──────────────────┐ --jadx-host / --jadx-port ┌──────────────────┐
│ LLM Client │ ◄──────────────────► │ jadx-mcp-server │ ──────────────────────────► │ JADX-GUI Plugin │
│ (Claude, │ Where the MCP server │ │ Where the MCP server looks │ (jadx-ai-mcp) │
│ Codex..) │ LISTENS for clients │ │ for the JADX plugin │ │
└─────────────┘ └──────────────────┘ └──────────────────┘Flag | Default | Controls |
| off | Use HTTP transport instead of stdio |
|
| Where the MCP server listens (bind address for LLM clients) |
|
| Which port the MCP server listens on |
|
| Where to find the JADX plugin (the target JADX-GUI machine) |
|
| Which port the JADX plugin is on |
Usage Examples
Scenario 1 — Everything on the same machine (most common):
# Default: MCP server on localhost:8651, connects to JADX plugin on localhost:8650
uv run jadx_mcp_server.py --httpScenario 2 — Docker container or WSL (MCP server accessible from host network):
# MCP server listens on ALL interfaces so the host can reach it
# JADX plugin is still on the same machine
uv run jadx_mcp_server.py --http --host 0.0.0.0Scenario 3 — JADX-GUI running on a different machine (e.g., remote VM):
# MCP server runs locally, but connects to JADX plugin on a remote machine
uv run jadx_mcp_server.py --http --jadx-host 192.168.1.100Scenario 4 — Full remote setup (everything on different machines):
# MCP server listens on all interfaces on port 9999
# JADX plugin is on a different machine at 192.168.1.100:8652
uv run jadx_mcp_server.py --http --host 0.0.0.0 --port 9999 --jadx-host 192.168.1.100 --jadx-port 8652⚠️ Security Warning — Remote Binding
When using --host 0.0.0.0 (or any non-localhost address), the MCP server binds to all network interfaces over plain HTTP with no authentication. This means:
Anyone on the network can connect and invoke all MCP tools
There is no TLS encryption — traffic can be intercepted
An attacker can use the server to read decompiled code, rename classes/methods, and access debug info
Mitigations:
Only bind to
0.0.0.0on trusted, isolated networks (e.g., Docker bridge, local VM)Use a firewall to restrict access to the MCP port
Consider an SSH tunnel instead:
ssh -L 8651:127.0.0.1:8651 remote-host
Similarly, --jadx-host with a non-localhost address means the MCP server will make unauthenticated HTTP requests to that host. Ensure the target is trusted.
Driving the server from any OpenAI-compatible model
MCP-aware apps connect directly. For everything else that speaks POST /v1/chat/completions —
OpenRouter, LiteLLM, vLLM, Ollama's OpenAI layer, OmniRoute, … — examples/openai_compatible_client.py
is a reference adapter: it connects to a running jadx_mcp_server.py --http, converts the MCP tool list
into OpenAI function-calling tools, and runs the call → execute → feed-back loop until the model answers.
# terminal 1
uv run jadx_mcp_server.py --http --host 127.0.0.1 --port 9000
# the example needs the openai SDK; the server itself does not
pip install -r examples/requirements.txt
# OpenAI
OPENAI_API_KEY=sk-... python examples/openai_compatible_client.py \
--prompt "What does com.example.app.MainActivity do?"
# a local gateway (any placeholder key works)
OPENAI_BASE_URL=http://127.0.0.1:11434/v1 OPENAI_API_KEY=ollama OPENAI_MODEL=llama3.1 \
python examples/openai_compatible_client.py
# show the tool schema the model is offered, without calling a model at all
python examples/openai_compatible_client.py --list-tools--base-url, --api-key and --model (or the OPENAI_BASE_URL / OPENAI_API_KEY / OPENAI_MODEL
environment variables) point it at any provider. --max-steps caps how many tool rounds a question may
take and --max-tool-chars truncates a single result, so one large class dump cannot blow the model's
context. Run it without --prompt for an interactive session.
🛣️ Future Roadmap
Add Support for apktool
Add support for hermes code (ReactNative Application)
Add docker support
Add more useful MCP Tools
Make LLM be able to modify code on JADX
Add prompts templates, give llm access to Android APK Files as Resources
Build MCP Client to support Local LLMEND-GOAL : Make all android reverse engineering and APK modification tools Connect with single MCP server to make reverse engineering apk files as easy as possible purely from vibes.
NOTE For Contributors
The files related to JADX-AI-MCP can be found here
The files related to jadx-mcp-server can be found in this repository only.
🙏 Credits
This project is a plugin for JADX, an amazing open-source Android decompiler created and maintained by @skylot. All core decompilation logic belongs to them. I have only extended it to support my MCP server with AI capabilities.
The original README.md from jadx is included here in this repository for reference and credit.
This MCP server is made possible by the extensibility of JADX-GUI and the amazing Android reverse engineering community.
Also huge thanks to @aaddrick for developing Claude desktop for Debian based linux.
And in last thanks to @anthropics for developing the Model Context Protocol and @FastMCP team
And all open source maintainers and contributors that makes libraries and dependencies which allows project like this possible.
Audited and Received Assessment Badge
Thank you Mseep.net for auditing and providing Assessment Badge.
Dependencies
This project uses following awesome libraries.
Plugin - Java
Javalin - https://javalin.io/ - Apache 2.0 License
SLF4J - https://slf4j.org/ - MIT License
org.w3c.dom - https://mvnrepository.com/artifact/org.w3c.dom - W3C Software and Document License
MCP Server - Python
FastMCP - https://github.com/jlowin/fastmcp - Apache 2.0 License
httpx - https://www.python-httpx.org - BSD-3-Clause (“BSD licensed”)
📄 License
This plugin inherits the Apache 2.0 License from the original JADX repository.
⚖️ Legal Warning
Disclaimer
The tools jadx-ai-mcp and jadx_mcp_server are intended strictly for educational, research, and ethical security assessment purposes. They are provided "as-is" without any warranties, expressed or implied. Users are solely responsible for ensuring that their use of these tools complies with all applicable laws, regulations, and ethical guidelines.
By using jadx-ai-mcp or jadx_mcp_server, you agree to use them only in environments you are authorized to test, such as applications you own or have explicit permission to analyze. Any misuse of these tools for unauthorized reverse engineering, infringement of intellectual property rights, or malicious activity is strictly prohibited.
The developers of jadx-ai-mcp and jadx_mcp_server shall not be held liable for any damage, data loss, legal consequences, or other consequences resulting from the use or misuse of these tools. Users assume full responsibility for their actions and any impact caused by their usage.
Use responsibly. Respect intellectual property. Follow ethical hacking practices.
🙌 Contribute or Support
Found it useful? Give it a ⭐️
Got ideas? Open an issue or submit a PR
Built something on top? DM me or mention me — I’ll add it to the README!
Built with ❤️ for the reverse engineering and AI communities.
Available Tools
34 toolsadd_commentA
Add a comment to decompiled code, shown in JADX-GUI and saved with the project.
Comment a class by passing only class_name, a method by also passing method_name (use method_signature such as '(I)V' to pick between overloads), or a field by passing field_name.
To comment a code line, pass line=N, the 1-based line number in the decompiled source of that class; get it from get_class_source(with_line_numbers=True) rather than counting lines. The comment is appended to the end of that line, and on a class, method or field declaration line it comments that declaration instead, matching what the comment shortcut does in JADX-GUI. Braces and blank lines have nothing to comment and are rejected, listing the nearest lines that work. Line numbers shift once a comment is added above, so re-read the source before addressing another line.
Every write is verified against the freshly decompiled code and the response echoes the rendered line, so there is no need to read the class back to check. A comment that does not render is rolled back and returns an error rather than being silently stored, which JADX itself does not detect.
A new comment on the same target replaces the previous one, so annotations can be refined without creating duplicates, and passing an empty comment removes it. style is one of LINE, BLOCK, BLOCK_CONDENSED, JAVADOC or JAVADOC_CONDENSED (default: LINE).
Use this to record what a class or method actually does while reverse engineering: the comments persist in the JADX project and are searchable later with search_classes_by_keyword(search_in="comment").
Inputs: comment (required), class_name (required), line, style, +3 more. Returns: object
clear_cacheA
Clear the decompilation source cache and reset counters. Use when switching APKs or to free memory.
Inputs: no named parameters. Returns: object
debug_get_stack_framesB
Get current stack frames (call stack).
Inputs: no named parameters. Returns: object
debug_get_threadsA
Get all threads in the debugged process.
Inputs: no named parameters. Returns: object
debug_get_variablesA
Get current variables when process is suspended.
Inputs: no named parameters. Returns: object
fetch_current_classA
Fetch the currently selected class and its code from the JADX-GUI plugin.
Kotlin compiler metadata (@Metadata / @DebugMetadata) is stripped by default; pass slim=False for a raw dump. Line numbering is unaffected.
Inputs: slim. Returns: object
get_all_classesC
Returns a list of all classes in the project with pagination support.
Inputs: count, offset. Returns: object
get_all_resource_file_namesC
Retrieve all resource files names.
Inputs: count, offset. Returns: object
get_android_manifestA
Retrieve and return the AndroidManifest.xml content.
Inputs: no named parameters. Returns: object
get_cache_statsA
Get decompilation cache statistics: hits, misses, hit_rate, cached_classes, compressed_mb, compression_ratio.
Inputs: no named parameters. Returns: object
get_class_sourceA
Fetch the Java source of a specific class.
Set with_line_numbers=True to get every line prefixed with its 1-based line number. Those are the numbers add_comment takes as its 'line' argument, so use this before placing a line comment instead of counting lines yourself.
Kotlin compiler metadata (@Metadata / @DebugMetadata) is stripped by default, which is where a large part of a Kotlin dump goes; the line numbers stay the same, so add_comment keeps working. Pass slim=False for a raw, unmodified dump.
Inputs: class_name (required), slim, with_line_numbers. Returns: object
get_fields_of_classB
List all field names in a class.
Inputs: class_name (required). Returns: object
get_main_activity_classA
Fetch the main activity class from AndroidManifest.xml.
Kotlin compiler metadata is stripped by default; pass slim=False for a raw dump.
Inputs: slim. Returns: object
get_main_application_classes_codeB
Fetch main application classes' code with pagination.
Kotlin compiler metadata is stripped from every class by default; pass slim=False for raw dumps.
Inputs: slim, count, offset. Returns: object
get_main_application_classes_namesA
Fetch main application classes' names from Manifest package.
Inputs: no named parameters. Returns: object
get_manifest_componentA
Retrieve specified component data from AndroidManifest.xml, support filter exported components. Support standard Android components: activity, provider, service, receiver.
Inputs: component_type (required), only_exported. Returns: object
get_method_by_nameB
Fetch the source code of a method from a specific class.
Kotlin compiler metadata is stripped by default; pass slim=False for a raw dump.
Inputs: class_name (required), method_name (required), slim, method_signature. Returns: object
get_methods_of_classB
List all method names in a class.
Inputs: class_name (required). Returns: object
get_package_treeA
Get all packages in the APK sorted by class count. Shows total_classes, total_packages, and per-package name, class_count, is_likely_library. Use this first to understand the APK structure before searching.
Inputs: no named parameters. Returns: object
get_resource_fileC
Retrieve resource file content.
Inputs: resource_name (required). Returns: object
get_selected_textA
Returns the currently selected text in the decompiled code view.
Inputs: no named parameters. Returns: object
get_smali_of_classC
Fetch the smali representation of a class.
Inputs: class_name (required). Returns: object
get_stringsC
Retrieve contents of strings.xml files.
Inputs: count, offset. Returns: object
get_xrefs_to_classB
Find all references to a class.
Inputs: class_name (required), count, offset. Returns: object
get_xrefs_to_fieldC
Find all references to a field.
Inputs: class_name (required), field_name (required), count, offset. Returns: object
get_xrefs_to_methodC
Find all references to a method.
Inputs: class_name (required), method_name (required), count, offset. Returns: object
list_commentsA
List the comments already stored in the project, optionally filtered to one class.
Each entry reports class_name, node_type (CLASS/METHOD/FIELD), node_id, comment and style. Use this before add_comment to see what is already annotated instead of re-deriving it.
Inputs: class_name. Returns: object
rename_classC
Renames a specific class.
Inputs: new_name (required), class_name (required). Returns: object
rename_fieldC
Renames a specific field.
Inputs: new_name (required), class_name (required), field_name (required). Returns: object
rename_methodC
Renames a specific method, optionally scoped to class_name.
Inputs: new_name (required), method_name (required), class_name, method_signature. Returns: object
rename_packageB
Renames a package and all its classes.
Inputs: new_package_name (required), old_package_name (required). Returns: object
rename_variableC
Renames a specific variable in a method.
Inputs: new_name (required), class_name (required), method_name (required), variable_name (required), +2 more. Returns: object
search_classes_by_keywordA
Search for classes containing a specific keyword with flexible filtering options.
This tool performs a comprehensive search across decompiled Android code, allowing you to:
Search within specific packages by providing a package name
Target specific search scopes (class names, method names, fields, code content, comments)
Combine multiple search scopes for precise results
Args: search_term: The keyword or string to search for. This is the main search query.
package (optional): Package name to limit the search scope.
- If empty string (default), searches across all packages in the APK
- If provided, only searches within classes belonging to the specified package
- Example: "com.example.app" to search only in that package
search_in (optional): Comma-separated list of search scopes to target.
Valid values:
- "class": Search in class names only
- "method": Search in method names only
- "field": Search in field names only
- "code": Search in code content (method bodies, statements, etc.)
- "comment": Search in comments
You can specify one or multiple scopes:
- Single scope: "class" (only class names)
- Multiple scopes: "class,method" (class names OR method names)
- Combined: "class,method,code" (searches in all three scopes)
Default: "code" (searches in code content)
offset (optional): Starting index for pagination. Default: 0
count (optional): Maximum number of results to return. Default: 20Returns: dict: Paginated list of classes containing the search term, with metadata about matches
MCP Tool: search_classes_by_keyword Description: Advanced search tool that finds classes matching a keyword with package filtering and scope targeting capabilities. Use this when you need to find specific code patterns, class names, method names, or other identifiers across the decompiled APK.
Inputs: search_term (required), count, offset, package, +1 more. Returns: object
search_method_by_nameC
Search for a method name across all classes.
Inputs: method_name (required). Returns: object
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 34 tools
Most tools map to clearly distinct JADX operations such as decompilation, search, rename, xrefs, comments, debug, and resources. There is some overlap: search_method_by_name overlaps search_classes_by_keyword when searching methods, and multiple class-source retrieval paths require reading scope carefully. Descriptions mostly resolve these, so misselection risk is moderate rather than high.
Names are consistently snake_case and mostly follow a verb_noun pattern such as get_..., search_..., rename_..., add_..., list_..., and clear_.... Minor deviations exist: fetch_current_class uses fetch instead of get, and debug_* tools carry an extra group prefix, but the overall pattern remains predictable.
34 tools is well above the typical tight MCP surface, and several groups such as search variants, main-application getters, and cache/debug helpers could be consolidated or made optional. The domain is broad, so not every tool is gratuitous, but the surface is heavy for an agent to navigate efficiently.
The tool set covers the reverse-engineering lifecycle: class/method/field/smali/source retrieval, package tree, keyword search, xrefs, renames, comments, manifest/resources, GUI selection, cache, and debug inspection. No obvious core operation is missing; remaining gaps are niche rather than workflow-blocking.
Related MCP Connectors
Code intelligence for coding agents: semantic, AST, graph, and full-text search. 279+ languages.
Code intelligence platform for AI agents. 20 tools for architecture, security & impact analysis.
Codebase intelligence for agents: 152 structured artifacts across 21 programs, one call.
Code intelligence for LLMs. Analyze, search, and retrieve code from any public git repository.
Related MCP Servers
- AlicenseBqualityBmaintenanceA Model Context Protocol server that connects to a custom JADX fork (JADX-AI) and enables local LLMs to interact with decompiled Android app code for live reverse engineering assistance.32848Apache 2.0
- AlicenseNot gradedqualityDmaintenanceMCP server for analyzing Android APK, DEX, or JAR files via a headless jadx engine, enabling LLM agents to query decompiled code, symbols, call graphs, and more.2GPL 3.0
- FlicenseNot gradedqualityBmaintenanceEnables Android APK security auditing through natural language by decompiling APKs with Apktool and running static analysis heuristics for attack surface, permissions, secrets, crypto, native libraries, and more, with every analysis logged to disk as markdown reports.-
- AlicenseAqualityBmaintenanceEnables AI clients to manage ADB devices and packages, detect packers, pull APKs, and unpack hardened Android apps via static extraction, BlackDex, or Frida, then convert DEX files to smali. Supports listing, reading, and regex-searching smali classes to locate APIs and other reverse-engineering targets.13111 npm2MIT