A2A 与其他协议的初步比较：MCP 和更多

摘要：A2A（Agent2Agent）协议为企业 AI 代理的互操作性提供了标准化框架，但它并非唯一的解决方案。Anthropic 的 Model Context Protocol（MCP）等协议也在尝试解决 AI 系统间的协作问题。本文深入比较 A2A 与 MCP，分析它们的设计目标、技术架构和适用场景，同时简要提及其他协议（如 Language Server Protocol）。通过 GitHub 仓库的实现、MCP 文档的细节和 Mermaid 图表，我们将揭示 A2A 的独特优势与局限，为开发者提供硬核的技术洞察。

1. 引言：AI 协作协议的竞争格局

随着 AI 代理在企业中的普及，协作与互操作性成为关键挑战。Google 的 A2A（Agent2Agent） 协议通过代理间通信（Agent-to-Agent Communication）打破孤岛，而 Anthropic 的 Model Context Protocol（MCP） 则专注于连接 AI 模型与外部数据源和工具。两者都旨在提升 AI 系统的协同能力，但目标和实现方式截然不同。

此外，AI 领域还有其他协议，例如 Language Server Protocol（LSP）为开发工具提供了灵感。这些协议的出现反映了行业对标准化协作的迫切需求。本文将以 A2A 和 MCP 为重点，结合 Google A2A GitHub 仓库和 MCP 官方文档，深入对比它们的架构、功能和生态影响。

2. A2A 概述：代理间的协作标准

如前几篇所述，A2A 是 Google 主导的开源协议，专注于 代理间通信。其核心设计包括：

AgentCard：代理的元数据，描述名称、能力（如文本、表单、音视频）和通信端点。
任务（Task）：代理间的工作单元，遵循状态生命周期（Created → In Progress → Completed/Failed）。
动态协商：代理通过 AgentCard 交换信息，运行时协商交互模式。
通信机制：支持 HTTP 和 WebSocket，兼顾简单任务和实时流。

A2A 的目标是让不同供应商、框架的代理（如费用报销、汇率转换代理）无缝协作，类似互联网的 HTTP 协议。以下是 A2A 的架构示意图：

graph TD
    A[User] -->|提交任务| B[Host Agent]
    B -->|AgentCard 交换| C[Remote Agent 1]
    B -->|AgentCard 交换| D[Remote Agent 2]
    C -->|任务执行| E[A2A Protocol]
    D -->|任务执行| E
    E -->|结果返回| B
    B -->|汇总结果| A

3. MCP 概述：AI 与工具的连接器

根据 MCP 官方文档，Model Context Protocol（MCP）是 Anthropic 推出的开源协议，旨在 标准化 AI 模型与外部数据源和工具的交互。MCP 将 AI 应用比作“USB-C 端口”，为模型提供统一的接口，连接数据库、API、文件系统等资源。核心特性包括：

客户端-服务器模型：AI 应用（Host，如 Claude Desktop）作为客户端，连接到 MCP 服务器（提供工具或数据）。
工具调用：MCP 服务器注册工具（如天气查询、GitHub API），AI 模型动态调用。
传输层：支持标准输入输出（stdio）、Server-Sent Events（SSE）和 JSON-RPC，适配不同环境。
动态发现：客户端查询服务器的工具列表，运行时决定调用方式。

MCP 的目标是增强 AI 模型的上下文访问能力，例如让 Claude 查询实时天气或分析 GitHub 代码。以下是 MCP 的架构示意图：

graph TD
    A[AI Application] -->|MCP Client| B[MCP Server]
    B --> C[Tool: Weather API]
    B --> D[Tool: GitHub API]
    B --> E[Tool: File System]
    A -->|查询工具| B
    B -->|返回工具列表| A
    A -->|调用工具| B
    B -->|工具结果| A

4. A2A vs. MCP：硬核对比

4.1 设计目标

