Aller au contenu
Guide

MCP vs A2A : choisir le bon protocole d'agent IA

| 9 min read

MCP connecte les modèles d'IA aux outils. A2A connecte les agents IA les uns aux autres. Comparez l'architecture, l'authentification, le format de message et l'adoption pour choisir le bon protocole.

Robot representing AI agent communication
Photo by Alex Knight on Unsplash

Votre agent IA doit appeler une API de recherche DNS. Il doit également confier une tâche de recherche à un agent distinct sur un autre serveur. Ce sont deux problèmes différents, et l’industrie a construit deux protocoles différents pour les résoudre : PCM (Model Context Protocol) d’Anthropic et A2A (Agent à Agent) de Google.

Les développeurs ne cessent de demander lequel choisir. La réponse : ils résolvent différents problèmes. MCP connecte un modèle aux outils. A2A connecte les agents aux agents. Ce guide décrit l'architecture, le format des messages, le modèle d'authentification et l'adoption de chaque protocole afin que vous puissiez faire le bon appel pour votre système.

MCP en 60 secondes

MCP est un protocole ouvert qui permet aux modèles d'IA d'accéder à des outils et des données externes. Considérez-le comme un port USB-C pour l’IA : une interface standard, de nombreux outils. Le modèle envoie une requête JSON-RPC décrivant quel outil appeler et avec quels paramètres. Le serveur MCP exécute l'outil et renvoie des données structurées.

Voici à quoi ressemble un appel d'outil MCP sur le fil : 

// MCP tool call: model asks the server to execute a tool
{
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "name": "lookup_dns",
    "arguments": {
      "domain": "stripe.com",
      "type": "MX"
    }
  },
  "id": 1
}

// MCP tool result: server returns structured data
{
  "jsonrpc": "2.0",
  "result": {
    "content": [
      {
        "type": "text",
        "text": "{\"domain\":\"stripe.com\",\"type\":\"MX\",\"records\":[{\"priority\":1,\"value\":\"aspmx.l.google.com\",\"ttl\":300}]}"
      }
    ]
  },
  "id": 1
}

Le modèle ne touche jamais directement le réseau. Il décrit l'intention (« rechercher les enregistrements MX pour stripe.com ») et le serveur MCP gère l'exécution. Cela maintient le modèle en mode bac à sable tout en lui donnant accès aux données du monde réel.

Botoi exécute un serveur MCP sur api.botoi.com/mcp avec 49 outils de développement. Connectez-le à Claude, Cursor ou VS Code en une seule ligne : 

# Connect botoi's 49 tools via MCP in one command
claude mcp add botoi --transport streamable-http https://api.botoi.com/mcp

# Now your agent can call tools like:
# lookup_dns, lookup_whois, ssl_check, jwt_sign,
# pii_detect, email_validate, hash, uuid_generate,
# json_format, base64_encode, and 39 more

A2A en 60 secondes

A2A est un protocole ouvert pour la communication d'agent à agent. Là où MCP connecte un modèle à des outils, A2A connecte un agent à d'autres agents. Chaque agent publie une « Carte d'agent » sur une URL bien connue décrivant ses compétences, ses capacités et ses exigences d'authentification. D'autres agents découvrent cette carte et envoient des tâches.

Voici une carte d'agent : 

// A2A Agent Card: published at /.well-known/agent.json
{
  "name": "invoice-processor",
  "description": "Extracts line items from PDF invoices and returns structured data",
  "url": "https://agents.example.com/invoice",
  "version": "1.0.0",
  "capabilities": {
    "streaming": true,
    "pushNotifications": false
  },
  "skills": [
    {
      "id": "extract-invoice",
      "name": "Extract Invoice Data",
      "description": "Parses a PDF invoice and returns line items as JSON"
    }
  ],
  "authentication": {
    "schemes": ["bearer"]
  }
}

Et voici comment un agent envoie une tâche à un autre : 

