Perché Claude, ChatGPT o un agente sviluppato in proprio possano leggere un sensore o commutare un relè, serve un modo per scoprire quali dispositivi esistono, che cosa rilevano e che cosa sono autorizzati a fare. Un server MCP per dispositivi IoT è proprio questa porta d’accesso. Espone sensori e controller attraverso strumenti che l’agente può chiamare, esegue quelle chiamate sul sistema reale e applica le regole su chi può fare che cosa.

Il protocollo in sé è semplice. Sono i dispositivi a rendere diverso il lavoro di progettazione, perché non si comportano come documenti e database: alcuni restano in modalità sleep per minuti interi, le letture diventano obsolete e una chiamata sbagliata può aprire una valvola. Questa guida spiega come si incastrano i vari pezzi, come funziona la discovery quando ogni dispositivo ha comandi diversi e che cosa decidere prima di costruire o collegare un server.

In breve

  • Il Model Context Protocol offre ai client AI un unico modo standard per scoprire e chiamare strumenti, così un solo server può servire Claude, ChatGPT, Cursor e altri.
  • Per i dispositivi, la discovery avviene di solito su due livelli: l’agente prima elenca i dispositivi, poi chiede quali letture e quali comandi ha un dispositivo specifico.
  • Costruire un proprio server significa soprattutto incapsulare un’API dei dispositivi già esistente con nomi dei tool chiari, limiti sugli input e controlli dei permessi lato server.
  • Si parte in sola lettura, si aggiunge in seguito un piccolo insieme di comandi predefiniti e si lascia a una persona la conferma di qualsiasi azione che cambi lo stato fisico.

Come si usa il Model Context Protocol con i dispositivi IoT?

Il Model Context Protocol, di solito abbreviato in MCP, è uno standard aperto per collegare le applicazioni AI a strumenti e dati esterni. L’applicazione AI (il client) dialoga con un server MCP, che offre tre tipi di elementi: tool (strumenti) che il modello può chiamare, resource (risorse) che può leggere come contesto e prompt che una persona può scegliere da un menu. In ufficio potrebbero essere «cerca ticket» o «leggi un foglio di calcolo». Nell’IoT corrispondono a elementi concreti dell’impianto.

Concetto MCP Che cosa significa di solito per i dispositivi
Tool Un’azione: leggere l’ultimo valore, recuperare lo storico, inviare un comando predefinito
Resource Contesto che il client può caricare: un elenco di dispositivi, una mappa delle stanze, una settimana di letture
Prompt Una richiesta riutilizzabile, per esempio «riassumi gli allarmi della notte per l’edificio B»
Server L’adattatore che custodisce le credenziali e dialoga con la piattaforma dei dispositivi
Client Claude, ChatGPT, Cursor o un agente sviluppato in proprio, che decide quale tool chiamare

Tre aspetti rendono l’IoT diverso dagli esempi abituali. I dati invecchiano: una temperatura di 40 minuti fa può essere inutile, quindi ogni lettura restituita dal server dovrebbe riportare il proprio timestamp. I dispositivi non sono sempre raggiungibili: molti sensori a batteria trasmettono solo a intervalli di qualche minuto e subito dopo restano in ascolto per poco. E le azioni hanno conseguenze che vanno oltre lo schermo, perché un comando sbagliato può lasciare una pompa in funzione o una valvola aperta. Ognuno di questi aspetti incide su come va progettato il server.

Prendiamo una domanda semplice come «la sala server è troppo calda?». Se il sensore invia dati ogni 15 minuti e l’ultimo messaggio è arrivato 50 minuti fa, la risposta onesta è «non lo so: il sensore ha smesso di trasmettere». Un server che restituisce solo il numero, senza l’ora in cui è stato misurato, spinge il modello a rispondere con sicurezza usando dati vecchi. Restituire il valore, l’unità di misura, il timestamp e l’ultimo contatto del dispositivo permette al modello di dire che cosa sa e che cosa non sa.

Come funziona la tool discovery per gli agenti AI?

La tool discovery per gli agenti AI è il passaggio in cui il client chiede a un server che cosa sa fare. In MCP il client invia una richiesta tools/list e il server risponde con il nome di ogni tool, una descrizione in linguaggio comune e uno schema JSON per i suoi input. Il client mette quelle descrizioni davanti al modello, e il modello sceglie un tool leggendole, come farebbe un nuovo collega con le etichette di un pannello di controllo.