A2A：聚焦 代理间通信，目标是让多个 AI 代理（Host 和 Remote）像人类一样协作、分工完成复杂任务。例如，一个 Host Agent 协调费用报销和汇率转换代理，组成工作流。
MCP：聚焦 AI 与工具的交互，目标是让 AI 模型（LLM）通过标准化接口访问外部资源。例如，Claude 调用 MCP 服务器查询数据库或执行 Web 搜索。

差异：A2A 强调代理间的对等协作（Peer-to-Peer），而 MCP 更像客户端（AI）对服务器（工具）的单向调用。社交媒体上对此的讨论也反映了这一点：A2A 被视为代理协作协议，MCP 则更像工具调用框架。

4.2 技术架构

A2A：
- 协议核心：基于 JSON Schema（a2a.json），定义 AgentCard 和 Task 结构。
- 通信：HTTP（同步任务）和 WebSocket（实时流、推送通知）。
- 动态性：通过 AgentCard 的 capabilities（如 interactionModes）支持多模态协商（文本、表单、音视频）。
- 认证：AgentAuthentication 支持简单方案（如 Bearer），未来计划扩展（参考 GitHub Issues）。
- 示例：GitHub 仓库的 google_adk 展示了费用报销代理的端到端实现。
MCP：
- 协议核心：基于 JSON-RPC 2.0，定义工具注册和调用接口（参考 MCP 规范)。
- 通信：支持 stdio（本地工具）、SSE（实时流）和 HTTP（远程调用）。
- 动态性：客户端通过 list_tools 请求获取服务器的工具列表，动态调用（如 get-alerts 或 fetch_pr_changes）。
- 认证：当前依赖外部机制（如 API 密钥），规范中提到未来支持更复杂的授权。
- 示例：MCP 仓库的 Python SDK（modelcontextprotocol/python-sdk）展示了天气查询和 BMI 计算工具。

差异：A2A 的架构更偏向分布式系统，强调代理间的状态管理和协商；MCP 更像轻量级 RPC 框架，专注于工具的快速调用。A2A 的多模态支持（音视频）比 MCP 的文本/数据优先设计更灵活，但 MCP 的传输层（stdio、SSE）更适合本地和轻量场景。

以下是两者的通信流程对比：

graph TD
    subgraph A2A
        A1[Host Agent] -->|HTTP/WebSocket| A2[Remote Agent]
        A1 -->|AgentCard 交换| A3[Remote Agent]
        A2 -->|任务结果| A1
        A3 -->|任务结果| A1
    end
    subgraph MCP
        M1[AI Client] -->|stdio/SSE| M2[MCP Server]
        M1 -->|list_tools| M2
        M2 -->|工具列表| M1
        M1 -->|调用工具| M2
        M2 -->|工具结果| M1
    end

4.3 适用场景

A2A：
- 企业工作流：协调多个代理完成复杂任务，例如财务审批 + 汇率转换 + 报表生成。
- 跨供应商协作：连接 Google、AWS、Microsoft 的代理，打破平台壁垒。
- 多模态交互：支持文本、表单、音视频，适配客服、教育等场景。
- 示例：一个 Host Agent 收集用户表单，调用 Remote Agent 验证数据并生成视频报告。
MCP：
- 工具集成：为 AI 模型提供外部上下文，例如 Claude 查询 GitHub PR 或 Notion 页面。
- 开发环境：增强 IDE（如 VS Code、Zed Editor）或桌面应用（如 Claude Desktop）的 AI 能力。
- 实时数据：支持天气查询、Web 搜索等动态数据源。
- 示例：Claude 通过 MCP 服务器分析 GitHub 代码变更，生成 PR 评审。

差异：A2A 更适合需要多个代理协同的分布式场景，MCP 更适合单 AI 模型增强上下文的场景。例如，A2A 可以构建一个代理网络，MCP 则更像给 Claude 加装“插件”。

4.4 生态与社区

