Which integrations are available for this server?

Provides comprehensive control over Android devices via the Android Debug Bridge (adb), including UI automation, app management, file operations, logging, network configuration, and system inspection. Supports root-level file operations and other privileged actions on devices rooted with Magisk, extending file management capabilities.

How do I use adb-mcp?

1. Click on "Deploy Server". 2. Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state. 3. In the chat, type @ followed by the MCP server name and your instructions, e.g., "@adb-mcp list installed packages" 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.

adb-mcp

by FlashZ

Overview Schema Source Related Servers Discussions Admin

Python

Local

adb-mcp

A comprehensive, structured-output MCP server around the Android Debug Bridge.

Give an AI agent (Claude Code, or any MCP client) direct, first-class control of an Android device — launch apps, drive the UI, capture logs and screenshots, push/pull files, wire up port forwards — so the workflow becomes:

agent → launch_package() → capture_screen() → tap_element("Send") → logcat_dump() → pull() → analyse()

…with no copy/paste of shell output, and no unrestricted adb shell tool (that escape hatch is opt-in and off by default).

90 tools across 9 groups. Every tool returns structured JSON — never raw terminal text.

Why

The usual loop is: you type adb shell …, copy the output, paste it to the AI, it reasons, tells you the next command, you type it. adb-mcp collapses that into tools the agent calls itself. It was built for mobile reverse-engineering / QA automation, but works for any adb task.

Related MCP server: DeepADB

Design principles

Idempotent, named operations — force_stop(pkg), reverse_port(...) — not execute_any_shell_command().
Structured outputs — {"pid": 8421, "status": "running"}, not a wall of text.
Scoped, not omnipotent — no generic shell by default. run_shell exists only as an explicit opt-in (ADB_MCP_ALLOW_SHELL=1). Destructive tools (delete_file, clear_app_data, uninstall) are clearly named and delete_file refuses protected roots (/, /system, /data, …).
Multi-device aware — every device tool takes an optional serial; get_devices flags is_usb so you can tell a USB phone from a network/emulator target (e.g. WSA).

Install

pip install adbmcp          # from PyPI
# or from a clone:
pip install -e .

PyPI package name is adbmcp; the import package and python -m target are adb_mcp, and the installed console command is adbmcp.

Requires Python ≥ 3.10 and the Android platform-tools (adb) on your machine. adb is auto-detected from ANDROID_HOME, the default SDK location, scoop, or PATH; override with ADB_PATH.

Register with an MCP client

An MCP server is just a program the client launches and talks to over stdio. "Installing" it means telling your client what command to run plus any env — the same three things everywhere: command, args, env. After pip install adbmcp you get both an adbmcp command and python -m adb_mcp.server; use whichever your client resolves (see the Windows PATH note if a bare adbmcp isn't found). Sanity-check it launches:

adbmcp        # starts and waits on stdio; Ctrl-C to exit. No output = healthy.

claude mcp add adb --env ADB_SERIAL=RFCWC17BKJY -- adbmcp

Add --scope user to enable it in every project. Or drop a .mcp.json in a project root (see examples/mcp.json):

{
  "mcpServers": {
    "adb": {
      "command": "adbmcp",
      "args": [],
      "env": {
        "ADB_SERIAL": "RFCWC17BKJY",   // optional default device
        "ADB_MCP_ALLOW_SHELL": "0"      // set "1" to enable run_shell
      }
    }
  }
}

Run /mcp inside Claude Code to confirm it connected.

Edit claude_desktop_config.json (Windows: %APPDATA%\Claude\, macOS: ~/Library/Application Support/Claude/) and restart the app:

{
  "mcpServers": {
    "adb": {
      "command": "adbmcp",
      "args": [],
      "env": { "ADB_SERIAL": "RFCWC17BKJY" }
    }
  }
}

codex mcp add adb -- adbmcp, or add to ~/.codex/config.toml:

[mcp_servers.adb]
command = "adbmcp"
args = []

[mcp_servers.adb.env]
ADB_SERIAL = "RFCWC17BKJY"

Add to opencode.json (project root) or ~/.config/opencode/opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "adb": {
      "type": "local",
      "command": ["adbmcp"],
      "enabled": true,
      "environment": { "ADB_SERIAL": "RFCWC17BKJY" }
    }
  }
}

