Copiloto de IA Industrial para Operadores: Respostas Baseadas em Dados ISA-95 ao Vivo

Um copiloto de IA industrial é um assistente que permite aos operadores fazer perguntas em linguagem simples, como "por que a linha 2 ficou mais lenta depois do almoço?" numa fábrica de autopeças em Joinville, e receber respostas baseadas em dados reais da planta. Neste guia você vai entender como esse copiloto é montado, por que uma árvore de topics bem estruturada segundo a ISA-95 é o ingrediente mais importante e como ligar um copiloto somente leitura a dados MQTT ao vivo sem deixá-lo tocar nas máquinas.

O que um copiloto de IA industrial realmente faz

A palavra "copiloto" é usada de forma vaga, então vale ser preciso. Em uma planta, um copiloto útil faz quatro coisas:

1. Responde perguntas de status a partir de dados ao vivo: velocidade atual, temperatura, estado dos alarmes, última peça boa.
2. Explica o contexto combinando valores ao vivo com documentos: o POP de um código de falha, o histórico de manutenção de uma bomba, o checklist de setup.
3. Resume turnos, alarmes e paradas em uma linguagem que um supervisor pode colar em uma nota de passagem de turno.
4. Sugere próximos passos, mas deixa a decisão e a ação para um humano.

O que ele não deve fazer, pelo menos no início, é emitir comandos. Um copiloto que lê é uma ferramenta de produtividade. Um copiloto que escreve em equipamentos é um sistema de controle, e precisa de outro nível de engenharia, que abordamos em nosso guia sobre controle seguro de dispositivos IoT com IA.

O modelo de linguagem (LLM) em si não sabe nada sobre a sua planta. Tudo o que torna a resposta correta vem dos dados que você fornece no momento da pergunta. É por isso que a arquitetura ao redor do modelo importa muito mais do que a escolha do modelo.

Por que dados ao vivo estruturados superam um despejo de dados

A abordagem ingênua é exportar um CSV de tags e colá-lo no prompt. Isso falha rapidamente: nomes de tags como PLC3_DB12_W4 não significam nada para um modelo, o snapshot já está desatualizado quando alguém lê a resposta e a janela de contexto se enche de valores irrelevantes.

Um namespace estruturado segundo a ISA-95 resolve os três problemas. Quando cada valor fica em um caminho como acme/plant1/assembly/line2/press4/temperature, a própria hierarquia carrega significado. O modelo consegue ver que press4 pertence à line2, que pertence a assembly. Uma pergunta sobre a "linha 2" se traduz naturalmente em um filtro de topic acme/plant1/assembly/line2/#. É a mesma ideia por trás do Unified Namespace, explicada em nosso artigo sobre MQTT Sparkplug B e o Unified Namespace.

O MQTT se encaixa naturalmente porque o broker já guarda o último valor retido de cada topic. Um serviço de copiloto pode assinar a subárvore que lhe interessa, manter um snapshot em memória e entregar ao modelo apenas a parte relevante para a pergunta. Se a planta já tem um gêmeo digital alimentado pelo mesmo namespace, o copiloto lê exatamente os mesmos valores que o gêmeo mostra.

Arquitetura de referência para um copiloto de IA industrial

Uma organização prática tem cinco partes:

1. Publicadores na borda: gateways de CLP, edge nodes Sparkplug B ou pequenos serviços Python publicam os dados das máquinas no broker.
2. O broker MQTT no meio. O ConnectMQ detecta topics ISA-95 e de Unified Namespace e consegue decodificar payloads Sparkplug B e republicá-los em topics ISA-95 legíveis; por exemplo, spBv1.0/factory1/DDATA/line1/cnc1 vira connectmq/factory1/production/line1/cnc1/telemetry. Essa árvore republicada tem exatamente o formato que um modelo de linguagem lida bem.
3. Um serviço de copiloto que se conecta ao broker como um client MQTT comum, assina em modo somente leitura e mantém um snapshot ao vivo.
4. Ferramentas que o LLM pode chamar, como get_area_snapshot(path) ou list_active_alarms(line). O modelo nunca consulta o broker diretamente; ele pede ao seu código.
5. Um índice de documentos para procedimentos e manuais, que é o domínio da geração aumentada por recuperação para dados industriais.

O serviço de copiloto é código seu, rodando na sua infraestrutura e conversando com o provedor de LLM que você escolher. O ConnectMQ é a camada de mensageria; ele não executa o modelo. Essa separação é saudável: você pode trocar de modelo sem mexer na planta.

