Tutoriel : Création de Deux Agents Python avec le Protocole A2A de Google Étape par Étape

Name

Elwynn AI

Updated on 10/04/2025

Le protocole Agent-à-Agent (A2A) de Google est une norme ouverte qui permet à différents agents IA de communiquer et de travailler ensemble, peu importe le cadre ou le fournisseur dont ils proviennent (GitHub - google/A2A (opens in a new tab)). En termes plus simples, A2A donne à vos agents un langage commun pour interagir. Ce tutoriel vous guidera à travers la création de deux agents Python simples – l'un agissant comme un serveur A2A et l'autre comme un client A2A – qui communiquent entre eux en utilisant le protocole A2A. Nous couvrirons la configuration, expliquerons le fonctionnement de base d'A2A, et fournirons des exemples de code annotés pour les deux agents. Aucune expérience préalable avec A2A n'est requise, et nous éviterons les concepts avancés comme les chaînes d'outils complexes ou l'orchestration multi-agent pour garder les choses accessibles aux débutants.

Qu'est-ce que le Protocole A2A ?

À sa base, A2A est un protocole (basé sur HTTP) qui standardise la manière dont les agents échangent des messages, des requêtes, et des données. Voici quelques concepts clés dans A2A :

• Carte d'Agent : Un fichier de métadonnées public (généralement hébergé sur /.well-known/agent.json) décrivant les capacités, compétences, URL d'endpoint, et exigences d'authentification d'un agent. D'autres agents ou clients récupèrent cette carte pour découvrir ce que l'agent peut faire (GitHub - google/A2A (opens in a new tab)). C'est essentiellement la "carte de visite" de l'agent dans le réseau A2A.
• Serveur A2A : Un agent qui expose un endpoint API HTTP implémentant les méthodes A2A (par exemple, des endpoints pour envoyer des tâches). Il reçoit des requêtes et exécute des tâches au nom d'autres agents (GitHub - google/A2A (opens in a new tab)).
• Client A2A : Une application ou un agent qui envoie des requêtes à l'URL d'un serveur A2A pour initier des tâches ou des conversations (GitHub - google/A2A (opens in a new tab)). Dans un scénario agent-à-agent, le composant client d'un agent appellera le composant serveur d'un autre agent via A2A.
• Tâche : L'unité de travail fondamentale dans A2A. Un client commence une tâche en envoyant un message (en utilisant une requête tasks/send) à un agent. Chaque tâche a un ID unique et passe par un cycle de vie d'états (par exemple, submitted, working, input-required, completed, etc.) (GitHub - google/A2A (opens in a new tab)).
• Message : Un seul tour dans la communication entre le client (rôle "user") et l'agent (rôle "agent"). La requête du client est un message (du "user"), et la réponse de l'agent est un message (de l'"agent") (GitHub - google/A2A (opens in a new tab)).
• Partie : Un morceau de contenu dans un message. Un message est composé d'une ou plusieurs parties. Les parties peuvent être du texte, des fichiers, ou des données structurées. Par exemple, une partie texte (TextPart) contient du texte brut, tandis qu'une partie fichier peut contenir une image ou d'autres données binaires (GitHub - google/A2A (opens in a new tab)). Dans ce tutoriel, nous nous en tiendrons à de simples parties texte pour plus de clarté.

Comment Fonctionne la Communication A2A (Flux de Base) : Lorsque qu'un agent veut communiquer avec un autre via A2A, l'interaction suit généralement un flux standardisé :

1. Découverte : Le client découvre d'abord l'autre agent en récupérant sa Carte d'Agent (généralement depuis l'URL /.well-known/agent.json du serveur) (GitHub - google/A2A (opens in a new tab)). Cette carte indique au client comment se nomme l'agent, ce qu'il peut faire, et où envoyer les requêtes.
2. Initiation : Le client envoie ensuite une requête à l'endpoint A2A de l'agent serveur pour commencer une tâche – généralement via une POST à l'endpoint tasks/send. Cette requête initiale inclut un ID de tâche unique et le premier message utilisateur (par exemple, une question ou commande) (GitHub - google/A2A (opens in a new tab)).
3. Traitement : L'agent serveur reçoit la requête de tâche et la traite. Si l'agent supporte les réponses en streaming, il peut streamer des mises à jour intermédiaires en retour (en utilisant des événements envoyés par le serveur) pendant qu'il travaille, bien que dans notre exemple simple, nous n'utiliserons pas de streaming. Autrement, l'agent traitera la tâche et renverra une réponse finale une fois terminé (GitHub - google/A2A (opens in a new tab)). La réponse contiendra le résultat de la tâche – généralement un ou plusieurs messages de l'agent (et éventuellement des artefacts comme des fichiers si cela fait partie de la tâche). Pour des interactions textuelles de base, la réponse finale inclura simplement le message de réponse de l'agent.