.cursor/mcp.json (project) or ~/.cursor/mcp.json (global) — same shape as Claude:

{
  "mcpServers": {
    "adb": { "command": "adbmcp", "args": [], "env": { "ADB_SERIAL": "RFCWC17BKJY" } }
  }
}

.vscode/mcp.json — note the servers key and explicit type:

{
  "servers": {
    "adb": { "type": "stdio", "command": "adbmcp", "args": [], "env": { "ADB_SERIAL": "RFCWC17BKJY" } }
  }
}

Any other MCP-capable client (Cline, Zed, Windsurf, …) works the same way — point it at the adbmcp command with your env; only the config file location differs.

Windows PATH note. Clients spawn the server in their own environment and may not inherit your shell's PATH, so a bare adbmcp can fail to resolve. If a client won't start it, use the absolute interpreter + module form (and pin ADB_PATH too):
{
  "command": "C:\\Users\\you\\AppData\\Local\\Programs\\Python\\Python312\\python.exe",
  "args": ["-m", "adb_mcp.server"],
  "env": {
    "ADB_PATH": "C:\\Users\\you\\AppData\\Local\\Android\\Sdk\\platform-tools\\adb.exe",
    "ADB_SERIAL": "RFCWC17BKJY"
  }
}

Configuration

env var	meaning
`ADB_PATH`	Path to `adb` (auto-detected if unset).
`ANDROID_HOME` / `ANDROID_SDK_ROOT`	SDK root used for adb auto-detection.
`ADB_SERIAL`	Default device serial. USB phone: `RFCWC17BKJY`; WSA/emulator: `127.0.0.1:58526`.
`ADB_MCP_ALLOW_SHELL`	`1`/`true` enables the opt-in `run_shell` escape hatch (default off).

Every device-facing tool also accepts a serial argument to override per call, and you can switch the session default at runtime with set_default_device.

Tool reference (90)

Device (15)

get_devices · get_state · adb_version · get_device_properties · get_screen_info · get_battery · connect · disconnect · wait_for_device · reboot · set_default_device · get_default_device · root_adb · unroot_adb · remount

Apps (16)

list_packages · launch_package · launch_activity · force_stop · kill_background · clear_app_data · app_status · get_current_activity · get_package_info · install_apk · uninstall · grant_permission · revoke_permission · set_package_enabled · start_service · send_broadcast

Input (12)

tap · long_press · swipe · drag · text · keyevent · press_home · press_back · press_recents · press_power · press_enter · wake_and_unlock

UI automation (3)

dump_ui · find_elements · tap_element — parse the live view hierarchy (uiautomator) and tap elements by text / resource-id / content-description instead of guessing pixel coordinates.

Logs (8)

logcat_start · logcat_stop · logcat_dump · logcat_filter · logcat_clear · get_crash_log · get_anr_traces · capture_bugreport — background capture with parsed records {time, pid, tid, level, tag, message}.

Media (5)

capture_screen (inline PNG) · capture_screen_to_file · capture_screen_base64 · record_screen_start · record_screen_stop

Files (9)

list_files · file_exists · stat_file · pull · push · read_file · write_file · make_dir · delete_file — read_file/write_file/list_files support as_root (su -c …) for rooted devices (WSA/Magisk).

Network (11)

forward_port · reverse_port · list_forwards · list_reverses · remove_forward · remove_reverse · clear_forwards · get_ip_address · set_wifi · set_mobile_data · set_airplane_mode — reverse_port maps a device port to your PC (local API/CDN shims).

System (11)

get_prop · set_prop · get_setting · put_setting · list_processes · get_meminfo · get_top · get_uptime · dumpsys (scoped to a named service) · list_services · run_shell (opt-in)

Example: investigate an in-app action

Prompt: "Find what happens when I send a fleet."

launch_package("com.geargames.homeworld")
capture_screen()                       # observe
tap_element(text="Fleet")              # navigate via the view hierarchy
logcat_start(clear=True)
tap_element(text="Send")               # trigger
logcat_dump(tags=["Unity","libc"])     # structured records
pull("/sdcard/Android/data/com.game/files/save.db", "dumps/save.db")