Un tool per leggere i dati di un dispositivo potrebbe essere descritto così:

{"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"]}}

Per le azioni generiche funziona bene. I comandi sono più complicati, perché un dimmer accetta una luminosità da 0 a 100, un controller di valvola accetta apertura o chiusura e un termostato accetta un setpoint entro certi limiti. Se ogni comando di ogni dispositivo diventasse un tool a sé, un sito con 300 dispositivi potrebbe pubblicare migliaia di tool e il modello ne verrebbe sommerso.

La soluzione abituale è una discovery in due passaggi. Il server espone un insieme piccolo e stabile di strumenti per agenti AI come list_devices, list_commands e run_command. L’agente chiama list_devices per trovare il dimmer della sala riunioni 3, poi list_commands per quel solo dispositivo, che restituisce i comandi definiti con i relativi parametri e limiti. Solo allora chiama run_command con una luminosità di 40. Il protocollo permette anche a un server di avvisare i client quando il suo elenco di tool cambia, cosa utile quando si aggiungono dispositivi durante una sessione.

È in casi come questo che lo schema dimostra il suo valore. Supponiamo che all’agente venga chiesto di «abbassare un po’ la luce nella sala 3» e che la luce sia a 70. Senza limiti potrebbe inviare 7, fraintendendo «un po’». Con uno schema che indica che la luminosità è un intero da 10 a 100, e una descrizione del comando che dice «i passi tipici sono di 10», è molto più probabile che invii 60. Il server dovrebbe comunque rifiutare qualsiasi valore fuori intervallo, perché il modello sta interpretando una descrizione e può sempre sbagliare.

Come creare un server MCP

Per creare un server MCP per dispositivi non si parte dai protocolli radio. Si parte da ciò che contiene già i dati dei dispositivi, di solito una piattaforma IoT o un gateway con un’API, e lo si incapsula. Un ordine di lavoro pratico:

  1. Definire il perimetro. Scegliere le domande e le azioni di cui l’agente ha davvero bisogno. «Leggere qualsiasi sensore, recuperare 30 giorni di storico, eseguire i cinque comandi che abbiamo definito» è un primo perimetro migliore di «tutto ciò che l’API sa fare».
  2. Scegliere un SDK. I software development kit ufficiali gestiscono i messaggi del protocollo, così il codice deve solo definire i tool e i relativi handler.
  3. Incapsulare l’API della piattaforma. Ogni handler chiama l’API esistente con le credenziali del server e trasforma la risposta in risultati brevi e leggibili, con unità di misura e timestamp.
  4. Scrivere le descrizioni per un lettore senza contesto. Indicare che cosa restituisce il tool, quali unità usa e quando non va usato. È da qui che deriva gran parte della qualità.
  5. Applicare i permessi sul server. Verificare ogni chiamata rispetto ai diritti dell’utente e ai limiti dei parametri del comando, qualunque cosa abbia chiesto il modello.
  6. Testare con un inspector prima di qualsiasi client. L’MCP Inspector ufficiale permette di chiamare ogni tool a mano e di leggere le risposte grezze.
  7. Scegliere un trasporto. Un server locale per un solo sviluppatore può girare come processo su quella macchina; un server condiviso richiede un hosting remoto e un’autorizzazione per singolo utente.

Quando i dispositivi si trovano già in Kilo, il livello di incapsulamento è sottile. Gli handler si costruiscono sulle API REST e gRPC di Kilo per sviluppatori, usando una chiave API con scope definiti per area e vincolata a un’unica organizzazione, e una chiave limitata agli scope di lettura è una prima credenziale sensata per un server sviluppato in casa.

Prima di costruire qualsiasi cosa, conviene verificare se la piattaforma parla già il protocollo. Kilo espone un proprio endpoint MCP e contrassegna il tool dei comandi come distruttivo, così i client possono chiedere conferma all’utente prima che un comando venga inviato.

Come collegare Claude ai dispositivi IoT con MCP

