Protocole A2A : Comment faire communiquer deux agents IA (Tutoriel 2025)

Niveau : Intermédiaire
Prérequis : Python 3.12+, notions de base en IA

---

Vous utilisez déjà des agents IA pour automatiser vos tâches ? Imaginez maintenant les faire collaborer entre eux. C’est exactement ce que permet le protocole A2A (Agent-to-Agent), lancé par Google en avril 2025 et désormais géré par la Linux Foundation.

Dans ce tutoriel, je vous montre concrètement comment créer deux agents IA capables de communiquer ensemble. Pas de théorie abstraite : du code fonctionnel, des exemples pratiques et des cas d’usage concrets.

---

Qu’est-ce que le protocole A2A ?

Le protocole A2A (Agent2Agent) est un standard ouvert qui permet à des agents IA de se découvrir, d’échanger des informations et de collaborer peu importe le framework utilisé (LangChain, CrewAI, Semantic Kernel…) ou le fournisseur cloud (AWS, Azure, GCP).

Pensez-y comme le HTTP des agents IA : un langage commun qui leur permet de “se parler” sans intégrations complexes.

Ce que A2A permet de faire

• Découverte automatique : un agent peut interroger les capacités d’un autre agent
• Communication standardisée : échange de messages en JSON-RPC via HTTP
• Tâches complexes distribuées : déléguer des sous-tâches à des agents spécialisés
• Sécurité native : authentification et autorisation de niveau entreprise

A2A vs MCP : quelle différence ?

Si vous connaissez le MCP (Model Context Protocol) d’Anthropic, vous vous demandez peut-être comment ces deux protocoles s’articulent.

La réponse est simple : ils sont complémentaires.

Protocole	Rôle	Analogie
MCP	Agent → Outils	Permet à un agent d’utiliser des outils (APIs, bases de données)
A2A	Agent → Agent	Permet aux agents de collaborer entre eux

En pratique, un agent peut utiliser MCP pour accéder à ses outils internes, puis A2A pour communiquer avec d’autres agents externes.

---

Les concepts clés à comprendre

Avant de coder, voici les 4 éléments essentiels du protocole A2A.

1. L’Agent Card (carte de visite)

Chaque agent expose une “carte de visite” au format JSON, accessible à l’URL /.well-known/agent.json. Cette carte décrit :

• Le nom et la description de l’agent
• Son URL d’accès
• Ses capacités (streaming, notifications push…)
• Ses compétences (skills)

C’est grâce à cette carte qu’un agent coordinateur peut découvrir automatiquement ce que les autres agents savent faire.

2. Les Skills (compétences)

Les skills définissent ce que l’agent sait faire. Par exemple :

• Un agent météo avec le skill “prévisions météorologiques”
• Un agent restaurant avec le skill “recherche de restaurants”
• Un agent calendrier avec le skill “gestion des disponibilités”

3. Les Tasks (tâches)

La tâche est l’unité de travail dans A2A. Un client envoie une requête, l’agent la traite et retourne un résultat. Chaque tâche passe par différents états : submitted, working, input-required, completed.

4. Les Messages

Les échanges se font via des messages structurés contenant des “parts” (texte, fichiers, données structurées). Le client envoie un message avec le rôle “user”, l’agent répond avec le rôle “agent”.

---

Tutoriel pratique : créer un assistant SEO multi-agents

Passons à la pratique avec un cas d’usage concret pour les pros du marketing digital. Nous allons créer un système d’analyse de contenu avec trois agents :

• Agent Analyse SEO : évalue la qualité SEO d’un texte (densité de mots-clés, longueur, structure)
• Agent Suggestions : propose des améliorations et mots-clés complémentaires
• Agent Coordinateur : orchestre les deux pour générer un rapport complet

L’objectif : soumettre un texte et obtenir un audit SEO automatisé.

Étape 1 : Préparer l’environnement

Vérifiez d’abord que Python est installé :

python --version  # Doit être >= 3.12
pip --version