Local-server / shim workflow

reverse_port(device_port=7071, host_port=7071)   # app's localhost:7071 -> your PC shim
reverse_port(device_port=7072, host_port=7072)
launch_package("com.geargames.homeworld")
logcat_filter(tags=["Curl","PlayFab"])

Development

pip install -e ".[dev]"
pytest -q          # device-free smoke tests (imports, registration, parsers)
ruff check .

CI runs the same on Python 3.10–3.12.

Safety

MCP servers execute local commands and can touch files, logs, and devices, so overly permissive ones become dangerous when an agent chains their tools. adb-mcp is deliberately scoped:

No always-on arbitrary shell. run_shell is the only general-shell tool and it is off unless ADB_MCP_ALLOW_SHELL=1.
Injection-hardened. adb shell concatenates its args through the device's sh, so every list-form command is shlex.quoted in one central place — a payload like "; rm -rf /sdcard" in a package name or dumpsys arg becomes a literal argument, never a second command. Covered by tests.
Few, guarded mutating tools — write_file, delete_file (refuses /, /system, /data, …), clear_app_data, uninstall, install_apk, set_prop, put_setting, the set_* network toggles.

Point it at a device you own and trust, run one server per intended device (use ADB_SERIAL/serial), and leave ADB_MCP_ALLOW_SHELL off unless you need it. See SECURITY.md for the full model.

License

MIT — see LICENSE.

Available Tools

90 tools

adb_versionA

Return the host adb client version string and the resolved adb path.

Inputs: no named parameters. Returns: object

app_statusC

Return {package, pid, running} for a package.

Inputs: package (required), serial. Returns: object

capture_bugreportB

Capture a full bugreport zip to local_path (slow; can take minutes).

Inputs: local_path (required), serial. Returns: object

capture_screenA

Capture a screenshot and return it as an inline PNG image. If save_path is given, also writes the PNG there. Ideal for an observe->decide->tap loop / OCR.

Inputs: serial, save_path.

capture_screen_base64A

Capture a screenshot and return {format, bytes, base64} — for when a raw base64 payload is preferred over an inline image.

Inputs: serial. Returns: object

capture_screen_to_fileA

Capture a screenshot and save it to save_path, returning {status, path, bytes} (no inline image — use when you only need the file).

Inputs: save_path (required), serial. Returns: object

clear_app_dataB

Clear ALL app data for a package (destructive: wipes saves/cache/prefs).

Inputs: package (required), serial. Returns: object

clear_forwardsB

Remove ALL forward and reverse rules for the device.

Inputs: serial. Returns: object

connectB

adb connect ip:port — attach a network device (WSA, emulator, wireless).

Inputs: host_port (required). Returns: object

delete_fileA

Delete a device file or (recursive=True) directory. DESTRUCTIVE. Refuses obviously dangerous roots like '/', '/system', '/data'.

Inputs: remote (required), serial, as_root, recursive. Returns: object

disconnectA

adb disconnect a network device (or all if host_port omitted).

Inputs: host_port. Returns: object

dragB

Drag (slow swipe) from (x1,y1) to (x2,y2). Alias of swipe with a longer default.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +2 more. Returns: object

dumpsysA

Run dumpsys <service> for a NAMED service (e.g. 'battery', 'wifi', 'activity', 'meminfo', 'connectivity') and return the raw text (capped). Scoped to a service name — not an arbitrary shell.

Inputs: service (required), args, serial, max_chars. Returns: object

dump_uiA

Dump the current on-screen view hierarchy as a flat list of elements {text, resource_id, content_desc, class, clickable, enabled, bounds:{...,center_x,center_y}}.

non_empty_only drops nodes with no text/id/description (usually layout containers); clickable_only keeps only clickable nodes.

Inputs: serial, clickable_only, non_empty_only. Returns: result

file_existsC

Check whether a path exists on the device. Returns {exists, is_dir}.

Inputs: remote (required), serial, as_root. Returns: object

find_elementsA

