Servidor MCP de MAS

Servidor MCP para Android para Claude Code, Cursor, Codex y cualquier cliente MCP

25 herramientas que le dan a tu cliente de IA ojos y manos en Android: capturas que puede mirar, OCR y coincidencia de plantillas, toques, deslizamientos y escritura, ejecuciones de macros y un agente que construye una macro a partir de una frase. Controla BlueStacks, LDPlayer, MuMu, MEmu o cualquier emulador compatible con adb en Windows o Mac, un teléfono conectado a tu PC o dispositivos Android en la nube siempre encendidos desde un único endpoint remoto.

Servidor alojado con un token generado a partir de tu clave de MAS, y después el conector local gratuito como servidor stdio.

claude mcp add --transport http mas https://api.automationmacro.com/mcp --header "Authorization: Bearer $MAS_MCP_TOKEN"
claude mcp add mas-local -- python -m masagent mcp
Descargar la app Conoce MAS Agent Documentación de configuración

Qué es

Qué hace el servidor MCP para Android de MAS

MCP es el protocolo que usan los clientes de IA para llamar a herramientas externas. Este servidor convierte un dispositivo Android en esas herramientas. Tu cliente pide una captura y recibe una imagen que puede mirar; pregunta qué dice la pantalla y recibe líneas de OCR con su confianza y sus cajas; envía una plantilla y recibe dónde está; toca, desliza, escribe y pulsa teclas; abre y cierra apps. Eso es lo que hace cualquier servidor MCP para Android, y funciona igual en un emulador, en un teléfono conectado o en un dispositivo en la nube.

El servidor de MAS hace además lo que un servidor de dispositivo no puede. Lee y ejecuta las macros de tu biblioteca, le pide a MAS Agent que explore una app y devuelva una macro Python terminada, y expone el mapa que el agente aprendió de esa app, además de la referencia completa del SDK como recurso MCP para que tu cliente escriba código de macros con el estilo de la casa. Eso lo convierte en un servidor MCP para automatización Android en la capa del dispositivo y en un servidor MCP de automatización móvil en las capas de arriba: macros, el agente, los mapas. No es un plugin de Android Studio ni un asistente de programación. Controla el dispositivo.

Servidor alojado

Las 25 herramientas, en tus dispositivos en la nube

Un único endpoint HTTP remoto. Reserva un dispositivo en la nube, contrólalo, ejecuta macros en el servidor, crea otras nuevas con el agente, lee mapas de app. Nada que instalar, y tu equipo puede estar apagado.

Conector local, gratis

13 herramientas de dispositivo y visión, en tu equipo

Un servidor stdio que ejecutas tú. Controla todo lo que adb pueda ver: BlueStacks, LDPlayer, MuMu, MEmu en Windows o macOS, o un teléfono con depuración USB. Pantalla, entrada, OCR y coincidencia de plantillas. Sin cuenta.

Emuladores

Controla emuladores Android: BlueStacks, LDPlayer, MuMu, MEmu en Windows o Mac

El conector local es un servidor MCP para emuladores Android pensado para el emulador que ya tienes en tu escritorio. Arráncalo con python -m masagent mcp, apúntalo a un dispositivo con un argumento o con la variable MAS_DEVICE, o deja que tome el primer dispositivo que liste adb. Necesita adb en tu PATH y nada más, y nunca se conecta a ningún servidor. Es la configuración de MCP con emulador Android que busca casi todo el mundo: un comando, adb, listo. La página Connect de la app de MAS te guía paso a paso.

  • BlueStacks
  • LDPlayer
  • MuMu
  • MEmu
  • Windows
  • macOS

Los juegos son el caso que rompe los servidores basados en árbol de accesibilidad: no hay árbol que leer. El conector trabaja a partir de píxeles, así que un modelo puede recorrer la pantalla de un juego igual que la pantalla de ajustes.

Dispositivos en la nube

Dispositivos Android en la nube, nada que instalar

El servidor alojado llega a los dispositivos siempre encendidos que MAS ejecuta por ti. lease_device abre una sesión de control y devuelve el id de reserva que necesita cada herramienta de dispositivo; activa auto_start y arrancará antes un dispositivo detenido. La reserva se renueva en cada llamada y caduca tras 10 minutos de inactividad, así un cliente olvidado no puede retener un dispositivo para siempre. run_macro se ejecuta en el dispositivo en el servidor y author_macro pone a MAS Agent a trabajar en él, ambos con tu equipo apagado.

Las herramientas de dispositivo no tienen cargo por llamada; funcionan en los dispositivos en la nube de tu cuenta, $80/mes cada uno con la asignación mensual de créditos. Ver dispositivos en la nube.

Tu propio teléfono

Un servidor MCP por ADB para el teléfono que tienes en la mesa