En résumé, A2A définit un cycle clair de requête-réponse pour les agents : un client découvre les capacités d'un agent (Carte d'Agent), lui envoie une tâche (avec un message utilisateur initial), et reçoit la réponse de l'agent (sous forme de messages et d'artefacts), le tout dans un format JSON cohérent. Maintenant, configurons notre environnement et construisons un exemple minimal pour voir ça en action.

MCP est un protocole similaire pour le développement de l’IA, qui permet à l’IA d’accéder à des outils existants, des API web ou des données. Si vous êtes intéressé par MCP, consultez ce tutoriel MCP How to Build a MCP service for your blog site.

Installation et Configuration

Avant d'écrire du code, assurez-vous d'avoir les outils requis installés :

• Python 3.12 ou supérieur – les exemples A2A recommandent Python 3.12+ (voire Python 3.13) pour la compatibilité (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)).
• UV (gestionnaire de paquets Python) – c'est un outil optionnel mais recommandé par le projet A2A pour gérer les dépendances et exécuter les exemples (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)). UV est un gestionnaire de paquets moderne ; cependant, si vous préférez, vous pouvez aussi utiliser pip/venv pour installer les dépendances manuellement. Dans ce tutoriel, nous garderons les choses simples et utiliserons les outils Python standards.
• Dépôt Google A2A – obtenir le code officiel d'A2A en clonant le dépôt GitHub :

  git clone https://github.com/google/A2A.git
  Cela téléchargera le projet sur votre machine. Notre code de tutoriel fera référence à des parties de ce dépôt (notamment les utilitaires de client A2A échantillons).
• Dépendances – si vous utilisez UV, vous pouvez le laisser gérer automatiquement les dépendances. Par exemple, depuis le répertoire samples/python du dépôt, vous pouvez exécuter uv sync (pour installer les deps) ou exécuter des commandes comme uv run ... comme montré dans le README officiel. Si vous préférez utiliser pip, assurez-vous d'installer les bibliothèques nécessaires pour notre code d'exemple :

  pip install flask requests
  La bibliothèque Flask sera utilisée pour créer un serveur HTTP simple pour notre agent, et requests sera utilisé pour que le client appelle l'agent. (Le code exemple officiel A2A utilise FastAPI/UVICorn et une bibliothèque client interne, mais pour une approche accessible aux débutants, nous utilisons Flask et requests pour plus de clarté.)

Création d'un Agent Serveur A2A Simple

Tout d'abord, nous allons construire le côté serveur : un agent qui écoute les tâches entrantes et y répond. Notre agent sera extrêmement simple – il acceptera une invite texte et la renverra simplement avec un message sympathique. Malgré sa simplicité, il suivra la structure du protocole A2A afin que n'importe quel client A2A puisse communiquer avec lui.

Capacités de l'Agent et Carte d'Agent : Pour que notre agent soit découvrable, il doit fournir une Carte d'Agent. Dans un déploiement réel, nous hébergerions un fichier JSON sur /.well-known/agent.json sur le serveur. Pour notre application Flask, nous pouvons servir ces données via un endpoint. La Carte d'Agent inclut généralement des champs comme le nom de l'agent, une description, l'URL de son endpoint A2A, les fonctionnalités supportées (capacités), etc. (GitHub - google/A2A (opens in a new tab)). Nous allons construire une Carte d'Agent minimale avec juste quelques champs clés.