Find on-screen elements matching any of text / resource_id / content_desc. Substring match by default; exact=True requires a full match. Returns the same element records as dump_ui, each with a bounds.center for tapping.

Inputs: text, exact, serial, resource_id, +1 more. Returns: result

force_stopB

Force-stop an app (idempotent). Returns {package, status}.

Inputs: package (required), serial. Returns: object

forward_portA

adb forward tcp:local tcp:remote — forward a HOST port to a DEVICE port (host connects locally, traffic reaches the device).

Inputs: local_port (required), remote_port (required), serial. Returns: object

get_anr_tracesA

Pull the most recent ANR trace file (/data/anr/traces.txt or /data/anr/). Returns {status, local, size} (needs root/permission on some devices).

Inputs: serial, local_path. Returns: object

get_batteryB

Return battery level/status/health/temperature (from dumpsys battery).

Inputs: serial. Returns: object

get_crash_logB

Dump the 'crash' logcat buffer (native + Java crashes), newest tail records.

Inputs: tail, serial. Returns: result

get_current_activityB

Return the currently focused activity/package (foreground app).

Inputs: serial. Returns: object

get_default_deviceA

Return the currently active default device serial (runtime or ADB_SERIAL).

Inputs: no named parameters. Returns: object

get_device_propertiesB

Return the target environment: model, manufacturer, abi, android release, sdk level, build fingerprint, and screen info. Tells the agent exactly what it is targeting before acting.

Inputs: serial. Returns: object

get_devicesA

List attached devices/emulators with state and transport.

Returns [{serial, state, is_usb, model, device, transport_id}]. is_usb is False for network devices (serials containing ':', e.g. WSA/emulators).

Inputs: no named parameters. Returns: result

get_ip_addressB

Return the device's IPv4 address on an interface (default wlan0).

Inputs: iface, serial. Returns: object

get_meminfoA

Return memory info. With a package: that app's total PSS (kB); otherwise the global summary (Total/Free/Used/Lost RAM). Returns parsed fields + raw text.

Inputs: serial, package. Returns: object

get_package_infoB

Return structured package info: versionName, versionCode, targetSdk, minSdk, installer, firstInstall/lastUpdate times, and granted runtime permissions.

Inputs: package (required), serial. Returns: object

get_propA

Read a single system property by name, or ALL props as a dict when name is omitted (parses getprop).

Inputs: name, serial.

get_screen_infoB

Return effective display size and density: {width, height, density, raw}.

Prefers the Override size (what input coordinates map to) when set.

Inputs: serial. Returns: object

get_settingB

Read an Android setting. namespace = 'system' | 'secure' | 'global'.

Inputs: key (required), namespace (required), serial. Returns: object

get_stateB

Return the connection state of a device: device / offline / unauthorized.

Inputs: serial. Returns: object

get_topB

Return a one-shot top snapshot of the top count processes by CPU (raw text).

Inputs: count, serial. Returns: object

get_uptimeB

Return device uptime (seconds + human string) from /proc/uptime and uptime.

Inputs: serial. Returns: object

grant_permissionB

Grant a runtime permission, e.g. 'android.permission.CAMERA' (pm grant).

Inputs: package (required), permission (required), serial. Returns: object

install_apkA

Install an APK, or a split-APK set via install-multiple when >1 path given. replace=-r, grant_permissions=-g, downgrade=-d. Returns {status, message}.

Inputs: apk_paths (required), serial, replace, downgrade, +1 more. Returns: object

keyeventC

Send a key event. Accepts a numeric keycode or a name like BACK, HOME, ENTER, TAB, DEL, APP_SWITCH, VOLUME_UP (KEYCODE_ prefix optional).

Inputs: keycode (required), serial, longpress. Returns: object

kill_backgroundA

Kill an app's background processes (am kill, gentler than force-stop).

Inputs: package (required), serial. Returns: object

launch_activityB

Start an explicit activity, e.g. 'com.app/.MainActivity' (am start -n). Returns the am output and resulting pid if resolvable.

Inputs: component (required), serial. Returns: object

launch_packageB

Launch an app by package via its LAUNCHER intent (idempotent). Returns {package, pid, status}.

