【万文超详A2A 协议】从个体赋能到群体智能，智能体间的“TCP/IP协议“

A2A协议：智能体协作的"TCP/IP"标准 A2A协议旨在解决智能体协作中的关键痛点，包括框架不兼容、厂商壁垒和数据隔离等问题。作为智能体间的"TCP/IP协议"，A2A基于Apache2.0开源许可，定义了统一的通信、协作与协商规则。核心架构包含四大组件（Client、Server、Executor、Agent）和三层协议栈（应用层、表示层、传输层）。

名为沙丁鱼的猫446

1160人浏览 · 2026-01-19 19:52:28

名为沙丁鱼的猫446 · 2026-01-19 19:52:28 发布

一、核心认知：A2A 协议到底解决什么问题？˚𝜗𝜚🍒ᝰ.ᐟ

在 A2A 出现前，智能体协作面临三大核心痛点：

🔴框架不兼容：LangGraph、CrewAI、Google ADK 等框架各自为战，智能体间缺乏统一通信接口；

🟡框架锁定：LangChain 开发的 Agent 无法与 LlamaIndex 开发的 Agent 直接对话。

🟢 厂商壁垒：Salesforce 的 Agent 无法直接指挥Workday 的 Agent 工作。

🔵数据隔离：Agent 难以跨越企业内部 CRM、ERP 、HRM 等多个系统。

🟣协作无标准：不同厂商的智能体（如 Salesforce 销售智能体、SAP 财务智能体）无法直接委托任务；

🔴隐私难保障：协作时需暴露内部逻辑或数据，存在商业机密泄露风险。

最大问题：如何让这些身怀绝技的 Agent 突破壁垒， 形成一个高效的协作网络？

因此，A2A 协议的本质的是智能体间的 “TCP/IP 协议”—— 它基于 Apache 2.0 开源许可，定义了统一的通信、协作与协商规则，让任何智能体无论出身（厂商、框架），都能像人类团队一样分工协作，且无需暴露内部实现细节。

A2A 开源项目：https://github.com/a2aproject/A2A

二、架构解密：A2A 的核心组件与通信模型˚𝜗𝜚🍒ᝰ.ᐟ

A2A 的架构设计遵循 “简单高效、兼容现有技术栈” 的原则，核心由 “四大组件 + 三层协议栈” 构成

2.1 四大核心组件˚𝜗𝜚🍒ᝰ.ᐟ

🔴A2A Client：任务发起方，可为任意框架开发的智能体（如 LangChain 构建的代码分析智能体）；

🟡A2A Server：提供服务的智能体服务端，通常基于 uvicorn/FastAPI 搭建；

🔵AgentExecutor：核心 “任务执行器”，负责接收 HTTP 请求、解析任务，是连接 Server 与实际 Agent 的中间枢纽；

🟣Agent：任务实际执行者，可通过 LangGraph、Vertex AI ADK、CrewAI 等任意框架实现。

这一架构的关键优势是解耦——Client 无需关心 Server 端 Agent 的实现框架，只需通过标准接口通信，极大降低了集成成本。

2.2 A2A架构˚𝜗𝜚🍒ᝰ.ᐟ

通信模型：采用 Client- Server 架构。

🔴 Client-Agent: 发起任务的 Agent。

🟡Remote-Agent: 接收并执行任务的 Agent（服务）。

协议栈：

🔴应用层: A2A 协议 (定义任务、消息、状态等)。

🟡表示层: JSON-RPC 2.0 (封装请求/响应的格式，如 {"method": "tasks/send", ...} )。

🟢传输层: HTTP(S) (用于请求-响应) & SSE (用于服务端流式推送)。

内部组件：

🔴AgentExecutor: 接收 HTTP 请求，解析 JSON-RPC，调用 Agent 实现。

🟡Agent: 任务的实际执行者 (可用 LangGraph, Vertex AI ADK, CrewAI 等任何框架实现)。

2.3 关键组件：Agent Card（智能体的 “数字名片”）˚𝜗𝜚🍒ᝰ.ᐟ

🔴是什么: 一个标准化的 JSON 文件，用于声明 Agent 的能力与身份。

🟡位置: 通常发布在服务的公开入口 /.well-known/agent.json。

