Servidor MCP do MAS

Servidor MCP Android para Claude Code, Cursor, Codex e qualquer cliente MCP

25 ferramentas que dão ao seu cliente de IA olhos e mãos no Android: capturas de tela que ele enxerga, OCR e correspondência de modelo, toques, deslizes e digitação, execuções de macro e um agente que cria uma macro a partir de uma frase. Controle BlueStacks, LDPlayer, MuMu, MEmu ou qualquer emulador compatível com adb no Windows ou Mac, um celular conectado ao seu PC ou dispositivos Android na nuvem sempre ligados a partir de um único endpoint remoto.

Servidor hospedado com um token da sua chave MAS, depois o 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
Baixar o app Conheça o MAS Agent Documentação de configuração

O que é

O que o servidor MCP Android do MAS faz

MCP é o protocolo que clientes de IA usam para chamar ferramentas externas. Este servidor transforma um dispositivo Android nessas ferramentas. Seu cliente pede uma captura de tela e recebe uma imagem que consegue enxergar; pergunta o que a tela diz e recebe linhas de OCR com confiança e caixas; envia um modelo e recebe de volta onde ele está; toca, desliza, digita e pressiona teclas; abre e fecha apps. Essa é a parte que todo servidor MCP Android faz, e ela funciona do mesmo jeito em um emulador, em um celular conectado ou em um dispositivo na nuvem.

O servidor do MAS também faz a parte que um servidor de dispositivo não consegue. Ele lê e executa as macros da sua biblioteca, pede ao MAS Agent para explorar um app e devolver uma macro Python pronta, e expõe o mapa que o agente aprendeu daquele app, além da referência completa do SDK como recurso MCP para que seu cliente escreva código de macro no estilo da casa. Isso o torna um servidor MCP para automação Android na camada do dispositivo, e um servidor MCP de automação móvel nas camadas acima: macros, o agente, os mapas. Não é um plugin do Android Studio nem um assistente de código. Ele controla o dispositivo.

Servidor hospedado

Todas as 25 ferramentas, nos seus dispositivos na nuvem

Um endpoint HTTP remoto. Reserve um dispositivo na nuvem, controle-o, rode macros no servidor, crie novas com o agente, leia mapas de app. Nada para instalar, e seu PC pode ficar desligado.

Conector local, gratuito

13 ferramentas de dispositivo e visão, na sua máquina

Um servidor stdio que você mesmo executa. Ele controla tudo o que o adb enxerga: BlueStacks, LDPlayer, MuMu, MEmu no Windows ou macOS, ou um celular com depuração USB. Tela, entrada, OCR e correspondência de modelo. Sem precisar de conta.

Emuladores

Controle emuladores Android: BlueStacks, LDPlayer, MuMu, MEmu no Windows ou Mac

O conector local é um servidor MCP para emulador Android, para o emulador que já está na sua mesa. Inicie com python -m masagent mcp, aponte para um dispositivo com um argumento ou com a variável MAS_DEVICE, ou deixe que ele use o primeiro dispositivo que o adb listar. Ele precisa do adb no PATH e de nada mais, e nunca se conecta a servidores externos. Essa é a configuração de MCP com emulador Android que a maioria das pessoas procura: um comando, adb, pronto. A página Conectar do app MAS mostra o passo a passo.

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

Jogos são o caso que quebra servidores baseados em árvore de acessibilidade: não há árvore para ler. O conector trabalha a partir dos pixels, então um modelo consegue jogar em uma tela de jogo do mesmo jeito que navega em uma tela de configurações.

Dispositivos na nuvem

Dispositivos Android na nuvem, nada para instalar

O servidor hospedado alcança os dispositivos sempre ligados que o MAS roda para você. lease_device abre uma sessão de controle e retorna o id de reserva de que toda ferramenta de dispositivo precisa; defina auto_start e ele inicia um dispositivo parado antes. A reserva se renova a cada chamada e expira depois de 10 minutos ociosos, então um cliente esquecido não consegue segurar um dispositivo para sempre. run_macro executa no dispositivo pelo servidor e author_macro coloca o MAS Agent para trabalhar nele, ambos com o seu PC desligado.