Inputs: package (required), serial. Returns: object

list_filesA

List a device directory: [{name, size, is_dir, is_link, perms}]. as_root uses su -c ls on rooted devices. Symlinked dirs (e.g. /sdcard on Samsung) are dereferenced so their contents are listed, not the link.

Inputs: remote_dir (required), serial, as_root. Returns: result

list_forwardsB

List active adb forward rules: [{serial, local, remote}].

Inputs: serial. Returns: result

list_packagesA

List installed package names. filter = case-insensitive substring. only_third_party excludes system apps; include_paths returns {package, apk}.

Inputs: filter, serial, only_enabled, include_paths, +1 more. Returns: result

list_processesA

List running processes (ps -A): [{pid, ppid, name, user}]. filter = name substring.

Inputs: filter, serial. Returns: result

list_reversesC

List active adb reverse rules: [{remote, local}].

Inputs: serial. Returns: result

list_servicesC

List all dumpsys service names available on the device.

Inputs: serial. Returns: result

logcat_clearC

Clear the device logcat ring buffers (logcat -c).

Inputs: serial. Returns: object

logcat_dumpA

Return recent logcat lines as records {time, pid, tid, level, tag, message}.

Reads the running capture's buffer if active, else does a one-shot logcat -d. tags = filter by tag substring(s); priority = min level V/D/I/W/E/F; message_contains = substring filter on the message; tail = newest N records.

Inputs: tags, tail, serial, priority, +1 more. Returns: result

logcat_filterC

Convenience: logcat_dump filtered to the given tags (e.g. ['Unity','libc','DEBUG']).

Inputs: tags (required), tail, serial. Returns: result

logcat_startA

Start a background logcat capture to a temp file. Read it with logcat_dump/ logcat_filter; end it with logcat_stop. Only one capture runs at a time. buffers optionally selects e.g. 'main,system,crash'.

Inputs: clear, serial, buffers. Returns: object

logcat_stopA

Stop the background logcat capture started by logcat_start.

Inputs: no named parameters. Returns: object

long_pressA

Long-press at (x, y) for duration_ms (implemented as a zero-distance swipe).

Inputs: x (required), y (required), serial, duration_ms. Returns: object

make_dirC

Create a directory on the device (mkdir -p).

Inputs: remote (required), serial, as_root. Returns: object

press_backC

Press the BACK button.

Inputs: serial. Returns: object

press_enterC

Press ENTER.

Inputs: serial. Returns: object

press_homeC

Press the HOME button.

Inputs: serial. Returns: object

press_powerB

Press the POWER button (toggles screen on/off).

Inputs: serial. Returns: object

press_recentsA

Open the recent-apps / overview screen (APP_SWITCH).

Inputs: serial. Returns: object

pullC

Pull a file/dir from the device to host path local.

Inputs: local (required), remote (required), serial. Returns: object

pushC

Push a host file local to device path remote.

Inputs: local (required), remote (required), serial. Returns: object

put_settingC

Write an Android setting. namespace = 'system' | 'secure' | 'global'.

Inputs: key (required), value (required), namespace (required), serial. Returns: object

read_fileB

Read a text file from the device (up to max_bytes). as_root uses su -c cat (WSA/Magisk). Returns {remote, truncated, content}.

Inputs: remote (required), serial, as_root, max_bytes. Returns: object

rebootB

Reboot the device. mode: '' (normal), 'recovery', 'bootloader', or 'sideload'.

Inputs: mode, serial. Returns: object

record_screen_startA

Start recording the screen on-device (screenrecord runs in the background). time_limit_s caps duration (screenrecord max 180s per segment). size like '720x1280' to downscale. Call record_screen_stop to finish and pull the mp4.

Inputs: size, serial, time_limit_s, bit_rate_mbps. Returns: object

record_screen_stopA

Stop the background screen recording, pull it to local_path, and clean up the on-device file. Returns {status, local, size}.

Inputs: local_path (required), serial. Returns: object

remountB

Remount /system (and other partitions) read-write (adb remount). Needs root.

Inputs: serial. Returns: object

remove_forwardB

Remove a single adb forward rule for tcp:local_port.

Inputs: local_port (required), serial. Returns: object