// A2A task/send: one agent asks another to do work
{
  "jsonrpc": "2.0",
  "method": "tasks/send",
  "params": {
    "id": "task-abc-123",
    "message": {
      "role": "user",
      "parts": [
        {
          "type": "text",
          "text": "Extract line items from this invoice PDF"
        },
        {
          "type": "file",
          "mimeType": "application/pdf",
          "uri": "https://storage.example.com/invoices/2026-march.pdf"
        }
      ]
    }
  },
  "id": 2
}

La principale différence avec MCP : les tâches A2A sont opaques. L'agent appelant ne sait pas ni ne contrôle la manière dont l'agent destinataire effectue le travail. Il pourrait utiliser des outils MCP, appeler d'autres agents via A2A ou exécuter une logique propriétaire. A2A définit le contrat entre agents, pas entre un modèle et un outil.

Tableau comparatif

Dimension MCP (protocole de contexte de modèle) A2A (agent à agent)
Créé par Anthropique (novembre 2024) Google (avril 2025)
Objectif principal Connectez les modèles d'IA aux outils et aux données Connectez les agents IA les uns aux autres
Modèle de communication Outil d'appels de modèles, obtient le résultat L'agent délègue la tâche à l'agent
Format de fil JSON-RPC 2.0 JSON-RPC 2.0
Transport stdio (local), Streamable HTTP (à distance) HTTPS
Découverte Le serveur expose la liste d'outils via tools/list L'agent publie la carte d'agent sur /.well-known/agent.json
Modèle d'authentification Défini par le serveur (clé API, OAuth, aucune) Agent Card déclare les schémas (porteur, OAuth 2.0, clé API)
Streaming Événements envoyés par le serveur pour les résultats de l'outil Événements envoyés par le serveur pour les mises à jour de tâches
État Sans état ou basé sur une session Cycle de vie des tâches (soumis, en cours, terminés, échoués)
Multimodal Résultats des outils basés sur du texte Texte, fichiers, images, données structurées dans les parties du message
Portée d'exécution Appel d'outil unique avec entrées/sorties définies Tâche à durée indéterminée ; l'agent décide comment le compléter

Architecture : comment elles s'articulent

MCP fonctionne au niveau de la couche outil. A2A fonctionne au niveau de la couche orchestration. Dans un système multi-agents, l'orchestrateur utilise A2A pour déléguer des tâches à des agents spécialisés. Chaque spécialiste utilise MCP pour accéder à ses outils. 

Orchestrator Agent (A2A client)
  |
  |-- A2A task/send --> Research Agent
  |                        |-- MCP tools/call --> lookup_dns
  |                        |-- MCP tools/call --> lookup_whois
  |                        |-- MCP tools/call --> ssl_check
  |
  |-- A2A task/send --> Compliance Agent
  |                        |-- MCP tools/call --> pii_detect
  |                        |-- MCP tools/call --> email_validate
  |
  |-- A2A task/send --> Report Agent
                           |-- MCP tools/call --> markdown_to_html
                           |-- MCP tools/call --> pdf_from_html

L'agent orchestrateur reçoit une requête du type « auditer la posture de sécurité de example.com ». Il divise cela en sous-tâches et les délègue via A2A : un agent recherche DNS et SSL, un autre vérifie l'exposition des informations personnelles, un troisième compile le rapport. Chaque agent utilise MCP pour appeler les outils spécifiques dont il a besoin.

MCP et A2A ne sont pas en concurrence. MCP répond : « Comment mon agent utilise-t-il les outils ? » A2A répond « comment mes agents se parlent-ils ? » La plupart des systèmes multi-agents de production ont besoin des deux.

Quand utiliser MCP

  • Votre modèle d'IA doit appeler des API, interroger des bases de données ou lire des fichiers
  • Vous souhaitez un agent unique ayant accès à de nombreux outils (comme les 49 outils du serveur Botoi MCP)
  • Vous avez besoin d'appels d'outils déterministes avec des schémas d'entrée/sortie définis
  • Vous construisez dans une limite de confiance unique ; le modèle et les outils appartiennent au même système
  • Vous souhaitez un support client étendu : Claude Desktop, Claude Code, Cursor, VS Code, Windsurf et ChatGPT prennent tous en charge MCP.