Installez les dépendances nécessaires :

pip install flask requests

Pour le SDK officiel A2A (optionnel mais recommandé pour la production) :

pip install a2a-sdk

Étape 2 : Créer l’Agent Analyse SEO

Cet agent évalue les métriques SEO de base d’un contenu. Créez agent_seo_analyse.py :

from flask import Flask, jsonify, request
import re

app = Flask(__name__)

AGENT_CARD = {
    "name": "Agent Analyse SEO",
    "description": "Analyse les métriques SEO d'un contenu textuel",
    "url": "http://localhost:10001/",
    "version": "1.0.0",
    "defaultInputModes": ["text"],
    "defaultOutputModes": ["text"],
    "capabilities": {"streaming": False},
    "skills": [{
        "id": "seo-analysis",
        "name": "Analyse SEO",
        "description": "Évalue densité de mots-clés, longueur et structure",
        "tags": ["seo", "analyse", "contenu"],
        "examples": ["Analyse ce texte pour le SEO"]
    }]
}

def analyze_content(text, keyword):
    """Analyse SEO basique d'un contenu"""
    words = text.lower().split()
    word_count = len(words)
    
    # Densité du mot-clé principal
    keyword_count = text.lower().count(keyword.lower())
    density = (keyword_count / word_count * 100) if word_count > 0 else 0
    
    # Détection des titres (lignes commençant par #)
    headings = len(re.findall(r'^#+\s', text, re.MULTILINE))
    
    # Score basique
    score = 0
    issues = []
    
    if word_count < 300:
        issues.append("Contenu trop court (< 300 mots)")
    elif word_count >= 800:
        score += 30
    else:
        score += 15
        
    if 1.0 <= density <= 3.0:
        score += 30
    elif density < 1.0:
        issues.append(f"Densité mot-clé faible ({density:.1f}%)")
    else:
        issues.append(f"Sur-optimisation détectée ({density:.1f}%)")
        
    if headings >= 3:
        score += 20
    elif headings == 0:
        issues.append("Aucun titre détecté")
    else:
        score += 10
        
    if word_count > 0:
        score += 20  # Bonus contenu existant
    
    return {
        "word_count": word_count,
        "keyword_density": round(density, 2),
        "headings_count": headings,
        "score": min(score, 100),
        "issues": issues
    }

@app.route('/.well-known/agent.json')
def get_agent_card():
    return jsonify(AGENT_CARD)

@app.route('/task', methods=['POST'])
def handle_task():
    data = request.json
    text = data.get('content', '')
    keyword = data.get('keyword', '')
    
    if not text or not keyword:
        return jsonify({
            "status": "completed",
            "message": {"role": "agent", "parts": [{"type": "text", "text": "Erreur: contenu ou mot-clé manquant"}]}
        })
    
    analysis = analyze_content(text, keyword)
    
    response = f"""📊 ANALYSE SEO
• Nombre de mots: {analysis['word_count']}
• Densité "{keyword}": {analysis['keyword_density']}%
• Titres détectés: {analysis['headings_count']}
• Score global: {analysis['score']}/100
• Problèmes: {', '.join(analysis['issues']) if analysis['issues'] else 'Aucun'}"""
    
    return jsonify({
        "status": "completed",
        "data": analysis,
        "message": {"role": "agent", "parts": [{"type": "text", "text": response}]}
    })

if __name__ == '__main__':
    print("Agent Analyse SEO démarré sur http://localhost:10001")
    app.run(port=10001)

Étape 3 : Créer l’Agent Suggestions

Cet agent propose des améliorations basées sur l’analyse. Créez agent_seo_suggestions.py :

from flask import Flask, jsonify, request

app = Flask(__name__)