Se o papel do broker nesse cenário for novidade para você, nosso artigo sobre o que um broker MQTT faz é uma introdução rápida.

Construindo a camada de contexto ao vivo em Python

O núcleo do copiloto é um pequeno serviço que espelha parte da árvore de topics em memória e a expõe como ferramenta. O exemplo abaixo usa paho-mqtt 2.x e o servidor MQTT público (gratuito), para que você possa executá-lo imediatamente. Substitua o prefixo pelo seu próprio ID aleatório.

import json
import threading
import time
import paho.mqtt.client as mqtt

BROKER = "broker.connectmq.com"
PREFIX = "connectmq/demo/k7f3q9/plant1"   # use seu próprio id aleatório
snapshot = {}
lock = threading.Lock()

def on_connect(client, userdata, flags, reason_code, properties):
    print("connected:", reason_code)
    client.subscribe(f"{PREFIX}/#", qos=1)

def on_message(client, userdata, msg):
    try:
        value = json.loads(msg.payload)
    except ValueError:
        value = msg.payload.decode(errors="replace")
    with lock:
        snapshot[msg.topic] = {"value": value, "received": time.time()}

def get_area_snapshot(path: str, max_age_s: int = 300) -> dict:
    """Tool exposed to the LLM: latest values under an ISA-95 path."""
    base = f"{PREFIX}/{path.strip('/')}"
    now = time.time()
    with lock:
        return {
            topic[len(PREFIX) + 1:]: {
                "value": entry["value"],
                "age_s": round(now - entry["received"]),
                "stale": now - entry["received"] > max_age_s,
            }
            for topic, entry in snapshot.items()
            if topic == base or topic.startswith(base + "/")
        }

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="copilot-reader-k7f3q9")
client.on_connect = on_connect
client.on_message = on_message
client.connect(BROKER, 1883, keepalive=60)
client.loop_start()

if __name__ == "__main__":
    time.sleep(3)
    print(json.dumps(get_area_snapshot("assembly/line2"), indent=2))

Para dar a ele algo para ler, publique alguns valores com retained message a partir de outro terminal:

mosquitto_pub -h broker.connectmq.com -p 1883 -i seed-k7f3q9 -r -q 1 \
  -t connectmq/demo/k7f3q9/plant1/assembly/line2/press4/temperature -m '{"c": 71.4}'
mosquitto_pub -h broker.connectmq.com -p 1883 -i seed-k7f3q9 -r -q 1 \
  -t connectmq/demo/k7f3q9/plant1/assembly/line2/press4/state -m '"RUNNING"'

Três escolhas de design nesse código importam mais do que parece:

• A idade e a obsolescência são retornadas com cada valor. Um LLM informa alegremente uma temperatura de duas horas atrás como se fosse atual. Tornar a obsolescência explícita permite que o modelo diga "não há dados recentes" em vez de inventar confiança. Observe que um valor retido entregue no momento da assinatura recebe um timestamp de recebimento novo; portanto, para um controle rigoroso de obsolescência, inclua no payload um timestamp da origem.
• Os caminhos são relativos e delimitados. A ferramenta só lê abaixo de PREFIX, então um modelo confuso não consegue vagar por outros namespaces.
• O serviço é somente leitura. Ele assina e nunca publica em topics de equipamentos.

Em seguida, você registra get_area_snapshot como uma ferramenta (função) na API de LLM que usar. Nosso guia sobre function calling de LLM para IoT explica o padrão de schema de ferramentas e, se você preferir uma interface padronizada, um servidor MCP para MQTT expõe o mesmo recurso a qualquer client compatível.

Escrevendo o prompt do copiloto para perguntas da planta

O prompt de sistema deve descrever o namespace, não os dados. Algo assim funciona bem:

You are an assistant for operators at plant1.
Live data is organised as <area>/<line>/<cell>/<signal>, for example assembly/line2/press4/temperature.
Use get_area_snapshot(path) to read live values. Never guess a value you did not read.
If a value is marked stale, say so. You cannot change any equipment. For actions, tell the operator what to check.
Answer in short sentences and quote the topic path for every number you mention.

Pedir ao modelo que cite o caminho do topic para cada número é um hábito barato e poderoso. Os operadores podem verificar qualquer afirmação no explorador de topics ao vivo, e respostas erradas ficam fáceis de identificar e reportar.

Checklist de design de um copiloto de IA industrial

Antes de mostrar um copiloto a uma equipe de turno, percorra esta lista:

