Se você quer que o Claude, o ChatGPT ou o seu próprio agente consulte um sensor ou acione um relé, ele precisa de um jeito de descobrir quais dispositivos existem, o que eles informam e o que têm permissão para fazer. Um servidor MCP para dispositivos IoT é essa porta de entrada. Ele expõe seus sensores e controladores por meio de ferramentas que o agente pode chamar, executa essas chamadas no sistema real e controla quem pode fazer o quê.

O protocolo em si é simples. O que muda o trabalho de projeto são os dispositivos, porque eles se comportam de um jeito diferente de documentos e bancos de dados: alguns ficam em suspensão por vários minutos seguidos, as leituras ficam desatualizadas e uma chamada errada pode abrir uma válvula. Este guia mostra como as peças se encaixam, como funciona a descoberta quando cada dispositivo tem comandos diferentes e o que decidir antes de construir ou conectar um servidor.

O essencial

  • O Model Context Protocol dá aos clientes de IA uma forma padronizada de descobrir e chamar ferramentas, então um único servidor pode atender Claude, ChatGPT, Cursor e outros.
  • Com dispositivos, a descoberta costuma acontecer em duas camadas: o agente primeiro lista os dispositivos e depois pergunta quais leituras e comandos um dispositivo específico tem.
  • Construir o seu próprio servidor é, basicamente, encapsular uma API de dispositivos já existente com nomes de ferramentas claros, limites de entrada e verificações de permissão no lado do servidor.
  • Comece só com leitura, acrescente mais tarde um pequeno conjunto de comandos predefinidos e mantenha uma pessoa confirmando tudo o que altera o estado físico.

Como o Model Context Protocol é usado com dispositivos IoT?

O Model Context Protocol, geralmente abreviado como MCP, é um padrão aberto para conectar aplicações de IA a ferramentas e dados externos. A aplicação de IA (o cliente) conversa com um servidor MCP, que oferece três tipos de coisa: ferramentas (tools) que o modelo pode chamar, recursos (resources) que ele pode ler como contexto e prompts que uma pessoa pode escolher em um menu. Num escritório, isso poderia ser "pesquisar tickets" ou "ler uma planilha". Na IoT, eles se referem ao local físico.

Conceito do MCP O que costuma significar para dispositivos
Tool (ferramenta) Uma ação: ler o valor mais recente, buscar o histórico, enviar um comando predefinido
Resource (recurso) Contexto que o cliente pode carregar: uma lista de dispositivos, um mapa das salas, uma semana de leituras
Prompt Uma solicitação reutilizável, como "resumir os alarmes da madrugada no prédio B"
Servidor O adaptador que guarda as credenciais e conversa com a plataforma de dispositivos
Cliente Claude, ChatGPT, Cursor ou um agente que você escreveu, que decide qual ferramenta chamar

Três coisas diferenciam a IoT dos exemplos habituais. Os dados envelhecem: uma temperatura de 40 minutos atrás pode não servir para nada, então toda leitura que o servidor devolve deve trazer seu carimbo de data e hora. Os dispositivos nem sempre estão acessíveis: muitos sensores a bateria só transmitem a cada poucos minutos e só escutam por um breve momento depois. E as ações têm consequências além da tela, já que um comando errado pode deixar uma bomba ligada ou uma válvula aberta. Cada um desses pontos define como o servidor deve ser projetado.

Pegue uma pergunta simples como "a sala de servidores está quente demais?". Se o sensor informa a cada 15 minutos e a última mensagem chegou há 50 minutos, a resposta honesta é "não sei; o sensor parou de se comunicar". Um servidor que devolve só o número, sem o momento em que ele foi medido, convida o modelo a responder com confiança usando dados antigos. Devolver o valor, a unidade, o carimbo de data e hora e o momento em que o dispositivo foi visto pela última vez permite que o modelo diga o que sabe e o que não sabe.

Como funciona a descoberta de ferramentas para agentes de IA?

A descoberta de ferramentas para agentes de IA é a etapa em que o cliente pergunta a um servidor o que ele sabe fazer. No MCP, o cliente envia uma requisição tools/list, e o servidor responde com o nome de cada ferramenta, uma descrição em linguagem simples e um JSON schema para as entradas dela. O cliente coloca essas descrições diante do modelo, e o modelo escolhe uma ferramenta lendo-as, do mesmo jeito que um colega recém-chegado leria as etiquetas de um painel de controle.