# Base de mots-clés connexes (simulée - en prod, utiliser une API comme SEMrush)
RELATED_KEYWORDS = {
    "ia": ["intelligence artificielle", "machine learning", "deep learning", "chatgpt", "automatisation"],
    "seo": ["référencement naturel", "google", "mots-clés", "backlinks", "serp"],
    "marketing": ["stratégie digitale", "content marketing", "inbound", "conversion", "leads"],
    "automatisation": ["workflow", "n8n", "zapier", "no-code", "productivité"],
    "agent": ["agents ia", "multi-agent", "autonome", "orchestration", "llm"]
}

AGENT_CARD = {
    "name": "Agent Suggestions SEO",
    "description": "Génère des recommandations et mots-clés complémentaires",
    "url": "http://localhost:10000/",
    "version": "1.0.0",
    "defaultInputModes": ["text"],
    "defaultOutputModes": ["text"],
    "capabilities": {"streaming": False},
    "skills": [{
        "id": "seo-suggestions",
        "name": "Suggestions SEO",
        "description": "Propose des mots-clés LSI et recommandations",
        "tags": ["seo", "mots-clés", "optimisation"],
        "examples": ["Suggère des mots-clés pour 'IA'"]
    }]
}

def generate_suggestions(keyword, analysis_data):
    """Génère des suggestions basées sur l'analyse"""
    suggestions = []
    related = []
    
    # Trouver mots-clés connexes
    keyword_lower = keyword.lower()
    for key, values in RELATED_KEYWORDS.items():
        if key in keyword_lower or keyword_lower in key:
            related.extend(values[:3])
    
    if not related:
        related = ["longue traîne", "intention utilisateur", "contenu enrichi"]
    
    # Suggestions basées sur les problèmes détectés
    if analysis_data:
        if analysis_data.get('word_count', 0) < 800:
            suggestions.append("Enrichir le contenu pour atteindre 800-1500 mots")
        
        density = analysis_data.get('keyword_density', 0)
        if density < 1.0:
            suggestions.append(f"Ajouter 2-3 occurrences de '{keyword}' naturellement")
        elif density > 3.0:
            suggestions.append("Réduire la répétition du mot-clé, utiliser des synonymes")
            
        if analysis_data.get('headings_count', 0) < 3:
            suggestions.append("Structurer avec des sous-titres H2/H3")
            
        if analysis_data.get('score', 0) < 60:
            suggestions.append("Ajouter une méta-description optimisée")
            suggestions.append("Inclure des liens internes pertinents")
    
    return {
        "related_keywords": related[:5],
        "suggestions": suggestions[:5]
    }

@app.route('/.well-known/agent.json')
def get_agent_card():
    return jsonify(AGENT_CARD)

@app.route('/task', methods=['POST'])
def handle_task():
    data = request.json
    keyword = data.get('keyword', '')
    analysis_data = data.get('analysis', {})
    
    result = generate_suggestions(keyword, analysis_data)
    
    response = f"""💡 SUGGESTIONS D'OPTIMISATION

🔑 Mots-clés complémentaires à intégrer:
{chr(10).join(['  • ' + kw for kw in result['related_keywords']])}

📝 Recommandations:
{chr(10).join(['  • ' + s for s in result['suggestions']])}"""
    
    return jsonify({
        "status": "completed",
        "data": result,
        "message": {"role": "agent", "parts": [{"type": "text", "text": response}]}
    })

if __name__ == '__main__':
    print("Agent Suggestions SEO démarré sur http://localhost:10000")
    app.run(port=10000)

Étape 4 : Créer l’Agent Coordinateur

Le coordinateur orchestre les deux agents pour produire un rapport complet :

import requests
from flask import Flask, jsonify, request

app = Flask(__name__)

AGENTS = {
    "analyse": "http://localhost:10001",
    "suggestions": "http://localhost:10000"
}

def discover_agent(base_url):
    """Découvre un agent via son Agent Card A2A"""
    try:
        response = requests.get(f"{base_url}/.well-known/agent.json", timeout=5)
        return response.json()
    except Exception as e:
        print(f"Erreur découverte {base_url}: {e}")
        return None

