IA Generativa na Manufatura: Casos de Uso Práticos Baseados em Dados da Fábrica

A IA generativa na manufatura gera mais valor quando trabalha sobre dados reais da fábrica, e não sobre conhecimento genérico. Este artigo percorre os casos de uso que se sustentam em um chão de fábrica real, de uma planta de autopeças em Campinas a um frigorífico no Centro-Oeste, a infraestrutura de dados de que eles precisam e as salvaguardas que mantêm um modelo de linguagem útil em vez de arriscado. Ao final, você saberá com qual projeto começar e como alimentá-lo com dados de máquinas ao vivo via MQTT.

Por que os projetos de IA generativa na manufatura emperram

A maioria dos primeiros experimentos impressiona em uma demonstração e depois perde força. O padrão é conhecido: alguém cola alguns códigos de alarme em uma janela de chat, recebe uma explicação plausível e a equipe conclui que o modelo "conhece" as máquinas. Uma semana depois, ele explica com toda a confiança um alarme que não existe naquele controlador.

O problema de fundo é o grounding. Um grande modelo de linguagem tem amplo conhecimento sobre máquinas CNC, CLPs e métodos de qualidade, mas não sabe nada sobre a sua linha 3, a sua receita para a peça 4711 ou o fato de que o forno do turno da noite sempre trabalha dez graus acima. Sem esse contexto, ele preenche a lacuna com palpites.

Portanto, a pergunta útil não é "o que a IA generativa consegue fazer?", mas "quais tarefas consistem basicamente em transformar dados e documentos existentes em texto, e onde podemos fornecer esses dados ao modelo de forma confiável?". Essa mudança de enfoque aponta para uma lista curta de casos de uso que funcionam.

Casos de uso que funcionam hoje

Relatórios de turno e resumos de paradas

Este é o ganho mais fácil. Toda fábrica tem alguém que passa a última meia hora do turno compilando o que aconteceu: quais máquinas pararam, por quê, quantas peças foram produzidas e o que o próximo turno deve observar. Os dados já existem como estados de máquinas e contadores. Um pequeno serviço pode coletar os eventos do turno, montar um resumo estruturado (com os números calculados em código, não pelo modelo) e pedir ao modelo de linguagem que o transforme em um texto legível.

A decisão de design importante é deixar o modelo escrever, não calcular. Calcule o OEE, os minutos de parada e as contagens de peças em Python ou SQL, passe-os como fatos e instrua o modelo a usar somente esses valores. Para um passo a passo mais aprofundado desse padrão, veja resumos de dados de sensores com LLM.

Assistentes de diagnóstico

Quando uma máquina alarma às 3 da manhã, o técnico precisa da página do manual, do último incidente semelhante e do estado atual dos sinais relacionados. Um assistente de diagnóstico recupera essas peças e as apresenta junto com uma checklist sugerida. A recuperação sobre manuais e chamados anteriores é o núcleo, e é por isso que esse caso de uso costuma se apoiar em geração aumentada por recuperação para dados industriais.

A parte ao vivo importa tanto quanto os documentos. Um assistente que vê "temperatura do spindle subindo há 20 minutos, vazão de refrigerante caiu às 02:41" dá sugestões muito melhores do que um que vê apenas o número do alarme.

Ajuda com código e integração

Engenheiros gastam uma quantidade surpreendente de tempo escrevendo código de integração: uma função Node-RED para reformatar um payload, um assinante em Python, uma consulta SQL para um relatório. Modelos de linguagem são bons em rascunhar isso quando veem exemplos reais. Dê ao modelo um payload MQTT de exemplo e a sua convenção de topics, e ele rascunha um parser em segundos. Trate a saída como código de um colega novo: revise, teste no broker público de testes e só então promova.

Copilotos industriais

Combine os três itens acima e você terá o que os fornecedores chamam de copiloto de IA industrial: uma interface única em que o operador faz perguntas, recebe resumos e rascunha ações, muitas vezes sobre o mesmo modelo de dados de um gêmeo digital da linha. Comece com acesso somente leitura. Gravar setpoints ou comandos a partir de um modelo é um problema separado, muito mais difícil, com salvaguardas próprias.

A base de dados: transmitindo dados da fábrica via MQTT

Todos os casos de uso acima dependem de dados atualizados e estruturados. O MQTT é uma escolha natural porque máquinas, gateways e dispositivos de borda já publicam nele, e qualquer número de consumidores pode assinar sem tocar nas máquinas.

Uma estrutura de topics prática segue os níveis ISA-95, para que tanto pessoas quanto modelos consigam lê-la:

connectmq/factory1/production/line1/cnc1/telemetry
connectmq/factory1/production/line1/cnc1/state
connectmq/factory1/production/line1/cnc1/alarms

Um payload típico de telemetria:

{
  "ts": "2026-10-16T02:41:12Z",
  "spindleTempC": 61.4,
  "coolantFlowLpm": 8.2,
  "spindleLoadPct": 74,
  "partCount": 1532
}

Nomes de topics legíveis cumprem duas funções: ajudam as pessoas em um explorador de topics e dão contexto ao modelo sem custo. Um modelo que vê line1/cnc1/alarms não precisa que lhe digam do que se tratam os dados.

Um coletor de turno mínimo em Python

O serviço abaixo assina uma unidade inteira, guarda o estado mais recente de cada máquina e conta os alarmes. No fim do turno, ele entregaria esse resumo estruturado ao LLM que você usar. Ele usa o servidor MQTT público (gratuito) em broker.connectmq.com, então mantenha os dados sintéticos.

import json
import time
import uuid
from collections import defaultdict

