Le protocole A2A, ou Agent2Agent, est un standard ouvert qui permet une communication structurée entre les agents d’IA, les clients et les outils. Dans ce tutoriel, vous pouvez créer un système d’agent où un client de chat traite les requêtes utilisateur et les envoie à un agent d’IA sur un serveur conforme à la norme A2A.
La plupart des applications d’IA agentique mettent en œuvre une communication personnalisée entre les composants (par exemple, ChatChain de ChatDev), ce qui rend difficile la réutilisation du même agent dans différentes applications ou l’intégration d’outils externes. Ce manque de standardisation empêche l’interopérabilité et limite le développement d’un écosystème d’agents plus large.
A2A résout cette limitation en séparant la couche de communication de la logique d’agent grâce à un protocole standardisé basé sur HTTP, JSON-RPC 2.0 et Server-Sent Events (SSE). Ce découplage permet aux agents de collaborer entre eux, de répondre aux requêtes client et d’accéder à des outils externes sans code d’intégration personnalisé.
A2A prend en charge les architectures décentralisées qui permettent aux équipes de faire évoluer leurs systèmes d’IA de manière progressive sans casser le code client. Les équipes peuvent mettre à jour les outils, échanger des modèles ou modifier le comportement des agents tout en conservant une interface cohérente dans des workflows complexes.
Les agents échangent des informations dans des messages structurés au format JSON-RPC qui incluent des métadonnées qui enrichissent les interactions des agents de manière claire et cohérente. Chaque serveur A2A expose une fiche AgentCard à un point de terminaison bien connu (.well-known/agent-card.json) qui décrit les capacités de l’agent sous forme de données JSON structurées. Cela permet aux clients de découvrir dynamiquement ce qu’un agent peut faire, de la même manière que la documentation de l’API décrit les points de terminaison disponibles.
Suivez ce guide pour créer et gérer un système d’agents A2A, et acquérez une expérience pratique avec :
Remarque : si vous avez travaillé avec ACP (Agent Communication Protocol), vous constaterez quelques similitudes. ACP, initialement développé par BeeAI d’IBM, s’est associé à Google A2A sous l’égide de la Linux Foundation. BeeAI utilise désormais des adaptateurs A2A (A2AServer et A2AAgent) pour fournir une communication conforme au protocole A2A. A2A fonctionne également avec MCP (Model Context Protocol) pour permettre aux agents d’interagir avec les sources de données et les outils, créant ainsi des écosystèmes d’agents interopérables.
Ce projet montre comment A2A permet une séparation claire entre l’interface client et la logique d’agent.
Le workflow suit cette séquence :
Ce workflow démontre un modèle réutilisable applicable aux cas d’utilisation nécessitant une communication structurée entre clients et agents, tels que les chatbots, les systèmes d’automatisation des tâches, les agents de support client et les assistants de recherche avec orchestration des outils.
Ce projet utilise un seul agent d’IA avec plusieurs capacités d’outil. Dans les systèmes plus complexes, vous pouvez déployer plusieurs agents spécialisés, chacun se concentrant sur des domaines ou des tâches spécifiques.
RequirementAgent (BeeAI) : un agent déclaratif qui sélectionne et coordonne dynamiquement plusieurs outils en fonction de la requête utilisateur. Il utilise :
Le serveur A2A (
2. Configuration de l’agent : crée un RequirementAgent avec des outils et de la mémoire pour gérer le cycle de vie de l’agent
3. Configuration du serveur : expose l’agent via des points de terminaison HTTP conformes à A2A.
Le serveur expose automatiquement une fiche AgentCard à l’adresse /.well-known/agent-card.json qui décrit les capacités de l’agent et permet de valider les configurations d’agent.
Le client A2A (
Configuration de la connexion : crée un adaptateur client A2A
Les
Échange de messages : envoie des prompts asynchrones et traite les réponses :
Les
Voici la configuration système requise pour exécuter ce projet :
Avant de vous lancer, voici un aperçu des outils nécessaires pour ce projet :
Ce projet utilise Ollama comme fournisseur de modèle pour l’agent d’IA. Suivez ces étapes pour configurer Ollama :
Remarque : vous pouvez utiliser n’importe quel modèle compatible avec Ollama en paramétrant la
Pour exécuter ce projet, clonez le référentiel GitHub en utilisant https://github.com/IBM/ibmdotcom-tutorials.git comme URL HTTPS. Pour obtenir des étapes détaillées sur le clonage d’un dépôt, consultez la documentation GitHub.
Ce tutoriel se trouve dans le répertoire des projets du dépôt.
Dans un terminal, accédez au répertoire de ce tutoriel :
Ce projet nécessite l’exécution simultanée de deux scripts Python distincts, l’un pour le serveur et l’autre pour le client. Vous devez ouvrir deux fenêtres ou onglets de terminal.
Maintenez le terminal actuel ouvert, puis ouvrez un deuxième terminal et assurez-vous que les deux redirigent vers le répertoire de projet approprié (le
Vous utilisez un IDE ?
Si vous utilisez un IDE tel que Visual Studio Code, vous pouvez utiliser la fonctionnalité Split Terminal pour gérer plusieurs terminaux côte à côte.
Sinon, ouvrez deux fenêtres de terminal indépendantes et accédez dans chacune d’elles au répertoire du projet.
Les environnements virtuels permettent de séparer et de maintenir les dépendances. Pour séparer les dépendances serveur et client, créez un environnement virtuel pour chaque composant.
Pour le serveur :
Accédez au
Créer un environnement virtuel avec Python 3.11 :
Activez l’environnement virtuel :
Remarque pour les utilisateurs de Windows : utilisez venv\Scripts\Activate pour activer l’environnement virtuel.
Pour le client :
Accédez au
Créer et activer un environnement virtuel :
Installez les dépendances requises pour chaque composant en exécutant ce code dans chaque terminal :
Vous pouvez exécuter
Dans le premier terminal, démarrez le serveur d’agent A2A :
Vous devriez voir :
Le serveur écoute désormais les requêtes entrantes de l’application client, prêt à prendre en charge la communication d’agent à agent.
Dans l’autre terminal, démarrez le client A2A :
Vous êtes invité à saisir vos instructions :
Saisissez un message dans le terminal client et appuyez sur
Dans le terminal du serveur, vous pouvez voir les journaux de protocole A2A montrant la communication avec les notifications push :
La première requête récupère la fiche AgentCard qui décrit les capacités de l’agent. La deuxième requête envoie votre message sous la forme d’un
Remarque : les sorties des LLM sont probabilistes et peuvent varier chaque fois que vous exécutez le workflow, même avec la même entrée.
Expérimentez différents types de requêtes pour tester les différents outils de l’agent :
Accédez à https://0.0.0.0:9999/.well-known/agent-card.json dans votre navigateur pour afficher la fiche
Ce document JSON décrit :
Cette fiche AgentCard permet aux clients conformes au protocole A2A de découvrir l’agent et d’interagir avec lui sans connaître les détails de son implémentation au préalable.
Dans ce tutoriel, vous avez créé un système de chat en utilisant un serveur conforme au protocole A2A qui a présenté une interface structurée pour la communication client-agent. En séparant la couche de messagerie de la logique interne, le protocole Agent2Agent permet aux équipes de mettre à jour les capacités des agents, d’échanger des modèles ou de modifier les configurations des outils sans modifier le code client. Cette flexibilité est particulièrement précieuse lorsque vous coordonnez les tâches requises en entrée, pour suivre l’état des tâches ou pour traiter chaque opération comme une unité de travail distincte.
A2A fonctionne en définissant un format de message commun que tout composant conforme peut comprendre, ce qui permet aux agents autonomes de collaborer avec d’autres agents. La spécification du protocole définit comment les messages sont structurés au format JSON-RPC et enrichis de métadonnées pour assurer la cohérence et la clarté entre les interactions.
Ce tutoriel s’appuie sur les exemples de base fournis par le référentiel d’exemples A2A. Pour plus d’informations sur l’implémentation initiale, reportez-vous au fichier readme du référentiel, qui fournit plus de contexte et d’exemples pour la création de systèmes conformes à A2A.
Pour les déploiements réels, les serveurs A2A peuvent mettre en œuvre des mécanismes d’authentification pour sécuriser les points de terminaison des agents, utiliser les événements envoyés par le serveur pour les réponses en streaming et évoluer pour gérer les workflows de production. En suivant ce workflow, vous avez vu comment un client de ligne de commande peut interagir avec un agent d’IA via un protocole standardisé, permettant à l’agent d’IA de coordonner plusieurs outils et de fournir des réponses contextuelles. Cette approche démontre la puissance de l’A2A pour permettre la mise en place de systèmes d’IA maintenables, évolutifs et flexibles.
Une fois vos expérimentations avec le système terminées, suivez ces étapes pour arrêter proprement tous les composants en cours d’exécution :
Dans chaque fenêtre de terminal, appuyez sur Ctrl+C pour mettre fin au processus en cours.
Vous devriez obtenir une sortie comme celle-ci :
Si le serveur ne répond plus ou est bloqué à l’arrêt, vous pouvez forcer l’arrêt :
Recherchez l’identifiant du processus (PID) :
Identifiez le PID du processus que vous essayez d’arrêter.
Mettez fin au processus :
Répétez ce processus pour chaque serveur si nécessaire.
Et voilà. Vous avez réussi à exécuter un système de chat complet conforme au protocole A2A.
Créez, déployez et gérez de puissants assistants et agents IA qui automatisent les workflows et les processus grâce à l’IA générative.
Construisez l’avenir de votre entreprise avec des solutions d’IA en lesquelles vous pouvez avoir confiance.
IBM Consulting et ses services d'IA accompagnent les entreprises dans la redéfinition de leurs activités avec l'intelligence artificielle pour mener leur transformation.