def query_agent(base_url, data):
    """Envoie une tâche à un agent"""
    try:
        response = requests.post(f"{base_url}/task", json=data, timeout=10)
        return response.json()
    except Exception as e:
        return {"error": str(e)}

@app.route('/audit', methods=['POST'])
def run_seo_audit():
    """Orchestre un audit SEO complet via A2A"""
    data = request.json
    content = data.get('content', '')
    keyword = data.get('keyword', '')
    
    if not content or not keyword:
        return jsonify({"error": "Paramètres 'content' et 'keyword' requis"}), 400
    
    # Phase 1: Découverte des agents disponibles
    print("🔍 Découverte des agents A2A...")
    available_agents = {}
    for name, url in AGENTS.items():
        card = discover_agent(url)
        if card:
            available_agents[name] = card
            print(f"  ✓ {card['name']} ({card['skills'][0]['name']})")
    
    if len(available_agents) < 2:
        return jsonify({"error": "Agents requis non disponibles"}), 503
    
    # Phase 2: Analyse du contenu
    print("📊 Lancement de l'analyse SEO...")
    analyse_response = query_agent(AGENTS["analyse"], {
        "content": content,
        "keyword": keyword
    })
    
    analysis_data = analyse_response.get("data", {})
    analyse_text = analyse_response.get("message", {}).get("parts", [{}])[0].get("text", "")
    
    # Phase 3: Génération des suggestions (basées sur l'analyse)
    print("💡 Génération des suggestions...")
    suggestions_response = query_agent(AGENTS["suggestions"], {
        "keyword": keyword,
        "analysis": analysis_data
    })
    
    suggestions_text = suggestions_response.get("message", {}).get("parts", [{}])[0].get("text", "")
    
    # Phase 4: Synthèse du rapport
    report = f"""
═══════════════════════════════════════════
       RAPPORT D'AUDIT SEO - A2A
═══════════════════════════════════════════
🎯 Mot-clé cible: {keyword}
📄 Longueur analysée: {analysis_data.get('word_count', 'N/A')} mots

{analyse_text}

{suggestions_text}

═══════════════════════════════════════════
📌 Agents utilisés: {', '.join([a['name'] for a in available_agents.values()])}
═══════════════════════════════════════════
"""
    
    return jsonify({
        "status": "completed",
        "report": report,
        "raw_data": {
            "analysis": analysis_data,
            "suggestions": suggestions_response.get("data", {})
        }
    })

if __name__ == '__main__':
    print("Agent Coordinateur SEO démarré sur http://localhost:10002")
    print("Endpoint: POST /audit avec {content, keyword}")
    app.run(port=10002)

Étape 5 : Tester le système

Ouvrez 4 terminaux et lancez chaque agent :

# Terminal 1 - Agent Suggestions
python agent_seo_suggestions.py

# Terminal 2 - Agent Analyse
python agent_seo_analyse.py

# Terminal 3 - Coordinateur
python agent_coordinateur.py

Dans le terminal 4, testez avec un contenu :

curl -X POST http://localhost:10002/audit \
  -H "Content-Type: application/json" \
  -d '{
    "keyword": "agents IA",
    "content": "# Les agents IA révolutionnent le travail\n\nLes agents IA transforment notre façon de travailler. Ces systèmes autonomes peuvent exécuter des tâches complexes.\n\n## Comment fonctionnent les agents IA\n\nUn agent IA combine un modèle de langage avec des outils et une mémoire."
  }'

Résultat attendu :

═══════════════════════════════════════════
       RAPPORT D'AUDIT SEO - A2A
═══════════════════════════════════════════
🎯 Mot-clé cible: agents IA
📄 Longueur analysée: 42 mots

📊 ANALYSE SEO
• Nombre de mots: 42
• Densité "agents IA": 4.76%
• Titres détectés: 2
• Score global: 45/100
• Problèmes: Contenu trop court (< 300 mots), Sur-optimisation détectée (4.8%)