🟢作用: 实现动态能力发现 (Capability Discovery)。Client Agent 在协作前，可通过 HTTP GET 请求读取此文件，自动了解如何与 Remote Agent 通信，无需人工配置。

🔵核心内容: name, description: 身份信息。

url: A2A 服务端接口的基址 URL。

version: 协议版本。

capabilities: 支持的协议能力 (如 streaming, pushNotifications)。

authentication: 所需的身份认证方案 (如 bearer for OAuth2, apiKey)。

示例：Agent Card JSON 结构

{
  "name": "CalendarAgent",
  "description": "管理用户日历的智能体",
  "url": "http://localhost:8000/a2a",
  "version": "1.0.0",
  "capabilities": {"streaming": true, "pushNotifications": false},
  "authentication": {"schemes": ["apiKey"]},
  "skills": [
    {
      "id": "check_availability",
      "name": "检查时间段空闲状态",
      "examples": ["我明天上午10点有空吗？"]
    }
  ]
}

三、实战核心：A2A 协议的交互流程与代码实现˚𝜗𝜚🍒ᝰ.ᐟ

A2A 的交互围绕 “任务（Task）” 展开，核心流程分为 “发现 - 发送任务 - 推送通知 - 响应” 四步，下面结合 Python 实战代码拆解关键环节。

3.1 核心交互四要素˚𝜗𝜚🍒ᝰ.ᐟ

1. Task (任务): 整个交互的顶层容器，代表一次完整的工作。它有唯一的任务 ID（ taskId ）和状态（submitted, working, input，required, completed, failed, canceled ）。

2. Message (消息): 任务过程中客户端与服务端之间的单次对话。它有 role（user 或 agent）来区分发送方。一个任务可以包含多条消息。

3. Part (内容部件): 消息和产出物的基本组成单元，用于承载具体内容，如文本（TextPart）、文件（FilePart）或结构化数据（DataPart）。这使得 A2A 协议具备了强大的多模态能力。

4. Artifact (工件/产出物): 任务执行完成后最终生成的成果，例如一份报告、一张图片或一个数据集。其结构与消息类似，也由一个或多个 Part 组成。

3.2 A2A 交互流程详解：˚𝜗𝜚🍒ᝰ.ᐟ

1.Discovery (发现阶段)˚𝜗𝜚🍒ᝰ.ᐟ

🔴如图所示：客户端指向服务端的第一条箭头，旁边有 “Agent Card” (代理名片) 图标。

🟡流程说明: 这是交互的起点。在客户端向服务端分配任何具体任务之前，它首先需要“发现”服务端代理，并了解其能力。这个 “Agent Card” 形象地表示了服务端的元信息，比如：代理的名称和描述。它能执行什么类型的任务（例如，数据分析、代码生成、文档撰写等）。它接受什么格式的输入。

🟢技术关联: 这一步是建立连接和协商能力的基础，确保客户端发送的任务是服务端可以理解和处理的。

3.3.2 Send Task (发送任务)˚𝜗𝜚🍒ᝰ.ᐟ

🔴如图所示：客户端向服务端发送一个包含 Task -> Message - > Part 嵌套结构的数据包。

🟡流程说明: 客户端发起一个具体的工作请求。这个请求被封装成一个 Task。这个任务的初始内容是一条 Message，其 role 被设为“user”。

🟢这条消息由一个或多个 Part 组成。例如，用户输入 “帮我分析这份销售数据并生成图表”，这条请求可能包含一个 TextPart（文字指令）和一个 FilePart（包含销售数据的CSV 文件）。

🔵技术关联: 服务端收到后，会创建一个任务实例，并为其分配一个唯一的 taskId。此时，服务端可以立即向客户端推送一个 Task 对象或 TaskStatusUpdateEvent，将任务状态置为 submitted，告知客户端：“任务已收到并进入队列”。

3.3.3 Push Notifications (推送通知)˚𝜗𝜚🍒ᝰ.ᐟ

🔴如图所示: 从服务端指向客户端的多条虚线箭头。

🟡流程说明: 这一阶段体现了 A2A 交互的异步和流式特性。一旦任务开始执行（状态变为working），服务端会持续向客户端推送通知，让客户端实时了解任务进展。这些通知可以是：

🟢TaskStatusUpdateEvent: 状态更新事件。例如，从 submitted -> working。如果任务需要用户提供额外信息（如“请确认图表类型”），状态会变为 input-required ，任务暂停等待客户端回复。

