Server data from the Official MCP Registry
Full-featured ADB MCP server — 209 tools across 49 modules, from UI to baseband.
About
Full-featured ADB MCP server — 209 tools across 49 modules, from UI to baseband.
Security Report
Valid MCP server (6 strong, 2 medium validity signals). No known CVEs in dependencies. Imported from the Official MCP Registry. Trust signals: 3 highly-trusted packages. 1 finding(s) downgraded by scanner intelligence.
5 files analyzed · 1 issue found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
Permissions Required
This plugin requests these system permissions. Most are normal for its category.
How to Install
Add this to your MCP configuration file:
{
"mcpServers": {
"deepadb": {
"command": "npx",
"args": [
"-y",
"deepadb@1.1.7"
]
}
}
}Some servers take additional arguments. See the repository for details.
Documentation
View on GitHubFrom the project's GitHub README.
DeepADB
MCP (Model Context Protocol) server for AI agents that need to inspect, control, test, and diagnose Android devices through ADB—or directly on-device through Termux.
209 tools, 5 resources, and 4 prompts across 49 modules—from UI automation and application management to logs, network capture, baseband, firmware, security, and hardware diagnostics.
Get started
DeepADB runs as a local MCP server. It uses ADB on a host computer and automatically switches to direct execution when running on Android (detected through /system/build.prop).
git clone https://github.com/fullread/DeepADB.git
cd DeepADB
npm ci
npm run build
npm start
Add build/index.js to your MCP client configuration, then begin with these workflows:
| Goal | Start with |
|---|---|
| Confirm the toolchain and connected device | adb_health_check, then adb_devices |
| Inspect the current Android UI | adb_screen_state, then adb_ui_dump |
| Diagnose a device or app | adb_device_info, adb_logcat, and adb_dumpsys |
For a guided local connection, see MCP Client Configuration. Read SECURITY.md before exposing HTTP, WebSocket, or GraphQL transports beyond loopback.
Using llama.cpp or another local model? See Local LLM clients for direct stdio, authenticated browser HTTP, and small tool profiles. WebSocket is not required.
1.1.7 release
Version 1.1.7 fixes screenshot temporary-file isolation and root/Termux cleanup, retains Android sensor handle zero, and adds portable emulator regression coverage. The 209-tool interface and existing MCP clients/plugins remain compatible.
For deepadb-v1.1.7-prebuilt.zip, extract its contents into a
folder named deepadb-v1.1.7, then run:
cd deepadb-v1.1.7
npm ci --omit=dev
npm start
No TypeScript build is needed for the prebuilt archive.
npm install -g deepadb@1.1.7 installs the same patch from npm. For an HTTP client, use
the authenticated local LLM examples; WebSocket/GraphQL remain
optional and need their documented runtime dependencies.
Architecture
┌──────────────────────────────────────────────────┐
│ MCP Client │
│ (Any MCP-capable client) │
└──────────────────────┬───────────────────────────┘
│ stdio (JSON-RPC), HTTP (/mcp or /sse), or WebSocket
┌──────────────────────▼───────────────────────────┐
│ DeepADB Server │
│ │
│ ┌─────────────────────────────────────────────┐ │
│ │ Tool Modules (49) │ │
│ │ device │ shell │ packages │ files │ logs │ │
│ │ diagnostics │ ui │ build │ health │ │
│ │ wireless │ control │ logcat-watch │ │
│ │ forwarding │ screen-record │ emulator │ │
│ │ testing │ multi-device │ snapshot │ │
│ │ network-capture │ ci │ plugins │ baseband │ │
│ │ accessibility │ regression │ │
│ │ device-farm │ registry │ at-commands │ │
│ │ screenshot-diff │ workflow │ sensors │ │
│ │ split-apk │ mirroring │ test-gen │ │
│ │ ota-monitor │ ril-intercept │ │
│ │ device-profiles │ firmware-analysis │ │
│ │ workflow-market │ selinux-audit │ │
│ │ thermal-power │ network-discovery │ │
│ │ input-gestures │ wireless-firmware │ │
│ │ app-network │ database-inspector │ │
│ │ runtime-audit │ wear │ │
│ ├─────────────────────────────────────────────┤ │
│ │ Resources (5) │ Prompts (4) │ │
│ └───────────────────┬─────────────────────────┘ │
│ │ │
│ ┌───────────────────▼─────────────────────────┐ │
│ │ ToolContext (unified DI) │ │
│ │ server │ bridge │ deviceManager │ │
│ │ logger │ security │ config │ │
│ └───────────────────┬─────────────────────────┘ │
│ │ │
│ ┌───────────────────▼─────────────────────────┐ │
│ │ Middleware Layer │ │
│ │ OutputProcessor │ SecurityMiddleware │ │
│ │ InputSanitizer │ Logger (stderr-safe) │ │
│ └───────────────────┬─────────────────────────┘ │
│ │ │
│ ┌───────────────────▼─────────────────────────┐ │
│ │ Bridge Layer (auto-detect) │ │
│ │ │ │
│ │ ┌─────────────┐ ┌────────────────────┐ │ │
│ │ │ ADB Bridge │ OR │ Local Bridge │ │ │
│ │ │ (PC mode) │ │ (on-device mode) │ │ │
│ │ │ via adb.exe │ │ via sh/su direct │ │ │
│ │ └──────┬───────┘ └────────┬───────────┘ │ │
│ │ │ │ │ │
│ │ Retry │ Timeout │ Cache │ Serial routing │ │
│ └─────────┼─────────────────────┼─────────────┘ │
└────────────┼─────────────────────┼───────────────┘
│ │
┌───────▼───────┐ ┌───────▼───────┐
│ ADB Binary │ │ sh / su │
│ (USB/WiFi) │ │ (local) │
└───────┬───────┘ └───────┬───────┘
│ │
┌─────▼────────────────────▼─────┐
│ Android Device │
└────────────────────────────────┘
Dual-Mode Architecture
DeepADB operates in two modes, auto-detected at startup:
ADB Mode (default) — PC-side bridge
AI Agent (PC) ←→ MCP ←→ DeepADB (PC) ←→ ADB (USB) ←→ Android Device
Standard mode: DeepADB runs on a PC/Mac/Linux host and communicates with the device over USB via ADB. The complete 209-tool surface is registered through the ADB bridge with automatic retry on transient failures; environment-specific tools report their capability requirements when a host cannot run them.
On-Device Mode — direct local execution
AI Agent (Termux) ←→ MCP (stdio/HTTP) ←→ DeepADB (Termux) ←→ sh/su (local)
When DeepADB runs directly on the Android device (e.g., inside Termux), it auto-detects the environment and switches to LocalBridge. Commands execute directly via sh/su — no ADB server, no USB, no serialization overhead. The same 209-tool MCP surface is registered, with capability-aware guidance when an optional on-device binary such as sqlite3 is unavailable.
Current test profiles: npm test retains strict rooted Pixel 6a / Android 16
coverage. npm run test:emulator uses a disposable fixture app for portable
lifecycle/UI tests and verifies sensor readings against Android's actual inventory.
Pixel-only hardware checks have explicit skips in the emulator profile; unexpected
failures still fail its optional CI lane. See test setup and profile boundaries.
The older release baselines below describe their published artifacts. See the
1.1.7 changelog for the
current release and validation.
Dependency refresh (November 14, 2026): compatible development, optional-transport and transitive dependencies were updated. Build, lint, 394 device-free checks, 23 runner/profile checks and eight host browser checks pass; full and production-only audits report zero vulnerabilities. The refreshed tree also passes 879 on-device checks, zero failures and three cached-QEMU setup skips across 27 suites on the Pixel 6a, including PIN checks and actual VM boot/shutdown. It replaces the previous on-device installation while preserving shared state and VM cache. Staged and installed production copies each pass ten strict smoke checks; three direct Termux capture checks, eight installed-server browser checks and six WebSocket/GraphQL checks also pass. Hosted verification for this refresh is tracked in PR #66 checks. See the refresh record for details; the November 9 results below remain the earlier dependency-tree baseline.
1.1.7 validation (November 9, 2026): the full on-device regression passed 879 checks, zero failures, three cached-QEMU setup skips (882 total) across 27 suites on the rooted Pixel 6a / Android 16 with Termux Node 24.22.1. Actual VM boot/shutdown, all 30 sensor checks, 30 screenshot-cleanup checks, 46 UI/PIN checks, SQLite/Shannon diagnostics and existing client/plugin compatibility passed. The suite used an isolated validation checkout with the production build's matching files. Host/ADB coverage passed 826 checks with 18 expected skips; after the network-negative test correction, its boundary suite passed 79 checks. The final device-free set passed 394 checks with 17 expected skips. These are distinct test configurations; their counts are not interchangeable. Production-build verification also includes ten strict smoke checks before and after installation, three direct Termux-user capture/cleanup checks, eight real-browser HTTP checks and six authenticated WebSocket/GraphQL checks. The previous 1.1.6 installation and temporary test/rollback copies were removed; shared user state and VM images were preserved. The production directory contains runtime dependencies and the optional transport libraries, without the test/development checkout. Real phone-to-watch Wear validation remains deferred.
1.1.6 device validation (November 1, 2026): the released build's full on-device run passed 836 checks, 0 failed, 3 skipped (839 total) across all 24 suites on the rooted Pixel 6a / Android 16, using Termux Node 24.22.1 and SQLite 3.54.1. The three skips reuse the cached Alpine kernel, initrd and disk; the actual VM boot and shutdown checks passed. Coverage includes the 28 runtime-audit regressions, device SQLite, live Shannon AT/OK, client/plugin compatibility, POSIX security cases and PIN-based UI recovery. The production installation passed eight strict checks before and after promotion, plus eight real Chromium checks and six authenticated WebSocket/GraphQL checks. Following the final documentation audit and verified redeployment, 1.1.6 was the only DeepADB installation retained on the validation Pixel at that time; older installations and rollback copies were removed at the operator's request. Real phone-to-watch validation remains deferred.
The earlier 1.1.6 host/ADB baseline on Windows/Node 24.22.2 passed 783 checks,
0 failed, 18 expected skips (801 total). After the oversized-header test was
split into a portable regression, Node 22.23.4 device-free coverage passed
351 checks, 0 failed, 17 expected skips (368 total). Host skips cover
device-only or POSIX behavior, unavailable tcpdump and Windows file-symlink
privileges; they are distinct from the on-device results above.
v1.1.5 final audit-fix verification (Windows host): the ten device-free suites passed 295 checks, zero failures, and 17 expected skips (312 total) under Node 22.23.4 with coverage. The new hardening suite separately passed 41 checks on Node 24.22.2, with one Windows file-symlink capability skip; 16 other skips in the full CI set require hardware. Eight real-browser CORS/reload checks passed. The Pixel passed eight disposable POSIX path/link/race checks and five focused hardware smoke checks; the latest snapshot code also completed a real schema read through the isolated worker. These initial checks preceded the separate on-device release validation described below.
Final hardening hardware regression (October 31, 2026): all 22 host/ADB suites passed on the Pixel 6a / Android 16 using Node 24.22.2: 728 passed, 0 failed, 18 expected skips (746 total). This includes 41 audit-hardening, 33 local-LLM, 36 SDK/client/plugin compatibility, 93 security and 46 UI checks, plus live SQLite and Shannon validation. The skips are five on-device-only QEMU checks, twelve Windows/POSIX/tcpdump checks and one Windows file-symlink capability case. That last case is additionally covered by the disposable Pixel POSIX probes above. The suite exited successfully, left no ADB forwards, and made no repository file changes. This validates the host build; on-device LocalBridge execution is verified separately during release preparation.
1.1.5 release validation: the production-only package initializes with 209 tools, five resources/templates and four prompts. The staged Pixel build, using Termux Node 24.22.1 and SQLite 3.54.1, passed real SQLite schema/query reads, write rejection, runtime/health checks and a live Shannon handshake. Eight real-browser checks also passed against that on-device process, including authenticated SSE/Streamable HTTP, denied Origins and repeated page reloads. Six optional WebSocket/GraphQL checks passed with their production packages installed. The verified build was promoted to the normal installation path; Android auto-detection and all eight strict device checks passed again there. At that release's validation, the 1.1.4 rollback copy also started on the new runtime. The final host hardware rerun passed 728 checks with zero failures and 18 skips; device-free Node 24 coverage passed 295 checks with zero failures and 17 skips. GitHub CI covers Node 22/24/26 builds and regressions, real-browser MCP compatibility, coverage and dependency auditing, with separate CodeQL analysis for application code and GitHub Actions.
Earlier unreleased host hardware validation (October 31, 2026, before the final seven-finding hardening pass): the expanded suite,
including SDK migration, browser reconnect, request-ID/cancellation, plugin
callback lifetime, and profile regressions, completed on Pixel 6a / Android 16
with 687 passed, 0 failed, and 17 expected skips (704 total). Live llama.cpp
checks separately exercised stdio, authenticated browser
Streamable HTTP, and legacy SSE with the inspect profile; see
LOCAL_LLMS.md for the tested model and
browser HTTP reload recovery and its limits. Phone-to-watch Wear validation is deferred.
v1.1.4 host hardware validation: the full Pixel 6a / Android 16 regression completed with 604 passed, 0 failed, and 17 expected environment-specific skips (621 total). This includes live AT/OK validation on /dev/umts_router, a guarded read-only SQLite schema snapshot with cleanup, the unified runtime audit, per-app route context, and the single-device Wear preflight. The skips are the five on-device-only QEMU checks plus twelve Windows-host or unavailable-tcpdump security checks.
v1.1.3 hardware baseline: validated on a Pixel 6a (Android 16, Termux + Magisk + QEMU 10.2.1) across a four-cell test matrix — host (ADB) and on-device (LocalBridge), each with and without a device PIN — with 0 failures in every cell. The v1.1.3 suite contained 577 tests in the host/ADB configuration and 613 on-device; the difference is the QEMU virtualization and Alpine VM-boot suites, which run only on-device:
- ADB mode, no PIN: 556 passed / 0 failed / 21 skipped (577 total). Skips: 5 QEMU (on-device only), 7 gracefulKill unit tests (require POSIX signals, skipped on the Windows host), 3 tcpdump sanitization (tcpdump is root-only and unreachable over a non-root ADB shell), 2 host-shell round-trips (require a POSIX /bin/sh), 4 screen-state (require DA_TEST_PIN).
- ADB mode, with PIN: 560 passed / 0 failed / 17 skipped (577 total). The 4 screen-state tests unlock and run.
- On-device mode, no PIN: 606 passed / 0 failed / 7 skipped (613 total). All QEMU tests run, including Alpine Linux VM boot with KVM acceleration, big.LITTLE CPU topology detection, guest ADB connectivity error handling, and clean VM shutdown; the tcpdump and gracefulKill suites also run here (root + POSIX). Skips: 3 QEMU setup steps that no-op when the Alpine kernel/initrd/disk are already cached, 4 screen-state (require PIN).
- On-device mode, with PIN: 610 passed / 0 failed / 3 skipped (613 total). Every test enabled by the environment runs; the 3 skips are the cached-VM setup steps.
Privilege escalation: In ADB mode, all shell commands run as uid=2000 (the shell user) which has system-level permissions. In Termux, commands run as a regular app user. LocalBridge automatically elevates privileged commands through su when root (Magisk) is available:
- Command allowlist: 16 system commands (
settings,dumpsys,am,input,screencap,screenrecord,uiautomator,app_process,getenforce,setenforce,cmd,pm,wm,svc,ip,ifconfig) are routed throughsu -cto match ADB-mode behavior. - Path-based elevation: Commands referencing
/sdcard,/storage, or/system/paths are elevated to bypass Android scoped storage restrictions. - Root detection: Cached after a single
su -c idprobe at first use. Graceful degradation when root is unavailable. - Screenshot lifecycle: Allocate, capture and remove private device scratch files under the same identity. LocalBridge uses root when available, while the pulled output remains owned by the Termux user. Registered VM targets use ADB on the guest.
- The elevation allowlist is frozen (
ReadonlySet+Object.freeze) — not configurable via environment variables or runtime API.
Auto-detection: Checks for /system/build.prop (present on all Android devices, never on hosts). Override with DA_LOCAL=true or DA_LOCAL=false.
On-device setup (Termux):
pkg install nodejs-lts git sqlite
git clone https://github.com/fullread/DeepADB.git
cd DeepADB
npm ci
npm run build
Choose the launch mode for your client. For stdio, configure the MCP client to
launch node with the absolute path to DeepADB/build/index.js; the client
starts the process itself. To run a loopback HTTP listener instead:
DA_HTTP_HOST=127.0.0.1 DA_HTTP_PORT=3000 npm start # /mcp and legacy /sse
This listener is accessible only on the device, not directly over Wi-Fi. For browser clients, configure a bearer token and an exact Origin allowlist; see Local LLM clients. For remote access, follow the token and TLS reverse-proxy or SSH-tunnel guidance in SECURITY.md.
Use a supported Node LTS release; Node 24 is validated for this release. The
sqlite package supplies the sqlite3 executable required by on-device database
inspection. Production installs that omit development dependencies must install
ws and/or graphql separately when those optional transports are enabled.
Before replacing an existing device installation, stage the built package, keep
a rollback copy, and verify its actual LocalBridge execution with the device's
runtime and binaries. Host/ADB tests alone do not validate that deployment.
MCP Client Configuration
Configure a local stdio MCP server with node as the command and the absolute
path to build/index.js as its argument. The client starts the server process.
For clients that use an mcpServers JSON configuration, the equivalent is:
{
"mcpServers": {
"deepadb": {
"command": "node",
"args": ["/path/to/DeepADB/build/index.js"]
}
}
}
Other clients may use a settings form, TOML, or a different JSON layout; enter
the same command and argument using that client's configuration format. Leave
DA_HTTP_PORT, DA_WS_PORT, and DA_GRAPHQL_PORT unset for this stdio setup.
See Local LLM clients for explicit environment settings and
authenticated browser connections.
Available Tools (209)
Start with the capability area that matches your task; the complete reference remains below.
Complete tool reference
Health (1 tool)
adb_health_check— Comprehensive toolchain validation: ADB binary, server, device connection, authorization, root access, and storage writability
Runtime Audit (1 tool)
adb_runtime_audit— Unified read-only readiness audit for transport, Android userspace, root, SELinux, storage, command capabilities, UI/network diagnostics, SQLite, modem nodes, and Wear prerequisites
The audit retains successful checks when an independent probe fails. Its report
labels readiness as available, unavailable (a confirmed negative result),
or inconclusive (failed, timed out, incomplete, or not safely checked).
Audit status: partial and the Probe issues section identify incomplete
checks while preserving useful device information and snapshots. A partial
report is returned normally; failure to resolve the requested device remains a
tool error. complete means the checks completed, not that every capability is
available. Modem node visibility does not verify an AT handshake, and Play
services presence does not verify phone/watch pairing. Use the dedicated
Shannon and Wear tools for those narrower checks.
SQLite readiness follows the inspector's execution mode: host ADB uses the
host's Node SQLite backend (Node 22.16+ with node:sqlite enabled), while
on-device LocalBridge uses device sqlite3. A phone's SQLite binary cannot
make a missing host backend available. Backend availability alone does not
verify access to a particular app database.
Device (3 tools)
adb_devices— List all connected devices with state, model, and product infoadb_device_info— Detailed device properties (model, OS, SDK, build, security patch, ABI)adb_getprop— Read a specific system property or dump all properties
Shell (2 tools)
adb_shell— Execute arbitrary shell commands with configurable timeout (security-checked)adb_root_shell— Execute commands as root via su (requires rooted device, security-checked)
Packages (12 tools)
adb_install— Install APK with replace/downgrade optionsadb_uninstall— Remove package with optional data retentionadb_list_packages— List packages filtered by name or type (all/system/third-party)adb_package_info— Detailed package info (version, permissions, paths)adb_clear_data— Clear all app data and cacheadb_grant_permission— Grant a runtime permission to a packageadb_revoke_permission— Revoke a runtime permission from a package (reset permission state for testing denial flows)adb_list_permissions— List all declared and granted permissions for a package, filterable by granted/deniedadb_force_stop— Force-stop an app immediatelyadb_start_app— Launch an app by package name (resolves launcher activity)adb_restart_app— Force-stop then re-launch in one call (configurable delay)adb_resolve_intents— Discover registered activities, services, and receivers with intent filters
Room & SQLite Inspection (1 tool)
adb_sqlite_inspect— Package-scoped listing, schema inspection and validated read-only SQL. Prefersrun-as, falls back to root, rejects linked directories/files and verifies opened descriptors. Queries a private snapshot (database + WAL ≤64 MiB) with bounded execution and output, then removes it. Host inspection needs Node 22.16+ and runs in an isolated process; on-device inspection uses a trustedsqlite3binary. Neither backend queries the live app path. Snapshots are not transactional backups; concurrent writes may require retrying with the app stopped.
Files (18 tools)
adb_push— Push local file to device (hard-blocked kernel paths, fs-type awareness, storage reporting)adb_pull— Pull file from device to local filesystemadb_ls— List device directory contents (simple or detailed)adb_cat— Read text file from device with optional line limitadb_file_write— Create or overwrite text files via heredoc (buffer limit warning, fs-aware, post-verify)adb_find— Search for files by name/pattern with depth control and result cappingadb_file_stat— File metadata: size, permissions, timestamps, ownership, SELinux contextadb_file_checksum— SHA-256/SHA-1/MD5 hash with size-based timeout estimationadb_mkdir— Create directories with parent creation (-p), hard-blocked kernel pathsadb_rm— Delete files/directories with depth-based recursive protection and symlink resolutionadb_file_move— Move/rename with source depth protection and post-verifyadb_file_copy— Copy with pre-flight size+space check and post-verify size matchadb_file_chmod— Change permissions (Zod-validated octal mode, depth-based recursive protection)adb_file_touch— Create empty files or update timestamps (explicit timestamp support)adb_file_fsinfo— Filesystem report: type, mount, capacity, capabilities, SELinux, limitationsadb_file_chown— Change ownership (root required, depth-based recursive protection)adb_grep— Search file contents with fixed-string default, recursive depth control, result cappingadb_file_replace— Find/replace text in files (sed-backed, proper escaping, backup option)
Logs — Snapshots (3 tools)
adb_logcat— Filtered logcat snapshot with tag, priority, grep, and buffer selectionadb_logcat_clear— Clear all logcat buffersadb_logcat_crash— Crash buffer log snapshot
Logs — Persistent Watchers (4 tools)
adb_logcat_start— Start a background logcat watcher with ring buffer accumulationadb_logcat_poll— Retrieve new lines since last poll from a running watcheradb_logcat_stop— Stop a watcher session (or all sessions)adb_logcat_sessions— List all active watcher sessions with stats
Diagnostics (9 tools)
adb_dumpsys— Run dumpsys for any service (or list all services)adb_telephony— Cell info, signal strength, and network registration (parallel query)adb_battery— Battery status, level, temperature, and charging infoadb_network— WiFi, cellular, and IP connectivity (parallel query)adb_top— CPU and memory usage snapshotadb_perf_snapshot— Parallel memory, frame stats, and CPU profiling for a packageadb_bugreport— Full bug report zip capture (device state, logs, system info)adb_crash_logs— ANR traces and tombstone crash dumps from /data/anr/ and /data/tombstones/adb_heap_dump— Capture heap dump (.hprof) from a running process for memory analysis
Per-App Route Context (1 tool)
adb_app_route_context— Resolve an installed package to its UID and correlate its effectiveip ruleranges, route tables, network policy, VPN, and default-network state without changing routes or policy
UI (10 tools)
adb_screencap— Take screenshot with filename sanitization, saves locallyadb_screencap_annotated— Screenshot with UI element bounding boxes and numbered labels composited onto the PNG. Returns annotated image path plus a text legend. Ideal for LLM workflows that reference elements by numberadb_current_activity— Get focused activity and top window stackadb_input— Send tap, swipe, text, or keyevent inputadb_start_activity— Launch activities by intent or component nameadb_ui_dump— Dump full UI hierarchy. Supports three output formats:text(default, human-readable),tsv(compact tab-separated for token-efficient automation loops),xml(raw uiautomator XML)adb_ui_find— Search UI hierarchy by text, resource-id, or content-description (returns tap coordinates)adb_screen_state— Combined screen state in one call: foreground activity, screen dimensions and density, orientation, battery level, and a TSV list of interactive elements. Replaces 3–4 separate tool callsadb_screenrecord_start— Start recording the device screen (1-180s, stored on device)adb_screenrecord_stop— Stop recording and pull the mp4 video file locally
All built-in screenshot tools and workflow screenshot steps use a fresh private device directory per capture. Output filenames still select the saved local file; they never select device scratch paths. Cleanup is attempted after capture or transfer failures, and a cleanup failure is reported with its path instead of being hidden. Concurrent calls should use distinct output filenames if both saved images must be retained. Legacy scratch files are not automatically deleted.
Device Control (9 tools)
adb_airplane_mode— Toggle airplane mode with broadcast and verificationadb_airplane_cycle— Cycle airplane mode on/off to force cellular re-registrationadb_wifi— Enable or disable WiFiadb_mobile_data— Enable or disable mobile dataadb_location— Set location mode (off/sensors/battery/high)adb_screen— Wake, sleep, toggle, lock, or unlock the screen. Lock verifies keyguard state viadumpsys window. Unlock useswm dismiss-keyguard(works for swipe keyguards); supplypinto perform the full PIN entry sequence: wakes screen, swipes up to reveal keypad, types PIN, confirms, and verifies the keyguard sleep token was releasedadb_settings_get— Read any Android setting from system/secure/global namespaceadb_settings_put— Write any Android setting with read-back verificationadb_reboot— Reboot device (normal, recovery, or bootloader mode)
Wireless Debugging (4 tools)
adb_pair— Pair with device over WiFi using pairing codeadb_connect— Connect to device over WiFi/TCPadb_disconnect— Disconnect wireless device(s)adb_tcpip— Switch USB device to TCP/IP mode (auto-detects device IP)
Port Forwarding (8 tools)
adb_forward— Forward a local port to a device port (host → device)adb_reverse— Reverse-forward a device port to the host (device → host)adb_forward_list— List all active forward and reverse port mappingsadb_forward_remove— Remove a port forward or all forwardsadb_reverse_remove— Remove a reverse forward or all reverse forwardsadb_tunnel_open— Open a managed tunnel with opaque ID. Auto-picks a free host port for forward direction when omitted; registers cleanup so the tunnel is removed on server exitadb_tunnel_list— List active managed tunnels (those opened via adb_tunnel_open). Optional device filter; shows ID, direction, endpoints, and ageadb_tunnel_close— Close a managed tunnel by ID, or close all at once with id="all"
Emulator Management (3 tools)
adb_avd_list— List available AVDs (PC mode) or detect KVM/QEMU virtualization capabilities (on-device mode)adb_emulator_start— Launch an AVD with headless, cold boot, and GPU options (PC mode) or report QEMU alternative (on-device mode)adb_emulator_stop— Gracefully shut down a running emulator
QEMU/KVM Virtualization (8 tools)
adb_qemu_setup— Check and install QEMU for on-device virtualization. Verifies KVM, reports host CPU/RAM, installs via Termux pkgadb_qemu_images— Manage VM disk images: list, create (qcow2/raw), delete. Path containment verification prevents traversaladb_qemu_start— Boot a KVM-accelerated VM with dynamic resource allocation. Auto-detects optimal CPUs (total minus 1, reserving one for host) and memory (65% of physical RAM). Supports kernel/initrd/append for Android boot, ADB port forwardingadb_qemu_stop— Stop a running VM (graceful SIGTERM or force SIGKILL). Auto-disconnects guest ADB before killing. Reports running VMs if no name givenadb_qemu_status— Full status: KVM/QEMU availability, host resource budget, running VMs with PID/resources/uptime/ports/ADB connection state, image inventoryadb_qemu_connect— Connect to a running VM's guest ADB service. Restricted to localhost only — port derived from running VM state, never user input. Enables multi-device tools to operate on guest VMsadb_qemu_disconnect— Disconnect from a guest VM's ADB service. Clears connection state and removes guest from device listadb_qemu_guest_shell— Execute shell commands on a guest VM via ADB. Subject to security middleware. Guest serial derived internally — no user-supplied host/IP reaches the ADB binary
Test Sessions (3 tools)
adb_test_session_start— Start a named test session with organized output directoryadb_test_step— Capture a numbered step with screenshot and logcat into the sessionadb_test_session_end— End session, write summary manifest, return directory path
Multi-Device Orchestration (4 tools)
adb_multi_shell— Execute a command on all/selected devices in parallel (security-checked)adb_multi_install— Install an APK across multiple devices simultaneouslyadb_multi_compare— Run a command on all devices and highlight output differencesadb_multi_test— Comparative test workflow: run predefined diagnostic profiles (firmware/security/network/identity/full) or custom command lists across all devices including QEMU guests, compare per-check, report matches and differences
Wear Data Layer (1 tool)
adb_wear_datalayer_preflight— Read-only phone/watch role, Google Play services, Bluetooth, optional package, companion-association, and Data Layer service preflight; pairing identifiers are intentionally omitted
Input Gestures & UI Automation (15 tools)
adb_input_drag— Drag from point A to point B (usesdraganddropwith swipe fallback for older Android)adb_input_fling— High-velocity fling gesture for momentum-scrolling through lists and paged views (configurable duration 20-200ms)adb_input_long_press— Long press at coordinates with configurable hold durationadb_input_double_tap— Double tap with configurable interval between tapsadb_input_text— Dedicated text input with space/special character handlingadb_open_url— Open a URL on the device via VIEW intentadb_orientation— Get or set screen orientation (auto/portrait/landscape/reverse)adb_clipboard— Read or write device clipboardadb_input_pinch— Multi-touch pinch (zoom out) or spread (zoom in) gesture. Two fingers move symmetrically around a center point. Layered injection: parallelinput swipe(universal, no root) or rawsendeventMT Type B protocol (true multi-touch, root required). Auto-detects touchscreen device and capabilities viagetevent -p. Configurable center, radius, duration, angle, and interpolation stepsadb_tap_element— Find element by text/resource-id/content-description and tap its centeradb_wait_element— Poll UI hierarchy until an element appears or disappears (configurable timeout/poll interval)adb_wait_stable— Poll until consecutive UI dumps match (screen stabilization after transitions)adb_scroll_until— Scroll repeatedly until a target element is found, with optional auto-tapadb_screenshot_compressed— Capture screenshot with size/quality metadata for token-efficient workflowsadb_batch_actions— Execute multiple input actions (tap/swipe/fling/long_press/double_tap/keyevent/text/drag/pinch/back/home/sleep) in a single tool call with security validation
Device Awareness (3 tools)
adb_screen_size— Screen resolution, display density (DPI), aspect ratio, and DP width in one calladb_device_state— Combined snapshot: battery level/status/temp, network type, WiFi state, screen on/off, orientation, foreground activityadb_notifications— Parse active notifications with package, title, text, importance, channel, flags, and timestamp (filterable by package)
Snapshot/Restore (3 tools)
adb_snapshot_capture— Save comprehensive device state (packages, settings, properties) to JSONadb_snapshot_compare— Diff current state against a saved snapshot (added/removed packages, changed settings)adb_snapshot_restore_settings— Restore global/secure settings from a saved snapshot
Network Capture (3 tools)
adb_tcpdump_start— Start background packet capture via tcpdump (requires root)adb_tcpdump_stop— Stop capture and pull pcap file locally for Wireshark analysisadb_network_connections— Show active TCP/UDP connections (ss/netstat with /proc/net fallback)
CI/CD Integration (3 tools)
adb_ci_wait_boot— Wait for device/emulator to fully boot with configurable timeoutadb_ci_device_ready— Structured pass/fail readiness check (boot, PM, screen, network, disk)adb_ci_run_tests— Run instrumented tests viaam instrumentwith parsed pass/fail results
Baseband/Modem (6 tools)
adb_baseband_info— Modem firmware, RIL implementation, chipset, SIM configuration (dual SIM detection with per-slot state), network registration. IMEI retrieval is opt-in only (includeImei=true)adb_cell_identity— Cell ID (CID), TAC/LAC, EARFCN, PCI, PLMN from dumpsys phone for cellular network analysisadb_signal_detail— RSRP, RSRQ, SINR, RSSI, timing advance — raw radio measurements for signal analysisadb_neighboring_cells— All visible LTE/5G/WCDMA/GSM cells with identities and signal strengthsadb_carrier_config— Carrier configuration dump, carrier ID, preferred APNadb_modem_logs— RIL radio buffer, telephony framework, RILJ/RILC, kernel dmesg (root) modem logs
Accessibility Auditing (3 tools)
adb_a11y_audit— Targeted Android accessibility checks: missing labels, undersized touch targets (<48dp), duplicate descriptions, unfocusable clickablesadb_a11y_touch_targets— List all interactive elements with touch target dimensions in dp, flag undersizedadb_a11y_tree— Accessibility-focused UI tree showing only screen-reader-relevant elements with roles, labels, and states
Regression Detection (3 tools)
adb_regression_baseline— Capture performance baseline (memory, CPU, frame stats, battery, network) to JSONadb_regression_check— Compare current performance against a saved baseline with configurable regression thresholdsadb_regression_history— List all saved baselines with trends, optionally filtered by package
Device Farm (3 tools)
adb_farm_run— Run instrumented tests on Firebase Test Lab across multiple device models and API levelsadb_farm_results— Retrieve results from a Test Lab run or list recent test matricesadb_farm_matrix— List available device models and Android versions on Firebase Test Lab
Documentation truncated — see the full README on GitHub.
Reviews
No reviews yet
Be the first to review this server!
More Developer Tools MCP Servers
Rea
Freeby Morluto · Developer Tools
Reverse engineer anything from your terminal or agent with one CLI and MCP server.
Paperclip
Freeby Paperclipai · Developer Tools
Trending hip-hop artist momentum scores across four cultural dimensions.
Scrapling
Freeby D4Vinci · Developer Tools
Web scraping with stealth HTTP, real browsers, and Cloudflare bypass. CSS selectors supported.
Toleno
Freeby Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
MCP Marketplace
Freeby mcp-marketplace · Developer Tools
Search and install MCP servers from inside your AI client.
mcp-creator-python
Freeby mcp-marketplace · Developer Tools
Create, build, and publish Python MCP servers to PyPI — conversationally.