Endpoint tasks/send : A2A attend de l'agent qu'il implémente certains endpoints API. Le plus important est tasks/send, que le client appellera (HTTP POST) pour envoyer une nouvelle tâche (avec un message utilisateur) à l'agent (GitHub - google/A2A (opens in a new tab)). Notre application Flask définira une route pour /tasks/send pour gérer ces requêtes. Elle analysera le JSON entrant (qui contient l'ID de la tâche et le message de l'utilisateur), le traitera (dans notre cas, simple génération d'une réponse d'écho), et renverra une réponse JSON suivant le format A2A.

Écrivons le code pour notre agent serveur A2A simple en utilisant Flask :

from flask import Flask, request, jsonify
 
app = Flask(__name__)
 
# Définir les données de Carte d'Agent (métadonnées sur cet agent)
AGENT_CARD = {
    "name": "EchoAgent",
    "description": "Un agent simple qui renvoie les messages des utilisateurs.",
    "url": "http://localhost:5000",  # L'URL de base où cet agent est hébergé
    "version": "1.0",
    "capabilities": {
        "streaming": False,           # Cet agent ne supporte pas les réponses en streaming
        "pushNotifications": False    # Pas de notifications push dans cet exemple simple
    }
    # (Dans une Carte d'Agent complète, il pourrait y avoir plus de champs comme les infos d'authentification, etc.)
}
 
# Servir la Carte d'Agent à l'URL bien connue.
@app.get("/.well-known/agent.json")
def get_agent_card():
    """Point de terminaison pour fournir les métadonnées de cet agent (Carte d'Agent)."""
    return jsonify(AGENT_CARD)
 
# Gérer les requêtes de tâche entrantes à l'endpoint A2A.
@app.post("/tasks/send")
def handle_task():
    """Point de terminaison pour que les clients A2A envoient une nouvelle tâche (avec un message utilisateur initial)."""
    task_request = request.get_json()  # analyser la requête JSON entrante
    # Extraire l'ID de la tâche et le texte du message de l'utilisateur de la requête.
    task_id = task_request.get("id")
    user_message = ""
    try:
        # Selon la spécification A2A, le message de l'utilisateur est dans task_request["message"]["parts"][0]["text"]
        user_message = task_request["message"]["parts"][0]["text"]
    except Exception as e:
        return jsonify({"error": "Format de la requête invalide"}), 400
 
    # Pour cet agent simple, le "traitement" consiste simplement à renvoyer le message.
    agent_reply_text = f"Bonjour ! Vous avez dit : '{user_message}'"
 
    # Formuler la réponse au format de Tâche A2A.
    # Nous renverrons un objet Tâche avec l'état final = 'completed' et le message de l'agent.
    response_task = {
        "id": task_id,
        "status": {"state": "completed"},
        "messages": [
            task_request.get("message", {}),             # inclure le message utilisateur original dans l'historique
            {
                "role": "agent",                        # la réponse de l'agent
                "parts": [{"text": agent_reply_text}]   # contenu du message de l'agent en tant que TextPart
            }
        ]
        # Nous pourrions aussi inclure un champ "artifacts" si l'agent renvoyait des fichiers ou d'autres données.
    }
    return jsonify(response_task)
 
# Exécuter l'application Flask (serveur A2A) si ce script est exécuté directement.
if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

Comprendre le Code du Serveur : Analysons ce qui se passe dans le code ci-dessus :

