A2A（智能体协作）入门指南：从概念到实践
一、核心理念：为什么需要A2A？
在构建AI应用时，我们首先通过 MCP（工具调用协议） 让单个智能体变得强大------就像为一位工程师配备了一个完整的工具箱（数据库、邮件、API等）。但当面临复杂任务时，单一个体仍会力不从心。
A2A（Agent-to-Agent）协议应运而生，它的核心是让多个专业智能体像人类团队一样协作。 你可以将其理解为 "AI世界的Spring Cloud"：
- MCP 定义了工具如何被调用（DAO层），
- A2A 则定义了智能体如何发现彼此、分工协作（Service/Controller层）。
二、核心概念：技能清单与智能体网络
1. 与MCP的关键区别
| 维度 | MCP（Model Context Protocol） | A2A（Agent-to-Agent） |
|---|---|---|
| 交互对象 | 智能体 ↔ 工具（数据库、API） | 智能体 ↔ 智能体 |
| 核心清单 | 工具清单 ：具体函数，如get_weather |
技能清单：领域能力，如"天气分析专家" |
| 架构定位 | DAO层：提供原子化能力 | Service层：组织、决策、协作 |
| 调用模式 | 被动响应，固定接口 | 主动发现，动态协作 |
2. 核心组件
一个典型的A2A系统包含：
- 技能注册中心：智能体在此注册自己的技能（类似Spring Cloud的Eureka）。
- 智能体节点：具备特定能力的专业AI，如"数据分析Agent"、"邮件专家Agent"。
- 任务协调器（可选）：负责分解任务、路由给合适的智能体。
A2A智能体协作实战：基于OpenAI的智能体系统
一、重新理解：AI驱动的A2A架构核心
真正的A2A智能体系统的核心是每个智能体内部都有一个AI模型作为"大脑"，而不是预先编写死逻辑。传统代码只处理流程编排，而AI负责内容生成、决策和创造性工作。
让我们修正核心理念：
- 传统微服务 ：Service层是人类编写的固定逻辑
- A2A智能体 ：每个智能体是一个AI模型+专业工具，能理解任务、创造内容、做出决策
二、基于OpenAI的A2A架构实现
系统架构图
F
"专用系统提示词"
"OpenAI API调用"
"MCP工具: send_email"
E
"专用系统提示词"
"OpenAI API调用"
"MCP工具: get_sales_data"
"用户复杂请求"
主控智能体
OpenAI GPT-4
"1. 理解并分解任务"
"2. 查询技能注册中心"
"结构化分析结果"
"专业邮件内容"
"3. 整合与最终回复"
"给用户的完整答案"
三、完整代码实现：真正的AI智能体协作
1. 基础设施：智能体基类与注册中心
python
# agent_base.py
import openai
from abc import ABC, abstractmethod
from typing import Dict, Any, List
class AIAgent(ABC):
"""所有智能体的基类，封装OpenAI调用"""
def __init__(self, name: str, model: str = "gpt-3.5-turbo"):
self.name = name
self.model = model
self.system_prompt = "" # 由子类定义专业指令
self.client = openai.OpenAI(api_key="your-api-key-here")
def think(self, task: str, context: Dict = None) -> str:
"""让AI思考并生成响应"""
messages = [
{"role": "system", "content": self.system_prompt},
{"role": "user", "content": f"任务：{task}\n上下文：{context or '无'}"}
]
try:
response = self.client.chat.completions.create(
model=self.model,
messages=messages,
temperature=0.7,
max_tokens=1000
)
return response.choices[0].message.content
except Exception as e:
return f"思考过程出错：{str(e)}"
@abstractmethod
def execute(self, task: str, **kwargs) -> Dict[str, Any]:
"""执行具体任务（子类实现）"""
pass
def register_skill(self) -> Dict[str, Any]:
"""返回技能描述，用于注册中心"""
return {
"agent_name": self.name,
"skills": self._get_skills(),
"endpoint": self
}
@abstractmethod
def _get_skills(self) -> List[str]:
"""返回智能体技能列表"""
pass
# registry.py
class SkillRegistry:
"""AI技能注册中心"""
def __init__(self):
self.agents = {}
def register(self, agent: AIAgent):
info = agent.register_skill()
self.agents[info["agent_name"]] = info
print(f"✅ [注册中心] {agent.name} 注册成功 | 技能：{info['skills']}")
def find_agents_for_task(self, task_description: str) -> List[AIAgent]:
"""根据任务描述查找合适的智能体"""
# 这里可以加入更智能的匹配逻辑
matching_agents = []
for agent_info in self.agents.values():
if self._skill_matches_task(agent_info["skills"], task_description):
matching_agents.append(agent_info["endpoint"])
return matching_agents
def _skill_matches_task(self, skills: List[str], task: str) -> bool:
"""简化的技能匹配逻辑（实际中可用Embedding计算语义相似度）"""
task_lower = task.lower()
for skill in skills:
if skill.lower() in task_lower:
return True
return False2. 专业智能体实现（真正调用OpenAI）
python
# data_analyst_agent.py
from agent_base import AIAgent
import json
from typing import Dict, Any, List
class DataAnalystAgent(AIAgent):
"""数据分析智能体 - 使用OpenAI分析数据"""
def __init__(self):
super().__init__(name="数据分析专家", model="gpt-4")
# 专业系统提示词，塑造智能体专业能力
self.system_prompt = """你是一名资深数据分析专家，擅长从原始数据中提取洞察。
你的能力包括：
1. 识别数据模式和趋势
2. 生成数据驱动的建议
3. 用商业语言解释技术发现
4. 预测未来趋势
请以专业、清晰、有条理的方式回应所有数据相关请求。
如果是技术性任务，请解释你的分析过程。"""
def _get_skills(self) -> List[str]:
return ["数据分析", "趋势预测", "统计洞察", "图表解读", "业务分析"]
def execute(self, task: str, data_context: Dict = None) -> Dict[str, Any]:
print(f"🔍 [{self.name}] 开始分析任务：{task}")
# 步骤1: 让AI理解任务并制定分析计划
analysis_plan = self.think(
f"针对这个数据任务，请制定分析计划：{task}",
data_context
)
# 步骤2: 执行分析（这里模拟获取数据，实际中会调用MCP工具）
if data_context and "sales_data" in data_context:
analysis_input = f"销售数据：{json.dumps(data_context['sales_data'], indent=2)}"
else:
# 模拟一些数据供AI分析
analysis_input = """2024年1-3月销售数据：
- 1月：$450,000，新客户120人
- 2月：$520,000，新客户95人
- 3月：$610,000，新客户150人
主要产品线：A系列(40%)，B系列(35%)，C系列(25%)"""
# 步骤3: 调用AI进行深度分析
analysis_result = self.think(
f"请分析以下数据并提供商业洞察：\n{analysis_input}\n\n具体任务要求：{task}",
{"分析计划": analysis_plan}
)
# 步骤4: 生成执行摘要
summary = self.think(
"基于上述分析，生成一个3点的执行摘要，面向管理层",
{"详细分析": analysis_result}
)
return {
"agent": self.name,
"task": task,
"analysis_plan": analysis_plan,
"detailed_analysis": analysis_result,
"executive_summary": summary,
"recommendations": self._extract_recommendations(analysis_result),
"status": "completed"
}
def _extract_recommendations(self, analysis: str) -> List[str]:
"""让AI从分析中提取具体建议"""
prompt = f"从以下分析中提取3-5条具体的、可执行的商业建议：\n{analysis}"
recommendations_text = self.think(prompt)
# 简单解析AI返回的建议列表
return [rec.strip() for rec in recommendations_text.split('\n') if rec.strip() and len(rec.strip()) > 10]
# email_specialist_agent.py
from agent_base import AIAgent
from typing import Dict, Any, List
class EmailSpecialistAgent(AIAgent):
"""邮件专家智能体 - 使用OpenAI撰写专业邮件"""
def __init__(self):
super().__init__(name="邮件撰写专家", model="gpt-4")
self.system_prompt = """你是专业的商业邮件撰写专家，精通：
1. 各种商务场景的邮件写作（报告、跟进、营销、通知）
2. 调整语气以适应不同收件人（客户、团队、管理层）
3. 创建清晰、有说服力、专业的邮件内容
4. 遵守商务邮件的格式和礼仪规范
请根据具体需求创作恰到好处的邮件内容。"""
def _get_skills(self) -> List[str]:
return ["邮件撰写", "商务沟通", "内容创作", "语气调整", "邮件模板"]
def execute(self, task: str, context: Dict = None) -> Dict[str, Any]:
print(f"📧 [{self.name}] 开始邮件任务：{task}")
# 让AI理解邮件需求
requirements = self.think(
f"分析这个邮件任务的需求：{task}",
context
)
# 生成邮件草稿
email_draft = self._compose_email(task, context, requirements)
# 优化邮件（让AI自我审查和优化）
optimized_email = self.think(
"请优化以下邮件草稿，确保专业、清晰、得体：\n" + email_draft,
{"原始需求": task, "需求分析": requirements}
)
# 生成发送建议
sending_advice = self.think(
"基于这封邮件的内容，给出发送时间、后续跟进等建议",
{"邮件内容": optimized_email}
)
return {
"agent": self.name,
"task": task,
"requirements_analysis": requirements,
"email_content": optimized_email,
"subject": self._extract_subject(optimized_email),
"sending_advice": sending_advice,
"status": "completed"
}
def _compose_email(self, task: str, context: Dict, requirements: str) -> str:
"""核心：让AI撰写邮件"""
prompt = f"""请撰写一封专业邮件。
任务：{task}
需求分析：{requirements}
"""
if context and "data_analysis" in context:
prompt += f"需要包含的数据分析结果：\n{context['data_analysis']}\n\n"
prompt += "请生成完整的邮件，包括适当的称呼、正文、结尾敬语。"
return self.think(prompt)
def _extract_subject(self, email_content: str) -> str:
"""从邮件内容中提取主题行"""
subject = self.think(
"从以下邮件内容中提取一个恰当的主题行（不超过10个词）：\n" + email_content
)
return subject.strip()3. 主控协调智能体（真正的AI任务分解者）
python
# coordinator_agent.py
from agent_base import AIAgent
from registry import SkillRegistry
from typing import Dict, Any, List
import json
class CoordinatorAgent(AIAgent):
"""主控协调智能体 - 使用OpenAI分解和协调任务"""
def __init__(self, registry: SkillRegistry):
super().__init__(name="任务协调器", model="gpt-4")
self.registry = registry
self.system_prompt = """你是智能任务协调专家，擅长：
1. 理解复杂任务并将其分解为专业子任务
2. 识别完成任务所需的技能和专业领域
3. 协调多个专家智能体协作
4. 整合各专家的工作成果形成完整交付物
请以项目经理的思维工作，确保任务高效、准确地完成。"""
def _get_skills(self):
return ["任务分解", "资源协调", "进度管理", "结果整合"]
def handle_complex_request(self, user_request: str) -> Dict[str, Any]:
print(f"🎯 [{self.name}] 处理复杂请求：{user_request}")
# 步骤1: 用AI分析请求并制定执行计划
execution_plan = self._create_execution_plan(user_request)
# 步骤2: 分解任务并分配
subtasks = self._breakdown_tasks(user_request, execution_plan)
# 步骤3: 执行所有子任务
results = {}
for subtask in subtasks:
agent_type = subtask["assigned_agent_type"]
agents = self.registry.find_agents_for_task(agent_type)
if agents:
agent = agents[0] # 选择第一个匹配的智能体
print(f" 📋 分配任务到 {agent.name}: {subtask['description']}")
# 添加上下文信息
context = {}
if "data_analysis" in results:
context["data_analysis"] = results["data_analysis"]["detailed_analysis"]
# 执行子任务
result = agent.execute(subtask["description"], context)
results[subtask["id"]] = result
else:
print(f" ⚠️ 未找到处理 {agent_type} 的智能体")
# 步骤4: 用AI整合所有结果
final_output = self._integrate_results(user_request, results)
return {
"original_request": user_request,
"execution_plan": execution_plan,
"subtasks": subtasks,
"agent_results": results,
"final_output": final_output,
"status": "all_completed"
}
def _create_execution_plan(self, request: str) -> str:
"""让AI创建执行计划"""
return self.think(
f"为以下复杂请求创建一个分步执行计划：\n\n请求：{request}",
{"当前时间": "2024年Q2", "优先级": "高"}
)
def _breakdown_tasks(self, request: str, plan: str) -> List[Dict]:
"""让AI分解任务并推荐执行者"""
prompt = f"""基于以下请求和执行计划，分解为具体的子任务：
原始请求：{request}
执行计划：{plan}
请列出3-5个子任务，每个任务包含：
1. 任务描述
2. 所需技能类型
3. 预计输出
请用JSON格式回复，结构如下：
{{
"tasks": [
{{
"id": "task_1",
"description": "任务描述",
"required_skills": ["技能1", "技能2"],
"assigned_agent_type": "最适合的智能体类型",
"expected_output": "期望输出"
}}
]
}}
"""
response = self.think(prompt)
try:
# 尝试解析JSON响应
start_idx = response.find('{')
end_idx = response.rfind('}') + 1
json_str = response[start_idx:end_idx]
data = json.loads(json_str)
return data.get("tasks", [])
except:
# 如果AI没有返回标准JSON，创建默认分解
return [
{
"id": "task_1",
"description": f"分析相关数据：{request}",
"required_skills": ["数据分析"],
"assigned_agent_type": "数据分析",
"expected_output": "数据分析报告"
},
{
"id": "task_2",
"description": f"基于分析结果创建沟通内容：{request}",
"required_skills": ["邮件撰写"],
"assigned_agent_type": "邮件撰写",
"expected_output": "专业邮件内容"
}
]
def _integrate_results(self, original_request: str, results: Dict) -> str:
"""让AI整合所有智能体的工作成果"""
results_summary = "\n\n".join([
f"## {result['agent']} 的工作：\n"
f"任务：{result['task']}\n"
f"关键输出：{result.get('executive_summary', result.get('email_content', '无'))[:200]}..."
for result in results.values()
])
return self.think(
f"请整合以下专家们的工作成果，形成对原始请求的完整回复：\n\n"
f"原始请求：{original_request}\n\n"
f"各专家工作摘要：\n{results_summary}\n\n"
f"请生成一个连贯、专业、完整的最终答复。",
{"整合模式": "面向管理层的执行摘要"}
)4. 完整工作流程演示
python
# main_demo.py
from registry import SkillRegistry
from data_analyst_agent import DataAnalystAgent
from email_specialist_agent import EmailSpecialistAgent
from coordinator_agent import CoordinatorAgent
def main():
print("🤖 基于OpenAI的A2A智能体协作系统")
print("=" * 60)
# 1. 创建技能注册中心
registry = SkillRegistry()
# 2. 创建专业智能体（每个都有OpenAI大脑）
print("\n创建专业智能体...")
data_agent = DataAnalystAgent()
email_agent = EmailSpecialistAgent()
# 3. 注册智能体技能
registry.register(data_agent)
registry.register(email_agent)
# 4. 创建主协调器
coordinator = CoordinatorAgent(registry)
# 5. 模拟用户复杂请求
complex_requests = [
"分析我们第一季度销售数据，识别增长点，并给销售团队写一封激励邮件",
"评估最近三个月的客户满意度数据，找出改进机会，然后起草给产品团队的改进建议邮件",
"对比去年和今年的市场活动ROI，总结有效策略，并创建给市场部门的分享邮件"
]
print(f"\n{'='*60}")
print("开始处理复杂请求（每个请求都会触发多智能体协作）")
print('='*60)
for i, request in enumerate(complex_requests, 1):
print(f"\n📥 请求 #{i}: {request}")
print("-" * 40)
# 6. 协调器处理请求（触发AI协作）
result = coordinator.handle_complex_request(request)
# 7. 展示结果
print(f"\n✅ 请求处理完成！")
print(f" 执行计划：{result['execution_plan'][:100]}...")
print(f" 涉及智能体：{len(result['subtasks'])} 个")
# 展示每个智能体的贡献
for task_id, agent_result in result['agent_results'].items():
agent_name = agent_result['agent']
if "数据" in agent_name:
print(f" 📊 {agent_name} 提供了 {len(agent_result.get('recommendations', []))} 条建议")
elif "邮件" in agent_name:
subject = agent_result.get('subject', '无主题')
print(f" 📧 {agent_name} 撰写了邮件：{subject}")
# 展示最终AI生成的整合答复
print(f"\n💡 最终整合答复（前200字符）：")
print(result['final_output'][:200] + "...")
print("=" * 60)
if __name__ == "__main__":
# 设置OpenAI API密钥（实际使用中应从环境变量读取）
import os
# os.environ["OPENAI_API_KEY"] = "your-api-key-here"
main()四、关键AI调用点解析
在这个真正的A2A系统中，AI在多个层面工作：
- 任务分解层（协调器）：使用GPT-4理解复杂请求，分解为专业任务
- 专业执行层（各智能体）：每个智能体用专用系统提示词+GPT模型执行专业工作
- 结果整合层（协调器）：再次调用GPT整合所有专家输出
五、运行效果示例
🤖 基于OpenAI的A2A智能体协作系统
============================================================
创建专业智能体...
✅ [注册中心] 数据分析专家 注册成功 | 技能：['数据分析', '趋势预测', '统计洞察', '图表解读', '业务分析']
✅ [注册中心] 邮件撰写专家 注册成功 | 技能：['邮件撰写', '商务沟通', '内容创作', '语气调整', '邮件模板']
============================================================
开始处理复杂请求（每个请求都会触发多智能体协作）
============================================================
📥 请求 #1: 分析我们第一季度销售数据，识别增长点，并给销售团队写一封激励邮件
----------------------------------------
🎯 [任务协调器] 处理复杂请求：分析我们第一季度销售数据，识别增长点，并给销售团队写一封激励邮件
🔍 [数据分析专家] 开始分析任务：分析第一季度销售数据，识别关键增长点
📋 分配任务到 数据分析专家: 分析第一季度销售数据，识别关键增长点
📧 [邮件撰写专家] 开始邮件任务：基于销售分析结果给销售团队写激励邮件
📋 分配任务到 邮件撰写专家: 基于销售分析结果给销售团队写激励邮件
✅ 请求处理完成！
执行计划：1. 数据收集与清洗 -> 2. 趋势分析与增长点识别 -> 3. 激励邮件框架设计 -> 4. 邮件内容创作与优化...
涉及智能体：2 个
📊 数据分析专家 提供了 4 条建议
📧 邮件撰写专家 撰写了邮件：第一季度销售佳绩与激励
💡 最终整合答复（前200字符）：
基于数据分析专家和邮件撰写专家的协作，我们完成了对第一季度销售数据的全面分析。关键发现：3月份销售额达到$610,000，同比增长35%，主要增长驱动力来自...六、核心优势
- 真正的AI驱动：每个决策、每段内容都由OpenAI模型生成
- 专业分工：每个智能体有专用系统提示词，成为领域专家
- 灵活协作：协调器动态分解任务，智能匹配专家
- 可解释性：每个步骤都有AI的思考过程记录
这个系统展示了A2A架构的真正潜力------不是预先编程的流程，而是由多个AI专家动态协作解决复杂问题。