# Claude + MCP + TagoIO para desenvolvedores de IoT

> Opere sua stack de IoT com IA. Claude e o MCP da TagoIO permitem gerenciar dispositivos, dados, alertas e scripts sem fluxos manuais.

![Claude + MCP + TagoIO para desenvolvedores de IoT](https://tago.io/og/pt-br/blog/claude-mcp-tagoio-for-iot-developers.png)

Se você já construiu um produto de IoT do zero, sabe que o trabalho raramente está no dispositivo. O dispositivo é a parte fácil. O difícil é tudo o que precisa existir ao redor dele: endpoints de ingestão, armazenamento de séries temporais que aguente um ano de uplinks a cada cinco segundos, parsers de payload para cada versão de firmware que você já lançou, dashboards que seus clientes realmente vão olhar, regras de alerta que acionam a pessoa certa, contas de usuário, acesso baseado em papéis, portais white-label, trilhas de auditoria, conformidade regional e os dez cron jobs que ninguém documentou.

Construir tudo isso sozinho é possível. Mantê-lo por cinco anos em cem tipos de dispositivos é outro esporte. É aqui que uma plataforma como a TagoIO mostra seu valor, e onde uma nova peça da stack muda a velocidade com que um único desenvolvedor consegue avançar: o servidor MCP da TagoIO, que deixa o Claude conversar diretamente com sua conta de IoT. Para um tour rápido do que isso habilita na prática, veja [Construa soluções de IoT mais rápido com o Claude e o TagoIO MCP](https://tago.io/blog/build-iot-solutions-faster-with-claude-and-tagoio-mcp).

## **A cilada do "eu mesmo construo isso"**

Todo líder de engenharia de IoT já teve essa conversa. O roadmap tem cinquenta SKUs conectados. Alguém desenha uma arquitetura: um cluster Kafka aqui, Postgres com TimescaleDB ali, Grafana para os dashboards, Keycloak para autenticação, um pequeno serviço Node para fazer o parse dos payloads, um microsserviço de alertas, uma interface de admin por cima, tudo colado com Terraform.

Seis meses depois, o time de dispositivos ainda está discutindo com o time de plataforma por que a ingestão perde 0,4% dos pacotes quando uma região faz failover. O serviço de dashboards está na terceira reescrita. Ninguém consegue responder "qual foi a umidade média no armazém na terça-feira passada, entre 14h e 16h?" sem escrever SQL. Os clientes pedem um aplicativo mobile com a marca deles. O time de conformidade quer evidências de ISO 27001. Dois engenheiros pedem demissão.

A plataforma deveria ser um meio para um fim. Virou o produto.

Uma plataforma de IoT feita sob medida tira esse trabalho do seu colo. Provisionamento de dispositivos, armazenamento mutável e imutável, parsers de payload, dashboards, ações, scripts de Analysis, portais white-label, multi-região, RBAC, logs de auditoria e os SDKs para conversar com tudo isso vêm como um único produto. Você para de manter infraestrutura e passa a entregar funcionalidades.

Essa é a parte da história que a maioria dos times de IoT já entende. A parte mais nova é o que acontece quando você coloca um assistente de IA por cima dessa plataforma.

## **O que o MCP realmente é**

O Model Context Protocol (MCP) é um padrão aberto da Anthropic que permite a assistentes de IA como o Claude conversar com sistemas externos por meio de uma interface de ferramentas bem definida. Em vez de descrever sua conta de IoT em um prompt longo, o Claude chama ferramentas reais contra o sistema real: liste estes dispositivos, pegue estes dados, crie esta ação, escreva este script de Analysis.

O servidor MCP da TagoIO é um pequeno programa (ou endpoint hospedado) que expõe sua conta TagoIO ao Claude como um conjunto de ferramentas tipadas. O Claude lê o catálogo de ferramentas, escolhe a certa para o que você pediu, preenche os parâmetros e age. Você vê o resultado no chat, e a mudança aparece no seu console de admin da TagoIO.

O efeito prático: a maior parte do trabalho operacional que você fazia clicando pela interface de admin ou escrevendo scripts pontuais, agora você faz em português simples, direto da sua IDE.

## **Configuração em dois minutos**

O servidor MCP da TagoIO tem duas versões. O servidor remoto em [https://mcp.ai.tago.io](https://mcp.ai.tago.io) não exige instalação. A opção local roda via `npx` se você quiser tê-la na sua máquina. As duas se autenticam com um Profile Token da sua conta TagoIO em [admin.tago.io/profile](https://admin.tago.io/profile).

Para o Claude Code, um comando:

```shell
claude mcp add-json @tago-io/mcp '{"type":"http","url":"https://mcp.ai.tago.io","headers":{"Authorization":"Bearer YOUR-TAGOIO-TOKEN"}}'
```

Para o Claude Desktop, adicione isto ao `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "@tago-io/mcp": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://mcp.ai.tago.io",
        "--header",
        "Authorization: Bearer YOUR-TAGOIO-TOKEN"
      ]
    }
  }
}
```

Reinicie, e o Claude já consegue alcançar sua conta. Se você está na EU West ou em uma instância dedicada da TagoIO, adicione um header `x-tagoio-region` com `eu-w1` ou a URL completa da sua API.

Uma observação sobre tokens: o Profile Token concede acesso total à conta e é a escolha certa enquanto você está explorando. Para produção, mude para um Analysis Token vinculado a um Analysis com escopo restrito. O mesmo servidor MCP, com um raio de impacto menor.

## **O que o servidor MCP realmente faz**

O servidor atual (v3) agrupa as ferramentas em alguns serviços. A cobertura é ampla o bastante para que a maior parte do trabalho do dia a dia caiba nele.

**Dispositivos.** `device-operations` cuida de busca, criação, atualização, exclusão e configuração. Você pode pesquisar por nome (com correspondência por curinga embutida), por tag, por connector, por network, por estado ativo. `device-data-operations` executa consultas com agregações: avg, sum, min, max, count e condicional. O agrupamento por tempo vai de minuto a ano. `device-delete-data` remove dados de um dispositivo quando você precisa.

**Ações.** `action-operations` cobre o CRUD completo das Actions da TagoIO, as regras que disparam quando um dispositivo envia dados que batem com uma condição. Alertas por e-mail, webhooks, gatilhos de Analysis, tudo.

**Analysis.** `analysis-operations` lê, escreve e atualiza scripts de Analysis (o código Node.js que a TagoIO executa no servidor por você). Combinado com `tagoio-code-search`, o Claude consegue gerar código de Analysis com as chamadas certas do SDK da TagoIO, em vez de alucinar o formato da API. `tagoio-documentation-search` consulta a documentação da TagoIO sob demanda.

**Entities.** `entity-operations` e `entity-data` trabalham com as Entities da TagoIO, a camada relacional para dados que não são séries temporais: registros de clientes, hierarquias de ativos, tabelas de configuração.

**Integração, profile, usuários do RUN.** `integration-lookup` encontra connectors e networks. `profile-lookup` e `profile-metrics` dão o estado da conta e o uso. `user-lookup` atua sobre os usuários do TagoRUN para implantações white-label.

Isso é superfície suficiente para gerenciar uma frota, depurar um dispositivo, montar um alerta, escrever um script no servidor e checar a saúde da sua conta, tudo no mesmo chat.

## **Como isso fica na prática**

Alguns exemplos do que um engenheiro de IoT agora consegue fazer sem sair da IDE.

**Achar um dispositivo com comportamento estranho.**

"Mostre todos os dispositivos no connector `warehouse-east` que não enviaram dados nas últimas 24 horas e ainda estão marcados como ativos."

O Claude chama `device-operations` com `operation: lookup`, filtra por connector e então confere o `last_input` em cada um. Você recebe a lista de volta como uma tabela.

**Puxar dados históricos sem escrever SQL.**

"Qual foi a temperatura média e máxima do dispositivo `Cold Storage 04` entre 1º e 15 de novembro, agrupada por dia?"

O Claude chama `device-data-operations` com o ID do dispositivo, a variável `temperature`, agregação `avg` e `max`, bucket de tempo `day` e o intervalo de datas. A resposta traz os números. Se você quiser um gráfico, é só pedir.

**Provisionar um novo dispositivo com um parser.**

"Crie um novo dispositivo mutável chamado `Boiler Sensor 12`, marque com as tags `region:north` e `type:boiler`, anexe o connector LoRaWAN que usamos para a linha de caldeiras e configure o parser de payload para decodificar os quatro primeiros bytes em base64 como temperatura em décimos de grau."

O Claude resolve o connector via `integration-lookup`, chama `device-operations` com `operation: create` e escreve o parser ali mesmo.

**Escrever um script de Analysis que normalmente levaria uma hora.**

"Escreva um script de Analysis que rode a cada hora, observe todos os dispositivos com a tag `type:boiler` e, se a pressão média na última hora estiver acima de 4,5 bar, envie um e-mail para o time de operações e crie uma Action da TagoIO com o dispositivo sinalizado como `at-risk`."

O Claude puxa o formato do SDK via `tagoio-code-search`, rascunha o script e o cria através de `analysis-operations`. Você revisa o código no chat e coloca para rodar.

**Auditar antes de uma demo para um cliente.**

"Liste todas as Actions da conta, agrupe por tipo de gatilho e me diga quais não dispararam nos últimos 30 dias."

`action-operations` com lookup e depois `profile-metrics` para cruzar a atividade. Cinco segundos de trabalho que antes eram uma revisão manual de trinta minutos.

Nenhuma dessas é uma demonstração. São as mesmas operações que os times de IoT já fazem toda semana, comprimidas de cliques-e-abas para uma frase.

## **Por que a plataforma por baixo ainda importa**

O servidor MCP impressiona, mas ele vem depois de um ponto mais importante: ele funciona porque a TagoIO já tem APIs tipadas para cada conceito que importa em IoT. Dispositivos, dados, ações, analyses, entities, usuários, connectors, networks. O servidor MCP é uma camada fina que expõe essas APIs a uma IA. Se você tivesse construído sua própria plataforma, agora também estaria construindo seu próprio servidor MCP em cima dos seus próprios serviços internos não documentados. Isso é mais um trimestre de trabalho antes de a IA te ajudar em qualquer coisa.

Essa é a parte que vale levar a sério ao planejar um produto de IoT. A decisão de plataforma define o teto de quão rápido todo o resto consegue se mexer, incluindo o ferramental de IA que vai ser padrão dentro de dois anos. Um banco de dados de nuvem genérico mais uma pilha de microsserviços não dá a um assistente de IA nenhum lugar limpo para se conectar. Uma plataforma de IoT feita sob medida dá.

Você não precisa de uma IA para justificar a TagoIO. A plataforma de IoT full-stack se sustenta sozinha: dashboards, RBAC, mobile, multi-região, o pacote completo, simples de começar e acessível em escala. Mas, quando você adiciona o Claude por cima via MCP, o trabalho diário de rodar uma frota deixa de parecer operação e passa a parecer conversa. Essa é a virada de verdade.

## **Experimente**

Se você já tem uma conta TagoIO, gerar um token e conectar o Claude leva cerca de dois minutos. Se não tem, o plano gratuito é suficiente para ver o ciclo de ponta a ponta com alguns dispositivos de teste.

O servidor MCP da TagoIO é open source em [github.com/tago-io/mcp-server](https://github.com/tago-io/mcp-server). A documentação cobre todas as IDEs e ferramentas de IA que suportam MCP hoje: VS Code, Cursor, Windsurf, Claude Code, Claude Desktop, JetBrains, Gemini CLI, Amazon Q, OpenAI Agents, Warp, Kiro. Escolha uma, cole a configuração, aponte o Claude para a sua frota e peça algo que você normalmente faria na mão.

Construa o produto, não a plataforma.

[llms.txt](https://tago.io/llms.txt)