• Nous avons créé une application Flask et défini un dictionnaire global AGENT_CARD. Celui-ci contient des informations de base sur notre agent. Notamment, il a un nom, une description, une URL (pointant vers lui-même sur localhost et le port 5000), et une section de capacités. Nous avons défini streaming: False car notre agent ne fera que de simples réponses synchrones (si un agent supportait le streaming, il gérerait tasks/sendSubscribe et streamerait des résultats partiels, ce que nous ne couvrons pas ici).
• Nous avons configuré une route /.well-known/agent.json qui renvoie le JSON de la carte d'agent. Cela imite l'emplacement standard où la carte d'un agent est censée être trouvée pour la découverte (GitHub - google/A2A (opens in a new tab)).
• Nous définissons une route POST pour /tasks/send. Lorsqu'un client A2A envoie une tâche, Flask appelle handle_task(). À l'intérieur de cette fonction :
  • Nous analysons le corps JSON de la requête en task_request. Selon le schéma A2A, cela inclura un "id" (ID de tâche) et un objet "message" représentant le message initial de l'utilisateur.
  • Nous extrayons le texte du message de l'utilisateur. Dans A2A, un message peut avoir plusieurs parties (par exemple, texte, fichiers). Ici nous supposons que la première partie est un texte et attrapons task_request["message"]["parts"][0]["text"]. Dans une implémentation plus robuste, nous vérifierions le type de la partie et gérerions les erreurs (notre code fait un simple try/except et renvoie une erreur 400 si le format n'est pas comme attendu).
  • Ensuite, nous générons la réponse de l'agent. Notre logique est triviale : nous prenons le texte utilisateur et préfixons "Bonjour ! Vous avez dit : ...". Dans un agent réel, c'est ici que la logique IA centrale résiderait (appel d'un LLM, effectuer des calculs, etc.).
  • Ensuite, nous construisons l'objet réponse Tâche. Nous devons renvoyer l'id (pour que le client sache à quelle tâche cela correspond), définir le status.state à "completed" (puisque nous avons terminé la tâche), et fournir une liste de messages. Nous incluons le message utilisateur original (pour le contexte/historique) puis ajoutons notre réponse de l'agent comme un autre message. Chaque message a un role ("user" ou "agent") et une liste de parts. Nous utilisons une seule TextPart contenant notre texte de réponse pour le message de l'agent.
  • Enfin, nous renvoyons cela sous forme JSON. Flask va sérialiser le dictionnaire Python en JSON pour nous.

Avec ce serveur en cours d'exécution, notre agent est effectivement "en ligne" sur http://localhost:5000. Il peut servir sa Carte d'Agent et gérer les requêtes de tâches.

Création d'un Agent Client A2A Simple

Maintenant que nous avons un agent serveur, nous avons besoin d'un client qui peut lui parler. Ce client pourrait être un autre agent ou simplement une application orientée utilisateur. En termes d'A2A, c'est un client A2A car il va consommer l'API A2A de notre agent serveur (GitHub - google/A2A (opens in a new tab)). Pour notre tutoriel, nous écrirons un petit script Python qui jouera le rôle d'un second agent (ou utilisateur) envoyant une question à notre EchoAgent et recevant la réponse.

Étapes pour le Client :

1. Découvrir l'agent : Le client doit récupérer la Carte d'Agent de l'agent serveur pour connaître son endpoint et ses capacités. Nous savons que notre carte d'agent est sur http://localhost:5000/.well-known/agent.json. Nous pouvons utiliser la bibliothèque Python requests pour GET cette URL.
2. Envoyer une tâche : Ensuite, le client enverra une requête POST à l'endpoint tasks/send de l'agent avec une charge JSON représentant la tâche. Cette charge devrait inclure :
   • un "id" unique pour la tâche (chaque chaîne ou nombre unique ; par exemple, "task1"),
   • un objet "message" avec role: "user" et une liste parts contenant la requête de l'utilisateur comme TextPart.
3. Recevoir la réponse : L'agent répondra avec un JSON représentant la Tâche (y compris le message de réponse de l'agent). Le client doit lire cela et extraire la réponse de l'agent.

Écrivons le code du client pour effectuer ces étapes :

import requests
import uuid
 
# 1. Découvrir l'agent en récupérant sa Carte d'Agent
AGENT_BASE_URL = "http://localhost:5000"
agent_card_url = f"{AGENT_BASE_URL}/.well-known/agent.json"
response = requests.get(agent_card_url)
if response.status_code != 200:
    raise RuntimeError(f"Failed to get agent card: {response.status_code}")