Activa la depuración USB, conecta el teléfono y el conector local lo lista junto a tus emuladores. Todas las herramientas de pantalla, entrada y visión funcionan en él: un modelo puede controlar un teléfono Android por MCP igual que controla un emulador, desde el cliente que ya usas, sin instalar nada en el teléfono.

Visión

Capturas que el modelo puede ver, OCR y coincidencia de plantillas

  • screenshot devuelve la pantalla como contenido de imagen, así el modelo la mira directamente en vez de adivinar a partir de un árbol. El conector local la escala a 1280 px en el lado largo e informa del factor de escala.
  • read_text ejecuta OCR sobre la pantalla o sobre una región y devuelve cada línea con su confianza y su caja delimitadora, así "toca la palabra Reclamar" es una coordenada, no una esperanza.
  • find_image busca con OpenCV la plantilla que envías, con un umbral que controlas tú, y devuelve la puntuación y el centro que tocar.

Herramientas

Las 25 herramientas

Cada herramienta por su nombre, con sus parámetros. Las herramientas "local y alojado" existen en ambas superficies; el resto necesita un dispositivo en la nube.

Device control

Pick a device and drive it: the same taps, swipes and keys a person would use.

  • list_devices local y alojado
    List the devices your client can reach, with their state. On the hosted server that is your cloud devices; on the local connector, whatever adb can see.
  • lease_device (device_id, auto_start) alojado
    Open a control session on one of your cloud devices and get the lease_id every device tool needs. Can boot a stopped device first. Leases expire after ten idle minutes and renew on every call.
  • release_device (lease_id) alojado
    End the control session. The device keeps running.
  • tap (x, y) local y alojado
    Tap the screen at device coordinates.
  • swipe (x1, y1, x2, y2, duration_ms) local y alojado
    Swipe between two points for scrolling and drags, with a chosen duration.
  • type_text (text) local y alojado
    Type text into the focused input field.
  • press_key (key) local y alojado
    Press BACK, HOME, ENTER, TAB, DEL or any KEYCODE_ name.
  • open_app (package) local y alojado
    Launch an app by package name.
  • close_app (package) local y alojado
    Force-stop an app by package name.
  • current_app local y alojado
    Report the package in the foreground.
  • screen_size local y alojado
    Return the screen size in pixels, the coordinate space for tap and swipe.
  • wait (ms) local y alojado
    Pause for animations and loading screens, up to ten seconds per call.

Vision

Let the model see the screen and locate things on it without guessing coordinates.

  • screenshot (lease_id) local y alojado
    Capture the screen and return it as an image the model can look at.
  • read_text (region) local y alojado
    OCR the whole screen or one region into text lines, each with a confidence and a bounding box.
  • find_image (template_base64, threshold) local y alojado
    Locate a template image on screen with OpenCV matching and return the match score and tap coordinates.

Macros and runs

Your macro library, readable and runnable from the client. Runs execute server-side on a cloud device.

  • list_macros (page, page_size) alojado
    List your saved macros with name, id and type, paged.
  • get_macro_code (macro_id, file) alojado
    Read a macro's source: the entry script by default, plus the file listing, or any file you name.
  • run_macro (macro_id, device_id, args) alojado
    Start a saved macro on a cloud device, server-side, with optional argument overrides. Returns a run_id.
  • get_run (run_id) alojado
    The state of a run, from launching through running to finished or failed, with its message.
  • stop_run (run_id) alojado
    Stop a running macro.

Agent authoring

Hand a goal to MAS Agent and get a finished macro back, from any client.

  • author_macro (prompt, device_id, model) alojado
    Ask MAS Agent to build a new macro on a cloud device from a plain-language goal. Runs for several minutes and spends AI credits. Returns a session_id.
  • get_agent_session (session_id, after_seq) alojado
    Progress of an authoring session: state, summary, the macro id once it exists, and the transcript events after your cursor, including any question the agent asked.
  • answer_agent_session (session_id, qid, answers) alojado
    Answer the agent's pending question so it can continue.
  • stop_agent_session (session_id) alojado
    Stop a session early. Work done so far is saved.

App maps

What the agent has learned about an app, readable by your client.

  • get_map (package, profile) alojado
    The learned menu map of an app: its screens and the proven routes between them.

Recursos

Documentos que publica el servidor para que un cliente pueda escribir código de macros sin salir de la conversación.

  • mas://docs/sdk-reference The full mas SDK reference, so an external agent can write macro code in house style.
  • mas://docs/house-library The house library of helpers the agent and the studio use.

Configuración

Añádelo en un minuto

El servidor alojado usa credenciales de cliente OAuth: crea una clave en la app, en API keys, elige sus alcances y cámbiala por un token de acceso que dura 1 hora. Envía ese token como cabecera bearer. El conector local no necesita clave. 