💡 SUGGESTIONS D'OPTIMISATION

🔑 Mots-clés complémentaires à intégrer:
  • agents ia
  • multi-agent
  • autonome

📝 Recommandations:
  • Enrichir le contenu pour atteindre 800-1500 mots
  • Réduire la répétition du mot-clé, utiliser des synonymes
  • Structurer avec des sous-titres H2/H3

═══════════════════════════════════════════
📌 Agents utilisés: Agent Analyse SEO, Agent Suggestions SEO
═══════════════════════════════════════════

Vous venez de créer votre premier système multi-agents A2A fonctionnel !

---

Cas d’usage concrets du protocole A2A

Le protocole A2A ouvre des possibilités passionnantes pour automatiser des workflows complexes.

1. Assistant de voyage intelligent

Un coordinateur qui interroge :

• Agent vols (recherche de billets)
• Agent hôtels (réservation d’hébergement)
• Agent météo (prévisions)
• Agent activités (suggestions locales)

2. Service client automatisé

Un agent principal qui délègue à :

• Agent FAQ (questions fréquentes)
• Agent technique (diagnostic de problèmes)
• Agent commercial (devis, commandes)
• Agent escalade (transfert humain si nécessaire)

3. Automatisation marketing

Intégration avec des outils comme n8n pour orchestrer :

• Agent analyse de données
• Agent rédaction de contenu
• Agent SEO
• Agent publication

Si vous utilisez déjà n8n pour vos automatisations, consultez notre guide d’installation n8n pour l’intégrer avec des agents A2A.

---

Aller plus loin avec A2A

Utiliser le SDK officiel Python

Pour des projets de production, utilisez le SDK officiel :

pip install a2a-sdk

from a2a.types import AgentCard, AgentSkill, AgentCapabilities
from a2a.server import A2AServer

skill = AgentSkill(
    id="my-skill",
    name="Mon Skill",
    description="Description du skill",
    tags=["exemple"],
    inputModes=["text"],
    outputModes=["text"]
)

agent_card = AgentCard(
    name="Mon Agent",
    description="Description de l'agent",
    url="http://localhost:9999/",
    version="1.0.0",
    capabilities=AgentCapabilities(),
    skills=[skill]
)

Intégrer avec l’Agent Development Kit (ADK)

Google propose l’ADK qui simplifie la création d’agents A2A :

from adk import to_a2a

# Convertit automatiquement un agent ADK en agent A2A
a2a_app = to_a2a(mon_agent)

Frameworks compatibles

A2A fonctionne avec les principaux frameworks d’agents IA :

• LangGraph
• CrewAI
• Semantic Kernel
• AutoGen

Découvrez d’autres agents IA autonomes sur notre annuaire pour vous inspirer.

---

Ce qu’il faut retenir

Le protocole A2A marque un tournant dans l’écosystème des agents IA. En permettant une communication standardisée entre agents, il ouvre la voie à des systèmes multi-agents vraiment interopérables.

Points clés :

• A2A est un standard ouvert géré par la Linux Foundation
• Il complète le MCP (outils) avec la communication agent-agent
• Chaque agent expose une “carte de visite” (Agent Card) pour la découverte
• La communication se fait en JSON-RPC sur HTTP
• Compatible avec tous les frameworks majeurs

Pour démarrer :

1. Commencez par créer des agents simples comme dans ce tutoriel
2. Testez la découverte automatique via les Agent Cards
3. Progressez vers des cas d’usage plus complexes

Le protocole est encore jeune (version 0.3 en juillet 2025), mais l’écosystème grandit rapidement avec plus de 150 organisations partenaires dont Adobe, Salesforce, SAP et ServiceNow.

---

FAQ

---

Ressources

• Documentation officielle A2A
• GitHub A2A Project
• Tutoriel Python A2A
• Comprendre le MCP
• Catégorie Agents IA sur IA-Insights

---

Vous avez testé le protocole A2A ? Partagez votre expérience en commentaire !