Skip to main content
Glama
Android Studio MCP

Android Studio MCP

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.

Platform Python FastMCP Tools License


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

gradlew, adb, emulator, avdmanager, sdkmanager, apkanalyzer, apksigner, aapt2, bundletool

build, test, lint, deps, signing, devices, emulators, APK/AAB analysis

★★★★★ headless, deterministic

2. Headless IDE CLI

studio64.exe inspect / format / diff, open project/file

full code inspection reports, reformat, navigation

★★★★☆

3. Live IDE

built‑in HTTP server (:63342) + stdioMcpServer MCP bridge

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 remediation list 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 at C:\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 tests

Wire 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_mcp

One‑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 a status (ok | error | confirmation_required) and a human summary. Destructive tools require confirm=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 with ASMCP_WORKSPACE_ROOTS.

  • Confirmation gating — destructive tools (as_close --force, as_adb_uninstall, as_avd_delete, as_format_code, as_sdk_install, as_restore_backup, …) return confirmation_required unless called with confirm=true.

  • Backups first — files are backed up before being reformatted/overwritten; projects can be zipped with as_project_backup.

  • Guarded device shell — as_adb_shell runs recognised read‑only commands freely but requires confirm=true for 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

ASMCP_STUDIO_HOME / STUDIO_HOME

C:\Program Files\Android\Android Studio

Android SDK

ASMCP_ANDROID_SDK / ANDROID_HOME / ANDROID_SDK_ROOT

%LOCALAPPDATA%\Android\Sdk

Workspace roots (allow‑list)

ASMCP_WORKSPACE_ROOTS (;‑separated)

E:\Projekte;%USERPROFILE%

Built‑in server port

ASMCP_BUILTIN_SERVER_PORT

63342

bundletool jar

ASMCP_BUNDLETOOL

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 domain

Testing

Suite

What

Result

scripts/smoke_test.py

env checks, gating, path allow‑list, scaffold round‑trip

17/17

scripts/build_test.py

real gradlew assembleDebug → signed APK → analysis

BUILD SUCCESSFUL

scripts/security_test.py

adb‑shell injection/chaining gate

6/6

pytest tests

pure parser functions

15/15

evals/android_studio_eval.xml

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_status tells you, and the CLI tools cover everything regardless.

  • Headless inspect indexes 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 tools
as_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_devicesA
Read-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_logcatA
Read-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_clearB
DestructiveIdempotent

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_pullA
Read-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_screenshotA
Read-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_shellA
Destructive

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_appA
Idempotent

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_uninstallA
DestructiveIdempotent

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_compareA
Read-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_filesizeA
Read-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_infoA
Read-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_methodsA
Read-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_signatureA
Read-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_deleteA
DestructiveIdempotent

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_listA
Read-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_stopA
DestructiveIdempotent

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_closeA
Destructive

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_configA
Read-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_diffA
Idempotent

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_codeA
DestructiveIdempotent

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_cleanA
DestructiveIdempotent

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_dependenciesA
Read-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_lintA
Idempotent

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_taskA
Destructive

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_reportA
Read-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_stopA
Idempotent

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_tasksA
Read-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_toolsA
Read-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_statusA
Read-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_codeA
Read-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_runningA
Read-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_readA
Read-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_stopB
Idempotent

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_ideA
Read-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_mcpA
Read-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_fileA
Idempotent

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_projectA
Idempotent

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_listA
Read-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_stopB
DestructiveIdempotent

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_infoA
Read-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_recentA
Read-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_validateA
Read-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_healthA
Read-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_restartA
Destructive

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_backupA
Destructive

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_retraceA
Read-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:

  1. assemble 2. install the APK 3. launch the launcher activity

  2. 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_screenrecordC
Read-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_licensesA
Idempotent

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_installA
Idempotent

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_listA
Read-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_statusA
Read-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_focusA
Idempotent

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_actionA
Destructive

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_screenshotA
Read-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_keysA
Destructive

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

    A3.6/5.0

    Scored across 73 tools

    Disambiguation4/5

    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.

    Naming Consistency5/5

    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.

    Tool Count2/5

    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.

    Completeness4/5

    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

    ActivityInactive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      C
      maintenance
      Provides 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 npm
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables 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 npm
      MIT