curl -s -X POST https://api.automationmacro.com/api/mcp/oauth/token -d grant_type=client_credentials -d client_secret=$MAS_API_KEY

Claude Code

Servidor alojado con el token de arriba, o el conector local como comando stdio:

claude mcp add --transport http mas https://api.automationmacro.com/mcp --header "Authorization: Bearer $MAS_MCP_TOKEN"
claude mcp add mas-local -- python -m masagent mcp

Cursor

En .cursor/mcp.json, una entrada HTTP remota con la cabecera:

{
  "mcpServers": {
    "mas": {
      "url": "https://api.automationmacro.com/mcp",
      "headers": { "Authorization": "Bearer <your token>" }
    }
  }
}

Codex CLI

En ~/.codex/config.toml, con el token en una variable de entorno:

[mcp_servers.mas]
url = "https://api.automationmacro.com/mcp"
bearer_token_env_var = "MAS_MCP_TOKEN"

Hermes, OpenCode, Gemini CLI y el resto

Cualquier cliente que acepte un servidor HTTP remoto con una cabecera o que lance un comando stdio. Claude Desktop y los conectores de claude.ai esperan un inicio de sesión interactivo, así que usa un puente local que añada la cabecera.

{
  "mcpServers": {
    "mas": { "type": "http", "url": "https://api.automationmacro.com/mcp", "headers": { "Authorization": "Bearer <your token>" } },
    "mas-local": { "command": "python", "args": ["-m", "masagent", "mcp"] }
  }
}

Compruébalo: pide a tu cliente que liste los dispositivos y después una captura. Endpoint https://api.automationmacro.com/mcp, protocolo 2025-06-18, documentos de descubrimiento en /.well-known.

El agente, como herramienta

author_macro: de una exploración con IA a una macro Python terminada

La mayoría de servidores MCP para Android se quedan en el dispositivo. Este te entrega el agente. author_macro toma un objetivo en lenguaje natural y un dispositivo en la nube y arranca una sesión de MAS Agent que explora la app, captura de la pantalla en vivo las imágenes plantilla y las regiones de texto que necesita, compila una macro Python determinista y la valida por repetición. get_agent_session devuelve la transcripción con un cursor y cualquier pregunta que haya hecho el agente; answer_agent_session la responde. La macro terminada aterriza en tu biblioteca con su id en la sesión, lista para run_macro, y cada ejecución posterior cuesta cero créditos de IA. Ver MAS Agent.

QA

Pruebas de apps Android y flujos de QA

Apunta un cliente a una build de pruebas en un emulador o en un dispositivo en la nube, recorre el flujo con tap, type_text y press_key, y comprueba cada pantalla con read_text o find_image. Recorre el flujo una vez con author_macro y se convierte en una comprobación repetible que puedes programar. Prueba la app a través de la pantalla como lo haría un usuario; no es un framework de pruebas unitarias.

Seguridad

Servidor remoto, transporte HTTP, claves con alcances y un conector que nunca se conecta a nada

El servidor alojado es JSON-RPC sin estado sobre HTTPS en un único endpoint. Las claves se crean en la app, se muestran una sola vez, pueden llevar fecha de caducidad y se revocan con un clic; los tokens generados a partir de ellas duran 1 hora. Cada clave lleva solo los alcances que le concedes:

  • devices:control lease a cloud device, see its screen, tap, type and manage apps
  • macros:run list and read macros, start, check and stop runs
  • macros:author start, follow, answer and stop an agent authoring session
  • maps:read read the learned map of an app

El conector local no hace llamadas de red propias: habla con adb en tu equipo y con tu cliente, nada más.

Preguntas frecuentes sobre el servidor MCP para Android

¿Qué es un servidor MCP para Android?

MCP (Model Context Protocol) es la forma en que los clientes de IA como Claude Code, Cursor y Codex llaman a herramientas externas. Un servidor MCP para Android expone un dispositivo Android como herramientas: hacer una captura, leer el texto que hay en ella, tocar, deslizar, escribir, abrir una app. El servidor de MAS expone 25 herramientas y añade lo que un servidor de dispositivo por sí solo no puede: ejecutar una macro guardada, pedirle a MAS Agent que construya una y leer el mapa que aprendió de una app.

¿Cómo conecto Claude Code a un emulador Android?

Para tu propio emulador, ejecuta el conector local gratuito (python -m masagent mcp) y añádelo a Claude Code como servidor stdio; controla cualquier dispositivo que adb pueda ver. Para un dispositivo en la nube, crea una clave en la app, cámbiala por un token y añade el servidor alojado con claude mcp add --transport http y una cabecera bearer. Los dos fragmentos están en esta página.

¿Funciona con BlueStacks, LDPlayer, MuMu, MEmu?