agent_card = response.json()
print("Agent découvert :", agent_card["name"], "-", agent_card.get("description", ""))
 
# 2. Préparer une requête de tâche pour l'agent
task_id = str(uuid.uuid4())  # générer un ID de tâche unique aléatoire
user_text = "Quelle est le sens de la vie ?"
task_payload = {
    "id": task_id,
    "message": {
        "role": "user",
        "parts": [
            {"text": user_text}
        ]
    }
}
print(f"Envoyer la tâche {task_id} à l'agent avec le message : '{user_text}'")
 
# 3. Envoyer la tâche à l'endpoint tasks/send de l'agent
tasks_send_url = f"{AGENT_BASE_URL}/tasks/send"
result = requests.post(tasks_send_url, json=task_payload)
if result.status_code != 200:
    raise RuntimeError(f"Requête de tâche échouée : {result.status_code}, {result.text}")
task_response = result.json()
 
# 4. Traiter la réponse de l'agent
# La réponse doit contenir l'ID de la tâche, le statut, et les messages (y compris la réponse de l'agent).
if task_response.get("status", {}).get("state") == "completed":
    # Le dernier message dans la liste doit être la réponse de l'agent (puisque notre agent a inclus l'historique dans les messages).
    messages = task_response.get("messages", [])
    if messages:
        agent_message = messages[-1]  # dernier message (de l'agent)
        agent_reply_text = ""
        # Extraire le texte des parties du message de l'agent
        for part in agent_message.get("parts", []):
            if "text" in part:
                agent_reply_text += part["text"]
        print("Réponse de l'agent :", agent_reply_text)
    else:
        print("Pas de messages dans la réponse!")
else:
    print("La tâche n'est pas terminée. Statut :", task_response.get("status"))

Comprendre le Code du Client : Voici ce que fait le client :

• Il utilise requests.get pour récupérer la carte d'agent depuis http://localhost:5000/.well-known/agent.json. En cas de succès, nous analysons le JSON et imprimons le nom et la description de l'agent pour vérifier que nous avons trouvé le bon agent.
• Nous générons un ID de tâche unique en utilisant uuid.uuid4(). C'est juste pour s'assurer que nous n'utilisons pas un ID en double (dans des scénarios réels, le client doit s'assurer que chaque tâche envoyée a un ID unique).
• Nous créons la charge de tâche comme un dictionnaire Python. Cette charge suit le schéma A2A : elle a un "id" (notre ID généré) et un "message" pour la requête de l'utilisateur. Le message a role: "user" et une partie contenant le texte "Quelle est le sens de la vie ?" (vous pouvez changer ce texte en n'importe quoi – l'EchoAgent le renverra simplement).
• Nous envoyons cette charge à l'endpoint tasks/send de l'agent en utilisant requests.post. Notez que nous utilisons le paramètre json=..., qui indique à la bibliothèque requests d'envoyer le dictionnaire sous forme de JSON.
• Nous vérifions un code de réponse 200 OK. Si le status n'est pas 200, nous levons une erreur. (Dans un script plus indulgent, vous pourriez gérer les réponses non-200 plus gracieusement.)
• Si l'appel a réussi, nous analysons la réponse JSON en task_response. Cela devrait être l'objet Tâche retourné par notre agent. Nous l'examinons ensuite :
  • Nous vérifions si status.state est "completed" – dans notre conception, l'agent le marquera comme terminé après une réponse. Si, par exemple, l'agent avait besoin de plus d'entrées ("input-required") ou a échoué, nous gèrerions ces cas. Pour simplifier, nous supposons la complétion.
  • Nous récupérons ensuite la liste des messages dans la réponse. Nous nous attendons à ce que le dernier message de cette liste soit la réponse de l'agent (puisque notre code serveur a ajouté le message de l'agent après celui de l'utilisateur). Nous extrayons le texte des parties du message de l'agent. Dans ce cas, cela devrait être la réponse d'écho que nous avons construite.
  • Enfin, nous imprimons la réponse de l'agent.

