尽管单个 AI Agent 具备先进能力，但在处理复杂、多方面问题时仍然常常面临局限性。为了克服这一限制， Agent 间通信(A2A)使得不同 AI Agent(可能基于不同框架构建)能够进行有效协作。这种协作涉及无缝 协调、任务委派和信息交换。
Google A2A 协议是一个旨在促进此类通用通信的开放标准。本章将探讨 A2A 的基本概念、实际应用以及在 Google ADK 中的具体实现。
Agent 间通信模式概述
Agent2Agent(A2A)协议是一个旨在实现不同 AI Agent 框架间通信与协作的开放标准。它确保了互操作性， 允许使用 LangGraph、CrewAI 或 Google ADK 等技术开发的 AI Agent 能够协同工作，无论其来源或框架差 异如何。
A2A 获得了众多技术公司和服务提供商的支持，包括 Atlassian、Box、LangChain、MongoDB、Salesforce、 SAP 和 ServiceNow。Microsoft 计划将 A2A 集成到 Azure AI Foundry 和 Copilot Studio，这展示了其对开 放协议的承诺。此外，Auth0 和 SAP 正在将 A2A 支持集成到其平台和 Agent 中。作为开源协议，A2A 欢迎社区贡献，以促进其发展和广泛采用。
A2A 的核心概念
A2A 协议为 Agent 交互提供了结构化方法，建立在若干核心概念之上。深入理解这些概念对于任何开发或集 成 A2A 兼容系统的开发者都至关重要。A2A 的基础支柱包括核心参与者、Agent 卡片、Agent 发现、通信和 任务、交互机制及安全性，所有这些都将详细讨论。
核心参与者:A2A 涉及三个主要实体:
・ 用户:发起对Agent协助的请求。
・ A2A 客户端(客户端 Agent):代表用户请求操作或信息的应用程序或 AI Agent。
・ A2A服务器(远程Agent):提供HTTP端点处理客户端请求并返回结果的AIAgent或系统。远程Agent 作为"不透明"系统运行，意味着客户端无需了解其内部操作细节。
Agent 卡片:
Agent 的数字身份由其 Agent 卡片定义，通常是 JSON 文件。此文件包含用于客户端交互和自 动发现的关键信息，包括 Agent 身份、端点 URL 和版本。它还详细说明支持的功能(如流式传输或推送通 知)、特定技能、默认输入/输出模式以及身份验证要求。以下是 WeatherBot 的 Agent 卡片示例。
{
"name": "WeatherBot",
"description":"Provides accurate weather forecasts and historical data.", "url": "http://weather−service.example.com/a2a",
"version": "1.0.0",
"capabilities": {
"streaming": true , "pushNotifications": false , "stateTransitionHistory": true
}, "authentication": {
"schemes": [ "apiKey"
] },
"defaultInputModes": [ "text"
], "defaultOutputModes": [
"text" ],
"skills": [ {
"id": "get_current_weather",
"name": "Get Current Weather",
"description": "Retrieve real−time weather for any location.", "inputModes": [
"text" ],
"outputModes": [ "text"
], "examples": [
"What's the weather in Paris?",
"Current conditions in Tokyo" ],
"tags": [ "weather", "current", "real −time"
] },
{
"id": "get_forecast",
"name": "Get Forecast",
"description": "Get 5−day weather predictions.", "inputModes": [
"text" ],
"outputModes": [ "text"
], "examples": [
"5−day forecast for New York",
"Will it rain in London this weekend?"
], "tags": [
"weather", "forecast", "prediction"
] }
] }
Agent 发现:
Agent 发现机制允许客户端找到描述可用 A2A 服务器能力的 Agent 卡片。此过程存在几种策 略:
-
・ 知名URI:Agent在标准化路径(如/.well‐known/agent.json)托管其Agent卡片。此方法为公共或 特定领域使用提供广泛、通常自动化的可访问性。
-
・ 策展注册表:这些注册表提供集中目录，其中发布 Agent 卡片，可根据特定标准查询。这非常适合需 要集中管理和访问控制的企业环境。
-
・ 直接配置:Agent 卡片信息被嵌入或私下共享。此方法适用于紧密耦合或私有系统，其中动态发现并 不重要。
无论选择何种方法，保护 Agent 卡片端点都很重要。这可通过访问控制、双向 TLS(mTLS)或网络限制实 现，特别是当卡片包含敏感(虽非秘密)信息时。
通信和任务:
-
在 A2A 框架中，通信围绕异步任务结构化，这些任务代表长时间运行进程的基本工作单元。每 个任务被分配唯一标识符，并通过一系列状态(如已提交、工作中或已完成)移动，此设计支持复杂操作中 的并行处理。Agent 间通信通过消息进行。
此通信包含属性(描述消息的键值元数据，如其优先级或创建时间)以及一个或多个部分(承载传递的实际 内容，如纯文本、文件或结构化 JSON 数据)。Agent 在任务期间生成的有形输出称为工件。与消息类似，工 件也由一个或多个部分组成，并可在结果可用时逐步流式传输。A2A 框架内所有通信都通过 HTTP(S) 进行， 使用 JSON‐RPC 2.0 协议作为有效载荷。为在多次交互中保持连续性，使用服务器生成的 contextId 来分组 相关任务并保留上下文。
-
交互机制:
-
A2A 提供多种交互方法以适应各种 AI 应用需求，每种方法都有独特机制:
-
・ 同步请求/响应:用于快速、即时操作。在此模型中，客户端发送请求并主动等待服务器处理并在单个 同步交换中返回完整响应。
-
・ 异步轮询:适用于需要更长时间处理的任务。客户端发送请求，服务器立即以"工作中"状态和任务 ID 确认。然后客户端可自由执行其他操作，并可通过发送新请求定期轮询服务器检查任务状态，直至 标记为"已完成"或"失败"。
-
・ 流式更新(服务器发送事件‐SSE):适用于接收实时、增量结果。此方法建立从服务器到客户端的持久 单向连接。它允许远程 Agent 持续推送更新(如状态更改或部分结果)，而无需客户端发出多个请求。
-
・ 推送通知(Webhook):专为非常长时间运行或资源密集型任务设计，其中维护恒定连接或频繁轮询
效率低下。客户端可注册 webhook URL，当任务状态发生重大变化(如完成时)，服务器将向该 URL 发送异步通知("推送")。
-
-
Agent 卡片指定 Agent 是否支持流式传输或推送通知功能。此外，A2A 是模态无关的，意味着它不仅可以为 文本促进这些交互模式，还可为音频和视频等其他数据类型促进，从而实现丰富的多模态 AI 应用。流式传 输和推送通知功能均在 Agent 卡片中指定。
同步请求示例 {
"jsonrpc": "2.0", "id": "1",
"method": "sendTask", "params": {
"id": "task−001", "sessionId": "session −001", "message": {
-
"role": "user", "parts": [
{
"type": "text",
"text": "What is the exchange rate from USD to EUR?"
} ]
}, "acceptedOutputModes": "historyLength": 5
} }
"text / plain"\], 同步请求使用 sendTask 方法，其中客户端请求并期望对其查询的单个完整答案。相比之下，流式请求使用 sendTaskSubscribe 方法建立持久连接，允许 Agent 随时间发送多个增量更新或部分结果。
流式请求示例 {
"jsonrpc": "2.0",
"id": "2",
"method": "sendTaskSubscribe", "params": {
"id": "task−002", "sessionId": "session −001", "message": {
"role": "user", "parts": [
{
"type": "text",
"text": "What' s the exchange rate for JPY to GBP today?"
} ]
}, "acceptedOutputModes": "historyLength": 5
} }
安全性:Agent 间通信(A2A)是系统架构的关键组成部分，能够在 Agent 间实现安全、无缝的数据交换。它 通过多个内置机制确保系统的稳健性和完整性。
・ 双向传输层安全(TLS):建立加密和认证连接，防止未经授权访问和数据拦截，确保通信安全。
・ 全面审计日志:所有 Agent 间通信均被详细记录，明确信息流、涉及的 Agent 和操作。此审计轨迹对
问责、故障排除和安全分析至关重要。
・ Agent 卡片声明:身份验证要求在 Agent 卡片中明确声明，这是概述 Agent 身份、能力和安全策略的
配置工件。这集中并简化了身份验证管理。
・ 凭据处理:Agent通常使用安全凭据(如OAuth2.0令牌或API密钥)进行身份验证，通过HTTP头传
递。此方法防止凭据在 URL 或消息正文中暴露，增强整体安全性。
A2A 与 MCP
A2A 是补充 Anthropic 模型上下文协议(MCP)的协议(见图 1)。MCP 专注于为 Agent 构建上下文及其与 外部数据和工具的交互，而 A2A 则促进 Agent 间的协调和通信，实现任务委派与协作。
图 1:A2A 和 MCP 协议比较
A2A 旨在提高效率、降低集成成本，并促进复杂多 Agent AI 系统开发中的创新和互操作性。因此，深入理解 A2A 的核心组件和操作方法对于有效设计、实施和应用协作式、互操作的 AI Agent 系统至关重要。
### 实际应用和用例
Agent 间通信对于跨不同领域构建复杂 AI 解决方案不可或缺，实现了模块化、可扩展性和增强智能。
・ 多框架协作:A2A的主要用例是使独立AIAgent能够通信协作，无论其底层框架(如ADK、LangChain、 CrewAI)如何。这对构建复杂多 Agent 系统至关重要，不同 Agent 专门处理问题的不同方面。
・ 自动化工作流编排:在企业环境中，A2A可通过使Agent委派和协调任务来促进复杂工作流。例如，一 个 Agent 可能处理初始数据收集，然后委派给另一个 Agent 进行分析，最后委派给第三个 Agent 生成 报告，所有通信均通过 A2A 协议进行。
・ 动态信息检索:Agent可以通过通信来检索和交换实时信息。主Agent可能从专门的"数据获取Agent" 请求实时市场数据，后者然后使用外部 API 收集信息并发送回来。
### Agent 间通信（A2A）代码示例
让我们检查 A2A 协议的实际应用。位于 https://github.com/google‐a2a/a2a‐samples/tree/main/samples 的存储库提供 Java、Go 和 Python 示例，说明各种 Agent 框架(如 LangGraph、CrewAI、Azure AI Foundry 和 AG2)如何使用 A2A 通信。此存储库中所有代码均在 Apache 2.0 许可证下发布。
建议通过 https://www.trickle.so/blog/how‐to‐build‐google‐a2a‐project 上的代码演示进一步探索 A2A。 此链接提供的资源包括 Python 和 JavaScript 中的示例 A2A 客户端和服务器、多 Agent Web 应用程序、命 令行界面以及各种 Agent 框架的示例实现。
**案例说明：**
我们将在LangChain4j框架下构建一个多Agent系统，用于演示Agent间通信（A2A）。我们将模拟一个企业环境中的工作流，其中包含三个Agent：一个用于数据收集，一个用于数据分析，一个用于报告生成。我们将使用简单的消息传递机制来实现Agent间的通信。
注意：由于LangChain4j本身并不直接提供多Agent通信的高级抽象，我们将基于其工具调用和对话管理功能来构建一个简单的Agent通信框架。
我们将创建三个Agent：
1. 1、DataCollectorAgent：负责收集数据（模拟从外部API获取数据）。
2. 2、DataAnalyzerAgent：负责分析数据（模拟对数据进行统计分析）。
3. 3、ReportGeneratorAgent：负责生成报告（模拟将分析结果整理成报告）。
此外，我们还需要一个协调者（Orchestrator）来协调这三个Agent的工作流。
在这个示例中，我们将使用LangChain4j的AiServices来创建Agent，并定义它们之间的通信接口。
步骤：
1. 1、定义每个Agent的接口和实现。
2. 2、创建一个协调者，它按照工作流顺序调用各个Agent。
3. 3、使用简单的请求-响应模型进行通信。
#### LangChain4j Agent 间通信（A2A）实现示例
以下是基于LangChain4j框架的Agent间通信（A2A）模式实现，展示了多Agent协作、工作流编排和信息检索交换的实际应用：
#### 1. Agent间通信基础框架
```java
import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.data.message.AiMessage;
import dev.langchain4j.data.message.ChatMessage;
import dev.langchain4j.data.message.SystemMessage;
import dev.langchain4j.data.message.UserMessage;
import dev.langchain4j.memory.ChatMemory;
import dev.langchain4j.memory.chat.MessageWindowChatMemory;
import dev.langchain4j.model.chat.ChatLanguageModel;
import dev.langchain4j.model.openai.OpenAiChatModel;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.service.MemoryId;
import lombok.extern.slf4j.Slf4j;
import java.util.*;
import java.util.concurrent.*;
@Slf4j
public class AgentCommunicationFramework {
// Agent注册表
private final Map<String, AgentDescriptor> agentRegistry = new ConcurrentHashMap<>();
// 消息队列
private final BlockingQueue<AgentMessage> messageQueue = new LinkedBlockingQueue<>();
private final ExecutorService agentExecutor = Executors.newCachedThreadPool();
public AgentCommunicationFramework() {
startMessageDispatcher();
}
/**
* 注册Agent
*/
public void registerAgent(AgentDescriptor descriptor) {
agentRegistry.put(descriptor.getId(), descriptor);
log.info("Agent 注册成功: {} - {}", descriptor.getId(), descriptor.getName());
}
/**
* 发送消息给Agent
*/
public CompletableFuture<AgentResponse> sendMessage(String toAgentId,
String fromAgentId,
Object payload,
MessageType type) {
AgentMessage message = AgentMessage.builder()
.messageId(UUID.randomUUID().toString())
.fromAgentId(fromAgentId)
.toAgentId(toAgentId)
.payload(payload)
.type(type)
.timestamp(System.currentTimeMillis())
.build();
CompletableFuture<AgentResponse> future = new CompletableFuture<>();
message.setResponseFuture(future);
try {
messageQueue.put(message);
log.debug("消息已发送: {} -> {}", fromAgentId, toAgentId);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
future.completeExceptionally(e);
}
return future;
}
/**
* 广播消息给多个Agent
*/
public Map<String, CompletableFuture<AgentResponse>> broadcast(String fromAgentId,
Object payload,
MessageType type,
List<String> toAgentIds) {
Map<String, CompletableFuture<AgentResponse>> futures = new HashMap<>();
for (String agentId : toAgentIds) {
CompletableFuture<AgentResponse> future = sendMessage(agentId, fromAgentId, payload, type);
futures.put(agentId, future);
}
return futures;
}
/**
* 启动消息分发器
*/
private void startMessageDispatcher() {
Thread dispatcher = new Thread(() -> {
while (!Thread.currentThread().isInterrupted()) {
try {
AgentMessage message = messageQueue.take();
processMessage(message);
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
break;
} catch (Exception e) {
log.error("消息处理失败", e);
}
}
});
dispatcher.setDaemon(true);
dispatcher.setName("Agent-Message-Dispatcher");
dispatcher.start();
log.info("Agent消息分发器已启动");
}
/**
* 处理消息
*/
private void processMessage(AgentMessage message) {
AgentDescriptor agent = agentRegistry.get(message.getToAgentId());
if (agent == null) {
log.error("目标Agent不存在: {}", message.getToAgentId());
completeMessageWithError(message, "目标Agent不存在");
return;
}
// 异步处理消息
agentExecutor.submit(() -> {
try {
AgentResponse response = agent.handleMessage(message);
message.getResponseFuture().complete(response);
log.debug("消息处理完成: {} -> {}", message.getFromAgentId(), message.getToAgentId());
} catch (Exception e) {
log.error("Agent处理消息失败: {}", agent.getId(), e);
completeMessageWithError(message, "处理失败: " + e.getMessage());
}
});
}
private void completeMessageWithError(AgentMessage message, String error) {
AgentResponse errorResponse = AgentResponse.builder()
.success(false)
.errorMessage(error)
.timestamp(System.currentTimeMillis())
.build();
message.getResponseFuture().complete(errorResponse);
}
// 数据类
@Data
@Builder
public static class AgentDescriptor {
private String id;
private String name;
private String description;
private List<String> capabilities;
private AgentHandler handler;
public AgentResponse handleMessage(AgentMessage message) {
return handler.handle(message);
}
}
public interface AgentHandler {
AgentResponse handle(AgentMessage message);
}
@Data
@Builder
public static class AgentMessage {
private String messageId;
private String fromAgentId;
private String toAgentId;
private Object payload;
private MessageType type;
private Long timestamp;
private CompletableFuture<AgentResponse> responseFuture;
}
@Data
@Builder
public static class AgentResponse {
private boolean success;
private Object data;
private String errorMessage;
private Long timestamp;
private Map<String, Object> metadata;
}
public enum MessageType {
TASK_REQUEST, // 任务请求
DATA_REQUEST, // 数据请求
RESULT_DELIVERY, // 结果交付
STATUS_UPDATE, // 状态更新
ERROR_REPORT // 错误报告
}
}2. 多框架协作实现
java
import dev.langchain4j.agent.tool.Tool;
import dev.langchain4j.service.AiServices;
import dev.langchain4j.service.MemoryId;
import dev.langchain4j.service.SystemMessage;
import lombok.extern.slf4j.Slf4j;
import java.util.*;
@Slf4j
public class MultiFrameworkCollaboration {
private final AgentCommunicationFramework a2aFramework;
// 不同框架的Agent
private final Map<String, BaseAgent> agents = new HashMap<>();
public MultiFrameworkCollaboration() {
this.a2aFramework = new AgentCommunicationFramework();
initializeAgents();
}
/**
* 初始化不同框架的Agent
*/
private void initializeAgents() {
// LangChain Agent (数据分析专家)
AgentCommunicationFramework.AgentDescriptor langchainAgent =
createLangChainAgent("analyst-agent", "数据分析专家");
a2aFramework.registerAgent(langchainAgent);
// ADK Agent (数据收集专家)
AgentCommunicationFramework.AgentDescriptor adkAgent =
createADKAgent("collector-agent", "数据收集专家");
a2aFramework.registerAgent(adkAgent);
// CrewAI Agent (报告生成专家)
AgentCommunicationFramework.AgentDescriptor crewAiAgent =
createCrewAIAgent("reporter-agent", "报告生成专家");
a2aFramework.registerAgent(crewAiAgent);
// 通用工具Agent
AgentCommunicationFramework.AgentDescriptor toolAgent =
createToolAgent("tool-agent", "工具执行专家");
a2aFramework.registerAgent(toolAgent);
}
/**
* 执行跨Agent协作任务
*/
public CompletableFuture<CollaborationResult> executeCollaborativeTask(TaskRequest request) {
log.info("开始执行协作任务: {}", request.getTaskDescription());
CompletableFuture<CollaborationResult> overallResult = new CompletableFuture<>();
// 任务分解和执行
TaskOrchestration orchestration = decomposeTask(request);
// 并行执行子任务
Map<String, CompletableFuture<AgentCommunicationFramework.AgentResponse>> taskFutures =
new HashMap<>();
for (SubTask subTask : orchestration.getSubTasks()) {
// 选择合适的Agent执行任务
String assignedAgent = assignAgentForTask(subTask);
TaskPayload payload = TaskPayload.builder()
.taskId(subTask.getId())
.description(subTask.getDescription())
.requirements(subTask.getRequirements())
.dependencies(subTask.getDependencies())
.build();
CompletableFuture<AgentCommunicationFramework.AgentResponse> future =
a2aFramework.sendMessage(
assignedAgent,
"orchestrator",
payload,
AgentCommunicationFramework.MessageType.TASK_REQUEST
);
taskFutures.put(subTask.getId(), future);
}
// 等待所有子任务完成
CompletableFuture.allOf(taskFutures.values().toArray(new CompletableFuture[0]))
.thenAccept(v -> {
// 收集结果
Map<String, Object> subTaskResults = new HashMap<>();
Map<String, String> subTaskErrors = new HashMap<>();
for (Map.Entry<String, CompletableFuture<AgentCommunicationFramework.AgentResponse>> entry :
taskFutures.entrySet()) {
try {
AgentCommunicationFramework.AgentResponse response = entry.getValue().get();
if (response.isSuccess()) {
subTaskResults.put(entry.getKey(), response.getData());
} else {
subTaskErrors.put(entry.getKey(), response.getErrorMessage());
}
} catch (Exception e) {
subTaskErrors.put(entry.getKey(), e.getMessage());
}
}
// 综合所有结果
CollaborationResult result = synthesizeResults(
request, orchestration, subTaskResults, subTaskErrors
);
overallResult.complete(result);
})
.exceptionally(e -> {
overallResult.completeExceptionally(e);
return null;
});
return overallResult;
}
/**
* 动态Agent协作 - 基于任务需求动态组建团队
*/
public CompletableFuture<TeamResult> dynamicTeamCollaboration(DynamicTaskRequest request) {
log.info("组建动态团队执行任务: {}", request.getTaskDescription());
// 1. 分析任务需求
TaskAnalysis analysis = analyzeTaskRequirements(request);
// 2. 选择最适合的Agent组建团队
List<String> teamMembers = selectTeamMembers(analysis);
// 3. 为团队分配角色
Map<String, TeamRole> roleAssignments = assignTeamRoles(teamMembers, analysis);
// 4. 执行团队协作
return executeTeamWorkflow(teamMembers, roleAssignments, request);
}
/**
* 跨框架Agent直接通信示例
*/
public Object directAgentCommunication(String fromAgentId,
String toAgentId,
Object query) {
log.info("直接Agent通信: {} -> {}", fromAgentId, toAgentId);
try {
CompletableFuture<AgentCommunicationFramework.AgentResponse> future =
a2aFramework.sendMessage(
toAgentId,
fromAgentId,
query,
AgentCommunicationFramework.MessageType.DATA_REQUEST
);
AgentCommunicationFramework.AgentResponse response = future.get(30, TimeUnit.SECONDS);
if (response.isSuccess()) {
return response.getData();
} else {
throw new RuntimeException("Agent通信失败: " + response.getErrorMessage());
}
} catch (Exception e) {
throw new RuntimeException("Agent通信异常", e);
}
}
// 创建不同框架的Agent实现
private AgentCommunicationFramework.AgentDescriptor createLangChainAgent(String id, String name) {
return AgentCommunicationFramework.AgentDescriptor.builder()
.id(id)
.name(name)
.description("基于LangChain框架的AI Agent，擅长数据分析和处理")
.capabilities(Arrays.asList("数据分析", "模式识别", "统计计算", "预测建模"))
.handler(new LangChainAgentHandler())
.build();
}
private AgentCommunicationFramework.AgentDescriptor createADKAgent(String id, String name) {
return AgentCommunicationFramework.AgentDescriptor.builder()
.id(id)
.name(name)
.description("基于ADK框架的AI Agent，擅长数据收集和外部API集成")
.capabilities(Arrays.asList("数据收集", "API调用", "网络爬虫", "实时数据获取"))
.handler(new ADKAgentHandler())
.build();
}
private AgentCommunicationFramework.AgentDescriptor createCrewAIAgent(String id, String name) {
return AgentCommunicationFramework.AgentDescriptor.builder()
.id(id)
.name(name)
.description("基于CrewAI框架的AI Agent，擅长报告生成和内容创作")
.capabilities(Arrays.asList("报告生成", "文档编写", "内容总结", "格式优化"))
.handler(new CrewAIAgentHandler())
.build();
}
private AgentCommunicationFramework.AgentDescriptor createToolAgent(String id, String name) {
return AgentCommunicationFramework.AgentDescriptor.builder()
.id(id)
.name(name)
.description("通用工具Agent，提供各种工具执行能力")
.capabilities(Arrays.asList("计算工具", "转换工具", "验证工具", "格式化工具"))
.handler(new ToolAgentHandler())
.build();
}
// Agent处理器实现
static class LangChainAgentHandler implements AgentCommunicationFramework.AgentHandler {
@Override
public AgentCommunicationFramework.AgentResponse handle(
AgentCommunicationFramework.AgentMessage message) {
log.info("LangChain Agent 处理消息: {}", message.getMessageId());
try {
// 模拟数据处理
Object payload = message.getPayload();
Object result = processWithLangChain(payload);
return AgentCommunicationFramework.AgentResponse.builder()
.success(true)
.data(result)
.timestamp(System.currentTimeMillis())
.metadata(Map.of("agent", "langchain", "processing_time", 1500L))
.build();
} catch (Exception e) {
return AgentCommunicationFramework.AgentResponse.builder()
.success(false)
.errorMessage(e.getMessage())
.timestamp(System.currentTimeMillis())
.build();
}
}
private Object processWithLangChain(Object input) {
// 模拟LangChain处理逻辑
return "LangChain分析结果: " + input.toString().toUpperCase() + " [已分析]";
}
}
// 其他Agent处理器类似...
// 数据类
@Data
@Builder
public static class TaskRequest {
private String taskId;
private String taskDescription;
private Map<String, Object> parameters;
private List<String> requiredCapabilities;
private Integer priority;
private Long timeoutMs;
}
@Data
@Builder
public static class CollaborationResult {
private String taskId;
private boolean success;
private Object finalResult;
private Map<String, Object> subTaskResults;
private List<String> errors;
private Long totalProcessingTime;
private List<String> involvedAgents;
}
}3. 自动化工作流编排实现
java
import lombok.extern.slf4j.Slf4j;
import java.util.*;
import java.util.concurrent.*;
@Slf4j
public class WorkflowOrchestration {
private final AgentCommunicationFramework a2aFramework;
private final WorkflowRepository workflowRepository;
// 工作流定义
private final Map<String, WorkflowDefinition> workflows = new HashMap<>();
public WorkflowOrchestration() {
this.a2aFramework = new AgentCommunicationFramework();
this.workflowRepository = new WorkflowRepository();
loadWorkflowDefinitions();
}
/**
* 执行企业工作流 - 数据收集 -> 分析 -> 报告生成
*/
public CompletableFuture<WorkflowResult> executeEnterpriseWorkflow(WorkflowRequest request) {
log.info("执行企业工作流: {}", request.getWorkflowName());
String workflowId = generateWorkflowId();
// 创建工作流执行上下文
WorkflowContext context = WorkflowContext.builder()
.workflowId(workflowId)
.request(request)
.startTime(System.currentTimeMillis())
.stepResults(new HashMap<>())
.variables(new HashMap<>())
.build();
// 获取工作流定义
WorkflowDefinition definition = workflows.get(request.getWorkflowName());
if (definition == null) {
throw new IllegalArgumentException("工作流未定义: " + request.getWorkflowName());
}
// 异步执行工作流
return CompletableFuture.supplyAsync(() -> {
try {
return executeWorkflowSteps(definition, context);
} catch (Exception e) {
log.error("工作流执行失败", e);
throw new RuntimeException("工作流执行失败: " + e.getMessage(), e);
}
});
}
/**
* 执行工作流步骤
*/
private WorkflowResult executeWorkflowSteps(WorkflowDefinition definition,
WorkflowContext context) {
log.info("开始执行工作流步骤: {}", definition.getName());
// 按顺序执行步骤
for (WorkflowStep step : definition.getSteps()) {
log.info("执行步骤: {} - {}", step.getOrder(), step.getName());
// 检查前置条件
if (!checkPreconditions(step, context)) {
log.warn("步骤前置条件不满足，跳过: {}", step.getName());
context.getStepResults().put(step.getName(),
StepResult.skipped("前置条件不满足"));
continue;
}
// 执行步骤
StepResult stepResult = executeStep(step, context);
context.getStepResults().put(step.getName(), stepResult);
// 更新上下文变量
if (stepResult.isSuccess() && step.getOutputVariable() != null) {
context.getVariables().put(step.getOutputVariable(), stepResult.getOutput());
}
// 检查是否应该继续
if (!shouldContinue(step, stepResult, context)) {
log.info("工作流提前终止于步骤: {}", step.getName());
break;
}
}
// 创建工作流结果
return buildWorkflowResult(definition, context);
}
/**
* 执行单个步骤 - 通过Agent通信
*/
private StepResult executeStep(WorkflowStep step, WorkflowContext context) {
try {
log.info("通过Agent执行步骤: {} -> {}", step.getName(), step.getAgentId());
// 准备步骤输入
Object stepInput = prepareStepInput(step, context);
// 发送给Agent执行
CompletableFuture<AgentCommunicationFramework.AgentResponse> future =
a2aFramework.sendMessage(
step.getAgentId(),
"workflow-orchestrator",
StepExecutionRequest.builder()
.stepName(step.getName())
.workflowId(context.getWorkflowId())
.input(stepInput)
.parameters(step.getParameters())
.build(),
AgentCommunicationFramework.MessageType.TASK_REQUEST
);
// 等待结果（带超时）
AgentCommunicationFramework.AgentResponse response =
future.get(step.getTimeoutSeconds(), TimeUnit.SECONDS);
if (response.isSuccess()) {
return StepResult.success(response.getData());
} else {
return StepResult.failed(response.getErrorMessage());
}
} catch (TimeoutException e) {
log.error("步骤执行超时: {}", step.getName());
return StepResult.failed("执行超时");
} catch (Exception e) {
log.error("步骤执行失败: {}", step.getName(), e);
return StepResult.failed("执行异常: " + e.getMessage());
}
}
/**
* 动态工作流调整 - 基于执行结果调整后续步骤
*/
public void adaptWorkflowDynamically(String workflowId,
AdaptationTrigger trigger) {
log.info("动态调整工作流: {}", workflowId);
WorkflowContext context = workflowRepository.getContext(workflowId);
if (context == null) {
throw new IllegalArgumentException("工作流上下文不存在: " + workflowId);
}
WorkflowDefinition definition = workflows.get(context.getRequest().getWorkflowName());
// 分析当前状态
AdaptationAnalysis analysis = analyzeWorkflowState(context, trigger);
// 决定调整策略
AdaptationStrategy strategy = determineAdaptationStrategy(analysis);
// 应用调整
applyAdaptation(definition, context, strategy);
}
/**
* 工作流监控和错误恢复
*/
@Scheduled(fixedDelay = 30000) // 每30秒检查一次
public void monitorAndRecoverWorkflows() {
log.debug("检查工作流状态...");
List<WorkflowContext> activeWorkflows = workflowRepository.getActiveWorkflows();
for (WorkflowContext context : activeWorkflows) {
// 检查是否超时
if (isWorkflowTimedOut(context)) {
log.warn("工作流超时: {}", context.getWorkflowId());
handleWorkflowTimeout(context);
}
// 检查失败步骤
List<StepResult> failedSteps = findFailedSteps(context);
if (!failedSteps.isEmpty()) {
log.info("检测到失败步骤，尝试恢复: {}", context.getWorkflowId());
attemptWorkflowRecovery(context, failedSteps);
}
}
}
/**
* 企业工作流示例：市场分析报告生成
*/
public CompletableFuture<MarketReport> generateMarketAnalysisReport(String market,
Date startDate,
Date endDate) {
WorkflowRequest request = WorkflowRequest.builder()
.workflowName("market-analysis-report")
.parameters(Map.of(
"market", market,
"startDate", startDate,
"endDate", endDate,
"reportType", "comprehensive"
))
.build();
return executeEnterpriseWorkflow(request)
.thenApply(workflowResult -> {
if (workflowResult.isSuccess()) {
return (MarketReport) workflowResult.getFinalOutput();
} else {
throw new RuntimeException("报告生成失败: " + workflowResult.getError());
}
});
}
// 工作流定义示例
private void loadWorkflowDefinitions() {
// 市场分析报告工作流
WorkflowDefinition marketAnalysisWorkflow = WorkflowDefinition.builder()
.name("market-analysis-report")
.description("市场分析报告生成工作流")
.steps(Arrays.asList(
WorkflowStep.builder()
.order(1)
.name("数据收集")
.agentId("data-collector-agent")
.description("收集市场数据")
.parameters(Map.of("dataSources", "market-api,news-feed,social-media"))
.outputVariable("rawMarketData")
.timeoutSeconds(300)
.build(),
WorkflowStep.builder()
.order(2)
.name("数据清洗")
.agentId("data-processor-agent")
.description("清洗和预处理数据")
.parameters(Map.of("cleaningRules", "standard-market-data"))
.inputVariable("rawMarketData")
.outputVariable("cleanedData")
.timeoutSeconds(180)
.build(),
WorkflowStep.builder()
.order(3)
.name("趋势分析")
.agentId("analytics-agent")
.description("分析市场趋势")
.parameters(Map.of("analysisMethods", "trend,seasonality,forecast"))
.inputVariable("cleanedData")
.outputVariable("trendAnalysis")
.timeoutSeconds(240)
.build(),
WorkflowStep.builder()
.order(4)
.name("报告生成")
.agentId("report-generator-agent")
.description("生成分析报告")
.parameters(Map.of("reportFormat", "executive-summary"))
.inputVariable("trendAnalysis")
.outputVariable("finalReport")
.timeoutSeconds(300)
.build()
))
.build();
workflows.put("market-analysis-report", marketAnalysisWorkflow);
// 客户支持工作流
WorkflowDefinition customerSupportWorkflow = WorkflowDefinition.builder()
.name("customer-support-escalation")
.description("客户支持升级工作流")
.steps(Arrays.asList(
WorkflowStep.builder()
.order(1)
.name("初始响应")
.agentId("chatbot-agent")
.description("自动响应客户问题")
.parameters(Map.of("responseTemplate", "standard-support"))
.outputVariable("initialResponse")
.build(),
WorkflowStep.builder()
.order(2)
.name("问题分类")
.agentId("classifier-agent")
.description("分类客户问题类型")
.inputVariable("customerQuery")
.outputVariable("problemCategory")
.build(),
WorkflowStep.builder()
.order(3)
.name("专家路由")
.agentId("router-agent")
.description("路由到合适的支持专家")
.inputVariable("problemCategory")
.outputVariable("assignedExpert")
.build(),
WorkflowStep.builder()
.order(4)
.name("专家处理")
.agentId("human-expert-agent")
.description("人工专家处理")
.inputVariable("assignedExpert")
.outputVariable("expertResolution")
.build()
))
.build();
workflows.put("customer-support-escalation", customerSupportWorkflow);
}
// 数据类
@Data
@Builder
public static class WorkflowDefinition {
private String name;
private String description;
private List<WorkflowStep> steps;
private Map<String, Object> defaultParameters;
private RetryPolicy retryPolicy;
private Integer maxExecutionTime;
}
@Data
@Builder
public static class WorkflowStep {
private Integer order;
private String name;
private String agentId;
private String description;
private Map<String, Object> parameters;
private String inputVariable;
private String outputVariable;
private Integer timeoutSeconds;
private List<String> preconditions;
}
@Data
@Builder
public static class WorkflowResult {
private String workflowId;
private String workflowName;
private boolean success;
private Object finalOutput;
private String error;
private Map<String, StepResult> stepResults;
private Long executionTime;
private Date completionTime;
}
@Data
@Builder
public static class StepResult {
private boolean success;
private Object output;
private String error;
private Long executionTime;
private String status; // SUCCESS, FAILED, SKIPPED, TIMEOUT
public static StepResult success(Object output) {
return StepResult.builder()
.success(true)
.output(output)
.status("SUCCESS")
.build();
}
public static StepResult failed(String error) {
return StepResult.builder()
.success(false)
.error(error)
.status("FAILED")
.build();
}
public static StepResult skipped(String reason) {
return StepResult.builder()
.success(false)
.error(reason)
.status("SKIPPED")
.build();
}
}
}4. 动态信息检索实现
java
import lombok.extern.slf4j.Slf4j;
import java.util.*;
import java.util.concurrent.*;
import java.util.stream.Collectors;
@Slf4j
public class DynamicInformationRetrieval {
private final AgentCommunicationFramework a2aFramework;
private final Map<String, DataSourceAgent> dataSourceAgents;
// 缓存管理
private final CacheManager cacheManager;
public DynamicInformationRetrieval() {
this.a2aFramework = new AgentCommunicationFramework();
this.dataSourceAgents = new HashMap<>();
this.cacheManager = new CacheManager();
initializeDataSourceAgents();
}
/**
* 初始化数据源Agent
*/
private void initializeDataSourceAgents() {
// 市场数据Agent
DataSourceAgent marketDataAgent = DataSourceAgent.builder()
.agentId("market-data-agent")
.name("市场数据专家")
.dataTypes(Arrays.asList(
DataType.STOCK_PRICES,
DataType.MARKET_INDICES,
DataType.FOREX_RATES,
DataType.COMMODITY_PRICES
))
.sources(Arrays.asList(
"yahoo-finance-api",
"bloomberg-api",
"reuters-api"
))
.updateFrequency(60) // 每60秒更新
.build();
registerDataSourceAgent(marketDataAgent);
// 新闻数据Agent
DataSourceAgent newsAgent = DataSourceAgent.builder()
.agentId("news-agent")
.name("新闻聚合专家")
.dataTypes(Arrays.asList(
DataType.NEWS_ARTICLES,
DataType.SOCIAL_MEDIA,
DataType.PRESS_RELEASES
))
.sources(Arrays.asList(
"news-api-org",
"twitter-api",
"reddit-api"
))
.updateFrequency(30) // 每30秒更新
.build();
registerDataSourceAgent(newsAgent);
// 天气数据Agent
DataSourceAgent weatherAgent = DataSourceAgent.builder()
.agentId("weather-agent")
.name("天气数据专家")
.dataTypes(Arrays.asList(
DataType.WEATHER_CURRENT,
DataType.WEATHER_FORECAST
))
.sources(Arrays.asList(
"openweathermap-api",
"weather-gov-api"
))
.build();
registerDataSourceAgent(weatherAgent);
// 公司数据Agent
DataSourceAgent companyDataAgent = DataSourceAgent.builder()
.agentId("company-data-agent")
.name("公司数据专家")
.dataTypes(Arrays.asList(
DataType.FINANCIAL_REPORTS,
DataType.SEC_FILINGS,
DataType.EMPLOYEE_COUNT
))
.sources(Arrays.asList(
"sec-edgar",
"crunchbase-api",
"linkedin-api"
))
.build();
registerDataSourceAgent(companyDataAgent);
}
/**
* 注册数据源Agent
*/
private void registerDataSourceAgent(DataSourceAgent agent) {
dataSourceAgents.put(agent.getAgentId(), agent);
// 注册到A2A框架
a2aFramework.registerAgent(
AgentCommunicationFramework.AgentDescriptor.builder()
.id(agent.getAgentId())
.name(agent.getName())
.description("数据源Agent: " + agent.getDataTypes())
.capabilities(new ArrayList<>(agent.getDataTypes()))
.handler(createDataSourceHandler(agent))
.build()
);
}
/**
* 动态信息检索 - 主Agent从专门的数据Agent请求数据
*/
public CompletableFuture<RetrievedData> retrieveInformation(String mainAgentId,
DataRequest request) {
log.info("主Agent {} 请求数据: {}", mainAgentId, request.getDataType());
// 1. 检查缓存
String cacheKey = generateCacheKey(request);
RetrievedData cachedData = cacheManager.get(cacheKey);
if (cachedData != null && !isCacheExpired(cachedData, request)) {
log.debug("使用缓存数据: {}", cacheKey);
return CompletableFuture.completedFuture(cachedData);
}
// 2. 选择合适的数据源Agent
List<String> suitableAgents = selectDataSourceAgents(request);
if (suitableAgents.isEmpty()) {
return CompletableFuture.failedFuture(
new RuntimeException("没有找到合适的数据源Agent: " + request.getDataType())
);
}
// 3. 并发向多个数据源Agent请求数据
List<CompletableFuture<AgentCommunicationFramework.AgentResponse>> futures =
suitableAgents.stream()
.map(agentId -> retrieveFromDataSourceAgent(agentId, mainAgentId, request))
.collect(Collectors.toList());
// 4. 合并和处理多个数据源的结果
return CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
.thenApply(v -> {
// 收集所有成功的结果
List<RetrievedData> allResults = new ArrayList<>();
List<String> errors = new ArrayList<>();
for (CompletableFuture<AgentCommunicationFramework.AgentResponse> future : futures) {
try {
AgentCommunicationFramework.AgentResponse response = future.get();
if (response.isSuccess()) {
allResults.add((RetrievedData) response.getData());
} else {
errors.add(response.getErrorMessage());
}
} catch (Exception e) {
errors.add(e.getMessage());
}
}
// 合并数据
RetrievedData mergedData = mergeDataFromMultipleSources(allResults, request);
// 更新缓存
cacheManager.put(cacheKey, mergedData, request.getCacheTtlSeconds());
return mergedData;
});
}
/**
* 实时数据流监控
*/
public void startRealTimeDataStream(String mainAgentId,
StreamRequest request,
DataStreamCallback callback) {
log.info("启动实时数据流监控: {}", request);
// 选择数据源Agent
String dataAgentId = selectPrimaryDataSourceAgent(request);
// 建立流式连接
establishDataStream(dataAgentId, mainAgentId, request, callback);
}
/**
* 智能数据源选择算法
*/
private List<String> selectDataSourceAgents(DataRequest request) {
List<String> selectedAgents = new ArrayList<>();
// 根据数据类型选择
for (DataSourceAgent agent : dataSourceAgents.values()) {
if (agent.getDataTypes().contains(request.getDataType())) {
// 考虑Agent的可用性和性能
if (isAgentAvailable(agent.getAgentId())) {
selectedAgents.add(agent.getAgentId());
}
}
}
// 如果没有找到完全匹配的，尝试相似类型
if (selectedAgents.isEmpty()) {
selectedAgents = findAgentsForSimilarDataType(request.getDataType());
}
// 根据优先级排序
selectedAgents.sort((a, b) -> {
DataSourceAgent agentA = dataSourceAgents.get(a);
DataSourceAgent agentB = dataSourceAgents.get(b);
return Integer.compare(
getAgentPriorityForRequest(agentB, request),
getAgentPriorityForRequest(agentA, request)
);
});
return selectedAgents;
}
/**
* 从数据源Agent检索数据
*/
private CompletableFuture<AgentCommunicationFramework.AgentResponse> retrieveFromDataSourceAgent(
String agentId, String requesterId, DataRequest request) {
return a2aFramework.sendMessage(
agentId,
requesterId,
DataSourceQuery.builder()
.requestId(UUID.randomUUID().toString())
.dataType(request.getDataType())
.parameters(request.getParameters())
.format(request.getFormat())
.realTime(request.isRealTime())
.build(),
AgentCommunicationFramework.MessageType.DATA_REQUEST
);
}
/**
* 数据聚合和验证
*/
private RetrievedData mergeDataFromMultipleSources(List<RetrievedData> dataList,
DataRequest request) {
if (dataList.isEmpty()) {
throw new RuntimeException("没有获取到任何数据");
}
// 如果只有一个数据源，直接返回
if (dataList.size() == 1) {
return dataList.get(0);
}
// 多个数据源的合并策略
switch (request.getMergeStrategy()) {
case "average":
return mergeByAveraging(dataList);
case "latest":
return mergeByLatest(dataList);
case "consensus":
return mergeByConsensus(dataList);
case "weighted":
return mergeByWeightedAverage(dataList, request.getSourceWeights());
default:
return mergeByDefault(dataList);
}
}
/**
* 市场数据检索示例
*/
public CompletableFuture<MarketData> getRealTimeMarketData(String symbol,
List<String> dataPoints) {
DataRequest request = DataRequest.builder()
.dataType(DataType.STOCK_PRICES)
.parameters(Map.of(
"symbol", symbol,
"dataPoints", dataPoints,
"interval", "1m",
"period", "1d"
))
.realTime(true)
.cacheTtlSeconds(30) // 30秒缓存
.mergeStrategy("latest")
.build();
return retrieveInformation("market-analyzer-agent", request)
.thenApply(retrievedData -> (MarketData) retrievedData.getData());
}
/**
* 多源新闻聚合示例
*/
public CompletableFuture<NewsSummary> getAggregatedNews(String topic,
Date startDate,
Date endDate) {
DataRequest request = DataRequest.builder()
.dataType(DataType.NEWS_ARTICLES)
.parameters(Map.of(
"topic", topic,
"startDate", startDate,
"endDate", endDate,
"language", "en",
"sentimentAnalysis", true
))
.format("summary")
.cacheTtlSeconds(300) // 5分钟缓存
.mergeStrategy("consensus")
.build();
return retrieveInformation("news-monitor-agent", request)
.thenApply(retrievedData -> (NewsSummary) retrievedData.getData());
}
// 数据源Agent处理器
private AgentCommunicationFramework.AgentHandler createDataSourceHandler(DataSourceAgent agent) {
return message -> {
DataSourceQuery query = (DataSourceQuery) message.getPayload();
try {
log.info("数据源Agent {} 处理查询: {}", agent.getAgentId(), query.getRequestId());
// 模拟从外部API获取数据
Object data = fetchFromExternalSources(agent, query);
RetrievedData retrievedData = RetrievedData.builder()
.requestId(query.getRequestId())
.dataType(query.getDataType())
.data(data)
.sourceAgentId(agent.getAgentId())
.timestamp(System.currentTimeMillis())
.confidence(calculateDataConfidence(data, agent))
.metadata(Map.of(
"source_count", 1,
"processing_time", System.currentTimeMillis() - message.getTimestamp()
))
.build();
return AgentCommunicationFramework.AgentResponse.builder()
.success(true)
.data(retrievedData)
.timestamp(System.currentTimeMillis())
.build();
} catch (Exception e) {
log.error("数据源Agent处理失败", e);
return AgentCommunicationFramework.AgentResponse.builder()
.success(false)
.errorMessage("数据获取失败: " + e.getMessage())
.timestamp(System.currentTimeMillis())
.build();
}
};
}
// 数据类
@Data
@Builder
public static class DataSourceAgent {
private String agentId;
private String name;
private List<DataType> dataTypes;
private List<String> sources;
private Integer updateFrequency; // 秒
private Double reliabilityScore;
private Map<String, Object> configuration;
}
@Data
@Builder
public static class DataRequest {
private DataType dataType;
private Map<String, Object> parameters;
private String format;
private boolean realTime;
private Integer cacheTtlSeconds;
private String mergeStrategy;
private Map<String, Double> sourceWeights;
}
@Data
@Builder
public static class RetrievedData {
private String requestId;
private DataType dataType;
private Object data;
private String sourceAgentId;
private Long timestamp;
private Double confidence;
private Map<String, Object> metadata;
}
public enum DataType {
STOCK_PRICES,
MARKET_INDICES,
FOREX_RATES,
COMMODITY_PRICES,
NEWS_ARTICLES,
SOCIAL_MEDIA,
WEATHER_CURRENT,
WEATHER_FORECAST,
FINANCIAL_REPORTS,
SEC_FILINGS
}
}5. 配置和监控
java
# application-a2a.yml
agent-communication:
# 通信框架配置
framework:
max-queue-size: 10000
dispatcher-threads: 5
agent-executor-threads: 20
message-timeout: 30000 # 30秒
# Agent注册配置
registry:
auto-discovery: true
heartbeat-interval: 30000 # 30秒心跳
max-inactive-time: 300000 # 5分钟无心跳则离线
# 消息协议配置
messaging:
protocol: "json-rpc" # 可选: json-rpc, rest, grpc
compression: true
encryption: false # 生产环境应为true
max-message-size: 10485760 # 10MB
# 监控配置
monitoring:
metrics-enabled: true
tracing-enabled: true
log-level: "INFO"
# 容错配置
fault-tolerance:
retry-attempts: 3
retry-delay: 1000 # 1秒
circuit-breaker:
enabled: true
failure-threshold: 5
timeout: 60000 # 60秒
# 工作流编排配置
workflow:
max-concurrent-workflows: 100
default-timeout: 3600000 # 1小时
persistence:
enabled: true
storage: "database" # 可选: database, redis
recovery:
enabled: true
max-retries: 3
retry-delay: 5000 # 5秒6. 使用示例
java
public class A2ADemo {
public static void main(String[] args) {
log.info("=== Agent间通信（A2A）演示开始 ===");
// 1. 多框架协作演示
System.out.println("=== 多框架协作演示 ===");
MultiFrameworkCollaboration collaboration = new MultiFrameworkCollaboration();
TaskRequest taskRequest = TaskRequest.builder()
.taskId("TASK001")
.taskDescription("分析市场趋势并生成报告")
.parameters(Map.of("market", "tech", "period", "2024-Q1"))
.requiredCapabilities(Arrays.asList("数据分析", "报告生成"))
.build();
CollaborationResult collabResult = collaboration.executeCollaborativeTask(taskRequest).join();
System.out.println("协作结果: " + collabResult.isSuccess());
System.out.println("涉及Agent: " + collabResult.getInvolvedAgents());
// 2. 自动化工作流编排演示
System.out.println("\n=== 自动化工作流编排演示 ===");
WorkflowOrchestration workflow = new WorkflowOrchestration();
WorkflowRequest wfRequest = WorkflowRequest.builder()
.workflowName("market-analysis-report")
.parameters(Map.of(
"market", "NASDAQ",
"reportType", "executive"
))
.build();
WorkflowResult wfResult = workflow.executeEnterpriseWorkflow(wfRequest).join();
System.out.println("工作流执行: " + wfResult.isSuccess());
System.out.println("执行时间: " + wfResult.getExecutionTime() + "ms");
// 3. 动态信息检索演示
System.out.println("\n=== 动态信息检索演示 ===");
DynamicInformationRetrieval retrieval = new DynamicInformationRetrieval();
// 获取实时市场数据
MarketData marketData = retrieval.getRealTimeMarketData(
"AAPL",
Arrays.asList("price", "volume", "change")
).join();
System.out.println("AAPL实时价格: " + marketData.getCurrentPrice());
System.out.println("数据来源: " + marketData.getSource());
// 4. 直接Agent通信演示
System.out.println("\n=== 直接Agent通信演示 ===");
Object directResult = collaboration.directAgentCommunication(
"analyst-agent",
"tool-agent",
"计算AAPL和GOOGL的平均市盈率"
);
System.out.println("直接通信结果: " + directResult);
log.info("=== A2A演示结束 ===");
}
}关键实现特性总结
-
1、统一的通信协议：
-
标准化的消息格式
-
异步消息传递
-
请求-响应模式支持
-
广播和多播通信
-
-
2、灵活的Agent发现和管理：
-
动态Agent注册
-
心跳监控
-
能力目录服务
-
负载均衡
-
-
3、强大的工作流引擎：
-
可视化工作流定义
-
条件分支和循环
-
错误处理和恢复
-
实时监控和调整
-
-
4、智能数据检索：
-
多源数据聚合
-
缓存策略
-
数据验证和清洗
-
实时流式处理
-
-
5、生产就绪特性：
-
容错和重试机制
-
性能监控
-
安全认证
-
可扩展架构
-
这个A2A实现展示了如何构建一个强大的多Agent系统，支持跨框架协作、自动化工作流编排和动态信息检索，为构建复杂的AI解决方案提供了坚实的基础。
概览
是什么
单个AI Agent(特别是基于不同框架构建的 Agent)在处理复杂、多方面问题时通常会遇到困难。 主要挑战是缺乏允许它们有效通信协作的通用语言或协议。这种隔离阻止了创建复杂系统，其中多个专门 Agent 可以结合独特技能解决更大的任务。如果没有标准化方法，集成这些不同的 Agent 既昂贵又耗时，并 阻碍了更强大、更具凝聚力的 AI 解决方案的开发。
为什么
Agent 间通信(A2A)协议为此问题提供了开放、标准化的解决方案。它是基于 HTTP 的协议，能 够实现互操作性，允许不同 AI Agent 无缝协调、委派任务和共享信息，无论其底层技术如何。核心组件是 Agent 卡片，这是描述 Agent 能力、技能和通信端点的数字身份文件，促进了发现和交互。A2A 定义了各种 交互机制，包括同步和异步通信，以支持不同的用例。通过为 Agent 协作创建通用标准，A2A 促进了构建复 杂、多 Agent Agentic 系统的模块化和可扩展生态系统。
经验法则
当您需要协调两个或多个 AI Agent 间协作时使用此模式，特别是如果它们使用不同框架(如 Google ADK、LangGraph、CrewAI)构建。它非常适合构建复杂、模块化应用程序，其中专门 Agent 处理 工作流的特定部分，例如将数据分析委派给一个 Agent，将报告生成委派给另一个 Agent。当 Agent 需要动 态发现和使用其他 Agent 能力完成任务时，此模式也必不可少。
图 2:A2A Agent 间通信模式
关键要点
-
・ GoogleA2A协议是一个开放、基于HTTP的标准，促进使用不同框架构建的AIAgent间的通信协作。
-
・ AgentCard 作为 Agent 的数字标识符，允许其他 Agent 自动发现和理解其能力。
-
・ A2A 提供同步请求‐响应交互(使用 tasks/send)和流式更新(使用 tasks/sendSubscribe)以适应不
同的通信需求。
-
・ 该协议支持多轮对话，包括input−required状态，允许Agent请求额外信息并在交互期间维护上下文。
-
・ A2A 鼓励模块化架构，其中专门 Agent 可在不同端口上独立运行，实现系统的可扩展性和分布式部署。
-
・ Trickle AI 等工具有助于可视化和跟踪 A2A 通信，帮助开发人员监控、调试和优化多 Agent 系统。
-
・ 虽然A2A是用于管理不同Agent间任务和工作流的高级协议，但模型上下文协议(MCP)为LLM提供与外部资源交互的标准化接口。
结论
A2A（Agent间通信）协议是一个关键的开放标准，旨在打破单个AI智能体固有的孤立性。通过提供通用的基于HTTP的通信框架，它确保了在不同平台（如Google ADK、LangGraph、CrewAI等）上构建的智能体之间能够实现无缝协作与互操作。
该协议的核心是 Agent 数字身份卡片------它清晰定义了每个智能体的能力、接口与元数据，使得其他智能体能够动态发现并与之交互。在通信模式上，A2A 支持多样化的交互方式，包括同步请求/响应、异步轮询以及实时数据流传输，能够灵活适应从简单查询到复杂工作流的各种应用场景。
这一设计使得开发者可以构建模块化、可扩展的多智能体系统，其中专业化的智能体能够相互组合，协同完成复杂的自动化任务与流程编排。安全性是该协议的基础要素，内置机制mTLS（双向 TLS 认证）和显式身份验证确保了通信过程的安全可靠。
虽然 A2A 与其他协议（如 MCP 等）相辅相成，但其独特之处在于专注于智能体之间的高层次协调与任务委派。该协议已获得多家主要技术公司的支持，并已有实际落地应用，突显了其在构建分布式智能系统中的重要地位。
总的来说，A2A 协议为开发者铺平了道路，使其能够构建更为复杂、分布化、智能协作的多智能体系统。它不仅是实现智能体互操作的技术框架，更是推动协同 AI 生态创新与发展的基础支柱。
参考文献
1、Chen, B. (2025, April 22). How to Build Your First Google A2A Project: A Step‐by‐Step Tutorial. Trickle.so Blog. https://www.trickle.so/blog/how‐to‐build‐google‐a2a‐project
2、GoogleA2AGitHubRepository.https://github.com/google‐a2a/A2A
3、GoogleAgentDevelopmentKit(ADK)https://google.github.io/adk‐docs/
4、GettingStartedwithAgent‐to‐Agent(A2A)Protocol:https://codelabs.developers.google.com/intro‐a2a‐purchasing‐concierge#0
5、GoogleAgentDiscovery‐https://a2a‐protocol.org/latest/
6、Communication between different AI frameworks such as LangGraph, CrewAI, and Google ADK https://www.trickle.so/blog /how‐to‐build‐google‐a2a‐project
7、Designing Collaborative Multi‐Agent Systems with the A2A Protocol https://www.oreilly.com/radar/designing‐collaborative‐multi‐agent‐systems‐with‐the‐a2a‐protocol/