Sí. El conector local habla con lo que liste adb devices, lo que cubre BlueStacks, LDPlayer, MuMu, MEmu y los demás emuladores compatibles con adb, en Windows o macOS. Nada en él está atado a una marca de emulador.

¿Cursor o Codex pueden controlar un emulador Android por MCP?

Sí. Cursor acepta el servidor alojado como entrada HTTP remota en mcp.json con una cabecera Authorization, y el conector local como comando stdio. Codex CLI acepta el servidor alojado con codex mcp add y un token bearer desde una variable de entorno. Las mismas herramientas aparecen en cada uno.

¿Qué otros clientes MCP funcionan?

Cualquier cliente que pueda llamar a un servidor MCP HTTP remoto con una cabecera bearer, o lanzar un servidor stdio: Claude Code, Cursor, Codex, Hermes, OpenCode, Gemini CLI y otros. Claude Desktop y los conectores personalizados de claude.ai esperan un flujo de inicio de sesión interactivo, así que con MAS se conectan a través de un puente local que añade la cabecera.

¿Necesito tener instalado ADB o Android Studio?

El conector local usa adb por debajo, así que adb tiene que estar en tu PATH; Android Studio no hace falta. El servidor alojado no necesita instalar nada: los dispositivos en la nube se controlan en el servidor y tu cliente solo llama a herramientas.

¿El modelo puede ver la pantalla de verdad?

Sí. screenshot devuelve la pantalla como una imagen que el modelo mira directamente. read_text ejecuta OCR y devuelve cada línea con su confianza y su caja delimitadora, y find_image busca la plantilla que envías y devuelve la puntuación y las coordenadas que tocar. No hace falta ningún árbol de accesibilidad, por eso funciona en juegos.

¿Puedo controlar un teléfono Android físico conectado a mi PC?

Sí, a través del conector local. Activa la depuración USB, conecta el teléfono y aparece en list_devices como cualquier emulador. Las herramientas de pantalla, entrada y visión funcionan igual.

¿Es un servidor MCP remoto o se ejecuta en local?

Ambas cosas. El servidor alojado es un único endpoint HTTP remoto, https://api.automationmacro.com/mcp, con las 25 herramientas para tus dispositivos en la nube. El conector local es un servidor stdio gratuito que ejecutas en tu propio equipo con 13 herramientas de dispositivo y visión para emuladores y teléfonos conectados. Las ejecuciones de macros, la creación con el agente y los mapas de app son solo del servidor alojado.

¿Cómo funciona la autenticación?

Con credenciales de cliente OAuth. Creas una clave en la app y eliges sus alcances; tu cliente cambia la clave por un token de acceso de una hora en https://api.automationmacro.com/api/mcp/oauth/token y lo envía como token bearer. Las claves pueden llevar fecha de caducidad y se pueden revocar en cualquier momento. Los documentos de descubrimiento se publican en /.well-known.

¿Qué devuelve author_macro y cuánto tarda?

Arranca una sesión de MAS Agent en un dispositivo en la nube y devuelve un id de sesión de inmediato. El agente explora la app durante varios minutos; get_agent_session transmite su transcripción con un cursor y muestra cualquier pregunta que haga, que respondes con answer_agent_session. Cuando termina, el id de la macro está en la sesión y la macro en tu biblioteca, lista para run_macro. Crearla gasta créditos de IA; ejecutar la macro terminada cuesta cero. Ver MAS Agent.

¿Es gratis? ¿Cuánto cuesta un dispositivo en la nube?

El conector local es gratis. El servidor alojado forma parte de tu cuenta de MAS; sus herramientas de dispositivo funcionan en los dispositivos en la nube que tengas, $80/mes cada uno con la asignación mensual de créditos, y no hay cargo por llamada en las herramientas de dispositivo. Ejecutar una macro terminada cuesta cero créditos; la creación con el agente gasta créditos mientras trabaja. Ver precios.

¿Puede funcionar 24/7 en un dispositivo en la nube sin mi PC encendido?

Sí. lease_device abre una sesión de control en un dispositivo en la nube y puede arrancar uno detenido; run_macro se ejecuta en el servidor. Tu PC no tiene que quedarse encendido, y la reserva se renueva en cada llamada y caduca tras 10 minutos de inactividad. Ver dispositivos en la nube.

¿Puedo usarlo para pruebas y QA de apps Android?

Sí. Apunta un cliente a una build de pruebas, recorre el flujo con tap, type y press_key, comprueba cada pantalla con read_text o find_image, y deja que author_macro convierta un flujo que recorres una vez en una comprobación repetible. Automatiza la app a través de la pantalla como lo haría un usuario; no es un framework de pruebas unitarias.

Descargar la app Ver precios Documentación de configuración