Développement d'un agent LLM décisionnel pour une usine simulée

(Un guide pratique de contrôle en boucle fermée utilisant Node-RED, MQTT et le LLM DeepSeek.)

Nous pensons que la prochaine génération de systèmes industriels ne se contentera peut-être pas de réagir — elle pourrait réfléchir, agir et apprendre.

Il ne s'agit pas seulement de récupérer des données de référence comme avec le RAG, de proposer des suggestions comme un chatbot ou de répondre passivement à des questions, mais d'exécuter activement des décisions et de fermer les boucles de contrôle, comme le ferait un expert humain.

Factory Agent est notre tentative d'esquisser cette possibilité :

Un système d'agent LLM doté de capacités de raisonnement, fonctionnant sur Node-RED, à l'écoute de sujets MQTT en temps réel et prenant des décisions pour une usine de fabrication simulée.

C'est un projet open-source, piloté par les événements et expérimental.

Non pas parce que nous avons toutes les réponses, mais parce que ce domaine est trop passionnant pour ne pas être exploré.

Pourquoi l'IA industrielle a besoin d'agents décisionnels

Le monde industriel regorge de données. Mais la prise de décision — surtout en périphérie (edge) — repose encore largement sur l'intuition humaine et des règles manuelles.

Les applications actuelles de l'IA dans l'industrie restent souvent passives : elles répondent à des questions, résument des documents ou assistent les interfaces. Mais très peu prennent réellement des décisions, exécutent des commandes et assument la responsabilité des résultats dans une boucle fermée.

Notre question était simple :

Pouvons-nous construire un système d'agent capable de détecter les événements d'une usine, de raisonner sur les stratégies possibles et d'exécuter des actions, tel un opérateur junior doté de l'instinct d'un expert ?

Pour explorer cette piste, nous avons commencé par un système minimal viable, que nous partageons en open-source afin d'inviter la communauté à le construire, l'étendre et le challenger.

Construction du système de contrôle en boucle fermée

Dans la théorie classique du contrôle, un régulateur en boucle fermée surveille en permanence les sorties et réinjecte les informations dans le système pour ajuster son comportement, permettant ainsi une auto-correction même dans des conditions changeantes (par exemple, les boucles PID dans le contrôle de processus).

Nous étendons ce paradigme au monde des agents LLM.

La boucle fonctionne désormais sur cinq couches essentielles :

Couche de perception

• Se connecte aux sources de données OT/IT de l'usine.
• Utilise un espace de nommage unifié (UNS) basé sur MQTT pour organiser les données en temps réel en sujets sémantiquement significatifs.
• Chaque agent « perçoit » l'environnement de l'usine à travers des sujets MQTT sélectionnés.

Couche de raisonnement et de prise de décision (couche agent)

• Chaque agent est une unité indépendante propulsée par un LLM.
• Possède ses propres prompts, objectifs et (à l'avenir) modules de mémoire.
• Chaque agent est un LLM indépendant doté de ses propres prompts et de sa propre mémoire. Il réfléchit, planifie et déclenche des actions lorsque nécessaire.

Couche de répartition des actions

• Les sorties des agents sont transformées en commandes JSON structurées.
• Celles-ci sont publiées via MQTT vers des sujets de contrôle.
• Chaque commande est adressée au composant système correspondant (par exemple, machine, chauffage, planificateur).

Couche d'exécution (environnement/usine)

• L'usine (réelle ou simulée) exécute les actions.
• Les changements qui en résultent sont republiés dans MQTT, fermant ainsi la boucle de rétroaction.

Couche de rétroaction et d'apprentissage

• Surveille les résultats des actions.
• Prépare les futurs mécanismes d'apprentissage : mises à jour de la mémoire de travail, notation des actions, traçage des stratégies.

Cela constitue une réalisation complète, pilotée par LLM, de la boucle classique « observer-planifier-agir-observer », désormais étendue pour prendre en charge des agents distribués et évolutifs.

Guide pratique

Présentation de l'architecture

Le système intègre quatre composants clés :

• Node-RED — Orchestration en temps réel des flux de messages entre les agents, les sujets et les systèmes d'exécution.
• Courtier MQTT — Une infrastructure légère pilotée par les événements qui permet une structure d'espace de noms unifié (UNS).
• Nœuds d'agent d'usine — Nœuds Node-RED spécialisés gérant la perception (entrée d'état), les invites de raisonnement et la génération d'actions par LLM.
• LLM (par ex. DeepSeek, Gemini) — Effectuent le raisonnement, la planification et la prise de décision en temps réel en fonction du contexte observé.

Chaque instance de LLM reçoit des états structurés provenant des sujets MQTT, réfléchit aux stratégies possibles et génère des instructions de contrôle qui sont renvoyées via MQTT.

Chaque instruction de contrôle est publiée au format sujet-charge utile. Par exemple :

Essayez par vous-même : Agent d'usine et simulation d'usine virtuelle

Nous avons mis à disposition à la fois les modules d'agent d'usine et le simulation d'usine virtuelle entièrement open-source, permettant à chacun d'explorer et de construire des systèmes de contrôle intelligents en boucle fermée.

Avec l'usine virtuelle, vous pouvez :

• Déployer un environnement de fabrication simulé qui publie des sujets MQTT réalistes en temps réel.
• Émuler des perturbations, des contraintes de ressources, des dynamiques de production, et plus encore.
• Tester en toute sécurité et de manière itérative vos configurations, stratégies et logique décisionnelle d'Agent d'Usine.

En connectant des nœuds d'Agent d'Usine, vous pouvez :

• Écouter les événements de l'usine en temps réel.
• Raisonner sur les stratégies opérationnelles à l'aide de LLM.
• Agir en renvoyant des instructions de contrôle au système de l'usine — complétant ainsi la boucle observer-planifier-agir-observer.

📂 Explorez le code source et le guide de démarrage rapide :

• Dépôt GitHub de l'Agent d'Usine

Et ensuite : Mémoire, Multi-Agent et l'avenir des usines pensantes

Ce n'est que le début. Les prochaines étapes amélioreront à la fois l'architecture et les composants internes :

• Du scheduling mono-agent à la collaboration multi-agent
• Prise en charge de davantage de LLM, permettant une intégration transparente des futurs modèles
• Accès aux outils pour les agents
  • Connexion des agents à des solveurs numériques, des modèles de ML et des API externes
• Simulation d'usine virtuelle améliorée, permettant des scénarios de test plus riches et plus diversifiés
• Intégration de la mémoire
  • Mémoire de travail (contrôle de la fenêtre de contexte)
  • Mémoire épisodique (historique des décisions)
  • Mémoire procédurale (stratégies réutilisables)
  • Mémoire sémantique (connaissances publiques)
• Améliorations de la boucle de rétroaction
  • Évaluation des actions, itération basée sur les retours

Nous ne construisons pas seulement un produit, nous concevons un terrain de recherche pour repenser la manière dont les usines peuvent raisonner, s'adapter et collaborer.

Construisons ensemble les usines intelligentes de demain.

‍