Allows AI agents to dynamically instrument Android applications, manage processes, inject scripts, and interact with Frida server on Android devices via ADB.
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., "@ya-frida-mcp list connected Frida devices"
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.
Pending JsBridge fix #3
Existing Frida MCP servers on the market are either abandoned, poorly maintained, or limited to a handful of basic operations. ya-frida-mcp was built from scratch to be a comprehensive, production-ready bridge between AI agents and Frida — covering device management, process control, script injection, memory operations, and even ADB integration out of the box.
59 MCP tools across 7 categories, all returning structured JSON for minimal token consumption.
Category | Tools | Highlights |
Device |
| Device management, system info, spawn gating, native library injection |
Process |
| Full process lifecycle; |
App |
| App enumeration with scope/identifiers filtering |
Script |
| JS injection (QJS/V8), RPC, child gating, bytecode compilation, script snapshots |
Memory |
| Read/write/scan/protect with hex I/O |
ADB (optional) |
| 17 tools, auto-registered when |
Frida Server (optional) |
| Auto-download, push, and manage frida-server on Android via ADB |
Also includes:
MCP Resources — live device list, session state, process/app enumeration as subscribable resources
MCP Prompts — workflow templates for native hooking, Java/ObjC hooking, Stalker tracing, module dumping
TOML Configuration — customize transport, default device, remote devices, timeouts
CLI Utilities — doctor, devices, ps, ls, tools, install/uninstall for MCP clients
One-command client setup — register into 22+ MCP clients including Claude Desktop, Cursor, VS Code, Windsurf, Roo Code, Cline, Kiro, and more
Structured output — all tools return compact JSON with Literal type hints for LLM-friendly schemas
Related MCP server: frida-mcp
# PyPI (recommended)
pip install ya-frida-mcp
# Or via uv
uv tool install ya-frida-mcp# Pick your client
ya-frida-mcp install claude-desktop
ya-frida-mcp install cursor
ya-frida-mcp install vscode
ya-frida-mcp install windsurf
ya-frida-mcp install roo-code
ya-frida-mcp install cline
# All supported clients at once
ya-frida-mcp install allKey | Client |
| Amazon Q Developer CLI |
| Augment Code |
| Claude Desktop |
| Claude Code |
| Cline |
| Copilot CLI |
| Crush |
| Cursor |
| Gemini CLI |
| Kilo Code |
| Kiro |
| LM Studio |
| Opencode |
| Qodo Gen |
| Qwen Coder |
| Roo Code |
| Trae |
| VS Code |
| VS Code Insiders |
| Warp |
| Windsurf |
| Zed |
# stdio (default, used by MCP clients)
ya-frida-mcp serve
# SSE transport
ya-frida-mcp serve -t sse -H 0.0.0.0 -p 8000ya-frida-mcp init-config # generates config.toml in current directory
ya-frida-mcp show-config # display resolved config
ya-frida-mcp -c /path/to/config.toml serve# config.toml
[server]
name = "ya-frida-mcp"
transport = "stdio" # "stdio" or "sse"
host = "127.0.0.1"
port = 8000
[frida]
default_device = "local" # "local", "usb", or device ID
script_timeout = 10
spawn_timeout = 15
[[frida.remote_devices]]
host = "192.168.1.100"
port = 27042ya-frida-mcp doctor # diagnose Frida connectivity
ya-frida-mcp devices # list Frida devices
ya-frida-mcp ps # list running processes (frida-ps)
ya-frida-mcp ls # list installed apps (frida-ls)
ya-frida-mcp tools # list all registered MCP tools
ya-frida-mcp version # show version info# Clone
git clone https://github.com/1shin-7/ya-frida-mcp.git
cd ya-frida-mcp
# Install dependencies
uv sync
# Run in dev mode
uv run ya-frida-mcp serve
# Lint
uv run ruff check ya_frida_mcp/
# List tools (verify registration)
uv run ya-frida-mcp toolsya_frida_mcp/
├── cli.py # Click CLI entry point
├── config.py # TOML configuration management
├── installer.py # MCP client config installers
├── server.py # FastMCP server factory + lifespan
├── resources.py # MCP resources
├── prompts.py # MCP workflow prompts
├── core/
│ ├── base.py # ABC base classes + async helpers
│ ├── device.py # Frida device wrapper + manager
│ ├── session.py # Session + script lifecycle
│ ├── adb.py # ADB CLI async wrapper
│ ├── frida_server.py # frida-server download & deploy logic
│ └── output.py # Structured output helpers
└── tools/
├── device.py # Device discovery tools
├── process.py # Process management tools
├── app.py # App enumeration tools
├── script.py # Script injection + RPC tools
├── memory.py # Memory read/write/scan tools
├── adb.py # ADB CLI tools (optional)
└── frida_server.py # frida-server management tools (optional)Frida — Dynamic instrumentation toolkit
FastMCP — Pythonic MCP server framework
Click — CLI framework
Claude — AI-assisted development
Connect to a remote Frida server (frida-server over TCP).
Inputs: host (required), port. Returns: object
Attach to a running process by PID or name.
Args: pid: Process PID (int). name: Process name (str). identifier: Application bundle identifier (str). frontmost: Attach to the frontmost application. device_id: Target device. Uses default if omitted. realm: Session realm — "native" or "emulated".
Inputs: pid, name, realm, device_id, +2 more. Returns: object
Compile a script to bytecode without loading it.
Args: pid: Target process PID (must have active session). source: JavaScript source code to compile. runtime: Script runtime — "qjs" (default, no Java/ObjC) or "v8" (full runtime with Java/ObjC bridge).
Returns: Base64-encoded bytecode.
Inputs: pid (required), source (required), runtime. Returns: object
Detach from a process session.
Inputs: pid (required). Returns: object
Disable child gating on a session.
Args: pid: Target process PID (must have active session).
Inputs: pid (required). Returns: object
Disable spawn gating on the device.
Args: device_id: Target device. Uses default if omitted.
Inputs: device_id. Returns: object
Enable child gating on a session.
When enabled, child processes created by the target are suspended until explicitly resumed.
Args: pid: Target process PID (must have active session).
Inputs: pid (required). Returns: object
Enable spawn gating on the device.
When enabled, newly spawned processes are suspended until explicitly resumed.
Args: device_id: Target device. Uses default if omitted.
Inputs: device_id. Returns: object
Enumerate exports of a specific module.
Args: pid: Target process PID (must have active session). module_name: Name of the module to inspect.
Inputs: pid (required), module_name (required). Returns: result
Enumerate loaded modules in a process.
Injects a helper script to call Process.enumerateModules(). Requires an active session for the given PID.
Args: pid: Target process PID (must have active session). name_filter: Optional substring filter on module name (case-insensitive). Use this to avoid returning hundreds of modules at once.
Inputs: pid (required), name_filter. Returns: result
List pending child processes that are waiting to be resumed.
Args: device_id: Target device. Uses default if omitted.
Inputs: device_id. Returns: result
List pending spawned processes that are waiting to be resumed.
Args: device_id: Target device. Uses default if omitted.
Inputs: device_id. Returns: result
Eternalize a script so it persists after detaching from the session.
Args: script_id: ID returned by frida_inject.
Inputs: script_id (required). Returns: object
Get info for a specific device. Uses default device if ID is omitted.
Inputs: device_id. Returns: object
Get details about the frontmost application.
Args: device_id: Target device. Uses default if omitted. scope: Enumeration scope — "minimal", "metadata", or "full".
Inputs: scope, device_id. Returns: result
Retrieve and drain pending messages from an injected script.
Messages are produced by send() calls in the injected JS.
Inputs: script_id (required). Returns: result
Inject a JavaScript snippet into a process.
The process must already have an active session (use frida_attach first).
IMPORTANT: The default runtime is QJS (QuickJS), which is lightweight but does NOT include the Java/ObjC bridges. If your script uses Java.perform(), Java.use(), ObjC.classes, or any Java/Objective-C APIs, you MUST set runtime="v8". Always use runtime="v8" for Android Java hooking.
Args: pid: Target process PID. source: JavaScript source code to inject. runtime: Script runtime — "qjs" (default, no Java/ObjC bridge) or "v8" (full runtime with Java/ObjC bridge support).
Returns: script_id for subsequent RPC calls or unloading.
Inputs: pid (required), source (required), runtime. Returns: object
Inject a native library from memory (base64-encoded binary) into a process.
Args: pid: Target process PID. blob_base64: Base64-encoded library binary. entrypoint: Name of the entry function in the library. data: String argument passed to the entrypoint. device_id: Target device. Uses default if omitted.
Inputs: pid (required), data (required), entrypoint (required), blob_base64 (required), +1 more. Returns: object
Inject a native library file (.so/.dylib) into a process.
Args: pid: Target process PID. path: Absolute path to the library on the device. entrypoint: Name of the entry function in the library. data: String argument passed to the entrypoint. device_id: Target device. Uses default if omitted.
Inputs: pid (required), data (required), path (required), entrypoint (required), +1 more. Returns: object
Kill a process by PID.
Inputs: pid (required), device_id. Returns: object
List RPC exports available on an injected script.
Args: script_id: ID returned by frida_inject.
Inputs: script_id (required). Returns: result
List all active script IDs.
Inputs: no named parameters. Returns: result
List all active session PIDs.
Inputs: no named parameters. Returns: result
List installed applications on a device (frida-ls equivalent).
Returns identifier, name, and PID (if running).
Args: device_id: Target device. Uses default if omitted. scope: Enumeration scope — "minimal", "metadata", or "full". When "full", includes parameters (version, build, etc.). identifiers: Optional list of bundle identifiers to filter by.
Inputs: scope, device_id, identifiers. Returns: result
List only currently running applications.
Args: device_id: Target device. Uses default if omitted. scope: Enumeration scope — "minimal", "metadata", or "full". identifiers: Optional list of bundle identifiers to filter by.
Inputs: scope, device_id, identifiers. Returns: result
List all available Frida devices (local, USB, remote).
Inputs: no named parameters. Returns: result
Change memory protection flags.
Inputs: pid (required), size (required), address (required), protection. Returns: object
Read bytes from process memory.
Args: pid: Target process PID (must have active session). address: Hex address string (e.g. "0x7fff12340000"). size: Number of bytes to read.
Inputs: pid (required), size (required), address (required). Returns: object
Scan process memory for a byte pattern.
Args: pid: Target process PID (must have active session). address: Start address (hex string). size: Number of bytes to scan. pattern: Frida-style pattern (e.g. "48 8b ?? 00").
Inputs: pid (required), size (required), address (required), pattern (required). Returns: result
Write bytes to process memory.
Args: pid: Target process PID (must have active session). address: Hex address string (e.g. "0x7fff12340000"). hex_data: Hex-encoded bytes to write (e.g. "deadbeef").
Inputs: pid (required), address (required), hex_data (required). Returns: object
Post a message to an injected script.
Args: script_id: ID returned by frida_inject. message: JSON-serializable message to send. data: Optional base64-encoded binary data.
Inputs: message (required), script_id (required), data. Returns: object
List running processes on a device (frida-ps equivalent).
Returns PID and name for each process.
Args: device_id: Target device. Uses default if omitted. scope: Enumeration scope — "minimal", "metadata", or "full". When "full", includes parameters (path, user, ppid, started). pids: Optional list of PIDs to filter by.
Inputs: pids, scope, device_id. Returns: result
Returns a dictionary of information about the host system.
Args: device_id: Target device. Uses default if omitted.
Inputs: device_id. Returns: object
Disconnect from a remote Frida server.
Inputs: host (required), port. Returns: object
Resume a suspended process.
Inputs: pid (required), device_id. Returns: object
Call an RPC export on an injected script.
The script must expose methods via rpc.exports.
Args: script_id: ID returned by frida_inject. method: Export method name (snake_case in Python, camelCase in JS). args: Positional arguments to pass.
Inputs: method (required), script_id (required), args.
Create a snapshot of a script for fast future loading.
Args: pid: Target process PID (must have active session). embed_script: JavaScript source to embed in the snapshot. warmup_script: Optional script to run during snapshot creation. runtime: Script runtime — "qjs" (default, no Java/ObjC) or "v8" (full runtime with Java/ObjC bridge).
Returns: Base64-encoded snapshot data.
Inputs: pid (required), embed_script (required), runtime, warmup_script. Returns: object
Spawn a new process and optionally attach to it.
Args: program: Path or bundle identifier to spawn. device_id: Target device. Uses default if omitted. auto_resume: Whether to resume the process after attaching. argv: Command-line arguments for the spawned process. env: Environment variables as key-value pairs. cwd: Working directory for the spawned process. stdio: Standard I/O mode — "inherit", "pipe", or "redirect".
Note:
If spawn times out on Android, call frida_fix_usap to disable
the USAP pool and detect root-hiding modules that may interfere
with Frida's spawn interception.
Inputs: program (required), cwd, env, argv, +3 more. Returns: object
Unload a previously injected script.
Inputs: script_id (required). Returns: object
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
Scored across 39 tools
Most tools have clearly distinct purposes, but a few pairs could cause confusion: frida_inject (JS) vs frida_inject_library_file/blob (native library), and frida_list_exports vs frida_enumerate_exports (RPC vs module exports). Descriptions are detailed enough to resolve ambiguity, so only minor overlap exists.
All tools share the frida_ prefix and use snake_case, but the verb style is inconsistent (ls vs list vs enumerate vs get). For example, frida_ls_devices vs frida_list_sessions, and frida_enumerate_exports vs frida_list_exports. Overall still readable and predictable.
39 tools is heavy, but the server aims to cover Frida's broad dynamic instrumentation surface across device, process, script, and memory domains. Most tools are distinct, but the count exceeds the 25-tool threshold, making it feel somewhat bloated.
The tool surface covers core Frida workflows: device/process discovery, attach/spawn, script injection with RPC and messaging, module/export enumeration, and memory read/write/scan/protect. No obvious critical gaps that would prevent an agent from accomplishing typical dynamic instrumentation tasks.
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
MCP server for building and testing AI agents with multi-model experimentation and insights.
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