A2A：
- 开源生态：托管于 GitHub，得到 Articul8、Arize AI 等企业支持，提供 Python 和 JavaScript 示例（samples/python/agents/google_adk）。
- 社区动态：开发者通过 GitHub Issues 讨论认证优化和流式传输改进。
- 采用前景：作为 Google 主导的协议，可能与 Google Cloud 深度整合，吸引企业用户。
MCP：
- 开源生态：托管于 GitHub（modelcontextprotocol/servers），支持多种 SDK（Python、Java、Kotlin、C#），集成工具如 GitHub、Notion、Slack。
- 社区动态：得到 Sourcegraph、Zed Editor 等开发工具支持，社区活跃于服务器开发（例如 server-brave-search）。
- 采用前景：Anthropic 的背书使其在 LLM 开发者中更具吸引力，尤其在 Claude 生态。

差异：A2A 的生态偏向企业级协作，MCP 更聚焦开发者工具和 LLM 集成。社交媒体提到，MCP 的工具调用特性更易上手，但 A2A 的代理协作更适合复杂场景。

5. 其他协议：LSP 和更多

5.1 Language Server Protocol（LSP）

LSP 是为代码编辑器设计的协议，标准化了语言服务器与 IDE 的交互（例如 VS Code 的代码补全）。MCP 明确提到受 LSP 启发，两者的相似性包括：

客户端-服务器模型：IDE（客户端）调用语言服务器（工具）。
动态发现：服务器声明支持的功能（如补全、诊断）。

与 A2A 的对比：

A2A 更通用，面向所有 AI 代理，而 LSP 局限于开发工具。
A2A 的多模态协商（音视频）比 LSP 的文本优先设计更灵活。
A2A 的任务生命周期支持复杂工作流，LSP 更适合单次请求。

5.2 其他协议

Open“Web Applets”：类似 MCP 的工具调用协议，强调 AI 代理的小型应用集成，但缺乏 A2A 的代理协商能力。
REST/gRPC：传统 API 协议，适合静态交互，但无法满足 AI 代理的动态需求。

6. 代码示例：A2A 与 MCP 的协作

为了展示 A2A 和 MCP 的潜在互补性，我们实现一个场景：A2A 协调代理，MCP 提供工具支持。假设一个费用报销代理（A2A）调用 MCP 服务器查询实时汇率。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
# A2A 费用报销代理，集成 MCP 汇率工具
from a2a import A2AServer, A2AClient, AgentCard, Task
from mcp.client import MCPClient

class ExpenseAgent(A2AServer):
    def __init__(self):
        card = AgentCard(
            name="ExpenseAgent",
            description="Processes expense reimbursements with real-time forex",
            url="http://localhost:8080/a2a",
            capabilities={"interactionModes": ["text"]}
        )
        super().__init__(card=card)
        self.mcp_client = MCPClient("http://localhost:9000/mcp")  # MCP 服务器

    async def handle_task(self, task: Task) -> dict:
        if task["type"] != "expense":
            return {"status": "failed", "error": "Invalid task type"}

        amount = task["data"]["amount"]
        currency = task["data"]["currency"]

        # 通过 MCP 查询汇率
        mcp_result = await self.mcp_client.request({
            "method": "convert_currency",
            "params": {"amount": amount, "from": currency, "to": "USD"}
        })

        if mcp_result["status"] == "success":
            usd_amount = mcp_result["result"]
            return {
                "status": "completed",
                "result": f"Approved {usd_amount} USD"
            }
        return {
            "status": "failed",
            "error": mcp_result["error"]
        }

if __name__ == "__main__":
    server = ExpenseAgent()
    server.run(port=8080)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
# MCP 汇率服务器（简化版）
from mcp.server import MCPServer

class ForexServer(MCPServer):
    def __init__(self):
        super().__init__(name="ForexServer", version="1.0")

    @tool("convert_currency")
    async def convert_currency(self, params: dict) -> dict:
        amount = params["amount"]
        from_currency = params["from"]
        to_currency = params["to"]
        # 模拟汇率转换
        rate = 1.2 if from_currency == "EUR" else 1.0
        converted = amount * rate
        return {"status": "success", "result": converted}

if __name__ == "__main__":
    server = ForexServer()
    server.run(port=9000)