remove_reverseC

Remove a single adb reverse rule for tcp:device_port.

Inputs: device_port (required), serial. Returns: object

reverse_portA

adb reverse tcp:device tcp:host — map a DEVICE port to a HOST port so the app's 127.0.0.1:<device_port> traffic reaches your PC (e.g. a local API/CDN shim).

Inputs: host_port (required), device_port (required), serial. Returns: object

revoke_permissionC

Revoke a runtime permission (pm revoke).

Inputs: package (required), permission (required), serial. Returns: object

root_adbA

Restart adbd as root (adb root). Only works on rooted/userdebug builds; on production builds use su via read_file(as_root=True) etc. instead.

Inputs: serial. Returns: object

run_shellA

Run an arbitrary device shell command. DISABLED by default — set the env var ADB_MCP_ALLOW_SHELL=1 to enable. Prefer the specific scoped tools; this exists only as an explicit, opt-in escape hatch. Returns {rc, output}.

Inputs: command (required), serial, timeout. Returns: object

send_broadcastB

Send a broadcast intent (am broadcast -a <action>). Optional target component and string extras {key: value}.

Inputs: action (required), extras, serial, component. Returns: object

set_airplane_modeB

Toggle airplane mode (settings + broadcast). May need root on newer Android.

Inputs: enabled (required), serial. Returns: object

set_default_deviceA

Set the session default device serial (overrides ADB_SERIAL for later calls). Pass an empty string to clear it.

Inputs: serial (required). Returns: object

set_mobile_dataB

Enable/disable mobile data via svc data (may need root on newer Android).

Inputs: enabled (required), serial. Returns: object

set_package_enabledB

Enable or disable a package (pm enable / pm disable-user).

Inputs: enabled (required), package (required), serial. Returns: object

set_propB

Set a system property (setprop). Many props are read-only or need root.

Inputs: name (required), value (required), serial. Returns: object

set_wifiB

Enable/disable Wi-Fi via svc wifi (may need root on newer Android).

Inputs: enabled (required), serial. Returns: object

start_serviceC

Start a service by component 'pkg/.Service' (am startservice).

Inputs: component (required), serial. Returns: object

stat_fileC

Return stat info for a device path: {size, mtime, perms, uid, gid} (best-effort).

Inputs: remote (required), serial. Returns: object

swipeB

Swipe from (x1,y1) to (x2,y2) over duration_ms. Use for scrolling/flinging.

Inputs: x1 (required), x2 (required), y1 (required), y2 (required), +2 more. Returns: object

tapC

Tap the screen at pixel (x, y).

Inputs: x (required), y (required), serial. Returns: object

tap_elementA

Find an element (by text/resource_id/content_desc) and tap its center. index selects among multiple matches. Returns the matched element + tap point.

Inputs: text, exact, index, serial, +2 more. Returns: object

textB

Type a string into the focused field. Spaces and shell-special characters are escaped so the literal text is entered.

Inputs: value (required), serial. Returns: object

uninstallB

Uninstall a package. keep_data=True keeps data/cache dirs (-k).

Inputs: package (required), serial, keep_data. Returns: object

unroot_adbB

Restart adbd without root (adb unroot).

Inputs: serial. Returns: object

wait_for_deviceA

Block until the device is online (or timeout). Useful after reboot/connect.

Inputs: serial, timeout. Returns: object

wake_and_unlockA

Wake the screen and swipe up to dismiss a non-secure lock screen.

Inputs: serial. Returns: object

write_fileA

Write text content to a device file by pushing a temp file (handles any content safely, unlike shell echo). as_root pushes to /data/local/tmp then su -c cp into place. Returns {status, remote, bytes}.

Inputs: remote (required), content (required), serial, as_root. Returns: object

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

Deploy Server

Claude Code, inside the Godot 4 editorFlockbay puts an AI agent in the real Godot 4 editor: it writes GDScript, runs your game and fixes what breaks. Free, or bring your own Claude Code or Codex.flockbay.comAd

TDQS

B3/5.0

Scored 2026-10-05 01:05 across 90 tools

Disambiguation3/5