As ferramentas de dispositivo não têm cobrança por chamada; elas funcionam nos dispositivos na nuvem da sua conta, $80/mês cada com a franquia mensal de créditos. Ver dispositivos na nuvem.

Seu próprio celular

Um servidor MCP Android via ADB para o celular na sua mesa

Ative a depuração USB, conecte o celular, e o conector local o lista ao lado dos seus emuladores. Todas as ferramentas de tela, entrada e visão funcionam nele: um modelo consegue controlar um celular Android por MCP do mesmo jeito que controla um emulador, a partir do cliente que você já usa, sem nada instalado no celular.

Visão

Capturas de tela que o modelo enxerga, OCR e correspondência de modelo

  • screenshot retorna a tela como conteúdo de imagem, então o modelo olha diretamente para ela em vez de adivinhar a partir de uma árvore. O conector local a redimensiona para 1280 px no lado maior e informa o fator de escala.
  • read_text roda OCR na tela ou em uma região e retorna cada linha com uma confiança e uma caixa delimitadora, então "toque na palavra Resgatar" vira uma coordenada, não uma esperança.
  • find_image procura um modelo que você envia usando OpenCV, com um limiar que você controla, e retorna a pontuação e o centro para tocar.

Ferramentas

Todas as 25 ferramentas

Cada ferramenta pelo nome, com seus parâmetros. As ferramentas "local e hospedado" existem nas duas superfícies; as demais precisam de um dispositivo na nuvem.

Device control

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

  • list_devices local e hospedado
    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) hospedado
    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) hospedado
    End the control session. The device keeps running.
  • tap (x, y) local e hospedado
    Tap the screen at device coordinates.
  • swipe (x1, y1, x2, y2, duration_ms) local e hospedado
    Swipe between two points for scrolling and drags, with a chosen duration.
  • type_text (text) local e hospedado
    Type text into the focused input field.
  • press_key (key) local e hospedado
    Press BACK, HOME, ENTER, TAB, DEL or any KEYCODE_ name.
  • open_app (package) local e hospedado
    Launch an app by package name.
  • close_app (package) local e hospedado
    Force-stop an app by package name.
  • current_app local e hospedado
    Report the package in the foreground.
  • screen_size local e hospedado
    Return the screen size in pixels, the coordinate space for tap and swipe.
  • wait (ms) local e hospedado
    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 e hospedado
    Capture the screen and return it as an image the model can look at.
  • read_text (region) local e hospedado
    OCR the whole screen or one region into text lines, each with a confidence and a bounding box.
  • find_image (template_base64, threshold) local e hospedado
    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) hospedado
    List your saved macros with name, id and type, paged.
  • get_macro_code (macro_id, file) hospedado
    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) hospedado
    Start a saved macro on a cloud device, server-side, with optional argument overrides. Returns a run_id.
  • get_run (run_id) hospedado
    The state of a run, from launching through running to finished or failed, with its message.
  • stop_run (run_id) hospedado
    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) hospedado
    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) hospedado
    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) hospedado
    Answer the agent's pending question so it can continue.
  • stop_agent_session (session_id) hospedado
    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) hospedado
    The learned menu map of an app: its screens and the proven routes between them.

Recursos

Documentos que o servidor publica para que um cliente escreva código de macro sem sair da conversa.

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

Configuração

Adicione em um minuto

O servidor hospedado usa credenciais de cliente OAuth: crie uma chave no app em Chaves de API, escolha seus escopos e troque-a por um token de acesso que dura 1 hora. Envie esse token como cabeçalho bearer. O conector local não precisa de chave. 

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 hospedado com o token acima, ou o 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

Em .cursor/mcp.json, uma entrada HTTP remota com o cabeçalho:

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

Codex CLI

Em ~/.codex/config.toml, com o token em uma variável de ambiente:

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

