Android Remote Control MCP

An Android application that runs as an MCP (Model Context Protocol) server, enabling AI models to fully control an Android device remotely using accessibility services and screenshot capture.

The app runs directly on your Android device (or emulator) and exposes an HTTP server (with optional HTTPS) implementing the MCP protocol. AI models like Claude can connect to it and interact with any app on the device — reading UI elements, tapping buttons, typing text, swiping, capturing screenshots, managing files, launching apps, and more.

Warning: This software is provided "as-is" without warranty of any kind, for research and educational purposes only. The authors do not condone the use of this tool for any illegal, unauthorized, or unethical activities. Users are solely responsible for ensuring their use complies with all applicable laws and regulations. By using this software, you agree to use it responsibly and at your own risk.

Features

MCP Server

• HTTP server running directly on Android (Ktor + Netty), with optional HTTPS
• Streamable HTTP transport at /mcp (MCP specification compliant, JSON-only, no SSE)
• Combined authentication: static bearer token and/or a self-contained OAuth 2.1 server (Claude.ai / Claude Desktop custom connectors, with on-device approval)
• Auto-generated self-signed TLS certificates (or custom certificate upload)
• Configurable binding: localhost (127.0.0.1) or network (0.0.0.0)
• Auto-start on boot
• Remote access tunnels via Cloudflare Quick Tunnels or ngrok (public HTTPS URL)

56 MCP Tools across 13 Categories

Screen introspection, system actions, touch actions, gestures, node actions, text input, utilities, file operations, app management, camera, intents, notifications, and location.

All tool names use the android_ prefix by default (e.g., android_tap). When a device slug is configured (e.g., pixel7), the prefix becomes android_pixel7_ (e.g., android_pixel7_tap).

See docs/MCP_TOOLS.md for the full tool reference with input/output schemas and examples.

Android App

• Material Design 3 UI with tabbed layout (Server / Settings / About) and dark mode
• Server status monitoring (running/stopped) with permission warning banner
• Connection info display (IP, port, token, tunnel URL)
• Per-tool and per-parameter permissions (enable/disable individual MCP tools)
• Permission management (Accessibility, Notifications, Camera, Microphone)
• Remote access tunnel configuration (Cloudflare / ngrok)
• Storage location management (automatic locations + SAF authorization for file tools)
• Server log viewer (MCP tool calls, tunnel events)
• Headless setup via ADB (configure, grant permissions, start/stop server without UI)

Comparison with Alternatives

Most alternatives rely on ADB running on a host machine, which means a USB cable or local network connection and a computer sitting next to the phone. This project runs entirely on the device itself, so you can expose the MCP endpoint through a tunnel and control your phone from anywhere.

On the token efficiency side, ADB-based tools typically return raw uiautomator XML dumps which can easily be 10-50x more verbose than the compact representation used here. Combined with numbered screenshot annotations, configurable image quality, and the ability to disable tools you don't need (every tool definition costs tokens on every turn), this significantly reduces the per-interaction cost in agentic loops.

Install

Option A: Download on your phone (easiest)

1. Open the Releases page on your phone's browser
2. Download the APK from the latest release
3. Open the downloaded APK and follow the prompts to install it (you may need to allow installation from unknown sources)

Option B: Download on your PC and install via ADB

1. Download the APK from the Releases page
2. Connect your phone via USB (with USB Debugging enabled)
3. Install the APK:

adb install app-release.apk

Option C: Build from sources

git clone https://github.com/danielealbano/android-remote-control-mcp.git
cd android-remote-control-mcp
make build
make install  # installs on connected device/emulator

See CONTRIBUTING.md for full build requirements and instructions.

Setup

1. Open the app and go to Settings > Permissions
2. Enable Accessibility Service (required for UI introspection, actions, and screenshots)
3. Grant additional permissions as needed (Camera, Microphone, Location, Notifications)
4. Configure storage locations in Settings > Storage if you plan to use file tools (includes automatic locations like Downloads, plus custom locations via SAF)
5. Go back to the Server tab and tap Start to start the MCP server

The server starts on http://127.0.0.1:8080 by default. The connection info (IP, port, token, URL) is displayed on the Server tab.

Note: 127.0.0.1 refers to the phone's localhost, not your computer. To connect from your computer, use adb port forwarding, bind to 0.0.0.0 (network mode), or enable a remote access tunnel.

Permissions Reference

The app declares the permissions below. Normal permissions are granted automatically at install. Runtime permissions and Special access require explicit user action (via the app's Settings > Permissions tab, or programmatically — see Granting Permissions Programmatically). All runtime permissions are optional: the app works without them, but the features that depend on them are disabled until granted.

Connect

Claude Desktop / Claude Code

Add the server to your .mcp.json configuration file:

{
  "mcpServers": {
    "android-phone": {
      "type": "http",
      "url": "http://DEVICE_IP:PORT/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_TOKEN"
      }
    }
  }
}

Replace DEVICE_IP, PORT, and YOUR_TOKEN with the values shown in the app's Server tab. If the server is bound to localhost (default), you'll need adb port forwarding or a [remote access tu