Many tools have distinct purposes, but several overlapping groups exist (e.g., capture_screen variants, tap vs tap_element, launch_package vs launch_activity, force_stop vs kill_background, logcat_dump vs logcat_filter). With 90 tools, an agent may struggle to select the right one, though descriptions help clarify boundaries.

Naming Consistency4/5

All tool names use snake_case, providing a consistent surface style. However, there is a mix of verb_noun (list_packages, get_devices) and bare verbs (connect, reboot, tap), and inconsistent verb choices for similar operations (set_prop vs put_setting). These are minor deviations from a uniform pattern.

Tool Count1/5

90 tools is far above the recommended 3-15 range and exceeds the 50+ threshold for extreme mismatch. While ADB is a complex domain, the tool count is excessive and many tools could be consolidated (e.g., screen capture variants, logcat controls), creating a high cognitive load for agents.

Completeness4/5

The set covers a very broad range of ADB functionality: device management, app lifecycle, file operations, input, logging, screen capture, networking, settings, and UI automation. Minor gaps exist (e.g., setting display size/density, managing users, kernel logs), but agents can work around most tasks.

Maintenance

ActivitySlowing

ResponsivenessNo recent community issues

Resources

Related MCP Connectors

hithereiamaliff-mcp-nextcloud
ai.smithery
A comprehensive Model Context Protocol (MCP) server that enables AI assistants to interact with yo…
Cloud Storage File Systems Workplace & Productivity
239
https://server.smithery.ai/@hithereiamaliff/mcp-nextcloud/mcp
Flowra
io.github.flowradev
MCP server for your apps' tools and custom tools, plus hosted AI agents and approval-gated workflows
Agent Orchestration Autonomous Agents
11
https://mcp.flowra.dev/mcp
mcp-server
com.niftypm
Nifty's MCP server — exposes tasks, projects, messages, and files as tools for AI agents.
Project Management Communication File Systems
2
https://mcp.niftypm.com/mcp
anotherai
dev.anotherai
MCP server for building and testing AI agents with multi-model experimentation and insights.
Agent Orchestration Autonomous Agents Testing & QA Tools
2
https://api.anotherai.dev/mcp

Related MCP Servers

ADB MCP Server
Shell Access App Automation Testing & QA Tools
LLL-404
F
license
A
quality
C
maintenance
A MCP server that enables AI assistants to control Android devices via ADB, supporting device info, screen control, input simulation, app management, shell execution, file transfer, and UI parsing.
Updated 15 days ago (2026-10-28 09:07 UTC)
20
-
DeepADB
Shell Access Developer Tools Testing & QA Tools
fullread
A
license
B
quality
B
maintenance
A comprehensive MCP server that enables AI agents to interact with Android devices through Android Debug Bridge (ADB), offering 198 tools for device control, app management, diagnostics, and more.
Updated 3 days ago (2026-11-10 03:40 UTC)
209
169 npm
23
Apache 2.0
android-mcp-server
Developer Tools Testing & QA Tools
jaye773
F
license
Not graded
quality
D
maintenance
A powerful MCP server that provides comprehensive Android device automation capabilities through ADB, enabling AI agents to interact with Android devices for testing, automation, and device control tasks.
Updated 5 months ago (2026-06-10 15:56 UTC)
1
-
android-adb-mcp
Shell Access Command Line File Systems
qinxiandiqi
A
license
Not graded
quality
D
maintenance
An MCP server that wraps Android ADB functionality into AI assistant tools, enabling device management, shell execution, file operations, app management, media capture, and log analysis via natural language.
Updated a year ago (2025-11-06 10:23 UTC)
23 npm
3
MIT

adb-mcp

Why

Design principles

Install

Register with an MCP client

Configuration

Tool reference (90)

Device (15)

Apps (16)

Input (12)

UI automation (3)

Logs (8)

Media (5)

Files (9)

Network (11)

System (11)

Example: investigate an in-app action

Local-server / shim workflow

Development

Safety

License

Available Tools

Tool Schema Changelog

TDQS

Maintenance

Resources

Related MCP Connectors

Related MCP Servers

ADB MCP Server

DeepADB

android-mcp-server

android-adb-mcp