Uma ferramenta de leitura de dispositivo poderia ser descrita assim:

{"name": "get_latest_reading",
 "description": "Latest value of one metric on one device, with its timestamp and unit.",
 "inputSchema": {"type": "object",
   "properties": {"device_id": {"type": "string"}, "metric": {"type": "string"}},
   "required": ["device_id", "metric"]}}

Isso funciona bem para ações genéricas. Comandos são mais difíceis, porque um dimmer aceita um brilho de 0 a 100, um controlador de válvula aceita abrir ou fechar e um termostato aceita um setpoint dentro de certos limites. Se você transformasse cada comando de cada dispositivo em uma ferramenta própria, um local com 300 dispositivos poderia publicar milhares de ferramentas, e o modelo se afogaria nelas.

A solução usual é a descoberta em duas etapas. O servidor expõe um conjunto pequeno e estável de ferramentas para agentes de IA, como list_devices, list_commands e run_command. O agente chama list_devices para encontrar o dimmer da sala de reunião 3 e depois list_commands para esse único dispositivo, que devolve os comandos definidos com seus parâmetros e limites. Só então ele chama run_command com brilho 40. O protocolo também permite que um servidor avise os clientes quando sua lista de ferramentas muda, o que ajuda quando dispositivos são adicionados durante uma sessão.

É em casos como este que o schema mostra o seu valor. Suponha que o agente receba o pedido "deixe a sala 3 um pouco mais escura" e a luz esteja em 70. Sem limites, ele poderia enviar 7, interpretando mal o "um pouco". Com um schema que diz que o brilho é um inteiro de 10 a 100 e uma descrição de comando que diz "os incrementos típicos são de 10", é bem mais provável que ele envie 60. Mesmo assim, o servidor deve rejeitar qualquer valor fora da faixa, porque o modelo está interpretando uma descrição e ainda pode errar.

Como criar um servidor MCP

Para criar um servidor MCP para dispositivos, você não começa pelos protocolos de rádio. Você começa por aquilo que já guarda os dados dos dispositivos, geralmente uma plataforma IoT ou um gateway com API, e encapsula isso. Uma ordem de trabalho prática:

  1. Defina o escopo. Escolha as perguntas e ações de que o agente realmente precisa. "Ler qualquer sensor, buscar 30 dias de histórico, executar os cinco comandos que definimos" é um primeiro escopo melhor do que "tudo o que a API consegue fazer".
  2. Escolha um SDK. Os kits de desenvolvimento de software (SDKs) oficiais cuidam das mensagens do protocolo, então o seu código só define as ferramentas e os handlers delas.
  3. Encapsule a API da plataforma. Cada handler de ferramenta chama a API existente com as credenciais do servidor e transforma a resposta em resultados curtos e legíveis, com unidades e carimbos de data e hora.
  4. Escreva descrições para um leitor sem nenhum contexto. Diga o que a ferramenta devolve, quais unidades usa e quando não deve ser usada. É daí que vem a maior parte da qualidade.
  5. Aplique as permissões no servidor. Confira cada chamada com base nos direitos do usuário e nos limites de parâmetros do comando, independentemente do que o modelo tenha pedido.
  6. Teste com um inspetor antes de qualquer cliente. O MCP Inspector oficial permite chamar cada ferramenta manualmente e ler as respostas brutas.
  7. Escolha um transporte. Um servidor local para um único desenvolvedor pode rodar como um processo na própria máquina dele; um servidor compartilhado precisa de hospedagem remota e de autorização por usuário.

Quando os dispositivos já estão no Kilo, a camada de encapsulamento é fina. Você construiria seus handlers sobre as APIs REST e gRPC do Kilo para desenvolvedores, usando uma chave de API com escopos por área e vinculada a uma única organização, e uma chave limitada a escopos de leitura é uma primeira credencial sensata para um servidor feito em casa.

Antes de construir qualquer coisa, verifique se a plataforma já fala o protocolo. O Kilo expõe seu próprio endpoint MCP e marca a ferramenta de comando como destrutiva, para que os clientes possam pedir a sua confirmação antes de um comando ser enviado.

Como conectar o Claude a dispositivos IoT com MCP