1. Qualidade do namespace: os topics têm nomes consistentes até o nível do sinal, com unidades no payload ou no nome?
2. Retained messages: todo topic de estado publica com retained message, para que um novo assinante veja os valores atuais imediatamente?
3. Credenciais somente leitura: o serviço de copiloto usa credenciais próprias que nunca são usadas para topics de comando?
4. Tratamento de obsolescência: todo resultado de ferramenta inclui a idade, e o prompt instrui o modelo a respeitá-la?
5. Rastreabilidade: toda resposta cita caminhos de topics ou fontes de documentos?
6. Registro: perguntas, chamadas de ferramentas e respostas são registradas para revisão?
7. Escopo: o copiloto está limitado às linhas e áreas pelas quais o usuário é responsável?
8. Escalonamento: o copiloto diz ao operador quem acionar quando não consegue responder?

Armadilhas comuns

Leituras alucinadas. O modelo preenche lacunas com números plausíveis. Contramedida: a instrução "nunca adivinhe" mais resultados de ferramentas que mostrem claramente os dados ausentes.

Contexto demais. Despejar a planta inteira em cada requisição é lento e confunde o modelo. Deixe o modelo chamar a ferramenta com um caminho estreito e resuma as séries numéricas antes de devolvê-las.

Confusão de unidades. Um valor 71.4 sem unidade convida a erros. Coloque as unidades no payload ({"c": 71.4}) ou nos metadados que a ferramenta retorna.

Dados sensíveis em brokers públicos. A área pública do servidor MQTT público em broker.connectmq.com pode ser lida por qualquer pessoa que adivinhe o topic. Isso serve para esta demonstração e para protótipos, mas dados de produção da planta pertencem a um broker MQTT gerenciado e privado com credenciais próprias.

Tratar o copiloto como autoridade. Os operadores devem vê-lo como um colega rápido que lê telas, não como o sistema de segurança. Mantenha o tratamento de alarmes e os intertravamentos onde estão.

Executando o copiloto com dados de produção

Passar da demonstração para uma linha real significa, na maior parte, mudar a conexão. Crie um broker no portal do ConnectMQ, copie as credenciais geradas e conecte via TLS:

client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="YOUR_CLIENT_ID")
client.username_pw_set("YOUR_USERNAME", "YOUR_PASSWORD")
client.tls_set()  # o repositório de CAs do sistema confia no certificado Let's Encrypt
client.connect("broker.connectmq.com", 8883, keepalive=60)

Um broker MQTT gerenciado tira o broker da sua lista de coisas para atualizar e monitorar, para que a equipe possa se concentrar na qualidade do namespace e no próprio copiloto. Para uma visão mais ampla de como IA e mensageria se encaixam, veja o guia de IA e IoT e, para opções de hospedagem, leia sobre a abordagem de broker MQTT na nuvem.

Dê ao seu copiloto um namespace de planta ao vivo

Antes de precisar de um modelo maior, um copiloto precisa de uma fonte de dados limpa, ao vivo e bem estruturada. O ConnectMQ oferece um broker MQTT gerenciado com detecção de topics ISA-95, decodificação de Sparkplug B e um explorador de topics ao vivo para conferir o que o copiloto vê. Crie um broker Serverless gratuito em app.connectmq.com, sem cartão de crédito, e aponte para ele o serviço somente leitura acima.

Perguntas frequentes

O ConnectMQ inclui um copiloto de IA?

Não. O ConnectMQ é o broker MQTT que entrega os dados ao vivo. O copiloto é um serviço seu, que se conecta como client MQTT e chama o LLM da sua escolha.

Um copiloto de IA industrial deve poder controlar máquinas?

Não no início. Comece em modo somente leitura, comprove a precisão e a utilidade e só depois adicione ações rigidamente protegidas e confirmadas por humanos, com listas de permissões, limites de taxa e logs de auditoria.

Por que a estrutura ISA-95 ajuda um modelo de linguagem?

A hierarquia de empresa, site, área, linha e célula dá a cada valor um caminho que se autodescreve, para que o modelo consiga traduzir uma pergunta sobre a "linha 2" em um filtro de topic preciso, em vez de tentar adivinhar nomes de tags enigmáticos.

O copiloto também pode usar dados históricos?

Sim. Os valores MQTT ao vivo respondem "o que está acontecendo agora", enquanto um historiador ou banco de dados de séries temporais responde "o que aconteceu". Exponha cada um como uma ferramenta separada, para que o modelo escolha a fonte certa.