mobile-debug-mcp
Allows launching, observing, interacting with, and debugging Android apps on emulators or devices via ADB, including tap, text input, swipe, screenshots, and log collection.
Supports interacting with Flutter apps, including canvas-based screens, via the semantics tree for element detection and manipulation.
Click on "Install 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., "@mobile-debug-mcpLaunch the Gmail app and display the inbox screen."
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.
mobile-debug-mcp
An MCP server that lets Claude drive a real Android app on an emulator/device like a QA engineer: launch, observe, act, verify — with logs and screenshots as evidence.
Unlike thin "adb over MCP" wrappers, every action returns the new screen state plus a
log delta, so the output is not "I tapped a button", it's "I tapped Sign in, the app
POSTed /auth, got a 401, and showed an error toast — here's the screenshot and the log lines."
It also learns the app as it goes. Every screen it sees becomes a node in a navigation map and every action an edge, so the second time you need Settings the agent takes a known route instead of re-exploring the UI — which is where the token cost in agentic QA actually goes.
Status: early — the primitive tool surface plus the app map and the first semantic actions. Flutter canvas screens are handled via the semantics tree. See PLAN.md.
Demo

Claude is asked to log out and log back in "and see if there are any errors". It reads the
screen, taps its way through, and reports what the app actually did — no hand-written
selectors. Full-quality recording: media/demo.mp4.
Related MCP server: androir-mcp
Quickstart
With an emulator running and adb on your PATH:
uv sync --extra dev --extra images
uv run mobile-debug-mcp --transport http # http://127.0.0.1:8765/mcpRegister it with Claude Code, then let the agent learn its way around:
claude mcp add --transport http mobile-debug http://127.0.0.1:8765/mcplaunch_app("com.example.app") → the landing screen, element-indexed, plus startup logs
map_app() → crawls the app, bounded, building the navigation map
get_map() → every screen it found and how each is reached
navigate_to("Settings") → replays a known route: Home —[tap 'Menu']→ Drawer → Settingsnavigate_to("Settings", plan_only=True) prints the route without touching the device.
Requirements
Python 3.11+
Android
platform-toolsonPATH(adb)A running emulator or a USB-connected device
Device selection: set ANDROID_SERIAL, or pass --device <serial>. With a single device
connected, it is picked automatically; with zero or more than one and no selection, the
server errors clearly.
Run
Two transports. Pick one.
HTTP — a long-lived local daemon (recommended)
uv run mobile-debug-mcp --transport http # http://127.0.0.1:8765/mcpOne daemon serves every project on the machine, so client config carries no absolute paths — commit this to any repo that wants the tools:
{ "mcpServers": { "mobile-debug": { "type": "http", "url": "http://127.0.0.1:8765/mcp" } } }The session outlives any single client, so the learned app map and logcat cursors persist across Claude sessions instead of being rebuilt each time. The trade: you start it — nothing auto-spawns it, and clients fail to connect while it's down.
Because the surface is now network-reachable, HTTP mode tightens two things stdio got for free:
Screenshot writes are sandboxed to
~/.config/mobile-debug-mcp/artifacts(--artifacts-dirto move it).take_screenshot(save_path=…)is otherwise an arbitrary-file-write primitive.DNS-rebinding protection is on, so a web page in your browser can't POST to the port. The MCP SDK leaves this off by default; this server turns it on.
Actions are serialised under a device lock — one device, one screen, so two concurrent clients can't interleave mid-action. That prevents corrupted actions, not logical races: two clients driving the same device still confuse each other, so don't.
--host binds elsewhere, but there is no authentication — anyone who can reach the
port can drive the device, read logcat (tokens, PII) and wipe app data. It warns if you
bind beyond loopback. Don't, without putting auth in front of it.
stdio — one process per client
uv run mobile-debug-mcpclaude mcp add mobile-debug -- uv run --directory /abs/path/to/mobile-debug-mcp mobile-debug-mcpAuto-spawned by the client, nothing to keep running — but the absolute path means the
registration doesn't travel between machines, and state is rebuilt every session.
save_path is unrestricted here, which is fine: the client already owns the process.
Tools
Primitives — every one returns the new screen state and the log delta it produced.
Tool | What it does |
| force-stop → optional |
| compact element list (+ optional downscaled screenshot) |
| tap by element id (or |
| focus a field and type (ASCII for now) |
| pure image, no hierarchy dump — for canvas/Flutter/video screens |
| PID-scoped logcat, classified |
| back / home / enter / … |
| scroll / drag between two points |
App map — navigate by learned route instead of re-exploring.
Tool | What it does |
| bounded auto-crawl that fills the map; skips destructive-looking controls |
| every known screen and how each is reached |
| declares a route, then replays it, re-resolving elements by selector |
Semantic — deterministic sense→act→verify state machines.
Tool | What it does |
| restart or clear-and-restart, then verify where it actually landed |
| route → unwind the back stack → relaunch, cheapest first; never blind-presses |
Development
uv run ruff check .
uv run ruff format .
uv run pytest # no device needed — adb is faked, screens come from fixturesSee CONTRIBUTING.md for layout and conventions, and SECURITY.md before exposing the HTTP transport anywhere.
License
MIT © Techmanu Pvt. Ltd. — see LICENSE.
Maintained by @MaheshPhuyal02.
Available Tools
3 toolsget_logsA
Query app logcat, PID-scoped to the current app.
By default returns the classified delta since the last action (crashes, ANRs,
errors + counts). With level set, returns raw filtered lines at that
priority and above.
Args:
lines: Max lines to fetch when not scoping to the last action.
level: Minimum priority to show raw: V/D/I/W/E.
since_last_action: Scope to the window since the most recent action.
| Name | Required | Description | Default |
|---|---|---|---|
| level | No | ||
| lines | No | ||
| since_last_action | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Without annotations, the description fully discloses that it returns a classified delta by default and raw lines with level, plus PID scoping and the since_last_action window. It is a read-only operation, which is appropriate. Could mention that response format is defined in the output schema.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is well-structured with a default behavior paragraph and an Args section. Each sentence adds value; no wasted words.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given 3 parameters, no annotations, and an output schema, the description covers purpose, default behavior, and parameters well. It does not describe output format, but that is handled by the output schema. Slightly incomplete regarding potential side effects or performance implications, but adequate.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 0%, but the description fully compensates by explaining each parameter: lines (max lines when not scoping to last action), level (minimum priority for raw), since_last_action (scope window). Adds meaning beyond schema types.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description explicitly states it queries app logcat PID-scoped to the current app, distinguishing default behavior (classified delta) from raw filtered lines with level. This clearly differentiates it from sibling tools like get_map and tap_element.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains when to use default mode vs raw mode ('With level set') and the role of lines parameter ('when not scoping to the last action'). However, it does not mention when not to use the tool or suggest alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_mapA
Return the learned app map for the current app — where is what.
Lists every known screen (name, activity, fingerprint, saved screenshot) and how each is reached (the incoming transitions), so you can plan against a map before touching the device. The map is built automatically as the app is driven.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations provided, so description bears full responsibility. It mentions the map is built automatically, implying it is a read-only operation. However, it does not explicitly confirm non-destructiveness or detail other behaviors like output format. Adequate but not thorough.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two sentences: first states main purpose, second elaborates on contents and usage. No unnecessary words, front-loaded with key action.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given zero parameters, an output schema exists (not shown), and complexity is low, the description sufficiently covers what the tool does, its contents, and its purpose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Input schema has zero parameters, so description need not add parameter details. With 100% schema coverage (nonexistent params), baseline is 4, and description appropriately adds no extraneous param info.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states it returns the learned app map with specific contents (screens, transitions) and uses a verb 'Return' with a clear resource. It is well-distinguished from siblings 'get_logs' and 'tap_element'.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies use for planning before interacting with the device ('so you can plan against a map before touching the device'). It does not explicitly state when not to use or suggest alternatives, but the context is clear.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
tap_elementA
Tap an element by id (preferred) or by raw coordinates.
Returns the new screen state and the log delta the tap produced. If the target moved or vanished since the last observation, it is re-resolved by selector, or the fresh screen is returned so you can retarget in one turn.
Args:
element: Element id from a recent screen state, e.g. e3.
x: X pixel (only if not using element).
y: Y pixel (only if not using element).
| Name | Required | Description | Default |
|---|---|---|---|
| x | No | ||
| y | No | ||
| element | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description bears full responsibility. It discloses the re-resolution behavior and mentions the return values. However, it does not discuss potential side effects (e.g., triggering navigation, destructive actions), authorization needs, or rate limits. The disclosure is adequate but not comprehensive for a tool that performs an action.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is concise and well-structured. It starts with the core action, then explains behavior in edge cases, and finally details parameters. Every sentence adds value without redundancy. It is appropriately sized for the tool's complexity.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the presence of an output schema (indicated by 'has output schema: true'), the description does not need to detail return values, but it still mentions them. The description covers the main functionality and an important edge case (re-resolution). However, it does not address error conditions or input validation, but overall it is sufficiently complete for an agent to use the tool effectively.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description explains the purpose of each parameter clearly: 'element' is an element id from a recent screen state with an example, and 'x'/'y' are pixel coordinates used only if not using element. It also states the preferred usage (element over coordinates). Given that schema description coverage is 0%, the description compensates well by adding meaning beyond the schema.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the action ('tap') and the resource ('element'), and explicitly distinguishes between two methods (by id or by raw coordinates). It also mentions what the tool returns (new screen state and log delta). There is no ambiguity given the sibling tools are 'get_logs' and 'get_map', which are clearly different actions.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description provides context on when re-resolution occurs if the target moved or vanished, which guides the agent on how to handle stale elements. However, it does not explicitly state when to use this tool versus alternatives or specify any prerequisites or constraints. The guidance is helpful but not exhaustive.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
3 tool updates
v0.1.0- First observed
get_logs - First observed
get_map - First observed
tap_element
TDQS
Each tool has a clearly distinct purpose: logs, screen map, and tapping. No overlap or ambiguity.
All tool names follow a consistent verb_noun pattern (get_logs, get_map, tap_element), making them predictable.
Three tools is minimal but reasonable for a focused debugging server; however, it feels slightly undersized for comprehensive mobile debugging.
Missing essential interactions like swipe, text input, or screenshot (though map includes screenshots). Significant gaps for real-world debugging workflows.
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Connectors
MCP server for building and testing AI agents with multi-model experimentation and insights.
Control real Android and iOS devices with LLM agents — tap, swipe, type, automate flows.
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
MCP server for AI agents to plan, verify, and deploy Cloudflare-native apps.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceAn MCP server designed for Android development, enabling AI assistants to directly control Android devices for screenshots, UI analysis, app management, and more.-
- AlicenseBqualityBmaintenanceAn MCP server that allows AI agents to drive real Android devices via adb, capturing screenshots, reading the live UI tree, and performing actions like tap, swipe, and type.13151Apache 2.0
- AlicenseAqualityCmaintenanceAn MCP server that gives AI agents full control of Android devices and emulators through plain ADB — no companion APK, no extra daemon, no telemetry.2617MIT
- AlicenseNot gradedqualityAmaintenanceAn MCP server that enables AI agents to control Android and iOS devices via natural language, using platform tools like adb and simctl.6,61346Apache 2.0
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/Techmanu-PVT-LTD/mobile-debug-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server