🔵TaskArtifactUpdateEvent (中间产出): 任务过程中产生的中间结果，比如报告的提纲、生成的部分代码等，可以作为临时的 Artifact 推送给客户端。

🟣Message: 服务端代理也可以发送 role 为 “agent” 的消息，用于进行对话式交流，例如 “我正在网上搜索相关资料 …”。

技术关联: 这种流式通信通常通过 Server-Sent Events (SSE) 实现，允许服务端单向地、持续地向客户端发送数据，非常适合长任务

3.2.4 Response (响应/成果交付)˚𝜗𝜚🍒ᝰ.ᐟ

🔴如图所示: 服务端向客户端发送一个包含 Artifact -> Part 嵌套结构的数据包。

🟡流程说明: 当任务最终完成时，服务端将最终的成果交付给客户端。这个成果被封装在一个或多个 Artifact 对象中。

🟢每个 Artifact 由一个或多个 Part 组成。例如，一个完成的报告可能包含一个 TextPart（总结）和一个 FilePart（完整的 PDF 文档）。

🔵技术关联: 成果是通过 TaskArtifactUpdateEvent 推送给客户端的。在交付所有 Artifact 之后，服务端会再推送一个最终的 TaskStatusUpdateEvent，将任务状态标记为 completed ( 或failed/canceled)，标志着本次任务生命周期的结束，SSE 连接也可能随之关闭。

总结：A2A 协议定义了清晰、健壮且灵活的交互模型

1. 结构化与多模态: 通过 Task > Message / Artifact > Part 的分层结构，实现了超越纯文本的多模态信息交换。

2. 异步与流式: 通过 Push Notifications（主要是 TaskStatusUpdateEvent），客户端可以实时、非阻塞地获取长任务的进度，提升了用户体验。

3. 完整的生命周期管理: Task 的状态机（ submitted -> working -> input-required - > completed / failed / canceled ）为任务管理提供了清晰的框架，使得追踪、暂停和恢复任务成为可能。

3.3 实战代码：搭建 A2A Server（基于 FastAPI+uvicorn）˚𝜗𝜚🍒ᝰ.ᐟ

以 “日历智能体” 为例，实现接收任务、查询日历、返回结果的完整流程：

步骤 1：安装依赖

pip install fastapi uvicorn google-adk pydantic

实现 A2A Server 核心代码

import uvicorn
from fastapi import FastAPI, Request
from pydantic import BaseModel
from google.adk.agents import LlmAgent
from google.adk.tools.google_api_tool import CalendarToolset

# 1. 初始化日历工具集（对接Google Calendar API）
async def create_calendar_agent(client_id, client_secret):
    toolset = CalendarToolset(client_id=client_id, client_secret=client_secret)
    return LlmAgent(
        model="gemini-2.0-flash",
        name="CalendarAgent",
        instruction="""你是日历管理智能体，使用工具查询用户空闲时间，
        支持格式："查询2025-08-01 10:00-11:00是否空闲" """,
        tools=await toolset.get_tools()
    )

# 2. 定义A2A任务请求模型（对应Task→Message→Part结构）
class Part(BaseModel):
    type: str  # text/file/data
    content: str

class Message(BaseModel):
    role: str  # user/agent
    parts: list[Part]

class TaskRequest(BaseModel):
    taskId: str
    message: Message

# 3. 搭建A2A Server
app = FastAPI()
agent = None  # 全局智能体实例

@app.on_event("startup")
async def startup():
    # 加载环境变量中的认证信息
    import os
    client_id = os.getenv("GOOGLE_CLIENT_ID")
    client_secret = os.getenv("GOOGLE_CLIENT_SECRET")
    global agent
    agent = await create_calendar_agent(client_id, client_secret)

# 4. 提供Agent Card访问接口
@app.get("/.well-known/agent.json")
async def get_agent_card():
    return {
        "name": "CalendarAgent",
        "description": "查询日历空闲状态的A2A服务",
        "url": "http://localhost:8000",
        "version": "1.0.0",
        "capabilities": {"streaming": True},
        "skills": [{"id": "check_availability", "name": "检查时间段空闲状态"}]
    }