À ce stade, notre client aura imprimé la réponse de l'agent. Dans la section suivante, nous ferons fonctionner à la fois le serveur et le client pour voir l'échange complet.

Exécution et Test des Agents

Pour tester nos deux agents, suivez ces étapes :

1. Démarrez l'agent serveur : Exécutez le script du serveur Flask (appelons-le echo_agent.py). Par exemple, dans votre terminal :

   python echo_agent.py

   Cela devrait démarrer le serveur de développement Flask sur http://localhost:5000. Vous devriez voir un message comme "Running on http://0.0.0.0:5000/ (opens in a new tab)". L'agent écoute maintenant les requêtes. (Assurez-vous que rien d'autre n'utilise déjà le port 5000, ou changez le port dans le code si nécessaire.)

2. Exécutez le script client : Ouvrez un autre terminal et exécutez le script client (par exemple, client_agent.py) :

   python client_agent.py

   Le client devrait imprimer quelque chose comme :

   Agent découvert : EchoAgent – Un agent simple qui renvoie les messages des utilisateurs.
   Envoyer la tâche 3f8ae8ac-... à l'agent avec le message : 'Quelle est le sens de la vie ?'
   Réponse de l'agent : Bonjour ! Vous avez dit : 'Quelle est le sens de la vie ?'

   Cela indique que le client a découvert l'agent avec succès, envoyé une question, et reçu la réponse. La réponse de l'agent est le message d'écho que nous attendions.

3. Vérifiez l'interaction : Vous pouvez également vérifier la sortie de la console du serveur. Flask enregistrera les requêtes qu'il a traitées. Vous devriez voir une requête GET pour /.well-known/agent.json et une requête POST vers /tasks/send, avec un status 200 pour chacune. Cela confirme le flux du protocole :

   • Découverte (le client GET la carte d'agent) → Initiation (le client POST la tâche) → Traitement/Complétion (le serveur répond avec réponse).

Félicitations! Vous venez d'implémenter une communication agent-à-agent de base utilisant le protocole A2A. Un agent a agi en tant que service (EchoAgent) et l'autre comme client qui l'interroge. Bien que cet exemple soit simpliste (le "IA" ne fait que répéter l'entrée), il démontre le raccordement nécessaire pour toute interaction A2A.

Utilisation de la Bibliothèque Client A2A (Optionnel)

Dans notre code client, nous avons fabriqué manuellement les requêtes HTTP en utilisant requests. Le dépôt GitHub officiel A2A fournit des classes d'aide pour simplifier ce processus. Par exemple, il y a une classe A2AClient qui peut gérer la récupération de la carte d'agent et l'envoi de tâches pour vous, ainsi qu'un A2ACardResolver pour découvrir la carte de l'agent. Voici comment nous pourrions les utiliser (pour ceux intéressés par une approche plus idiomatique) :

import asyncio
from samples.python.common.client import A2AClient, A2ACardResolver
from samples.python.common.types import TaskSendParams, Message, TextPart
 
async def query_agent(agent_url, user_text):
    # Récupérer la carte d'agent automatiquement
    card_resolver = A2ACardResolver(agent_url)
    agent_card = card_resolver.get_agent_card()
    print("Agent découvert :", agent_card.name)
    # Créer un client A2A avec la carte de l'agent
    client = A2AClient(agent_card=agent_card)
    # Préparer les paramètres de Tâche (en utilisant les classes de types A2A)
    payload = TaskSendParams(
        id=str(uuid.uuid4()),
        message=Message(role="user", parts=[TextPart(text=user_text)])
    )
    # Envoyer la tâche et attendre la complétion
    result_task = await client.send_task(payload)  # send_task est une méthode async
    # Extraire la réponse de l'agent de result_task
    if result_task.status.state.value == "completed":
        # L'objet Tâche A2A peut être inspecté pour messages et artefacts
        for msg in result_task.messages:
            if msg.role == "agent":
                # Imprimer les parties texte du message de l'agent
                print("Réponse de l'agent :", " ".join(part.text for part in msg.parts if hasattr(part, "text")))

