本期导读
在前四期，我们学习了RAG检索增强、Function Calling工具调用、MCP协议和Agent架构。现在我们要深入探讨Agent之间如何协作——A2A（Agent-to-Agent）协作模式。
A2A不是简单的多Agent系统，而是去中心化的Agent网络，每个Agent都是独立的智能节点，能够自主决策、直接通信、动态协作。
本文将深入讲解A2A的核心概念、技术架构、运行机制和实际应用。
本文内容包括：
- A2A的起源和核心概念
- A2A vs 传统多Agent系统的区别
- A2A的技术框架和设计模式
- A2A的运行机制和通信协议
- A2A的应用场景和案例分析
- Python实战：构建A2A协作网络
- A2A的挑战和未来发展趋势
一、A2A是什么？
1.1 A2A的定义
**A2A（Agent-to-Agent）**是指Agent之间直接进行协作和通信的模式，不依赖中央协调器。
传统多Agent系统：
┌─────────────┐
│ 中央协调器 │
└─────┬───────┘
│
┌─────┼─────┐
│ │ │
┌───▼───┐ │ ┌───▼───┐
│Agent A│ │ │Agent B│
└───────┘ │ └───────┘
│
┌─────▼───┐
│Agent C │
└─────────┘
A2A协作模式：
┌─────┐ ┌─────┐
│Agent│◄──►│Agent│
│ A │ │ B │
└──┬──┘ └──┬──┘
│ │
└────┬─────┘
│
┌───────▼───────┐
│Agent C ◄──► D │
└───────────────┘
1.2 A2A的起源
技术演进：
传统MAS → 分布式MAS → P2P MAS → A2A
↓ ↓ ↓ ↓
中央控制 分层控制 对等网络 完全去中心化
1.3 为什么需要A2A？
传统多Agent系统的局限性：
-
单点故障
- 中央协调器故障导致整个系统瘫痪
- 无法实现真正的容错
-
扩展性限制
- 中央节点成为性能瓶颈
- 难以水平扩展
-
灵活性不足
- 固定的协作模式
- 难以适应动态环境
-
隐私和安全
- 所有通信都经过中央节点
- 存在数据泄露风险
A2A的优势：
-
去中心化
- 没有单点故障
- 真正的分布式架构
-
高扩展性
- 水平扩展无限制
- 动态添加/移除Agent
-
高灵活性
- 动态协作模式
- 自适应环境变化
-
隐私保护
- 点对点通信
- 数据不经过第三方
1.4 A2A解决的核心问题
1. 分布式协作问题
- 如何让多个Agent在没有中央控制的情况下协作？
- 如何保证协作的一致性和可靠性？
2. 动态网络问题
- 如何处理Agent的动态加入和离开？
- 如何维护网络拓扑的稳定性？
3. 任务分配问题
- 如何在没有中央调度器的情况下分配任务？
- 如何实现负载均衡？
4. 冲突解决问题
- 如何处理Agent之间的资源冲突？
- 如何实现公平的资源分配？
5. 安全信任问题
- 如何建立Agent之间的信任关系？
- 如何防止恶意Agent的攻击？
二、A2A vs 传统多Agent系统
2.1 架构对比
| 维度 | 传统多Agent系统 | A2A协作模式 |
|---|---|---|
| 架构模式 | 中心化/分层化 | 去中心化 |
| 通信方式 | 通过中央节点 | 直接点对点 |
| 决策机制 | 中央协调 | 分布式共识 |
| 扩展性 | 受限于中央节点 | 水平扩展无限制 |
| 容错性 | 单点故障 | 分布式容错 |
| 灵活性 | 固定模式 | 动态适应 |
| 隐私性 | 中央可见 | 点对点保护 |
| 实现复杂度 | 相对简单 | 较为复杂 |
2.2 通信模式对比
传统多Agent通信：
sequenceDiagram
participant A as Agent A
participant C as 中央协调器
participant B as Agent B
A->>C: 发送消息
C->>C: 处理消息
C->>B: 转发消息
B->>C: 回复消息
C->>A: 转发回复
A2A直接通信：
sequenceDiagram
participant A as Agent A
participant B as Agent B
A->>B: 直接发送消息
B->>A: 直接回复消息
Note over A,B: 无需中间节点
2.3 任务分配对比
传统任务分配：
graph TD
A[任务请求] --> B[中央调度器]
B --> C[选择Agent]
B --> D[分配任务]
C --> E[Agent执行]
D --> E
E --> F[返回结果]
F --> B
B --> G[整合结果]
A2A任务分配：
graph TD
A[任务请求] --> B[广播任务]
B --> C[Agent竞标]
C --> D[选择最优Agent]
D --> E[直接分配]
E --> F[Agent执行]
F --> G[直接返回结果]
三、A2A技术框架
3.1 主流A2A框架
| 框架 | 语言 | 特点 | 适用场景 | 活跃度 |
|---|---|---|---|---|
| AutoGen | Python | 对话式A2A协作 | 多Agent对话 | ⭐⭐⭐⭐ |
| CrewAI | Python | 角色驱动的A2A | 团队协作 | ⭐⭐⭐⭐ |
| LangGraph | Python | 状态图A2A | 复杂工作流 | ⭐⭐⭐⭐ |
| Spring AI | Java | 企业级A2A | 微服务架构 | ⭐⭐⭐⭐ |
| Ray | Python | 分布式A2A | 大规模计算 | ⭐⭐⭐⭐ |
| Akka | Scala/Java | Actor模型A2A | 高并发系统 | ⭐⭐⭐ |
| Orleans | C# | 虚拟Actor A2A | .NET生态 | ⭐⭐⭐ |
3.2 A2A设计模式
3.2.1 发布-订阅模式
适用场景： 一对多通信，事件驱动
@Component
public class PubSubA2A {
private final MessageBroker messageBroker;
private final Map<String, List<Agent>> subscribers = new ConcurrentHashMap<>();
public void publish(String topic, Message message) {
messageBroker.publish(topic, message);
}
public void subscribe(String topic, Agent agent) {
subscribers.computeIfAbsent(topic, k -> new ArrayList<>()).add(agent);
messageBroker.subscribe(topic, agent);
}
public void unsubscribe(String topic, Agent agent) {
subscribers.get(topic).remove(agent);
messageBroker.unsubscribe(topic, agent);
}
}
3.2.2 请求-响应模式
适用场景： 一对一通信，同步调用
@Component
public class RequestResponseA2A {
private final Map<String, Agent> agentRegistry = new ConcurrentHashMap<>();
private final Map<String, CompletableFuture<Response>> pendingRequests = new ConcurrentHashMap<>();
public CompletableFuture<Response> sendRequest(String targetAgentId, Request request) {
Agent targetAgent = agentRegistry.get(targetAgentId);
if (targetAgent == null) {
return CompletableFuture.failedFuture(new AgentNotFoundException(targetAgentId));
}
CompletableFuture<Response> future = new CompletableFuture<>();
String requestId = UUID.randomUUID().toString();
pendingRequests.put(requestId, future);
targetAgent.receiveRequest(requestId, request);
return future;
}
public void sendResponse(String requestId, Response response) {
CompletableFuture<Response> future = pendingRequests.remove(requestId);
if (future != null) {
future.complete(response);
}
}
}
3.2.3 竞标模式
适用场景： 任务分配，资源竞争
@Component
public class BiddingA2A {
private final Map<String, List<Bid>> activeBids = new ConcurrentHashMap<>();
private final ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(4);
public void announceTask(Task task) {
String taskId = task.getId();
activeBids.put(taskId, new ArrayList<>());
// 广播任务
broadcastTask(task);
// 设置竞标截止时间
scheduler.schedule(() -> selectWinner(taskId), 30, TimeUnit.SECONDS);
}
public void submitBid(String taskId, Bid bid) {
List<Bid> bids = activeBids.get(taskId);
if (bids != null) {
bids.add(bid);
}
}
private void selectWinner(String taskId) {
List<Bid> bids = activeBids.remove(taskId);
if (bids != null && !bids.isEmpty()) {
Bid winner = bids.stream()
.max(Comparator.comparing(Bid::getScore))
.orElse(null);
if (winner != null) {
assignTask(taskId, winner.getAgentId());
}
}
}
}
3.2.4 共识模式
适用场景： 分布式决策，状态同步
@Component
public class ConsensusA2A {
private final Map<String, ConsensusSession> sessions = new ConcurrentHashMap<>();
private final int quorumSize;
public CompletableFuture<ConsensusResult> proposeConsensus(String sessionId, Proposal proposal) {
ConsensusSession session = sessions.computeIfAbsent(sessionId,
k -> new ConsensusSession(sessionId, quorumSize));
return session.propose(proposal);
}
public void vote(String sessionId, String agentId, Vote vote) {
ConsensusSession session = sessions.get(sessionId);
if (session != null) {
session.vote(agentId, vote);
}
}
private static class ConsensusSession {
private final String sessionId;
private final int quorumSize;
private final Map<String, Vote> votes = new ConcurrentHashMap<>();
private final CompletableFuture<ConsensusResult> result = new CompletableFuture<>();
public ConsensusSession(String sessionId, int quorumSize) {
this.sessionId = sessionId;
this.quorumSize = quorumSize;
}
public CompletableFuture<ConsensusResult> propose(Proposal proposal) {
// 实现共识逻辑
return result;
}
public void vote(String agentId, Vote vote) {
votes.put(agentId, vote);
if (votes.size() >= quorumSize) {
ConsensusResult result = calculateConsensus();
this.result.complete(result);
}
}
private ConsensusResult calculateConsensus() {
// 计算共识结果
return new ConsensusResult();
}
}
}
四、A2A运行机制
4.1 A2A通信协议
4.1.1 消息格式
public class A2AMessage {
private String messageId;
private String senderId;
private String receiverId;
private MessageType type;
private String content;
private Map<String, Object> metadata;
private long timestamp;
private String signature;
public enum MessageType {
REQUEST, RESPONSE, NOTIFICATION, HEARTBEAT, DISCOVERY, CONSENSUS
}
}
4.1.2 通信流程
sequenceDiagram
participant S as Sender Agent
participant N as Network Layer
participant R as Receiver Agent
S->>S: 创建消息
S->>S: 签名消息
S->>N: 发送消息
N->>N: 路由消息
N->>R: 转发消息
R->>R: 验证签名
R->>R: 处理消息
R->>N: 发送响应
N->>S: 转发响应
S->>S: 处理响应
4.2 A2A发现机制
4.2.1 服务发现
graph TD
A[新Agent启动] --> B[广播发现消息]
B --> C[现有Agent响应]
C --> D[建立邻居关系]
D --> E[交换能力信息]
E --> F[更新路由表]
G[Agent离开] --> H[发送离开通知]
H --> I[邻居更新路由表]
I --> J[重新计算路径]
4.2.2 能力发现
@Component
public class CapabilityDiscovery {
private final Map<String, Set<String>> agentCapabilities = new ConcurrentHashMap<>();
private final Map<String, Set<String>> capabilityAgents = new ConcurrentHashMap<>();
public void registerCapabilities(String agentId, Set<String> capabilities) {
agentCapabilities.put(agentId, capabilities);
for (String capability : capabilities) {
capabilityAgents.computeIfAbsent(capability, k -> new HashSet<>()).add(agentId);
}
// 广播能力更新
broadcastCapabilityUpdate(agentId, capabilities);
}
public List<String> findAgentsWithCapability(String capability) {
return new ArrayList<>(capabilityAgents.getOrDefault(capability, Collections.emptySet()));
}
public Set<String> getAgentCapabilities(String agentId) {
return agentCapabilities.getOrDefault(agentId, Collections.emptySet());
}
private void broadcastCapabilityUpdate(String agentId, Set<String> capabilities) {
CapabilityUpdateMessage message = new CapabilityUpdateMessage(agentId, capabilities);
messageBroker.broadcast("capability.update", message);
}
}
4.3 A2A任务分配机制
4.3.1 任务分解
graph TD
A[复杂任务] --> B[任务分析器]
B --> C[分解为子任务]
C --> D[识别依赖关系]
D --> E[创建任务图]
E --> F[分配执行Agent]
F --> G[并行执行]
G --> H[结果聚合]
4.3.2 负载均衡
@Component
public class LoadBalancer {
private final Map<String, AgentMetrics> agentMetrics = new ConcurrentHashMap<>();
private final LoadBalancingStrategy strategy;
public String selectAgent(List<String> candidateAgents, Task task) {
return strategy.selectAgent(candidateAgents, task, agentMetrics);
}
public void updateMetrics(String agentId, AgentMetrics metrics) {
agentMetrics.put(agentId, metrics);
}
public interface LoadBalancingStrategy {
String selectAgent(List<String> candidates, Task task, Map<String, AgentMetrics> metrics);
}
@Component
public static class RoundRobinStrategy implements LoadBalancingStrategy {
private final AtomicInteger counter = new AtomicInteger(0);
@Override
public String selectAgent(List<String> candidates, Task task, Map<String, AgentMetrics> metrics) {
if (candidates.isEmpty()) return null;
int index = counter.getAndIncrement() % candidates.size();
return candidates.get(index);
}
}
@Component
public static class LeastLoadStrategy implements LoadBalancingStrategy {
@Override
public String selectAgent(List<String> candidates, Task task, Map<String, AgentMetrics> metrics) {
return candidates.stream()
.min(Comparator.comparing(agentId ->
metrics.getOrDefault(agentId, new AgentMetrics()).getCurrentLoad()))
.orElse(null);
}
}
}
4.4 A2A容错机制
4.4.1 故障检测
graph TD
A[Agent A] --> B[发送心跳]
B --> C[Agent B]
C --> D[响应心跳]
D --> E[更新状态]
F[心跳超时] --> G[标记为故障]
G --> H[通知其他Agent]
H --> I[重新分配任务]
I --> J[更新路由表]
4.4.2 故障恢复
@Component
public class FaultToleranceManager {
private final Map<String, AgentStatus> agentStatuses = new ConcurrentHashMap<>();
private final ScheduledExecutorService healthChecker = Executors.newScheduledThreadPool(2);
@PostConstruct
public void startHealthCheck() {
healthChecker.scheduleAtFixedRate(this::checkAgentHealth, 0, 30, TimeUnit.SECONDS);
}
private void checkAgentHealth() {
for (Map.Entry<String, AgentStatus> entry : agentStatuses.entrySet()) {
String agentId = entry.getKey();
AgentStatus status = entry.getValue();
if (status.isHealthy() && isAgentUnreachable(agentId)) {
markAgentAsFailed(agentId);
handleAgentFailure(agentId);
}
}
}
private void handleAgentFailure(String failedAgentId) {
// 1. 重新分配失败Agent的任务
reassignTasks(failedAgentId);
// 2. 更新路由表
updateRoutingTable(failedAgentId);
// 3. 通知其他Agent
notifyAgentFailure(failedAgentId);
// 4. 尝试恢复Agent
attemptAgentRecovery(failedAgentId);
}
private void reassignTasks(String failedAgentId) {
List<Task> failedTasks = taskManager.getTasksByAgent(failedAgentId);
for (Task task : failedTasks) {
String newAgent = loadBalancer.selectAgent(getAvailableAgents(), task);
if (newAgent != null) {
taskManager.reassignTask(task.getId(), newAgent);
}
}
}
}
五、A2A应用场景
5.1 智能交通系统
场景描述： 多个自动驾驶车辆Agent协作，实现交通优化和事故避免。
A2A协作模式：
graph TD
A[车辆Agent A] --> B[交通信息交换]
C[车辆Agent B] --> B
D[车辆Agent C] --> B
B --> E[路径规划]
E --> F[协调行驶]
F --> G[避免碰撞]
G --> H[优化交通流]
Java实现：
@Component
public class TrafficA2ASystem {
private final Map<String, VehicleAgent> vehicles = new ConcurrentHashMap<>();
private final TrafficCoordinator coordinator;
public void registerVehicle(String vehicleId, VehicleAgent vehicle) {
vehicles.put(vehicleId, vehicle);
coordinator.notifyVehicleJoined(vehicleId, vehicle.getPosition());
}
public void handleTrafficEvent(String vehicleId, TrafficEvent event) {
VehicleAgent vehicle = vehicles.get(vehicleId);
if (vehicle != null) {
// 广播交通事件给附近车辆
List<String> nearbyVehicles = findNearbyVehicles(vehicleId, 1000); // 1km范围
for (String nearbyId : nearbyVehicles) {
VehicleAgent nearbyVehicle = vehicles.get(nearbyId);
if (nearbyVehicle != null) {
nearbyVehicle.receiveTrafficEvent(event);
}
}
}
}
public void coordinateTrafficFlow() {
// 收集所有车辆的位置和速度信息
Map<String, VehicleState> vehicleStates = vehicles.entrySet().stream()
.collect(Collectors.toMap(
Map.Entry::getKey,
entry -> entry.getValue().getCurrentState()
));
// 计算最优交通流
TrafficFlowOptimization optimization = coordinator.optimizeTrafficFlow(vehicleStates);
// 向相关车辆发送协调指令
for (Map.Entry<String, TrafficInstruction> entry : optimization.getInstructions().entrySet()) {
String vehicleId = entry.getKey();
TrafficInstruction instruction = entry.getValue();
VehicleAgent vehicle = vehicles.get(vehicleId);
if (vehicle != null) {
vehicle.executeTrafficInstruction(instruction);
}
}
}
}
5.2 分布式计算系统
场景描述： 多个计算Agent协作，处理大规模分布式计算任务。
A2A协作模式：
graph TD
A[任务分解] --> B[子任务分配]
B --> C[Agent 1]
B --> D[Agent 2]
B --> E[Agent 3]
C --> F[并行计算]
D --> F
E --> F
F --> G[结果收集]
G --> H[结果聚合]
Java实现：
@Component
public class DistributedComputingA2A {
private final Map<String, ComputeAgent> computeAgents = new ConcurrentHashMap<>();
private final TaskScheduler taskScheduler;
private final ResultAggregator resultAggregator;
public CompletableFuture<ComputationResult> executeDistributedTask(ComputationTask task) {
// 1. 任务分解
List<SubTask> subTasks = taskDecomposer.decompose(task);
// 2. 分配子任务
Map<String, SubTask> assignments = assignSubTasks(subTasks);
// 3. 并行执行
Map<String, CompletableFuture<SubTaskResult>> futures = new HashMap<>();
for (Map.Entry<String, SubTask> entry : assignments.entrySet()) {
String agentId = entry.getKey();
SubTask subTask = entry.getValue();
ComputeAgent agent = computeAgents.get(agentId);
if (agent != null) {
futures.put(agentId, agent.executeSubTask(subTask));
}
}
// 4. 等待所有子任务完成
return CompletableFuture.allOf(futures.values().toArray(new CompletableFuture[0]))
.thenApply(v -> {
Map<String, SubTaskResult> results = new HashMap<>();
for (Map.Entry<String, CompletableFuture<SubTaskResult>> entry : futures.entrySet()) {
try {
results.put(entry.getKey(), entry.getValue().get());
} catch (Exception e) {
// 处理子任务失败
results.put(entry.getKey(), SubTaskResult.failed(e.getMessage()));
}
}
// 5. 聚合结果
return resultAggregator.aggregate(results);
});
}
private Map<String, SubTask> assignSubTasks(List<SubTask> subTasks) {
Map<String, SubTask> assignments = new HashMap<>();
List<String> availableAgents = getAvailableAgents();
for (int i = 0; i < subTasks.size(); i++) {
String agentId = availableAgents.get(i % availableAgents.size());
assignments.put(agentId, subTasks.get(i));
}
return assignments;
}
}
5.3 智能家居系统
场景描述： 多个智能设备Agent协作，实现智能家居自动化控制。
A2A协作模式：
graph TD
A[用户指令] --> B[智能网关]
B --> C[设备发现]
C --> D[设备Agent 1]
C --> E[设备Agent 2]
C --> F[设备Agent 3]
D --> G[协调控制]
E --> G
F --> G
G --> H[执行动作]
H --> I[状态反馈]
Java实现：
@Component
public class SmartHomeA2A {
private final Map<String, DeviceAgent> devices = new ConcurrentHashMap<>();
private final SceneManager sceneManager;
private final EventBus eventBus;
public void registerDevice(String deviceId, DeviceAgent device) {
devices.put(deviceId, device);
eventBus.publish(new DeviceRegisteredEvent(deviceId, device.getCapabilities()));
}
public void executeScene(String sceneName) {
Scene scene = sceneManager.getScene(sceneName);
if (scene != null) {
// 并行执行场景中的所有动作
List<CompletableFuture<Void>> futures = scene.getActions().stream()
.map(action -> executeAction(action))
.collect(Collectors.toList());
CompletableFuture.allOf(futures.toArray(new CompletableFuture[0]))
.thenRun(() -> {
// 场景执行完成
eventBus.publish(new SceneExecutedEvent(sceneName));
});
}
}
private CompletableFuture<Void> executeAction(DeviceAction action) {
DeviceAgent device = devices.get(action.getDeviceId());
if (device != null) {
return device.executeAction(action)
.thenAccept(result -> {
// 记录执行结果
eventBus.publish(new ActionExecutedEvent(action, result));
});
}
return CompletableFuture.completedFuture(null);
}
public void handleSensorEvent(String deviceId, SensorEvent event) {
DeviceAgent device = devices.get(deviceId);
if (device != null) {
// 根据传感器事件触发相应的自动化动作
List<AutomationRule> rules = automationEngine.getRulesForEvent(event);
for (AutomationRule rule : rules) {
if (rule.evaluate(event)) {
executeAction(rule.getAction());
}
}
}
}
}
5.4 金融交易系统
场景描述： 多个交易Agent协作，实现智能投资组合管理和风险控制。
A2A协作模式：
graph TD
A[市场数据] --> B[分析Agent]
B --> C[风险评估]
C --> D[投资决策]
D --> E[交易执行]
E --> F[风险监控]
F --> G[动态调整]
G --> D
Java实现：
@Component
public class TradingA2ASystem {
private final Map<String, TradingAgent> tradingAgents = new ConcurrentHashMap<>();
private final RiskManager riskManager;
private final MarketDataProvider marketDataProvider;
public void registerTradingAgent(String agentId, TradingAgent agent) {
tradingAgents.put(agentId, agent);
riskManager.registerAgent(agentId, agent.getRiskProfile());
}
public void processMarketData(MarketData data) {
// 广播市场数据给所有交易Agent
for (TradingAgent agent : tradingAgents.values()) {
agent.receiveMarketData(data);
}
// 触发交易决策
triggerTradingDecisions(data);
}
private void triggerTradingDecisions(MarketData data) {
for (Map.Entry<String, TradingAgent> entry : tradingAgents.entrySet()) {
String agentId = entry.getKey();
TradingAgent agent = entry.getValue();
// 获取交易建议
TradingSignal signal = agent.analyzeMarketData(data);
if (signal != null && signal.isValid()) {
// 风险评估
RiskAssessment risk = riskManager.assessRisk(agentId, signal);
if (risk.isAcceptable()) {
// 执行交易
executeTrade(agentId, signal);
} else {
// 风险过高，拒绝交易
agent.notifyRiskRejection(signal, risk);
}
}
}
}
private void executeTrade(String agentId, TradingSignal signal) {
TradingAgent agent = tradingAgents.get(agentId);
if (agent != null) {
CompletableFuture<TradeResult> future = agent.executeTrade(signal);
future.thenAccept(result -> {
// 更新风险模型
riskManager.updateRiskModel(agentId, result);
// 通知其他Agent
notifyTradeExecution(agentId, result);
});
}
}
private void notifyTradeExecution(String executorId, TradeResult result) {
// 通知其他Agent交易执行情况
for (Map.Entry<String, TradingAgent> entry : tradingAgents.entrySet()) {
if (!entry.getKey().equals(executorId)) {
entry.getValue().receiveTradeNotification(executorId, result);
}
}
}
}
六、Python实战：构建A2A协作网络
6.1 环境准备
pip install python-a2a google-genai
export GOOGLE_API_KEY=你的GoogleAPIKey
项目结构建议：
.
├─ sub_agents.py # 子 Agents：天气/酒店
├─ router.py # 路由器：根据问题路由到子Agent
└─ llm_client.py # Gemini LLM 客户端（可选）
6.2 子Agents实现（Weather/Booking）
# sub_agents.py
from python_a2a import A2AServer, agent, skill, TaskStatus, TaskState, run_server
@agent(name="Weather", description="Weather 查询 Agent", version="1.0.0")
class WeatherAgent(A2AServer):
@skill(name="询问天气", description="输入城市，返回天气")
def get_weather(self, city: str):
return f"当前天气：{city} 晴 22°C"
def handle_task(self, task):
text = task.message.get("content", {}).get("text", "")
if "天气" in text:
city = text.split("天气")[-1].strip()
result = self.get_weather(city)
task.artifacts = [{"parts":[{"type":"text","text":result}]}]
task.status = TaskStatus(state=TaskState.COMPLETED)
else:
task.status = TaskStatus(
state=TaskState.INPUT_REQUIRED,
message={"role":"agent","content":{"type":"text","text":"请说：天气 xxx"}}
)
return task
@agent(name="Booking", description="航班或酒店推荐 Agent", version="1.0.0")
class BookingAgent(A2AServer):
@skill(name="推荐酒店", description="输入城市，推荐酒店")
def recommend_hotels(self, city: str):
return f"推荐酒店：{city} 广场大酒店，预算每晚约￥600"
def handle_task(self, task):
text = task.message.get("content", {}).get("text", "")
if "酒店" in text:
city = text.replace("酒店", "").strip()
hotels = self.recommend_hotels(city)
task.artifacts = [{"parts":[{"type":"text","text":hotels}]}]
task.status = TaskStatus(state=TaskState.COMPLETED)
else:
task.status = TaskStatus(
state=TaskState.INPUT_REQUIRED,
message={"role":"agent","content":{"type":"text","text":"请说：酒店 xxx"}}
)
return task
if __name__ == "__main__":
import threading
threading.Thread(target=lambda: run_server(WeatherAgent(), port=5101), daemon=True).start()
threading.Thread(target=lambda: run_server(BookingAgent(), port=5102), daemon=True).start()
print("子 Agents 已启动：Weather →5101，Booking→5102")
6.3 可选：Gemini LLM 客户端封装
# llm_client.py
import os, asyncio
import genai
from python_a2a.client.llm.base import BaseLLMClient
from python_a2a.types import Message, TextContent, MessageRole
class GeminiLLMClient(BaseLLMClient):
def __init__(self, model: str = "gemini‑flash‑1.5", temperature: float = 0.0):
self.client = genai.Client(api_key=os.getenv("GOOGLE_API_KEY"))
self.model = model
self.temperature = temperature
async def send_message(self, messages: list[Message], stream: bool = False) -> Message:
prompt_msgs = []
for m in messages:
role = "user" if m.role == MessageRole.USER else "assistant"
prompt_msgs.append(genai.ChatMessage(role=role, content=m.content.text))
base = genai.types.GenerateContentConfig(model=self.model, temperature=self.temperature)
response = await self.client.generate_content(config=base, messages=prompt_msgs, stream=stream)
parts = [TextContent(text=chunk.text) for chunk in response.chunks] if stream else [TextContent(text=response.last.text)]
combined = "".join(p.text for p in parts)
return Message(content=TextContent(text=combined), role=MessageRole.AGENT, parts=parts)
async def complete(self, messages: list[Message], stream: bool = False) -> list[Message]:
msg = await self.send_message(messages, stream=stream)
return [msg]
6.4 路由器实现与运行
# router.py
from python_a2a import A2AClient, AgentNetwork, AIAgentRouter
def main():
network = AgentNetwork(name="Top‑Level AgentNetwork")
network.add("weather", "http://127.0.0.1:5101")
network.add("booking", "http://127.0.0.1:5102")
llm_agent = A2AClient("http://127.0.0.1:5102") # 示例将 BookingAgent 作为LLM代理
router = AIAgentRouter(
llm_client=llm_agent,
agent_network=network,
routing_param="${question}"
)
while True:
query = input("\n用户输入：")
target, score = router.route_query(query)
print(f"[路由决策] 将 '{query}' 发给：{target} (置信度 {score:.2f})")
agent = network.get_agent(target)
response = agent.ask(query)
print("[Agent 回答] ", response)
if __name__ == "__main__":
main()
运行步骤：
# 1) 启动子 Agents（天气/酒店）
python sub_agents.py
# 2) 另开终端运行路由器
python router.py
# 3) 交互示例
用户输入：天气 北京
用户输入：酒店 上海
6.5 A2A控制器
package com.example.a2a.controller;
import com.example.a2a.core.A2AAgent;
import com.example.a2a.core.A2AResponse;
import com.example.a2a.network.A2ANetworkManager;
import org.springframework.web.bind.annotation.*;
import org.springframework.beans.factory.annotation.Autowired;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
/**
* A2A REST API控制器
*/
@RestController
@RequestMapping("/api/a2a")
public class A2AController {
@Autowired
private A2ANetworkManager networkManager;
@PostMapping("/agents")
public Map<String, String> registerAgent(@RequestBody AgentRegistrationRequest request) {
// 这里应该创建具体的Agent实例
// 简化实现
return Map.of("agentId", "agent-" + System.currentTimeMillis(), "status", "registered");
}
@DeleteMapping("/agents/{agentId}")
public Map<String, String> unregisterAgent(@PathVariable String agentId) {
networkManager.unregisterAgent(agentId);
return Map.of("agentId", agentId, "status", "unregistered");
}
@PostMapping("/tasks")
public CompletableFuture<A2AResponse> assignTask(@RequestBody TaskAssignmentRequest request) {
return networkManager.assignTask(
request.getTaskId(),
request.getDescription(),
request.getRequiredCapabilities()
);
}
@PostMapping("/messages")
public CompletableFuture<A2AResponse> sendMessage(@RequestBody MessageRequest request) {
return networkManager.sendMessage(
request.getSenderId(),
request.getReceiverId(),
request.getMessage()
);
}
@GetMapping("/agents")
public Map<String, Object> getAgents() {
return Map.of(
"totalAgents", networkManager.getAgentCount(),
"capabilities", networkManager.getAllCapabilities()
);
}
@GetMapping("/agents/capability/{capability}")
public List<String> getAgentsWithCapability(@PathVariable String capability) {
return networkManager.findAgentsWithCapability(capability);
}
}
/**
* Agent注册请求
*/
public record AgentRegistrationRequest(
String agentType,
List<String> capabilities,
Map<String, Object> configuration
) {}
/**
* 任务分配请求
*/
public record TaskAssignmentRequest(
String taskId,
String description,
List<String> requiredCapabilities
) {}
/**
* 消息请求
*/
public record MessageRequest(
String senderId,
String receiverId,
A2AMessage message
) {}
七、A2A的挑战和未来发展趋势
7.1 当前挑战
7.1.1 技术挑战
1. 网络延迟和可靠性
- 分布式环境下的网络延迟
- 网络分区和连接中断
- 消息丢失和重复
2. 一致性保证
- 分布式状态同步
- 事务一致性
- 最终一致性
3. 安全性
- Agent身份认证
- 消息加密
- 防止恶意Agent
4. 性能优化
- 消息路由优化
- 负载均衡
- 资源管理
7.1.2 业务挑战
1. 复杂性管理
- 系统复杂度增加
- 调试和监控困难
- 故障排查复杂
2. 标准化
- 缺乏统一标准
- 互操作性差
- 生态系统分散
3. 成本控制
- 基础设施成本
- 开发和维护成本
- 运营成本
7.2 未来发展趋势
7.2.1 技术趋势
1. 标准化协议
graph TD
A[A2A协议标准化] --> B[统一消息格式]
A --> C[统一通信协议]
A --> D[统一安全机制]
B --> E[互操作性提升]
C --> E
D --> E
2. 智能路由
- 基于AI的消息路由
- 自适应网络拓扑
- 动态负载均衡
3. 边缘计算集成
- 边缘Agent部署
- 低延迟协作
- 离线能力
4. 区块链集成
- 去中心化身份
- 智能合约协调
- 不可篡改记录
7.2.2 应用趋势
1. 大规模部署
- 企业级A2A系统
- 云原生A2A平台
- 混合云A2A网络
2. 行业应用
- 智能制造
- 智慧城市
- 自动驾驶
- 金融服务
3. 人机协作
- 人类-Agent协作
- 混合智能系统
- 增强智能
7.3 发展路线图
gantt
title A2A技术发展路线图
dateFormat YYYY-MM-DD
section 基础技术
协议标准化 :2024-01-01, 2024-12-31
安全机制 :2024-06-01, 2025-06-30
性能优化 :2024-09-01, 2025-09-30
section 平台建设
开发框架 :2024-03-01, 2025-03-31
云平台 :2024-09-01, 2025-12-31
工具链 :2025-01-01, 2025-12-31
section 应用推广
行业解决方案 :2025-01-01, 2026-12-31
生态建设 :2025-06-01, 2027-06-30
大规模部署 :2026-01-01, 2027-12-31
八、总结
核心要点回顾
- A2A是去中心化的Agent协作模式，不依赖中央协调器
- A2A解决了传统多Agent系统的单点故障、扩展性限制等问题
- A2A有多种设计模式：发布-订阅、请求-响应、竞标、共识等
- A2A运行机制包括：通信协议、发现机制、任务分配、容错机制
- A2A应用场景广泛：智能交通、分布式计算、智能家居、金融交易等
- Python实现：基于python-a2a的完整A2A协作网络