# 5. 处理任务请求（核心接口）
@app.post("/a2a/tasks/send")
async def handle_task(request: TaskRequest):
    # 解析用户任务（从Message→Part中提取请求内容）
    user_message = next(part.content for part in request.message.parts if part.type == "text")
    print(f"收到任务：{user_message} | taskId：{request.taskId}")
    
    # 调用智能体执行任务
    result = await agent.run(user_message)
    
    # 封装成果为Artifact返回
    return {
        "taskId": request.taskId,
        "status": "completed",
        "artifact": {
            "parts": [{"type": "text", "content": result}]
        }
    }

if __name__ == "__main__":
    uvicorn.run(app, host="0.0.0.0", port=8000)

3.3 两种核心交互模式（代码示例）˚𝜗𝜚🍒ᝰ.ᐟ

A2A 支持同步和流式两种交互模式，适配不同场景需求：

模式 1：同步请求 - 响应（适用于短任务）

流程：

🔴Client 发送一个 HTTP POST 请求。

🟡Server 执行整个任务。

🟢Server 将包含完整结果的 Task 或 Message 对象一次性返回。

中断处理：若中断，Client 可通过 task_id 轮询 (get_task) 获取最终结果。

# A2A Client示例（同步调用）
import requests

def sync_call_calendar_agent():
    task_request = {
        "taskId": "task-001",
        "message": {
            "role": "user",
            "parts": [{"type": "text", "content": "查询2025-08-01 10:00-11:00是否空闲"}]
        }
    }
    # 发送同步请求
    response = requests.post("http://localhost:8000/a2a/tasks/send", json=task_request)
    print("同步响应结果：", response.json()["artifact"]["parts"][0]["content"])

sync_call_calendar_agent()

模式 2：流式协作（适用于长任务，基于 SSE）˚𝜗𝜚🍒ᝰ.ᐟ

流程 (基于 SSE - Server-Sent Events)：

🔴Client 发送请求。

🟡Server 立即返回一个 Task (状态 submitted)。

🟢Server 在执行过程中，持续推送多个 TaskStatusUpdateEvent。

🔵任务产出时，推送 TaskArtifactUpdateEvent。

🟣任务完成，推送 Task (状态 completed)，关闭连接。

中断处理：Client 可通过 resubscribe 重新连接到 SSE 流。

# A2A Client示例（流式接收）
import requests
from sseclient import SSEClient

def streaming_call_agent():
    # 发起流式任务请求
    response = requests.post(
        "http://localhost:8000/a2a/tasks/sendSubscribe",
        json={"taskId": "task-002", "message": {"role": "user", "parts": [{"type": "text", "content": "查询未来7天空闲时段"}]}},
        stream=True
    )
    # 解析SSE流
    client = SSEClient(response)
    for event in client.events():
        data = json.loads(event.data)
        if data["status"] == "working":
            print("任务进度：", data["progress"])
        elif data["status"] == "completed":
            print("最终结果：", data["artifact"]["parts"][0]["content"])

streaming_call_agent()

示例：自动化招聘流程˚𝜗𝜚🍒ᝰ.ᐟ

协作链条：

1. 招聘经理 Agent (Client) 发起任务：“找候选人”。

2. 它通过 A2A 调用 LinkedIn Agent (Remote)。

3. LinkedIn Agent 返回候选人列表 (Artifact)。

4. 经理筛选后，招聘经理 Agent 通过 A2A 调用 日历 Agent 和 邮件 Agent，协调并发送面试邀请。

5. 面试后，再通过 A2A 调用 背调服务 Agent 发起背调

# 招聘经理Agent（A2A Client）
def recruitment_agent():
    # 1. 调用LinkedIn Agent获取候选人列表
    linkedin_response = requests.post(
        "http://linkedin-agent:8000/a2a/tasks/send",
        json={"taskId": "recruit-001", "message": {"role": "user", "parts": [{"type": "text", "content": "查找AI工程师候选人"}]}}
    )
    candidates = linkedin_response.json()["artifact"]["parts"][0]["content"]
    
    # 2. 调用日历Agent协调面试
    calendar_response = requests.post(
        "http://calendar-agent:8000/a2a/tasks/send",
        json={"taskId": "recruit-002", "message": {"role": "user", "parts": [{"type": "text", "content": f"为候选人{ candidates[:2] }安排下周面试"}]}}
    )
    return "面试安排完成：" + calendar_response.json()["artifact"]["parts"][0]["content"]