Introduction — Les systèmes multi-agents

Avant de commencer à coder, il est utile de comprendre ce qu’est un système multi-agents, comment les agents s’organisent entre eux, et comment la plateforme gAgent les accompagne. Cette page ne contient pas de code — elle pose les bases conceptuelles de tout ce qui suit.

Qu’est-ce qu’un système multi-agents ?

Un système multi-agents (SMA) est un programme composé de plusieurs entités autonomes — les agents — qui travaillent ensemble pour accomplir un objectif.

Chaque agent :

a ses propres responsabilités (ses behaviours)
prend ses décisions de façon indépendante
peut communiquer avec les autres agents pour coopérer, négocier ou se coordonner

Pensez à une ruche : chaque abeille est autonome, elle prend ses décisions seule, mais l’ensemble du système accomplit quelque chose de beaucoup plus complexe qu’une seule abeille ne pourrait faire. Un SMA fonctionne sur le même principe.

Pourquoi plusieurs agents plutôt qu’un seul programme ?

Décomposition — un problème complexe est découpé en sous-problèmes, chacun géré par un agent spécialisé.
Parallélisme — les agents travaillent en même temps, ce qui accélère le traitement.
Résilience — si un agent tombe en panne, les autres continuent à fonctionner.
Distribution — les agents peuvent tourner sur des machines différentes, réparties sur un réseau.

Les agents dans gAgent

Dans gAgent, chaque agent est une entité qui :

tourne de façon indépendante dès son démarrage
exécute une ou plusieurs tâches (behaviours) en parallèle
communique avec les autres agents via des messages FIPA ACL

Les agents peuvent être sur la même machine (communication par canaux locaux) ou sur des machines différentes (communication par réseau). Du point de vue du code, cela ne change rien : on utilise toujours les mêmes fonctions acl_send() et acl_receive().

Machine A                         Machine B
┌──────────────────────┐          ┌──────────────────────┐
│  Agent Alice         │          │  Agent Bob           │
│  Agent Carol         │◄────────►│  Agent Dave          │
│                      │  réseau  │                      │
└──────────────────────┘          └──────────────────────┘

La plateforme FIPA

Dans un système multi-agents, les agents ont besoin d’une infrastructure commune pour se trouver, s’identifier et se coordonner. C’est le rôle de la plateforme FIPA.

La plateforme gAgent (agentplatform) est un service à lancer avant les agents. Elle fournit deux services fondamentaux : l’AMS et le DF.

┌─────────────────────────────────────────────────────┐
│                  gAgent Platform                    │
│                                                     │
│   ┌──────────────────┐   ┌────────────────────┐    │
│   │  AMS             │   │  DF                │    │
│   │  (annuaire des   │   │  (annuaire des     │    │
│   │   agents)        │   │   services)        │    │
│   └──────────────────┘   └────────────────────┘    │
│                                                     │
└─────────────────────────────────────────────────────┘
      ▲           ▲                 ▲           ▲
   Agent A     Agent B          Agent C     Agent D

L’AMS — qui sont les agents ?

L”AMS (Agent Management System) est le registre officiel des agents actifs sur la plateforme. C’est l’équivalent d’un annuaire téléphonique : chaque agent s’y inscrit à son démarrage et s’en désinscrit à sa fin.

L’AMS permet de :

Savoir quels agents sont actifs à un instant donné
Connaître l’état de chaque agent (actif, suspendu, en attente…)
Contrôler les agents à distance (suspendre, réveiller, supprimer)

Quand un agent gAgent démarre, il s’enregistre automatiquement dans l’AMS sans que vous n’ayez à écrire la moindre ligne de code pour cela. Quand il termine, il se désinscrit automatiquement.

Agent Alice démarre
   → s'enregistre dans l'AMS : "alice, actif"

Agent Bob démarre
   → s'enregistre dans l'AMS : "bob, actif"

[AMS] registre :
  alice  →  actif
  bob    →  actif

Agent Alice termine
   → se désinscrit de l'AMS

[AMS] registre :
  bob    →  actif

La plateforme n’est pas obligatoire pour faire fonctionner vos agents. Sans elle, les agents tournent en mode autonome : ils s’exécutent normalement, mais ne sont pas enregistrés et ne peuvent pas être supervisés depuis l’extérieur.

Le DF — que font les agents ?

Le DF (Directory Facilitator) est l”annuaire des services offerts par les agents. Là où l’AMS répond à la question « qui est actif ? », le DF répond à la question « qui sait faire quoi ? ».

Un agent qui offre un service — calcul, traduction, planification, accès à une base de données — peut s’enregistrer dans le DF avec une description de ce service. D’autres agents peuvent ensuite interroger le DF pour trouver un agent capable de les aider.

Agent Alice s'enregistre dans le DF :
   type = "planification"
   ontologie = "logistique"

Agent Carol s'enregistre dans le DF :
   type = "traduction"
   ontologie = "langues"

Agent Bob interroge le DF :
   "qui fait de la planification logistique ?"
   → réponse : Alice

Bob contacte directement Alice.

Cela permet de construire des systèmes dynamiques où les agents ne se connaissent pas à l’avance : ils se découvrent au moment où ils en ont besoin, via le DF.

Les outils de supervision

La plateforme gAgent fournit deux outils pour observer et contrôler votre système en temps réel :

agentmanager — la console de gestion

agentmanager list      # liste tous les agents actifs
agentmanager watch     # affichage en temps réel, rafraîchi toutes les secondes
agentmanager suspend alice   # suspendre l'agent alice
agentmanager wake alice      # le réveiller
agentmanager kill alice      # l'arrêter

agentview — la visualisation web

Un serveur web léger qui affiche une carte SVG de vos agents en temps réel, accessible depuis un navigateur à l’adresse http://localhost:8080.

Déploiement sur plusieurs machines

Un système multi-agents prend tout son sens quand les agents sont répartis sur plusieurs machines. gAgent supporte ce mode de déploiement nativement.

Par défaut, les agents d’une même machine se trouvent via leur nom (communication locale). Pour qu’un agent sur la machine A puisse envoyer un message à un agent sur la machine B, il suffit de définir une variable d’environnement indiquant l’adresse réseau de l’agent destinataire :

# Sur la machine B — l'agent "bob" écoute sur le réseau
GAGENT_ENDPOINT_BOB=tcp://0.0.0.0:5555 ./mon_application

# Sur la machine A — alice sait où trouver bob
GAGENT_ENDPOINT_BOB=tcp://192.168.1.42:5555 ./mon_application_alice

Du côté du code, rien ne change : on utilise toujours acl_send("bob", message) exactement comme si bob était sur la même machine.

Machine A (192.168.1.10)          Machine B (192.168.1.42)
┌──────────────────────┐          ┌──────────────────────┐
│  Agent Alice         │          │  Agent Bob           │
│                      │          │                      │
│  acl_send("bob", m)  │─────────►│  acl_receive("bob")  │
│                      │  TCP     │                      │
└──────────────────────┘          └──────────────────────┘
Code identique sur les deux machines — seule la variable
d'environnement change.

Ce qu’il faut retenir

Un agent est une entité autonome avec ses propres tâches et sa propre logique.
Les agents communiquent par messages FIPA ACL, localement ou sur le réseau.
L”AMS sait quels agents sont actifs et dans quel état.
Le DF sait quels services sont disponibles et qui les offre.
La plateforme est optionnelle mais recommandée pour superviser votre système.
Le code est le même que les agents soient sur une ou plusieurs machines.

Les tutoriels suivants vous montrent comment mettre tout cela en pratique, étape par étape.