import paho.mqtt.client as mqtt

PREFIX = "connectmq/demo/genai-7f3a"
latest = {}
alarm_counts = defaultdict(int)


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


def on_message(client, userdata, msg):
    parts = msg.topic.split("/")
    machine = "/".join(parts[-3:-1])  # e.g. line1/cnc1
    kind = parts[-1]
    try:
        payload = json.loads(msg.payload)
    except json.JSONDecodeError:
        return
    if kind == "alarms":
        alarm_counts[machine] += 1
    else:
        latest.setdefault(machine, {}).update(payload)


def build_summary():
    return {
        "machines": latest,
        "alarmCounts": dict(alarm_counts),
        "generatedAt": time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime()),
    }


client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2,
                     client_id=f"shift-collector-{uuid.uuid4().hex[:8]}")
client.on_connect = on_connect
client.on_message = on_message
client.connect("broker.connectmq.com", 1883, keepalive=60)
client.loop_start()

try:
    while True:
        time.sleep(60)
        summary = build_summary()
        print(json.dumps(summary, indent=2))
        # Pass `summary` to your LLM with a prompt such as:
        # "Write a shift report using ONLY these facts. Do not invent numbers."
except KeyboardInterrupt:
    client.loop_stop()
    client.disconnect()

Observe que o broker não faz nenhum trabalho de IA aqui. O ConnectMQ transporta os dados de forma confiável; o coletor e o modelo são serviços seus que se conectam como clientes MQTT comuns. Essa separação é saudável: você pode trocar de modelo sem tocar nas máquinas.

Salvaguardas que mantêm a IA generativa útil

Uma checklist numerada que vale aplicar a todo piloto de IA generativa na manufatura:

1. Fatos entram, texto sai. Calcule todos os números fora do modelo e diga a ele para usar apenas os valores fornecidos.
2. Cite a fonte. Peça ao modelo que indique o topic, o documento ou o chamado de onde vem cada afirmação, e mostre isso ao usuário.
3. Somente leitura primeiro. Nenhum topic de comando ao alcance do modelo até que a versão somente leitura tenha conquistado confiança.
4. Aprovação humana para ações. Se o modelo rascunhar uma ordem de serviço ou uma mudança de setpoint, uma pessoa aprova. Veja controle seguro de dispositivos IoT por IA para os padrões do lado dos comandos.
5. Registre prompts e respostas. Você vai precisar deles para depurar respostas erradas e melhorar os prompts.
6. Mantenha dados sensíveis privados. Use um broker privado com credenciais para dados reais da fábrica, nunca o servidor MQTT público.
7. Meça a utilidade. Pergunte aos operadores se o resumo lhes poupou tempo; abandone os casos de uso que não poupam.

Onde o modelo deve rodar

APIs de LLM hospedadas são a forma mais rápida de começar e funcionam bem para resumos de dados não sensíveis. Fábricas com políticas de dados rígidas costumam rodar modelos abertos localmente; um servidor on-premises com um runtime de modelo local, assinando o broker da fábrica, consegue fazer isso sem que nenhum dado saia da unidade. Em qualquer caso, o caminho dos dados é o mesmo: as máquinas publicam no broker, um assinante monta o contexto, o modelo escreve o texto e o resultado volta para um topic, um sistema de chamados ou um e-mail.

Se você está mapeando a arquitetura mais ampla de modelos, dispositivos de borda e brokers, o guia de IA e IoT mostra onde cada tipo de modelo se encaixa.

Acertando a infraestrutura

O broker se torna uma dependência compartilhada assim que vários serviços leem os mesmos dados da fábrica, então ele não deve ser uma máquina virtual esquecida embaixo da mesa de alguém. Um broker MQTT gerenciado oferece TLS, credenciais e monitoramento sem que você precise operar o servidor. O ConnectMQ também detecta topics ISA-95 e Unified Namespace e pode republicar dados Sparkplug B em topics ISA-95 legíveis, exatamente o tipo de estrutura que torna os dados da fábrica mais fáceis de consumir, tanto para pessoas quanto para modelos.

Para prototipagem, o servidor MQTT público em broker.connectmq.com permite construir o coletor e os prompts com dados simulados antes que qualquer coisa toque a produção.

Comece o pipeline de dados da sua fábrica no ConnectMQ

A IA generativa é tão boa quanto os dados que você fornece a ela. Crie um broker privado no plano Serverless (Free) em app.connectmq.com, sem cartão de crédito, conecte um gateway ou simulador e veja os topics chegando no explorador de topics ao vivo. Com os dados fluindo, o seu primeiro gerador de relatórios de turno é questão de uma tarde de trabalho.

Perguntas frequentes

Qual é o melhor primeiro projeto de IA generativa em uma fábrica?

Resumos automáticos de turno ou de paradas. Os dados já existem, a saída é fácil de verificar e uma frase errada custa pouco, porque uma pessoa a lê antes de agir.

Um modelo de linguagem pode controlar máquinas diretamente?

Não deveria, pelo menos não sem limites rígidos e aprovação humana. Comece com assistentes somente leitura e adicione caminhos de comando apenas com validação, listas de permissões e etapas de confirmação.

O ConnectMQ inclui recursos de IA?

Não. O ConnectMQ é o broker MQTT que transporta os dados da fábrica; a sua aplicação de LLM se conecta a ele como um cliente MQTT normal, o que deixa você livre para escolher qualquer modelo.

Como impedir que o modelo invente números?

Calcule todas as métricas em código, passe os resultados como fatos estruturados e instrua o modelo a usar somente esses valores. Revisar as saídas em relação aos dados de origem durante o piloto pega os problemas restantes.