Android Studio MCP
Offers tools for Android development: build APK/AAB, manage emulators and devices, install apps, capture logs and screenshots, analyze APKs, and handle SDK components.
Provides tools for operating Android Studio: open projects, inspect code, format, run IDE actions, and manage the live IDE via HTTP bridge and UI automation.
Allows control over Gradle builds: run tasks for assembling, testing, linting, dependency analysis, and signing reports with structured results.
Enables headless IDE operations using JetBrains IntelliJ engine: code inspection, formatting, and diff via Android Studio's CLI tools.
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., "@Android Studio MCP Build and run the app on a Pixel 6 emulator"
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.
Android Studio MCP
Let Claude operate Android Studio and the entire Android toolchain — not just talk about it.
A professional Model Context Protocol server that turns Claude (Claude Code / Claude Desktop) into a real Android operator: build, test, lint, run on devices & emulators, analyse APKs, scaffold projects, inspect code headlessly, and drive the live IDE.
Why this exists
Android Studio is an IntelliJ‑based IDE. The reliable way to operate it programmatically is not to pixel‑click the GUI — it's to drive the same tools the IDE drives. This server is built stable‑first: the bulk of the power comes from the rock‑solid command‑line toolchain, with the live‑IDE bridge and UI automation as additional layers that degrade gracefully.
Layer | Mechanism | Covers | Robustness |
1. Build / SDK CLI |
| build, test, lint, deps, signing, devices, emulators, APK/AAB analysis | ★★★★★ headless, deterministic |
2. Headless IDE CLI |
| full code inspection reports, reformat, navigation | ★★★★☆ |
3. Live IDE | built‑in HTTP server ( | open‑in‑IDE, IDE state, IDE actions — while the IDE runs | ★★★☆☆ |
4. UI fallback | native Win32 focus + SendKeys + screenshot | any action via "Find Action", visual verification | ★★☆☆☆ |
Everything in layers 1–2 works whether or not the IDE is open and needs no plugins.
Related MCP server: AndroidBuildMCP
Highlights
🟢 One‑shot "Run" button —
as_run_app: build → install → launch → capture logs → detect crashes → screenshot, in a single call.🔨 Full Gradle control — assemble APK/AAB, unit & instrumented tests, lint, dependencies, signing report — with structured findings (lint XML & JUnit XML parsed into file/line/severity).
🩺 Self‑healing builds — failing builds return a
remediationlist mapping the error to the exact next tool to call (license → accept, missing platform → install, no device → start emulator).📱 Devices & emulators — list/create/start/stop AVDs, install/uninstall, streaming logcat you can poll, screenshots, screen recording, input injection.
🏗️ Project scaffolding — generate a real, buildable Views or Compose project (bundled Gradle wrapper, correct AGP/Kotlin/SDK levels).
🔍 Headless code inspection — run the IDE's offline "Inspect Code" engine and get structured problems back.
📦 APK / AAB analysis — package/version/permissions, method counts, sizes, signature verification, APK diff, AAB → installable APK set.
🔒 Safety‑first — workspace path allow‑list, confirmation gating for destructive actions, automatic backups, secret redaction, hardened device‑shell.
🧪 Tested — 73 tools, real APK built end‑to‑end, 15 parser unit tests, security‑gate regression, adversarial multi‑agent code review.
Requirements
Windows (the server is Windows‑targeted; paths and process control use Win32).
Android Studio (tested against build
AI‑261, 2026.1.x) — autodiscovered atC:\Program Files\Android\Android Studio.Android SDK with command‑line tools, platform‑tools, emulator and build‑tools — autodiscovered at
%LOCALAPPDATA%\Android\Sdk.Python ≥ 3.10 and uv.
All paths are autodiscovered but can be overridden (see Configuration).
Install
git clone https://github.com/MauricePutinas/Android-Studio-MCP-Claude-Code.git
cd Android-Studio-MCP-Claude-Code
uv sync
# sanity checks
uv run python -m android_studio_mcp --selfcheck # resolved paths + tool count
uv run python -m android_studio_mcp --list-tools # all 73 tools
uv run python scripts/smoke_test.py # 17/17 functional checks
uv run pytest tests -q # 15 parser unit testsWire into Claude
Claude Desktop — %APPDATA%\Claude\claude_desktop_config.json:
{
"mcpServers": {
"android-studio": {
"command": "C:\\Users\\<you>\\AppData\\Local\\hermes\\bin\\uv.exe",
"args": ["--directory", "C:\\path\\to\\Android-Studio-MCP-Claude-Code", "run", "python", "-m", "android_studio_mcp"]
}
}
}Claude Code (CLI):
claude mcp add android-studio --scope user -- uv --directory "C:\path\to\Android-Studio-MCP-Claude-Code" run python -m android_studio_mcpOne‑click bundle: build a .mcpb with powershell -File scripts\build_mcpb.ps1 and install it via Claude Desktop → Settings → Extensions → Install extension. See docs/CLAUDE_SETUP.md and docs/PACKAGING.md.
Note: the committed
manifest.json/ example configs are pre‑filled for the author's machine. Adjust the two absolute paths (project dir,uv.exe) to your setup.
Tool catalogue (73 tools)
All tools are prefixed
as_and return JSON with astatus(ok|error|confirmation_required) and a humansummary. Destructive tools requireconfirm=true.
as_status · as_is_running · as_launch · as_close · as_restart · as_open_project · as_open_file · as_diff
as_run_app (build→install→launch→logs→crash→screenshot) · as_logcat_watch_start / as_logcat_watch_read / as_logcat_watch_stop · as_proc_list / as_proc_stop
as_gradle_tasks · as_gradle_assemble · as_gradle_bundle · as_gradle_test (structured JUnit) · as_gradle_lint (structured findings) · as_gradle_clean · as_gradle_dependencies · as_gradle_signing_report · as_gradle_run_task · as_gradle_stop
as_sdk_list · as_sdk_install · as_sdk_accept_licenses
as_avd_list · as_avd_create · as_avd_delete · as_avd_start · as_avd_stop
as_adb_devices · as_adb_install · as_adb_uninstall · as_adb_logcat · as_adb_logcat_clear · as_adb_shell (guarded) · as_adb_screenshot · as_adb_input · as_adb_start_app · as_adb_stop_app · as_adb_pull · as_adb_push
as_project_create (real Views/Compose scaffold) · as_project_info (incl. version catalog) · as_project_validate · as_project_backup · as_project_list_recent
as_apk_info · as_apk_methods · as_apk_filesize · as_apk_verify_signature · as_apk_compare · as_aab_build_apks · as_aab_install
as_inspect_code (offline "Inspect Code" → structured problems) · as_format_code (reformat in place, backups first)
as_retrace (de‑obfuscate R8/ProGuard stack traces) · as_screenrecord (record device screen → mp4)
as_ide_status · as_ide_list_mcp_tools · as_ide_call_mcp_tool
as_ui_screenshot · as_ui_focus · as_ui_send_keys · as_ui_invoke_action (any IDE action via "Find Action")
as_report_health · as_logs_ide · as_logs_mcp · as_config · as_backup_file · as_restore_backup
Resources: asmcp://config · asmcp://idea-log · asmcp://projects/recent
Prompts: run_app · diagnose_build
Safety model
Path allow‑list — write/delete operations must target a path inside a configured workspace root (default:
E:\Projekte+ home). Override withASMCP_WORKSPACE_ROOTS.Confirmation gating — destructive tools (
as_close --force,as_adb_uninstall,as_avd_delete,as_format_code,as_sdk_install,as_restore_backup, …) returnconfirmation_requiredunless called withconfirm=true.Backups first — files are backed up before being reformatted/overwritten; projects can be zipped with
as_project_backup.Guarded device shell —
as_adb_shellruns recognised read‑only commands freely but requiresconfirm=truefor anything containing shell operators (;,|,&&,$(), …) or destructive markers.Secret redaction — keystore/store/key passwords and tokens are masked in all captured output and logs.
stdio‑safe logging — all logs go to stderr + a rotating file, never stdout.
Configuration
Resolution order for every setting: env var → config.json → autodiscovery → default.
Setting | Env var | Default |
Android Studio home |
|
|
Android SDK |
|
|
Workspace roots (allow‑list) |
|
|
Built‑in server port |
|
|
bundletool jar |
| auto‑downloaded on first use |
See config.example.json.
Architecture
src/android_studio_mcp/
├── app.py FastMCP instance
├── config.py toolchain autodiscovery + settings
├── runner.py safe subprocess execution (env, .bat, timeouts, redaction)
├── safety.py path allow‑list, confirmation gating, backups
├── procregistry.py background process registry (logcat watch, …)
├── parsers.py Gradle / ADB / AVD / SDK / aapt output parsers
├── report_parsers.py lint XML, JUnit XML, version catalog
├── diagnostics.py build‑failure → remediation rules
├── scaffold.py project templates (Views / Compose)
├── ide_http.py built‑in IDE server (:63342) client
├── mcp_bridge.py stdioMcpServer bridge
├── winauto.py native Win32 UI automation
└── tools/ 73 @mcp.tool definitions, grouped by domainTesting
Suite | What | Result |
| env checks, gating, path allow‑list, scaffold round‑trip | 17/17 |
| real | BUILD SUCCESSFUL |
| adb‑shell injection/chaining gate | 6/6 |
| pure parser functions | 15/15 |
| 10 read‑only eval Q&A (mcp‑builder format) | — |
A full capability/risk matrix is in docs/QUALITY.md.
Limitations
The official live‑IDE MCP (
stdioMcpServer) needs the MCP Server plugin (com.intellij.mcpServer). On a stock Android Studio it may not be installed —as_ide_statustells you, and the CLI tools cover everything regardless.Headless
inspectindexes the project first, so it can take minutes; don't run it while the same project is open in a running IDE (config‑dir contention).UI automation (SendKeys) is best‑effort and English‑keymap oriented; always verify via the returned screenshot.
The server is Windows‑only by design.
License
MIT © Maurice Putinas — see LICENSE.
Built with FastMCP. Not affiliated with Google or JetBrains. "Android" and "Android Studio" are trademarks of Google LLC.
Available Tools
73 toolsas_aab_build_apksA
Convert an Android App Bundle (.aab) into an installable .apks set (bundletool).
Args: params (AabBuildInput): aab_path, out_apks, universal, confirm.
Returns: str: JSON with the produced .apks path.
Inputs: params (required). Returns: result
as_aab_installA
Install a .apks set onto a connected device (bundletool install-apks).
Args: params (AabInstallInput): apks_path, serial, confirm.
Returns: str: JSON with the install result.
Inputs: params (required). Returns: result
as_adb_devicesARead-onlyIdempotent
List connected devices and emulators (adb devices -l).
Returns: str: JSON with 'devices': list of {serial, state, model, device, product, transport_id, is_emulator} and 'count'.
Inputs: no named parameters. Returns: result
as_adb_inputB
Send a tap/swipe/text/keyevent to the device (UI automation of the app).
Args: params (InputEventInput): kind ('text'|'keyevent'|'tap'|'swipe'), value, serial.
Returns: str: JSON with the command result.
Inputs: params (required). Returns: result
as_adb_installB
Install an APK onto a device/emulator.
Args: params (InstallInput): apk_path, serial, reinstall, allow_downgrade, grant_permissions.
Returns: str: JSON with the install result.
Inputs: params (required). Returns: result
as_adb_logcatARead-only
Dump a snapshot of the most recent device logs (non-streaming).
Args: params (LogcatInput): serial, lines, filter_spec, clear_first, grep.
Returns: str: JSON with 'log' (the captured text) and 'line_count'.
Inputs: params (required). Returns: result
as_adb_logcat_clearBDestructiveIdempotent
Clear the device log buffer (adb logcat -c).
Args: params (SerialInput): serial.
Returns: str: JSON with the command result.
Inputs: params (required). Returns: result
as_adb_pullARead-only
Copy a file from the device to this PC (adb pull).
Args: params (FileTransferInput): remote (device path), local (workspace path), serial.
Returns: str: JSON with the result and saved local path.
Inputs: params (required). Returns: result
as_adb_pushA
Copy a file from this PC to the device (adb push).
Args: params (FileTransferInput): local (workspace path), remote (device path), serial.
Returns: str: JSON with the result.
Inputs: params (required). Returns: result
as_adb_screenshotARead-only
Capture the device screen to a PNG on this PC (adb exec-out screencap).
Args: params (ScreenshotInput): out_path (inside a workspace root), serial.
Returns: str: JSON with 'saved_to' and the file size.
Inputs: params (required). Returns: result
as_adb_shellADestructive
Run a shell command on the device. Read-only commands run freely; anything potentially destructive requires confirm=true.
Recognised safe first-words include getprop, dumpsys, pm list, settings get, ls, cat, df, ps, am, input, wm, screencap. Commands containing markers like 'rm ', 'reboot', 'uninstall', 'clear', 'wipe' always require confirm=true.
Args: params (ShellInput): command, serial, confirm.
Returns: str: JSON with stdout/stderr, or confirmation_required.
Inputs: params (required). Returns: result
as_adb_start_appA
Launch an app by component or by package (via monkey launcher intent).
Args: params (StartAppInput): component ('pkg/.Activity') or package, serial.
Returns: str: JSON with the launch result.
Inputs: params (required). Returns: result
as_adb_stop_appAIdempotent
Force-stop an app (am force-stop). Does not delete data.
Args: params (PackageInput): package, serial (confirm not required).
Returns: str: JSON with the command result.
Inputs: params (required). Returns: result
as_adb_uninstallADestructiveIdempotent
Uninstall an application (removes app + data). Requires confirm=true.
Args: params (PackageInput): package, serial, confirm.
Returns: str: JSON with the uninstall result, or confirmation_required.
Inputs: params (required). Returns: result
as_apk_compareARead-onlyIdempotent
Compare the file sizes of two APKs (apkanalyzer apk compare).
Args: params (ApkCompareInput): apk_a (baseline), apk_b.
Returns: str: JSON with the comparison table.
Inputs: params (required). Returns: result
as_apk_filesizeARead-onlyIdempotent
Report the on-disk and estimated download size of an APK.
Args: params (ApkInput): apk_path.
Returns: str: JSON with file_size and download_size (bytes).
Inputs: params (required). Returns: result
as_apk_infoARead-onlyIdempotent
Summarise an APK: package, version, SDK levels, permissions, label.
Uses aapt2 badging (most reliable) and falls back to apkanalyzer.
Args: params (ApkInput): apk_path.
Returns: str: JSON with package, version_code/name, min_sdk, target_sdk, label, launchable_activity and permissions.
Inputs: params (required). Returns: result
as_apk_methodsARead-onlyIdempotent
Report dex method counts and the largest packages (apkanalyzer dex).
Args: params (ApkInput): apk_path.
Returns: str: JSON with the reference method count and per-package breakdown text.
Inputs: params (required). Returns: result
as_apk_verify_signatureARead-onlyIdempotent
Verify an APK's signature and print the signing certificates (apksigner).
Args: params (ApkInput): apk_path.
Returns: str: JSON with verified (bool) and the certificate details.
Inputs: params (required). Returns: result
as_avd_createA
Create a new Android Virtual Device from an installed system image.
The system image must already be installed (use as_sdk_install with e.g. 'system-images;android-34;google_apis;x86_64').
Args: params (AvdCreateInput): name, system_image, device, confirm.
Returns: str: JSON with the create command output, or confirmation_required.
Inputs: params (required). Returns: result
as_avd_deleteADestructiveIdempotent
Delete an Android Virtual Device permanently. Requires confirm=true.
Args: params (AvdDeleteInput): name, confirm.
Returns: str: JSON with the delete command output, or confirmation_required.
Inputs: params (required). Returns: result
as_avd_listARead-onlyIdempotent
List configured Android Virtual Devices.
Args: params (AvdListInput): detailed (bool).
Returns: str: JSON with 'names' (list) and, if detailed, 'avds' (list of {name, device, target, path, based_on}).
Inputs: params (required). Returns: result
as_avd_startB
Boot an AVD in the emulator (detached) and optionally wait for boot.
Args: params (AvdStartInput): name, cold_boot, wipe_data, headless, wait_boot.
Returns: str: JSON with the emulator pid and (if wait_boot) the booted serial.
Inputs: params (required). Returns: result
as_avd_stopADestructiveIdempotent
Stop a running emulator (adb emu kill).
Args: params (AvdStopInput): optional serial (else the first running emulator).
Returns: str: JSON with the command output.
Inputs: params (required). Returns: result
as_backup_fileB
Create a timestamped backup of a single file in the server backup dir.
Args: params (BackupFileInput): path.
Returns: str: JSON with the backup path.
Inputs: params (required). Returns: result
as_closeADestructive
Close Android Studio. Graceful by default; force-kill only on request.
A graceful close (default) sends a normal terminate signal so the IDE can save state. force=true uses taskkill /F which can lose unsaved work, so it additionally requires confirm=true.
Args: params (CloseInput): force (bool), confirm (bool).
Returns: str: JSON with the taskkill result, or a confirmation_required payload.
Inputs: params (required). Returns: result
as_configARead-onlyIdempotent
Show the fully-resolved configuration (all discovered paths and roots).
Returns: str: JSON with every resolved path, the workspace allow-list, and the built-in server URL. Use this to debug discovery/path issues.
Inputs: no named parameters. Returns: result
as_diffAIdempotent
Open the IDE's visual diff viewer for two files or directories.
Uses studio64.exe diff <left> <right>.
Args: params (DiffInput): left and right paths.
Returns: str: JSON with the launched command and pid.
Inputs: params (required). Returns: result
as_format_codeADestructiveIdempotent
Reformat files in place using the IDE's formatter (studio64.exe format).
Backups of every affected file are written to the server backup dir before formatting. Requires confirm=true.
Args: params (FormatInput): target, mask, recursive, confirm.
Returns: str: JSON with the formatter output and the list of backups created.
Inputs: params (required). Returns: result
as_gradle_assembleA
Build APK(s) with assemble and report the produced artefacts.
Equivalent to Android Studio's "Build > Build APK(s)". After a successful build the response lists the produced .apk paths under build/outputs.
Args: params (GradleAssembleInput): project_dir, variant ('Debug'/'Release'), optional module (':app'), timeout.
Returns: str: JSON with gradle status, command, and 'outputs' {apk,aab,mapping}.
Inputs: params (required). Returns: result
as_gradle_bundleB
Build an Android App Bundle (.aab) with bundle.
Args: params (GradleAssembleInput): project_dir, variant, optional module, timeout.
Returns: str: JSON with gradle status and produced 'outputs' (aab paths).
Inputs: params (required). Returns: result
as_gradle_cleanADestructiveIdempotent
Delete build outputs via 'gradle clean'. Only touches the build/ dir.
Args: params (GradleProjectInput): project_dir, timeout.
Returns: str: JSON with gradle status.
Inputs: params (required). Returns: result
as_gradle_dependenciesARead-onlyIdempotent
Print the dependency tree for a module.
Args: params (GradleDependenciesInput): project_dir, module (':app'), optional configuration filter, timeout.
Returns: str: JSON with the dependency tree in command.stdout.
Inputs: params (required). Returns: result
as_gradle_lintAIdempotent
Run Android Lint via Gradle and point to the generated reports.
Args: params (GradleProjectInput): project_dir, timeout.
Returns: str: JSON with gradle status. Reports: /build/reports/lint-results-*.html|xml.
Inputs: params (required). Returns: result
as_gradle_run_taskADestructive
Run arbitrary Gradle tasks with optional extra args (power tool).
Use the dedicated tools (assemble/test/lint/clean) when possible; this is the escape hatch for anything else (e.g. installDebug, uninstallAll, custom tasks).
Args: params (GradleRunTaskInput): project_dir, tasks (list), args (list), timeout.
Returns: str: JSON with gradle status, command output and detected build outputs.
Inputs: params (required). Returns: result
as_gradle_signing_reportARead-onlyIdempotent
Show signing configs and certificate fingerprints (SHA1/SHA256).
Useful for configuring API keys (Maps, Firebase). Secrets in the output are redacted by the server.
Args: params (GradleProjectInput): project_dir, timeout.
Returns: str: JSON with the signingReport output.
Inputs: params (required). Returns: result
as_gradle_stopAIdempotent
Stop all Gradle daemons for the project (frees memory, clears stuck state).
Args: params (GradleProjectInput): project_dir, timeout.
Returns: str: JSON with command output.
Inputs: params (required). Returns: result
as_gradle_tasksARead-onlyIdempotent
List the Gradle tasks available in a project.
Args: params (GradleTasksInput): project_dir, all_tasks (bool), timeout.
Returns: str: JSON with the raw 'tasks' output and the parsed build status.
Inputs: params (required). Returns: result
as_gradle_testA
Run unit tests (default) or instrumented connected tests.
Args: params (GradleTestInput): project_dir, instrumented (bool), module, timeout.
Returns: str: JSON with gradle status and parsed failures. HTML/XML test reports are written under /build/reports/tests and build/outputs.
Inputs: params (required). Returns: result
as_ide_call_mcp_toolA
Invoke a tool on the running IDE's built-in MCP server (live control).
Use as_ide_list_mcp_tools first to discover available tool names/arguments. Requires the official MCP Server plugin and a running IDE.
Args: params (CallMcpToolInput): name, arguments, timeout.
Returns: str: JSON with the tool result, or an error explanation.
Inputs: params (required). Returns: result
as_ide_list_mcp_toolsARead-onlyIdempotent
List the tools exposed by the running IDE's built-in MCP server.
Bridges to studio64.exe stdioMcpServer. Requires the official MCP Server
plugin. Returns an actionable message if unavailable.
Args: params (TimeoutInput): timeout.
Returns: str: JSON with available (bool), tools (list) or an error explanation.
Inputs: params (required). Returns: result
as_ide_statusARead-onlyIdempotent
Report live-IDE connectivity: process, built-in server, MCP plugin.
Returns: str: JSON with studio_running (bool), builtin_server_up (bool), builtin_server_url, about (IDE build info if reachable), official_mcp_plugin_installed (bool) and guidance.
Inputs: no named parameters. Returns: result
as_inspect_codeARead-onlyIdempotent
Run Android Studio's code inspection headlessly and return the problems.
This launches the IDE's offline inspection engine (the same one behind "Analyze > Inspect Code") via studio64.exe inspect, writes XML reports to a temp dir and parses them into a structured problem list grouped by severity and inspection. It must index the project first, so it can take minutes on a large project. Do not run while Android Studio is open with the same project (config-dir contention) — close it first or expect a slower run.
Args: params (InspectInput): project_dir, optional scope_dir, optional profile, max_problems, timeout.
Returns: str: JSON with total_problems, by_severity, by_inspection, and a truncated 'problems' list of {inspection, severity, file, line, description}.
Inputs: params (required). Returns: result
as_is_runningARead-onlyIdempotent
Quick check whether an Android Studio process (studio64.exe) is running.
Returns: str: JSON with running (bool) and processes (list of {image,pid,...}).
Inputs: no named parameters. Returns: result
as_launchA
Launch Android Studio (optionally opening a project), detached.
The IDE is started as an independent process so the call returns immediately with its PID. If a project_dir is given it is passed to studio64.exe to open that project. The IDE's built-in server takes a few seconds to come up.
Args: params (LaunchInput): optional project_dir to open.
Returns: str: JSON with pid, already_running (bool) and the launched command.
Inputs: params (required). Returns: result
as_logcat_watch_readARead-only
Read new output from a running logcat watch since a byte offset.
Args: params (WatchReadInput): watch_id, since_offset, grep.
Returns: str: JSON with 'text' (new lines), 'offset' (pass to the next read), 'running' and 'total_bytes'.
Inputs: params (required). Returns: result
as_logcat_watch_startA
Start a background logcat capture you can poll incrementally.
Returns a watch_id; read new lines with as_logcat_watch_read (pass the returned offset back each time) and stop it with as_logcat_watch_stop.
Args: params (WatchStartInput): serial, filter_spec, clear_first.
Returns: str: JSON with watch_id and the initial offset (0).
Inputs: params (required). Returns: result
as_logcat_watch_stopBIdempotent
Stop a running logcat watch (or any managed process) by id.
Args: params (ProcIdInput): proc_id (the watch_id).
Returns: str: JSON with the final process info.
Inputs: params (required). Returns: result
as_logs_ideARead-only
Return the tail of Android Studio's idea.log (optionally filtered by level).
Args: params (LogTailInput): lines, level (optional 'ERROR'/'WARN').
Returns: str: JSON with 'log' (text) and the source path.
Inputs: params (required). Returns: result
as_logs_mcpARead-only
Return the tail of this MCP server's own log file.
Args: params (LogTailInput): lines, level (optional).
Returns: str: JSON with 'log' (text) and the source path.
Inputs: params (required). Returns: result
as_open_fileAIdempotent
Open a file (optionally at a line/column) in the running Android Studio.
Prefers the built-in IDE server (instant, reuses the running window). Falls back to launching studio64.exe with --line if the server is not reachable.
Args: params (OpenFileInput): file (path), line (optional), column (optional).
Returns: str: JSON describing which method was used and whether it succeeded.
Inputs: params (required). Returns: result
as_open_projectAIdempotent
Open an existing project directory in Android Studio.
Launches (or reuses) the IDE with the given project. This does not modify project files.
Args: params (OpenProjectInput): project_dir (must exist).
Returns: str: JSON with the launched command and pid.
Inputs: params (required). Returns: result
as_proc_listARead-onlyIdempotent
List all background processes started by this server (watches etc.).
Returns: str: JSON with 'processes': list of {id, kind, running, pid, output_file, ...}.
Inputs: no named parameters. Returns: result
as_proc_stopBDestructiveIdempotent
Stop a managed background process by id.
Args: params (ProcIdInput): proc_id.
Returns: str: JSON with the final process info.
Inputs: params (required). Returns: result
as_project_backupA
Create a timestamped .zip backup of a project (excluding build artefacts).
Args: params (ProjectPathInput): project_dir.
Returns: str: JSON with the backup zip path.
Inputs: params (required). Returns: result
as_project_createA
Scaffold a new, buildable Android project (Views or Compose template).
Generates settings/build Gradle files, a Gradle wrapper, local.properties (pointing at the detected SDK), manifest, MainActivity and resources, then optionally opens it in Android Studio.
Args: params (CreateProjectInput): parent_dir, name, application_id, template, min_sdk, compile_sdk, open_in_studio, confirm.
Returns: str: JSON with project_dir, files_written, wrapper status, and a hint to build via as_gradle_assemble. Or confirmation_required.
Inputs: params (required). Returns: result
as_project_infoARead-onlyIdempotent
Extract metadata from an Android project without building it.
Reads settings/build Gradle files and the app manifest to report the modules, applicationId, version, SDK levels, plugins and permissions.
Args: params (ProjectPathInput): project_dir.
Returns: str: JSON with modules, application_id, version_code/name, min_sdk/target_sdk/compile_sdk, manifest (permissions, activities), and detected gradle files.
Inputs: params (required). Returns: result
as_project_list_recentARead-onlyIdempotent
List recently opened projects from Android Studio's config.
Args: params (RecentInput): limit.
Returns: str: JSON with 'recent' (list of project paths). Empty if none recorded.
Inputs: params (required). Returns: result
as_project_validateARead-onlyIdempotent
Check that a project has the expected structure and report problems.
Args: params (ProjectPathInput): project_dir.
Returns: str: JSON with 'valid' (bool), 'problems' (list) and 'checks' (dict).
Inputs: params (required). Returns: result
as_report_healthARead-onlyIdempotent
Produce a comprehensive markdown health report of the dev environment.
Aggregates installation/runtime status, SDK package count, connected devices, configured AVDs and (optionally) a project's metadata into one report.
Args: params (HealthInput): optional project_dir.
Returns: str: JSON with a 'markdown' report plus the underlying structured data.
Inputs: params (required). Returns: result
as_restartADestructive
Restart Android Studio (close then relaunch). Requires confirm=true.
Args: params (CloseInput): force (bool) for the close phase, confirm (bool).
Returns: str: JSON describing the close result and the relaunch pid.
Inputs: params (required). Returns: result
as_restore_backupADestructive
Restore a previously-created backup file to a destination. Requires confirm=true.
The current destination (if any) is itself backed up before being overwritten.
Args: params (RestoreInput): backup_path, restore_to, confirm.
Returns: str: JSON with the restore result.
Inputs: params (required). Returns: result
as_retraceARead-onlyIdempotent
De-obfuscate an R8/ProGuard stack trace using its mapping.txt (retrace).
Args: params (RetraceInput): mapping_file (mapping.txt), stacktrace (text).
Returns: str: JSON with the de-obfuscated trace in 'retraced'.
Inputs: params (required). Returns: result
as_run_appA
Build, install and launch an app on a device/emulator, then capture logs.
One-shot equivalent of Android Studio's Run button:
assemble 2. install the APK 3. launch the launcher activity
capture the app's recent logcat (and detect crashes) 5. optional screenshot.
Args: params (RunAppInput): project_dir, variant, module, serial, install, launch, capture_logcat_lines, screenshot, timeout.
Returns: str: JSON with a 'steps' object (build/install/launch/logcat/screenshot), the apk path, package, and 'crash_detected' (bool).
Inputs: params (required). Returns: result
as_screenrecordCRead-only
Record the device screen to an .mp4 and pull it to this PC.
Args: params (ScreenrecordInput): out_path, seconds, serial.
Returns: str: JSON with the saved local path and size.
Inputs: params (required). Returns: result
as_sdk_accept_licensesAIdempotent
Accept all pending Android SDK licenses (sdkmanager --licenses).
Args: params (LicensesInput): confirm, timeout.
Returns: str: JSON with the command output, or confirmation_required.
Inputs: params (required). Returns: result
as_sdk_installAIdempotent
Install one or more Android SDK packages (downloads + accepts licenses).
Args: params (InstallInput): packages (list of sdkmanager paths), confirm, timeout.
Returns: str: JSON with the install command output, or confirmation_required.
Inputs: params (required). Returns: result
as_sdk_listARead-onlyIdempotent
List installed (and optionally available) Android SDK packages.
Args: params (ListInput): installed_only (bool), timeout.
Returns: str: JSON with 'installed' and 'available' lists of {path, version, description}, plus the raw output.
Inputs: params (required). Returns: result
as_statusARead-onlyIdempotent
Report the full Android Studio / toolchain environment status.
Use this FIRST to understand what is available before acting. It reports whether Android Studio is installed and running, the resolved paths for the SDK / JBR / adb / emulator / sdkmanager, the IDE build number, whether the built-in IDE server is reachable, connected devices and a count of AVDs.
Args: params (StatusInput): response_format ('json'|'markdown') and deep (bool).
Returns: str: JSON (or markdown) with keys: studio_installed (bool), studio_running (bool), studio_build (str), paths (dict of resolved tool paths), adb_version (str|None), devices (list), avds (list[str]), java_version (str|None), builtin_server_up (bool), ide_plugins (dict).
Inputs: params (required). Returns: result
as_ui_focusAIdempotent
Bring the Android Studio window to the foreground.
Returns: str: JSON indicating whether a Studio window was found and focused.
Inputs: no named parameters. Returns: result
as_ui_invoke_actionADestructive
Invoke any IDE action via Find Action (Ctrl+Shift+A). Requires confirm=true.
This opens Find Action, types the action name and presses Enter — giving access to essentially any IDE command (e.g. 'Sync Project with Gradle Files', 'Rebuild Project', 'Reformat Code'). It is a best-effort UI path; verify the result with the returned screenshot. Prefer dedicated tools where they exist.
Args: params (InvokeActionInput): action (name), confirm, screenshot_after.
Returns: str: JSON with the result and a verification screenshot path.
Inputs: params (required). Returns: result
as_ui_screenshotARead-only
Capture a screenshot of the Android Studio window (or full screen).
Args: params (ScreenshotInput): out_path (optional), window_only (bool).
Returns: str: JSON with 'saved_to' and the captured dimensions.
Inputs: params (required). Returns: result
as_ui_send_keysADestructive
Focus Android Studio and send a raw SendKeys sequence. Requires confirm=true.
This is a generic, lower-reliability fallback. Prefer the CLI/Gradle/ADB tools. After sending, a screenshot is captured for verification.
Args: params (SendKeysInput): keys (SendKeys string), confirm, screenshot_after.
Returns: str: JSON with the send result and a verification screenshot path.
Inputs: params (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 73 tools
Most tools have distinct purposes with clear names and descriptions, but the large number (73) introduces some potential for confusion, especially among similar ADB and logcat tools. Overall, an agent can differentiate them.
All tools follow a consistent as_<category>_<verb> pattern (e.g., as_adb_devices, as_gradle_assemble). The naming is predictable and well-structured throughout the entire set.
73 tools is excessive for most use cases. While the server covers many sub-domains, this number is far above the typical well-scoped range (3-15), making it difficult to navigate and manage.
The tool set is very comprehensive, covering IDE control, ADB, Gradle, AVD, SDK, project management, and diagnostics. Minor gaps exist (e.g., limited ADB shell commands), but overall it addresses the Android development domain thoroughly.
Maintenance
Related MCP Connectors
Disposable cloud Android emulators for coding agents: run an APK or PR build, tap, type, screenshot.
Cloud Android 14 phones that Claude, Claude Code, Cursor and Codex can use over MCP. Ready in ~15 s. Plain-English tasks return pass/fail, steps, screenshots and video. 1¢ per phone-minute, AI included, 100 free minutes a month.
Give your AI agent a real cloud Android phone: push APKs, drive it, get screenshots and logs.
Control Android TV from any AI. 38 MCP tools: playback, recap, recommend, smart-home, schedules.
Related MCP Servers
- FlicenseAqualityDmaintenanceEnables remote control of Android phones via Claude Desktop, offering 45+ tools including UI automation for app interactions.5717-
- AlicenseAqualityDmaintenanceEnables AI agents to build, deploy, drive, and debug Android apps — managing Gradle builds, emulators, adb deployment, logcat capture, and full UI automation.5377 npm1MIT
- AlicenseNot gradedqualityCmaintenanceProvides 23 Android development tools for Gradle builds, emulator/device lifecycle, APK install/launch, screenshots, logs, ADB and UI Automator automation, along with an android-dev skill for guided workflows.73 npmMIT
- AlicenseNot gradedqualityCmaintenanceEnables AI coding agents to build, test, lint, and debug Android projects with concise Gradle output, filtered logcat, and connected-device inspection and interaction. It also supports setup across several agent clients and caps noisy output to save tokens.24 npmMIT