Collegare un client a un server esistente richiede pochi minuti, e i passaggi sono più o meno gli stessi in tutti i client:

  1. Aggiungere il server nelle impostazioni del client. Per un server remoto si incolla il suo URL; in Claude va inserito come connettore personalizzato. Un server locale di solito è indicato in un file di configurazione insieme al comando che lo avvia.
  2. Effettuare l’accesso quando il client apre la pagina di autorizzazione. Un server remoto dovrebbe chiedere l’identità dell’utente, così i suoi tool agiscono con i diritti di quell’utente e di nessun altro.
  3. Controllare quali tool sono comparsi. La maggior parte dei client mostra l’elenco e permette di disattivare i singoli tool, un modo semplice per cominciare con la sola lettura.
  4. Fare una domanda la cui risposta si può verificare di persona, per esempio la temperatura attuale di una stanza in cui si può leggere un termometro, e confrontare la risposta.
  5. Attivare le azioni per ultime e lasciare attiva nel client l’approvazione di ogni singola chiamata per tutto ciò che invia un comando.

ChatGPT, Cursor, Codex e gli altri client seguono la stessa logica con le proprie schermate di impostazione. Poiché il lato server è identico per tutti, un team può usare client diversi senza costruire integrazioni separate, e l’accesso si revoca in un unico punto.

Conviene anche mettere per iscritto tre o quattro domande di prova prima di distribuire un server a un team, ognuna con una risposta corretta nota: una temperatura ambiente verificabile, un dispositivo che si sa essere offline, un comando che dovrebbe essere rifiutato perché il valore è fuori intervallo. Vanno ripetute dopo ogni modifica alle descrizioni dei tool del server, perché una descrizione riformulata può cambiare il tool che il modello sceglie.

Due abitudini rendono più fluido l’uso quotidiano. Dare ai dispositivi i nomi che le persone usano quando ne parlano («porta cella frigo 2», non «node-4471»), perché il modello confronta le richieste con quei nomi. E tenere chiaro il ruolo dell’agente: lasciargli cercare informazioni, confrontare letture e spiegare che cosa ha trovato, mentre tutto ciò che deve succedere ogni volta, senza che nessuno lo chieda, va messo in una regola sulla piattaforma, dove viene eseguito indipendentemente dal fatto che qualcuno apra una chat.

Server MCP per dispositivi IoT: domande frequenti

Un server MCP può comunicare con dispositivi IoT MQTT?

Sì, anche se di solito non agganciandosi direttamente al broker. MQTT funziona a publish/subscribe, quindi un server dovrebbe sottoscrivere i topic e tenere in cache gli ultimi valori per rispondere a una domanda come «qual è la lettura adesso». È più semplice collegare il server MCP a una piattaforma che memorizza già i dati MQTT, e così l’agente ha a disposizione lo storico oltre al valore attuale.

Quale linguaggio si usa per creare un server MCP?

Va bene qualsiasi linguaggio in grado di leggere e scrivere JSON, perché i messaggi seguono JSON-RPC 2.0. Esistono SDK ufficiali per diversi linguaggi, tra cui TypeScript, Python, Java, C# e Go, ed è per questo che la maggior parte dei server per dispositivi viene scritta nello stesso linguaggio del backend già in uso nel team.

Quali app e client supportano il Model Context Protocol?

Il supporto si è diffuso rapidamente da quando Anthropic ha pubblicato lo standard, nel novembre 2024. Claude Desktop, Claude Code, ChatGPT, Cursor, Codex e Visual Studio Code con GitHub Copilot sono tra i client che possono collegarsi ai server MCP, anche se ognuno offre impostazioni diverse per i server locali e remoti.

Un server MCP può controllare dispositivi IoT LoRaWAN?

Sì, se il dispositivo accetta comandi, anche se non sempre all’istante. La maggior parte dei sensori LoRaWAN a batteria funziona come dispositivo di Classe A: questi dispositivi aprono le loro brevi finestre di ricezione solo subito dopo aver inviato un uplink, quindi un messaggio a loro destinato attende la trasmissione successiva. I dispositivi di Classe C alimentati da rete restano in ascolto di continuo e possono ricevere un comando quasi subito. In Kilo i comandi vanno ai dispositivi MQTT e ai controller LoRaWAN di Classe C, quindi un sensore di Classe A a batteria è un dispositivo da leggere, non da comandare.

L’intera catena sta su una scrivania. Si registrano un sensore di temperatura e una presa smart comandabile sul piano gratuito di Kilo, si collega Claude tramite l’endpoint MCP con attivi solo i tool di lettura e si fanno domande sulla stanza finché le risposte non coincidono con il termometro appeso al muro. Poi si definiscono i comandi di accensione e spegnimento della presa e si attiva il tool dei comandi, lasciando attiva in Claude l’approvazione di ogni singola chiamata.