Dans l'extrait ci-dessus, A2ACardResolver et A2AClient proviennent de la bibliothèque d'exemples A2A (située dans le répertoire samples/python/common du repo). Les TaskSendParams, Message, et TextPart sont des classes de données (probablement basées sur des modèles Pydantic) correspondant à des parties du schéma JSON A2A. En utilisant ceux-ci, nous n'avons pas à construire manuellement les dictionnaires ; nous créons des objets Python et la bibliothèque s'occupera de la sérialisation JSON et des appels HTTP. La méthode send_task du client est asynchrone (d'où l'utilisation de await), et elle renvoie un objet Task. Notre exemple montre comment vous pourriez récupérer la réponse de l'agent à partir de cet objet.

Remarque : Le code ci-dessus est à titre d'illustration et nécessite que le code du dépôt A2A soit accessible dans votre chemin Python. Si vous avez cloné le dépôt et installé ses exigences (via UV ou pip), vous pouvez l'intégrer dans votre client. L'outil en ligne de commande officiel dans le dépôt A2A effectue essentiellement ces étapes – il lit la Carte d'Agent et entre dans une boucle pour envoyer des tâches et imprimer des réponses (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)).

Conclusion

Dans ce tutoriel, nous avons couvert les bases du protocole A2A de Google et démontré une simple communication entre deux agents. Nous avons mis en place un serveur A2A minimal (EchoAgent) et un client qui interagit avec lui. En cours de route, nous avons appris les Cartes d'Agent (pour la découverte) et comment les tâches et les messages sont structurés dans A2A.

Bien que notre exemple soit un agent d'écho trivial, vous avez maintenant la base pour construire des agents plus complexes. Par exemple, vous pourriez remplacer la logique d'écho par un appel à un modèle de langage ou une API pour faire en sorte que l'agent résolve un problème ou réponde à des questions. La beauté d'A2A est que tant que votre agent adhère au protocole (sert une carte d'agent et implémente les endpoints de tâches), tout autre agent ou outil compatible A2A peut s'intégrer à lui.

Prochaines Étapes : Vous pourriez explorer les exemples de dépôt officiels A2A pour des modèles plus avancés. Par exemple, les échantillons de Google incluent un agent qui génère des images à partir de texte et les renvoie comme artefacts d'image (A2A/samples/python/agents/crewai/README.md at main · google/A2A · GitHub (opens in a new tab)), et un autre qui gère des dialogues de remplissage de formulaires multi-tours. Vous pouvez également essayer l'interface en ligne de commande (CLI) ou la démonstration web fournie pour discuter avec votre agent. Pour utiliser la CLI avec notre EchoAgent, vous pourriez exécuter : uv run hosts/cli --agent http://localhost:5000 (si vous avez UV et la configuration du dépôt) pour initier un chat de type REPL avec l'agent (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)).

En standardisant la communication entre agents, A2A ouvre la voie à un riche écosystème d'agents IA interopérables. Nous n'avons fait qu'effleurer la surface ici avec un exemple basique. Bonnes expérimentations avec A2A – et que vos agents collaborent efficacement !

Sources :

1. Google A2A GitHub – README de l'Agent2Agent Protocol (Vue Conceptuelle) (GitHub - google/A2A (opens in a new tab)) (GitHub - google/A2A (opens in a new tab)) (GitHub - google/A2A (opens in a new tab)) (GitHub - google/A2A (opens in a new tab))
2. Google A2A GitHub – Échantillons et Utilisation du CLI (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab)) (A2A/samples/python/hosts/cli at main · google/A2A · GitHub (opens in a new tab))
3. Google A2A GitHub – CrewAI Sample README (capacités de l'agent via A2A) (A2A/samples/python/agents/crewai/README.md at main · google/A2A · GitHub (opens in a new tab)) (pour une exploration plus approfondie)