Hermes, OpenCode, Gemini CLI e os demais

Qualquer cliente que aceite um servidor HTTP remoto com cabeçalho, ou que execute um comando stdio. Claude Desktop e os conectores do claude.ai esperam um login interativo, então use uma ponte local que adicione o cabeçalho.

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

Verifique: peça ao seu cliente para listar os dispositivos, depois uma captura de tela. Endpoint https://api.automationmacro.com/mcp, protocolo 2025-06-18, documentos de descoberta em /.well-known.

O agente, como ferramenta

author_macro: de uma exploração por IA a uma macro Python pronta

A maioria dos servidores MCP Android para no dispositivo. Este entrega o agente. author_macro recebe um objetivo em linguagem comum e um dispositivo na nuvem e inicia uma sessão do MAS Agent que explora o app, captura as imagens de modelo e regiões de texto de que precisa da tela ao vivo, compila uma macro Python determinística e a valida por repetição. get_agent_session retorna a transcrição com um cursor e qualquer pergunta que o agente fez; answer_agent_session responde. A macro pronta entra na sua biblioteca com seu id na sessão, pronta para run_macro, e cada execução depois disso custa zero créditos de IA. Conheça o MAS Agent.

QA

Testes de apps Android e fluxos de QA

Aponte um cliente para uma build de teste em um emulador ou dispositivo na nuvem, percorra o fluxo com tap, type_text e press_key, e verifique cada tela com read_text ou find_image. Percorra o fluxo uma vez com author_macro e ele vira uma verificação repetível que você pode agendar. Ele testa o app pela tela como um usuário faz; não é um framework de testes unitários.

Segurança

Servidor remoto, transporte HTTP, chaves com escopo e um conector que nunca se conecta a servidores externos

O servidor hospedado é JSON-RPC sem estado sobre HTTPS em um único endpoint. As chaves são criadas no app, exibidas uma vez, podem ter data de validade e são revogadas com um clique; os tokens gerados a partir delas duram 1 hora. Cada chave carrega apenas os escopos que você concede:

  • 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

O conector local não faz nenhuma chamada de rede própria: ele fala com o adb na sua máquina e com o seu cliente, nada mais.

Perguntas frequentes sobre o servidor MCP Android

O que é um servidor MCP Android?

MCP (Model Context Protocol) é como clientes de IA como Claude Code, Cursor e Codex chamam ferramentas externas. Um servidor MCP Android expõe um dispositivo Android como ferramentas: tirar uma captura de tela, ler o texto nela, tocar, deslizar, digitar, abrir um app. O servidor do MAS expõe 25 ferramentas e adiciona o que um servidor de dispositivo sozinho não consegue: rodar uma macro salva, pedir ao MAS Agent para criar uma e ler o mapa que ele aprendeu de um app.

Como conecto o Claude Code a um emulador Android?

Para o seu próprio emulador, execute o conector local gratuito (python -m masagent mcp) e adicione-o ao Claude Code como servidor stdio; ele controla qualquer dispositivo que o adb enxerga. Para um dispositivo na nuvem, crie uma chave no app, troque-a por um token e adicione o servidor hospedado com claude mcp add --transport http e um cabeçalho bearer. Os dois trechos estão nesta página.

Funciona com BlueStacks, LDPlayer, MuMu, MEmu?

Sim. O conector local fala com o que adb devices listar, o que cobre BlueStacks, LDPlayer, MuMu, MEmu e os outros emuladores compatíveis com adb, no Windows ou macOS. Nada nele é preso a uma marca de emulador.

O Cursor ou o Codex podem controlar um emulador Android por MCP?

Sim. O Cursor aceita o servidor hospedado como entrada HTTP remota em mcp.json com um cabeçalho Authorization, e o conector local como comando stdio. O Codex CLI aceita o servidor hospedado com codex mcp add e um token bearer de uma variável de ambiente. As mesmas ferramentas aparecem em cada um.

Quais outros clientes MCP funcionam?