Quand utiliser A2A

  • Vous avez plusieurs agents qui doivent se déléguer du travail
  • Les agents dépassent les limites de l'organisation (votre agent parle à l'agent d'un fournisseur)
  • Les tâches sont illimitées ; l'agent appelant ne prescrit pas comment le travail est effectué
  • Vous avez besoin d'un cycle de vie des tâches avec suivi du statut (soumis, en cours, terminé, échoué)
  • Les agents échangent du contenu riche : des fichiers, des images et des données structurées, pas des paramètres d'outils.

Modèles d'authentification et de confiance

MCP a une histoire d'authentification simple. Le serveur MCP décide de sa propre authentification. Certains serveurs n'ont pas besoin d'authentification (accès au système de fichiers local). D'autres nécessitent une clé API ou un jeton OAuth. Le client transmet les informations d'identification dans les en-têtes. Il n'y a pas de négociation d'authentification au niveau du protocole.

A2A intègre l'authentification dans la couche de découverte. Chaque carte d'agent déclare ses schémas d'authentification pris en charge. L'agent appelant lit la carte, choisit un schéma et s'authentifie avant d'envoyer des tâches. Cela fonctionne bien pour les scénarios inter-organisationnels dans lesquels les agents doivent négocier la confiance au moment de l'exécution.

Pour le serveur Botoi MCP, l'accès anonyme vous donne 5 requêtes par minute et 100 par jour. Ajoutez une clé API dans le Authorization en-tête pour les limites supérieures : 

{
  "mcpServers": {
    "botoi": {
      "type": "streamable-http",
      "url": "https://api.botoi.com/mcp"
    }
  }
}

Adoption en 2026

MCP a une longueur d’avance. Anthropic a livré MCP en novembre 2024 et, début 2026, tous les principaux assistants de codage d'IA le prennent en charge. Claude Desktop, Claude Code, Cursor, VS Code (GitHub Copilot), Windsurf et ChatGPT agissent tous en tant que clients MCP. L'écosystème compte des milliers de serveurs MCP couvrant les bases de données, les API, les systèmes de fichiers, les navigateurs et les outils de développement.

A2A est plus récent. Google a publié la spécification en avril 2025. L'adoption se développe dans les environnements d'entreprise où l'orchestration multi-agents est importante : automatisation de la chaîne d'approvisionnement, pipelines de traitement de documents et systèmes de service client avec des agents spécialisés. Le mécanisme de découverte de la carte d'agent facilite la création de marchés et d'annuaires d'agents.

Si vous construisez aujourd'hui un système d'appel d'outils mono-agent, MCP possède l'écosystème. Si vous créez une orchestration multi-agents, A2A fournit la couche de coordination dont vous avez besoin.

Un exemple concret de MCP : les 49 outils de Botoi

Le serveur MCP de Botoi sur api.botoi.com/mcp montre à quoi ressemble MCP en production. Il expose 49 outils de développement sélectionnés dans cinq catégories :

Catégorie Compter Exemples d'outils
Chercher 12 dns_lookup, whois_lookup, ssl_check, email_validate, tech_detect
Texte et données 10 json_format, base64_encode, csv_to_json, markdown_to_html
Développeuse 12 jwt_sign, uuid_generate, hachage, cron_describe, regex_test
Sécurité 5 aes_encrypt, pii_detect, totp_generate, credit_card_validate
Transformer 5 minify_js, sql_format, code_format, json_to_typescript

Le serveur utilise le transport HTTP Streamable, s'exécute sur Cloudflare Workers en périphérie et ne nécessite aucune configuration au-delà de la configuration sur une seule ligne. Chaque outil possède un schéma d'entrée typé et renvoie du JSON structuré. Le manifeste complet de l'outil se trouve à api.botoi.com/v1/mcp/tools.json.

