Skip to main content
Glama
Techmanu-PVT-LTD

mobile-debug-mcp

mobile-debug-mcp

CI License: MIT Python 3.11+

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 Code driving a Flutter login screen on an Android emulator through mobile-debug-mcp

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/mcp

Register 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/mcp
launch_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 → Settings

navigate_to("Settings", plan_only=True) prints the route without touching the device.

Requirements

  • Python 3.11+

  • Android platform-tools on PATH (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.

uv run mobile-debug-mcp --transport http        # http://127.0.0.1:8765/mcp

One 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-dir to 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-mcp
claude mcp add mobile-debug -- uv run --directory /abs/path/to/mobile-debug-mcp mobile-debug-mcp

Auto-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

launch_app

force-stop → optional pm clear → launch; returns screen state

get_screen_state

compact element list (+ optional downscaled screenshot)

tap_element

tap by element id (or x,y); returns new state + log delta

input_text

focus a field and type (ASCII for now)

take_screenshot

pure image, no hierarchy dump — for canvas/Flutter/video screens

get_logs

PID-scoped logcat, classified

press_key

back / home / enter / …

swipe

scroll / drag between two points

App map — navigate by learned route instead of re-exploring.

Tool

What it does

map_app

bounded auto-crawl that fills the map; skips destructive-looking controls

get_map

every known screen and how each is reached

navigate_to

declares a route, then replays it, re-resolving elements by selector

Semantic — deterministic sense→act→verify state machines.

Tool

What it does

reset_app

restart or clear-and-restart, then verify where it actually landed

go_home

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 fixtures

See 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 tools
get_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.

ParametersJSON Schema
NameRequiredDescriptionDefault
levelNo
linesNo
since_last_actionNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.5/5.0
Behavior4/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters5/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.3/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness5/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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).

ParametersJSON Schema
NameRequiredDescriptionDefault
xNo
yNo
elementNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.2/5.0
Behavior3/5

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.

Conciseness5/5

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.

Completeness4/5

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.

Parameters4/5

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.

Purpose5/5

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.

Usage Guidelines4/5

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.

  1. 3 tool updatesv0.1.0
    • First observedget_logs
    • First observedget_map
    • First observedtap_element

TDQS

A4.1/5.0
Disambiguation5/5

Each tool has a clearly distinct purpose: logs, screen map, and tapping. No overlap or ambiguity.

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern (get_logs, get_map, tap_element), making them predictable.

Tool Count3/5

Three tools is minimal but reasonable for a focused debugging server; however, it feels slightly undersized for comprehensive mobile debugging.

Completeness2/5

Missing essential interactions like swipe, text input, or screenshot (though map includes screenshots). Significant gaps for real-world debugging workflows.

Maintenance

ActivitySlowing
ResponsivenessSyncing

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

Related MCP Servers

Latest Blog Posts

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