Qualquer cliente que consiga chamar um servidor MCP HTTP remoto com cabeçalho bearer, ou executar um servidor stdio: Claude Code, Cursor, Codex, Hermes, OpenCode, Gemini CLI e outros. Claude Desktop e os conectores personalizados do claude.ai esperam um fluxo de login interativo, então com o MAS eles se conectam por uma ponte local que adiciona o cabeçalho.

Preciso ter ADB ou Android Studio instalado?

O conector local usa o adb por baixo, então o adb precisa estar no seu PATH; o Android Studio não é necessário. O servidor hospedado não precisa de nada instalado: os dispositivos na nuvem são controlados no servidor e seu cliente apenas chama ferramentas.

O modelo realmente enxerga a tela?

Sim. screenshot retorna a tela como uma imagem que o modelo olha diretamente. read_text roda OCR e retorna cada linha com uma confiança e uma caixa delimitadora, e find_image procura um modelo que você envia e retorna a pontuação e as coordenadas para tocar. Não precisa de árvore de acessibilidade, e é por isso que funciona em jogos.

Posso controlar um celular Android físico conectado ao meu PC?

Sim, pelo conector local. Ative a depuração USB, conecte o celular, e ele aparece em list_devices como qualquer emulador. As ferramentas de tela, entrada e visão funcionam do mesmo jeito.

É um servidor MCP remoto ou roda localmente?

Os dois. O servidor hospedado é um endpoint HTTP remoto, https://api.automationmacro.com/mcp, com todas as 25 ferramentas para os seus dispositivos na nuvem. O conector local é um servidor stdio gratuito que você executa na sua própria máquina com 13 ferramentas de dispositivo e visão para emuladores e celulares conectados. Execuções de macro, criação pelo agente e mapas de app existem apenas no hospedado.

Como funciona a autenticação?

Credenciais de cliente OAuth. Você cria uma chave no app e escolhe seus escopos; seu cliente troca a chave por um token de acesso de uma hora em https://api.automationmacro.com/api/mcp/oauth/token e o envia como token bearer. As chaves podem ter data de validade e podem ser revogadas a qualquer momento. Os documentos de descoberta são publicados em /.well-known.

O que author_macro retorna e quanto tempo leva?

Ele inicia uma sessão do MAS Agent em um dispositivo na nuvem e retorna um id de sessão na hora. O agente explora o app por vários minutos; get_agent_session transmite a transcrição com um cursor e mostra qualquer pergunta que ele fizer, que você responde com answer_agent_session. Quando termina, o id da macro está na sessão e a macro está na sua biblioteca, pronta para run_macro. A criação gasta créditos de IA; rodar a macro pronta custa zero. Conheça o MAS Agent.

É grátis? Quanto custa um dispositivo na nuvem?

O conector local é gratuito. O servidor hospedado faz parte da sua conta MAS; suas ferramentas de dispositivo funcionam nos dispositivos na nuvem que você possui, $80/mês cada com a franquia mensal de créditos, e não há cobrança por chamada nas ferramentas de dispositivo. Rodar uma macro pronta custa zero créditos; a criação pelo agente gasta créditos enquanto trabalha. Ver preços.

Pode rodar 24 horas em um dispositivo na nuvem sem o meu PC ligado?

Sim. lease_device abre uma sessão de controle em um dispositivo na nuvem e pode iniciar um que esteja parado; run_macro executa no servidor. Seu PC não precisa ficar ligado, e a reserva se renova a cada chamada e expira depois de 10 minutos ociosos. Ver dispositivos na nuvem.

Posso usar para testes de apps Android e QA?

Sim. Aponte um cliente para uma build de teste, percorra o fluxo com tap, type e press_key, verifique cada tela com read_text ou find_image, e deixe author_macro transformar um fluxo que você percorre uma vez em uma verificação repetível. Ele automatiza o app pela tela como um usuário faz; não é um framework de testes unitários.

Baixar o app Ver preços Documentação de configuração