Conectar um cliente a um servidor existente leva poucos minutos, e as etapas são mais ou menos as mesmas em todos os clientes:

  1. Adicione o servidor nas configurações do cliente. Para um servidor remoto, você cola a URL dele; no Claude, ele entra como um conector personalizado. Um servidor local costuma ser listado em um arquivo de configuração, junto com o comando que o inicia.
  2. Faça login quando o cliente abrir a página de autorização. Um servidor remoto deve perguntar quem você é, para que as ferramentas dele atuem com os seus direitos e os de mais ninguém.
  3. Confira quais ferramentas apareceram. A maioria dos clientes mostra a lista e permite desativar ferramentas individualmente, o que é uma forma fácil de começar só com leitura.
  4. Faça uma pergunta que você mesmo consiga verificar, como a temperatura atual de uma sala onde dá para ler um termômetro, e compare a resposta.
  5. Ative as ações por último e mantenha ativada no cliente a aprovação chamada a chamada para tudo o que envia um comando.

ChatGPT, Cursor, Codex e outros clientes seguem a mesma ideia, cada um com suas próprias telas de configuração. Como o lado do servidor é idêntico para todos eles, uma equipe pode usar clientes diferentes sem construir integrações separadas, e o acesso é revogado em um único lugar.

Também ajuda anotar três ou quatro perguntas de teste antes de liberar um servidor para uma equipe, cada uma com uma resposta certa conhecida: uma temperatura de sala que você consegue conferir, um dispositivo que você sabe que está offline, um comando que deve ser recusado porque o valor está fora da faixa. Rode essas perguntas depois de cada mudança nas descrições das ferramentas do servidor, já que uma descrição reescrita pode mudar a ferramenta que o modelo escolhe.

Dois hábitos deixam o uso no dia a dia mais tranquilo. Dê aos dispositivos os nomes que as pessoas usam quando falam deles ("porta da câmara fria 2", e não "node-4471"), porque o modelo compara os pedidos com esses nomes. E mantenha claro o papel do agente: deixe que ele consulte informações, compare leituras e explique o que encontrou, enquanto tudo o que precisa acontecer sempre, sem que ninguém peça, deve ficar em uma regra na plataforma, que roda mesmo que ninguém abra um chat.

Perguntas frequentes sobre servidor MCP para dispositivos IoT

Um servidor MCP consegue se comunicar com dispositivos IoT MQTT?

Sim, embora geralmente sem ficar conectado ao próprio broker. O MQTT funciona por publicação e assinatura, então um servidor teria de assinar tópicos e guardar em cache os valores mais recentes para responder a uma pergunta do tipo "qual é a leitura agora". Apontar o servidor MCP para uma plataforma que já armazena os dados MQTT é mais simples e dá ao agente o histórico, além do valor atual.

Qual linguagem é usada para criar um servidor MCP?

Qualquer linguagem que leia e escreva JSON serve, porque as mensagens seguem o JSON-RPC 2.0. Existem SDKs oficiais para várias linguagens, incluindo TypeScript, Python, Java, C# e Go, e é por isso que a maioria dos servidores para dispositivos é escrita na mesma linguagem do backend que a equipe já tem.

Quais apps e clientes suportam o Model Context Protocol?

O suporte se espalhou rapidamente desde que a Anthropic publicou o padrão, em novembro de 2024. Claude Desktop, Claude Code, ChatGPT, Cursor, Codex e o Visual Studio Code com GitHub Copilot estão entre os clientes que conseguem se conectar a servidores MCP, embora cada um ofereça configurações diferentes para servidores locais e remotos.

Um servidor MCP consegue controlar dispositivos IoT LoRaWAN?

Sim, se o dispositivo aceitar comandos, embora nem sempre de forma instantânea. A maioria dos sensores LoRaWAN a bateria funciona como dispositivo Classe A, que abre suas breves janelas de recepção somente logo depois de enviar um uplink, então uma mensagem para eles espera a próxima transmissão. Dispositivos Classe C, alimentados pela rede elétrica, escutam continuamente e podem receber um comando quase imediatamente. No Kilo, os comandos de dispositivo vão para dispositivos MQTT e controladores LoRaWAN Classe C, então um sensor Classe A a bateria é algo que você lê, e não controla.

A cadeia inteira cabe em cima de uma mesa. Registre um sensor de temperatura e uma tomada inteligente controlável no plano gratuito do Kilo, conecte o Claude pelo endpoint MCP com apenas as ferramentas de leitura ativadas e pergunte sobre a sala até que as respostas batam com o termômetro na parede. Depois, defina os comandos de ligar e desligar da tomada e ative a ferramenta de comando, com a aprovação chamada a chamada do Claude ainda ativa.