Il s'agit essentiellement de MCP : un serveur, de nombreux outils, des E/S structurées et un protocole standard auquel tout client compatible peut se connecter.

Cadre décisionnel

Posez ces trois questions :

  1. Votre modèle d’IA a-t-il besoin de faire appel à des outils externes ? Utilisez MCP. Connectez-vous à un serveur MCP (ou créez le vôtre) et votre modèle bénéficie d'un accès structuré aux outils.
  2. Avez-vous plusieurs agents qui doivent collaborer ? Utilisez A2A. Publiez des cartes d'agent, envoyez des tâches et suivez leur cycle de vie.
  3. Avez-vous les deux ? Utilisez les deux. A2A au niveau de la couche orchestration, MCP au niveau de la couche outil. Ils opèrent à différents niveaux et n’entrent pas en conflit.

Le choix n’est pas MCP ou A2A. Il s'agit de MCP, A2A ou MCP + A2A, selon la complexité de votre système. Commencez par MCP si vous avez besoin d’accéder aux outils. Ajoutez A2A lorsque vous avez besoin d’une coordination d’agents.

Commencez avec MCP

Connectez votre assistant IA à 49 outils de développement via le serveur Botoi MCP. Vérifiez le Documents de configuration MCP pour les configurations pour Claude Desktop, Claude Code, Cursor, VS Code et Windsurf. Parcourez le Documents sur l'API pour la liste complète de plus de 150 points de terminaison derrière le serveur MCP.

FAQ

Quelle est la différence entre MCP et A2A ?
MCP (Model Context Protocol) connecte un modèle d'IA à des outils et sources de données externes. A2A (Agent-to-Agent) connecte des agents d'IA indépendants entre eux afin qu'ils puissent déléguer des tâches, échanger des résultats et collaborer. MCP résout l’accès aux outils. A2A résout la coordination des agents. Ils ciblent différentes couches d’un système d’IA et peuvent fonctionner ensemble.
MCP et A2A peuvent-ils fonctionner ensemble dans le même système ?
Oui. Un modèle courant utilise A2A pour la communication entre agents au niveau de la couche d'orchestration, tandis que chaque agent utilise MCP pour accéder à ses propres outils et sources de données. L'agent orchestrateur délègue les tâches via A2A. Les agents spécialisés exécutent ces tâches en appelant les outils MCP. Les deux protocoles fonctionnent sur des couches différentes et n'entrent pas en conflit.
Quel protocole dois-je choisir pour mon application IA ?
Si votre modèle d'IA doit appeler des API externes, interroger des bases de données ou lire des fichiers, utilisez MCP. Si vous disposez de plusieurs agents IA qui doivent se déléguer du travail au-delà des limites de l’équipe ou de l’organisation, utilisez A2A. La plupart des systèmes de production qui dépassent le cadre d’un seul agent finissent par utiliser les deux.
Le MCP est-il uniquement destiné aux modèles Anthropic et A2A uniquement aux modèles Google ?
Non, les deux sont des protocoles ouverts. MCP fonctionne avec Claude, GPT, Gemini, Llama et tout modèle prenant en charge l'appel d'outils. A2A fonctionne avec n'importe quel environnement d'exécution d'agent, quel que soit le modèle sous-jacent. Anthropic a créé MCP et Google a créé A2A, mais aucun des deux protocoles n'est verrouillé par son créateur.
Quel transport chaque protocole utilise-t-il ?
MCP prend en charge stdio pour les serveurs d'outils locaux et Streamable HTTP (JSON-RPC 2.0) pour les serveurs distants. A2A utilise HTTPS avec JSON-RPC 2.0 pour toutes les communications. Les deux protocoles s'appuient sur JSON pour le formatage des messages. MCP prend également en charge les événements envoyés par le serveur pour les résultats de l'outil de streaming.

Commencez a construire avec botoi

150+ endpoints API pour la recherche, le traitement de texte, la generation d'images et les utilitaires pour developpeurs. Offre gratuite, sans carte bancaire.

Voir la documentation API Voir tous les outils