AgentFramework-零基础入门-第07章_创建多代理工作流

工作流是一个定义了多个代理如何协作、何时执行、如何传递信息的自动化流程。节点（Nodes）：每个代理或处理步骤边（Edges）：连接节点的路径，定义执行顺序数据流：在节点之间传递的信息控制流：决定执行路径的逻辑场景工作流类型主要优势适用行业简历筛选顺序+并行提高效率，标准化评估HR、招聘客户服务条件智能路由，自动化处理客服、电商内容创作混合+循环自动化创作，质量保证媒体、营销财务报表顺序+并行减少

许泽宇的技术分享

738人浏览 · 2025-11-29 23:23:34

许泽宇的技术分享 · 2025-11-29 23:23:34 发布

工作流概念

什么是工作流？

简单理解

想象一下你在公司里处理一个客户订单：

销售部门接收订单并确认需求
库存部门检查是否有货
财务部门处理付款
物流部门安排发货

这就是一个工作流！每个部门（代理）负责自己的任务，按照一定的顺序或规则协作完成整个流程。

在 AI 代理的世界里，工作流（Workflow） 就是让多个代理按照特定的流程协同工作，共同完成复杂任务的机制。

正式定义

工作流是一个定义了多个代理如何协作、何时执行、如何传递信息的自动化流程。它包含：

节点（Nodes）：每个代理或处理步骤
边（Edges）：连接节点的路径，定义执行顺序
数据流：在节点之间传递的信息
控制流：决定执行路径的逻辑

为什么需要多代理协作？

单一代理的局限性

一个代理就像一个全能员工，虽然可以处理很多事情，但会遇到以下问题：

复杂度过高：指令变得冗长复杂，难以维护
专业性不足：无法在每个领域都做到最好
可扩展性差：添加新功能需要修改整个代理
调试困难：出错时难以定位问题

多代理协作的优势

就像公司里的团队协作，多代理系统有以下优势：

1. 专业分工

每个代理专注于自己擅长的领域：

翻译代理专门负责翻译
分析代理专门负责数据分析
写作代理专门负责内容创作

2. 模块化设计

每个代理独立开发和测试
可以单独更新某个代理而不影响其他部分
代理可以在不同项目中复用

3. 并行处理

多个代理可以同时工作
大大提高处理速度
充分利用计算资源

4. 灵活组合

根据不同需求组合不同的代理
轻松添加或移除代理
适应不同的业务场景

5. 更好的可维护性

问题定位更容易
代码结构更清晰
团队协作更高效

实际应用场景

场景 1：内容创作流水线

研究代理 → 大纲代理 → 写作代理 → 审核代理 → 发布代理

场景 2：客户服务系统

接待代理 → 分类代理 → [技术支持代理 / 销售代理 / 投诉处理代理] → 总结代理

场景 3：数据分析管道

数据收集代理 → 清洗代理 → 分析代理 → 可视化代理 → 报告代理

工作流的类型

Microsoft Agent Framework 支持多种工作流类型，每种适用于不同的场景。

1. 顺序工作流（Sequential Workflow）

特点：代理按照固定顺序依次执行

流程图：

[代理A] → [代理B] → [代理C] → [代理D]

适用场景：

有明确先后顺序的任务
后续步骤依赖前面步骤的结果
流程相对固定

示例：文档翻译流程

原文分析代理 → 翻译代理 → 校对代理 → 格式化代理

优点：

逻辑清晰，易于理解
便于调试和维护
执行顺序可预测

缺点：

无法并行处理
灵活性较低
某个环节慢会影响整体速度

2. 并行工作流（Parallel Workflow）

特点：多个代理同时执行，最后汇总结果

流程图：

           ┌─→ [代理B] ─┐
[代理A] ───┼─→ [代理C] ─┼─→ [代理E]
           └─→ [代理D] ─┘

适用场景：

多个独立任务可以同时进行
需要从多个角度分析同一问题
追求处理速度

示例：市场调研分析

                    ┌─→ 竞品分析代理 ─┐
数据收集代理 ───────┼─→ 用户反馈代理 ─┼─→ 综合报告代理
                    └─→ 趋势分析代理 ─┘

优点：

处理速度快
充分利用资源
可以获得多角度的结果

缺点：

资源消耗较大
需要处理结果合并
调试相对复杂

3. 条件工作流（Conditional Workflow）

特点：根据条件动态选择执行路径

流程图：

                    ┌─→ [代理B] → [代理D]
[代理A] → [判断] ───┤
                    └─→ [代理C] → [代理E]

适用场景：

需要根据情况做出决策
不同类型的输入需要不同处理
有多种可能的执行路径

示例：智能客服路由

                        ┌─→ 技术支持代理 → 解决方案代理
接待代理 → 分类代理 ────┼─→ 销售咨询代理 → 产品推荐代理
                        └─→ 投诉处理代理 → 补偿方案代理

优点：

灵活性高
可以处理复杂业务逻辑
资源利用更高效

缺点：

逻辑较复杂
需要设计好判断条件
测试覆盖面要求高

4. 循环工作流（Loop Workflow）

特点：重复执行某些步骤直到满足条件

流程图：

[代理A] → [代理B] → [检查] ─┐
            ↑                │
            └────────────────┘
                (不满足条件)

适用场景：

需要迭代优化的任务
质量要求高，需要反复检查
自我改进的流程

示例：代码生成与优化

需求分析 → 代码生成 → 测试验证 → [通过？] ─┐
              ↑                           │
              └───────────────────────────┘
                      (未通过，继续优化)

优点：

可以持续改进结果
适合质量要求高的场景
自动化程度高

缺点：

可能陷入无限循环
需要设计好退出条件
执行时间不确定

5. 混合工作流（Hybrid Workflow）

特点：结合多种工作流类型

流程图：

                    ┌─→ [代理B] ─┐
[代理A] → [判断] ───┤            ├─→ [代理E] → [代理F]
                    └─→ [代理C] ─┤
                         ↓       │
                       [代理D] ──┘

适用场景：

复杂的业务流程
需要灵活组合多种模式
大型企业级应用

示例：智能内容创作平台

                        ┌─→ 图片生成代理 ─┐
主题分析 → [内容类型] ──┼─→ 文章写作代理 ─┼─→ 质量检查 → [合格？] ─┐
                        └─→ 视频脚本代理 ─┘                      │
                                                    ↑              │
                                                    └──────────────┘
                                                      (不合格，重新生成)

优点：

最大灵活性
可以应对复杂场景
充分发挥各种模式的优势

缺点：

设计和实现复杂
调试和维护成本高
需要仔细规划

工作流设计原则

1. 单一职责原则

每个代理只负责一个明确的任务，不要让一个代理做太多事情。

2. 松耦合原则

代理之间通过标准接口通信，减少相互依赖。

3. 可观测性原则

记录每个步骤的执行情况，便于监控和调试。

4. 容错性原则

设计好错误处理机制，某个代理失败不应导致整个流程崩溃。

5. 可扩展性原则

便于添加新的代理或修改现有流程。

工作流 vs 单一代理对比

特性	单一代理	多代理工作流
复杂度	低	中到高
专业性	通用	专业化
可维护性	一般	好
可扩展性	差	好
性能	一般	可并行，更快
成本	低	较高
适用场景	简单任务	复杂业务流程

何时使用工作流？

适合使用工作流的情况：

✅ 任务可以分解为多个独立步骤
✅ 需要不同专业能力的代理
✅ 有明确的流程和规则
✅ 需要并行处理提高效率
✅ 系统需要高可维护性
✅ 需要灵活组合不同功能

不需要工作流的情况：

❌ 任务非常简单，一个代理就能完成
❌ 没有明确的流程划分
❌ 开发时间和成本有限
❌ 只是原型或演示项目

小结

工作流是构建复杂 AI 代理系统的关键技术：

工作流让多个代理协同工作，就像团队协作一样
多代理协作带来专业分工、模块化、并行处理等优势
主要类型包括顺序、并行、条件、循环和混合工作流
选择合适的类型取决于具体的业务场景和需求
设计原则包括单一职责、松耦合、可观测性等

在接下来的课程中，我们将通过具体的业务场景和代码示例，学习如何创建和使用这些工作流。

思考题

你能想到哪些适合用多代理工作流解决的实际问题？
对于一个电商订单处理系统，你会如何设计工作流？
什么情况下并行工作流比顺序工作流更合适？

业务场景示例

本文档将介绍 5 个实际的业务场景，展示如何使用多代理工作流解决真实问题。每个场景都包含问题描述、解决方案和流程图。

场景 1：智能简历筛选系统

问题描述

HR 部门每天收到大量简历，需要：

从邮件或文件中提取简历信息
根据职位要求评估候选人
生成评估报告
推荐面试问题
发送反馈邮件

手动处理耗时且容易遗漏重要信息。

解决方案

使用多代理工作流自动化简历筛选流程：

代理分工：

简历解析代理：提取简历中的关键信息（教育、经验、技能等）
匹配评分代理：根据职位要求对候选人打分
报告生成代理：生成详细的评估报告
问题推荐代理：根据简历内容推荐面试问题
邮件发送代理：自动发送反馈邮件

工作流类型

顺序 + 并行混合工作流

流程图

                                    ┌─→ [报告生成代理] ─┐
[简历解析代理] → [匹配评分代理] ───┤                   ├─→ [邮件发送代理]
                                    └─→ [问题推荐代理] ─┘

流程说明

简历解析（顺序）
- 输入：PDF/Word 简历文件
- 输出：结构化的候选人信息
匹配评分（顺序）
- 输入：候选人信息 + 职位要求
- 输出：匹配分数和评估结果
并行处理（并行）
- 报告生成代理：创建详细评估报告
- 问题推荐代理：生成面试问题清单
- 两者同时进行，提高效率
发送反馈（顺序）
- 输入：报告 + 问题清单
- 输出：发送给 HR 和候选人的邮件

预期效果

⏱️ 处理时间：从 30 分钟降至 2 分钟
📊 准确率：提高 40%
🎯 一致性：评估标准统一
📈 效率：HR 可以专注于面试环节

场景 2：客户服务智能路由系统

问题描述

客服中心面临的挑战：

客户问题类型多样（技术、销售、投诉）
需要快速分类并路由到合适的专员
常见问题可以自动回答
复杂问题需要人工介入
需要记录和分析客户反馈

解决方案

使用条件工作流实现智能路由：

代理分工：

接待代理：欢迎客户，收集基本信息
意图识别代理：分析客户问题类型
知识库代理：查询常见问题答案
技术支持代理：处理技术问题
销售咨询代理：处理销售相关问题
投诉处理代理：处理客户投诉
总结代理：生成服务记录和分析报告

工作流类型

条件工作流

流程图

[接待代理] → [意图识别代理] → [知识库代理] → [能自动解决？]
                                                    │
                                    ┌───────────────┴───────────────┐
                                    │                               │
                                   是                              否
                                    │                               │
                                    ↓                               ↓
                              [直接回答]                    [问题类型判断]
                                    │                               │
                                    │               ┌───────────────┼───────────────┐
                                    │               │               │               │
                                    │          技术问题          销售问题        投诉问题
                                    │               │               │               │
                                    │               ↓               ↓               ↓
                                    │       [技术支持代理]   [销售咨询代理]   [投诉处理代理]
                                    │               │               │               │
                                    └───────────────┴───────────────┴───────────────┘
                                                    │
                                                    ↓
                                              [总结代理]

流程说明

接待阶段
- 欢迎客户
- 收集基本信息（姓名、订单号等）
意图识别
- 分析客户问题
- 识别问题类型和紧急程度
知识库查询
- 搜索常见问题库
- 判断是否可以自动解决
条件路由
- 如果可以自动解决：直接提供答案
- 如果需要人工：根据类型路由到专业代理
  - 技术问题 → 技术支持代理
  - 销售问题 → 销售咨询代理
  - 投诉问题 → 投诉处理代理
服务总结
- 记录服务过程
- 生成客户满意度调查
- 更新知识库

预期效果

🤖 自动解决率：60% 的问题无需人工
⚡ 响应速度：平均等待时间减少 70%
🎯 路由准确率：95% 以上
📊 数据洞察：自动生成服务分析报告

场景 3：内容创作与发布流水线

问题描述

内容团队需要：

根据热点话题生成文章大纲
撰写高质量文章
生成配图和图表
进行 SEO 优化
审核内容质量
发布到多个平台

手动操作流程长，容易出错。

解决方案

使用混合工作流实现自动化内容创作：

代理分工：

话题研究代理：分析热点话题和关键词
大纲生成代理：创建文章结构
内容写作代理：撰写文章正文
图片生成代理：创建配图
SEO 优化代理：优化标题和关键词
质量审核代理：检查内容质量
多平台发布代理：发布到不同平台

工作流类型

顺序 + 并行 + 循环混合工作流

流程图

[话题研究代理] → [大纲生成代理] → [内容写作代理]
                                        │
                        ┌───────────────┴───────────────┐
                        │                               │
                        ↓                               ↓
                  [图片生成代理]                  [SEO优化代理]
                        │                               │
                        └───────────────┬───────────────┘
                                        │
                                        ↓
                                  [质量审核代理]
                                        │
                                        ↓
                                  [质量合格？]
                                        │
                        ┌───────────────┴───────────────┐
                        │                               │
                       是                              否
                        │                               │
                        ↓                               │
                [多平台发布代理]                         │
                                                        │
                                        ┌───────────────┘
                                        │
                                        ↓
                              [返回内容写作代理修改]

流程说明

研究阶段（顺序）
- 分析当前热点话题
- 确定目标关键词
- 生成文章大纲
创作阶段（顺序）
- 根据大纲撰写文章
- 确保内容质量和可读性
优化阶段（并行）
- 图片生成：创建相关配图
- SEO 优化：优化标题、描述、关键词
- 两者同时进行，节省时间
审核阶段（循环）
- 检查内容质量
- 如果不合格：返回修改
- 如果合格：进入发布阶段
发布阶段（并行）
- 同时发布到多个平台
- 适配不同平台的格式要求

预期效果

⏱️ 创作时间：从 4 小时降至 30 分钟
📈 产量：提升 5 倍
🎯 SEO 效果：搜索排名提升 30%
✅ 质量一致性：标准化审核流程

场景 4：财务报表自动生成系统

问题描述

财务部门每月需要：

从多个系统收集数据
清洗和验证数据
进行财务分析
生成多种报表（损益表、资产负债表等）
创建可视化图表
生成分析报告
发送给相关人员

手动处理容易出错且耗时。

解决方案

使用并行工作流提高处理效率：

代理分工：

数据收集代理：从 ERP、CRM 等系统获取数据
数据清洗代理：清理和标准化数据
数据验证代理：检查数据完整性和准确性
损益表代理：生成损益表
资产负债表代理：生成资产负债表
现金流量表代理：生成现金流量表
可视化代理：创建图表和仪表板
分析报告代理：生成财务分析报告
分发代理：发送报表给相关人员

工作流类型

顺序 + 并行混合工作流

流程图

[数据收集代理] → [数据清洗代理] → [数据验证代理]
                                        │
                        ┌───────────────┼───────────────┐
                        │               │               │
                        ↓               ↓               ↓
                  [损益表代理]    [资产负债表代理]  [现金流量表代理]
                        │               │               │
                        └───────────────┼───────────────┘
                                        │
                        ┌───────────────┴───────────────┐
                        │                               │
                        ↓                               ↓
                  [可视化代理]                    [分析报告代理]
                        │                               │
                        └───────────────┬───────────────┘
                                        │
                                        ↓
                                  [分发代理]

流程说明

数据准备（顺序）
- 收集：从各系统获取原始数据
- 清洗：处理缺失值、异常值
- 验证：确保数据准确性
报表生成（并行）
- 三个代理同时生成不同报表
- 大幅缩短处理时间
- 充分利用计算资源
分析展示（并行）
- 可视化代理：创建图表
- 分析报告代理：撰写分析文字
- 两者同时进行
报表分发（顺序）
- 整合所有报表和分析
- 根据权限发送给不同人员
- 记录发送日志

预期效果

⏱️ 处理时间：从 2 天降至 2 小时
📊 准确率：减少 90% 的人为错误
🔄 实时性：可以随时生成最新报表
📈 洞察力：自动发现财务异常

场景 5：代码审查与优化助手

问题描述

开发团队需要：

审查代码质量
检查安全漏洞
分析性能问题
检查代码规范
生成改进建议
自动修复简单问题

手动审查耗时且可能遗漏问题。

解决方案

使用并行工作流进行全面代码审查：

代理分工：

代码解析代理：分析代码结构
质量检查代理：检查代码质量（复杂度、重复等）
安全扫描代理：检测安全漏洞
性能分析代理：分析性能瓶颈
规范检查代理：检查编码规范
建议生成代理：汇总问题并生成改进建议
自动修复代理：修复简单问题

工作流类型

并行工作流

流程图

                        ┌─→ [质量检查代理] ─┐
                        │                   │
                        ├─→ [安全扫描代理] ─┤
                        │                   │
[代码解析代理] ─────────┼─→ [性能分析代理] ─┼─→ [建议生成代理] → [自动修复代理]
                        │                   │
                        └─→ [规范检查代理] ─┘

流程说明

代码解析（顺序）
- 解析代码结构
- 构建抽象语法树（AST）
- 提取关键信息
并行检查（并行）
- 质量检查：复杂度、重复代码、可维护性
- 安全扫描：SQL 注入、XSS、敏感信息泄露
- 性能分析：算法复杂度、资源使用
- 规范检查：命名、格式、注释
- 四个代理同时工作，快速完成审查
建议生成（顺序）
- 汇总所有检查结果
- 按优先级排序问题
- 生成详细的改进建议
自动修复（顺序）
- 修复简单问题（格式、命名等）
- 生成修复后的代码
- 标记需要人工处理的复杂问题

预期效果

⏱️ 审查时间：从 2 小时降至 5 分钟
🔍 覆盖率：检查更全面
🛡️ 安全性：及时发现安全漏洞
🚀 代码质量：持续改进

场景对比总结

场景	工作流类型	主要优势	适用行业
简历筛选	顺序+并行	提高效率，标准化评估	HR、招聘
客户服务	条件	智能路由，自动化处理	客服、电商
内容创作	混合+循环	自动化创作，质量保证	媒体、营销
财务报表	顺序+并行	减少错误，实时生成	财务、会计
代码审查	并行	全面检查，快速反馈	软件开发

选择合适场景的建议

1. 分析任务特点

是否可以分解为多个步骤？
步骤之间的依赖关系如何？
是否有并行处理的机会？

2. 评估收益

能节省多少时间？
能提高多少准确率？
投入产出比如何？

3. 考虑实施难度

技术复杂度
数据准备工作
团队技能水平

4. 从简单开始

先实现核心流程
逐步添加功能
持续优化改进

小结

通过这 5 个实际场景，我们看到：

多代理工作流可以应用于各种行业和场景
不同的工作流类型适合不同的业务需求
合理的设计可以大幅提高效率和质量
从实际问题出发是设计工作流的关键

在下一节中，我们将学习如何用代码实现这些工作流。

思考题

你的工作中有哪些场景适合使用多代理工作流？
对于你想到的场景，应该使用哪种工作流类型？
如何评估实施工作流的投入产出比？

创建工作流

本文档将通过完整的代码示例，教你如何使用 Microsoft Agent Framework 创建不同类型的工作流。

前置准备

安装必要的 NuGet 包

dotnet add package Microsoft.Agents.AI
dotnet add package Microsoft.Agents.AI.Workflows
dotnet add package Microsoft.Extensions.AI
dotnet add package Azure.AI.OpenAI

基础配置

using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;
using Azure.AI.OpenAI;

// 配置 Azure OpenAI
var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
var apiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY");
var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT");

var chatClient = new AzureOpenAIClient(new Uri(endpoint), new ApiKeyCredential(apiKey))
    .AsChatClient(deploymentName);

工作流基础概念

核心组件

在 Microsoft Agent Framework 中，工作流由以下核心组件构成：

WorkflowBuilder：工作流构建器，用于定义工作流结构
Executor：执行器，代表工作流中的一个节点（可以是代理或函数）
Edge：边，连接执行器，定义数据流和控制流
Workflow：完整的工作流对象，可以执行

基本工作流结构

// 创建工作流构建器
var builder = new WorkflowBuilder();

// 添加执行器（代理）
var agent1 = builder.AddAgent("agent1", chatClient, "你是一个助手");
var agent2 = builder.AddAgent("agent2", chatClient, "你是另一个助手");

// 连接执行器
builder.AddEdge(agent1, agent2);

// 构建工作流
var workflow = builder.Build();

// 执行工作流
var result = await workflow.RunAsync("用户输入");

示例 1：顺序工作流

场景：文章翻译流水线

将中文文章翻译成英文，然后进行润色。

完整代码

using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;
using Azure.AI.OpenAI;

class SequentialWorkflowExample
{
    public static async Task Main()
    {
        // 配置 ChatClient
        var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
        var apiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY");
        var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT");

        var chatClient = new AzureOpenAIClient(new Uri(endpoint), new ApiKeyCredential(apiKey))
            .AsChatClient(deploymentName);

        // 创建工作流构建器
        var builder = new WorkflowBuilder();

        // 定义代理 1：翻译代理
        var translatorAgent = builder.AddAgent(
            "translator",
            chatClient,
            instructions: @"你是一个专业的中英翻译。
            将用户提供的中文文本翻译成英文。
            保持原文的语气和风格。
            只输出翻译结果，不要添加额外说明。"
        );

        // 定义代理 2：润色代理
        var polisherAgent = builder.AddAgent(
            "polisher",
            chatClient,
            instructions: @"你是一个英文写作专家。
            对提供的英文文本进行润色，使其更加流畅自然。
            保持原意不变，只改进表达方式。
            只输出润色后的结果。"
        );

        // 连接代理：翻译 → 润色
        builder.AddEdge(translatorAgent, polisherAgent);

        // 构建工作流
        var workflow = builder.Build();

        // 执行工作流
        Console.WriteLine("=== 文章翻译流水线 ===\n");
        
        string chineseText = @"人工智能正在改变我们的生活。
        从智能手机到自动驾驶汽车，AI 技术无处不在。
        它不仅提高了效率，还为我们带来了全新的可能性。";

        Console.WriteLine($"原文：\n{chineseText}\n");
        Console.WriteLine("处理中...\n");

        var result = await workflow.RunAsync(chineseText);

        Console.WriteLine($"最终结果：\n{result.FinalOutput}\n");
    }
}

代码解释

创建翻译代理
```
var translatorAgent = builder.AddAgent("translator", chatClient, instructions: "...");
```
- 第一个参数：代理的唯一标识符
- 第二个参数：ChatClient 实例
- instructions：代理的系统提示词

创建润色代理

var polisherAgent = builder.AddAgent("polisher", chatClient, instructions: "...");

同样的方式创建第二个代理

连接代理
```
builder.AddEdge(translatorAgent, polisherAgent);
```
- 定义数据流：翻译代理的输出 → 润色代理的输入
执行工作流
```
var result = await workflow.RunAsync(chineseText);
```
- 输入会先传给翻译代理
- 翻译结果自动传给润色代理
- 返回最终的润色结果

运行结果示例

=== 文章翻译流水线 ===

原文：
人工智能正在改变我们的生活。
从智能手机到自动驾驶汽车，AI 技术无处不在。
它不仅提高了效率，还为我们带来了全新的可能性。

处理中...

最终结果：
Artificial intelligence is transforming our lives in profound ways. 
From smartphones to autonomous vehicles, AI technology is ubiquitous. 
It not only enhances efficiency but also opens up entirely new possibilities.

示例 2：并行工作流

场景：产品评论分析

同时从多个角度分析产品评论：情感分析、关键词提取、改进建议。

完整代码

using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;

class ParallelWorkflowExample
{
    public static async Task Main()
    {
        var chatClient = ConfigureChatClient(); // 假设已配置

        var builder = new WorkflowBuilder();

        // 定义输入代理：接收评论
        var inputAgent = builder.AddAgent(
            "input",
            chatClient,
            instructions: "你负责接收用户评论，并原样传递给下游代理。"
        );

        // 定义并行代理 1：情感分析
        var sentimentAgent = builder.AddAgent(
            "sentiment",
            chatClient,
            instructions: @"分析评论的情感倾向。
            判断是正面、负面还是中性。
            给出情感分数（-1 到 1）。
            格式：情感：[正面/负面/中性]，分数：[数值]"
        );

        // 定义并行代理 2：关键词提取
        var keywordAgent = builder.AddAgent(
            "keyword",
            chatClient,
            instructions: @"从评论中提取关键词。
            找出最重要的 5 个词语。
            格式：关键词：[词1, 词2, 词3, 词4, 词5]"
        );

        // 定义并行代理 3：改进建议
        var suggestionAgent = builder.AddAgent(
            "suggestion",
            chatClient,
            instructions: @"根据评论提供产品改进建议。
            列出 2-3 条具体的改进建议。
            格式：建议：1. ... 2. ... 3. ..."
        );

        // 定义汇总代理：整合所有分析结果
        var summaryAgent = builder.AddAgent(
            "summary",
            chatClient,
            instructions: @"整合所有分析结果，生成综合报告。
            包含：情感分析、关键词、改进建议。
            用清晰的格式呈现。"
        );

        // 连接代理：创建并行结构
        builder.AddEdge(inputAgent, sentimentAgent);
        builder.AddEdge(inputAgent, keywordAgent);
        builder.AddEdge(inputAgent, suggestionAgent);

        // 所有并行代理的结果汇总到 summary
        builder.AddEdge(sentimentAgent, summaryAgent);
        builder.AddEdge(keywordAgent, summaryAgent);
        builder.AddEdge(suggestionAgent, summaryAgent);

        var workflow = builder.Build();

        // 执行工作流
        Console.WriteLine("=== 产品评论分析系统 ===\n");
        
        string review = @"这款手机的拍照功能非常出色，夜景模式特别好用。
        但是电池续航有点短，一天需要充两次电。
        另外，系统偶尔会卡顿，希望能优化一下。
        总体来说还是值得购买的。";

        Console.WriteLine($"评论内容：\n{review}\n");
        Console.WriteLine("分析中...\n");

        var result = await workflow.RunAsync(review);

        Console.WriteLine($"分析报告：\n{result.FinalOutput}\n");
    }
}

工作流结构图

                    ┌─→ [情感分析代理] ─┐
                    │                   │
[输入代理] ─────────┼─→ [关键词代理] ───┼─→ [汇总代理]
                    │                   │
                    └─→ [建议代理] ─────┘

关键点说明

并行执行

builder.AddEdge(inputAgent, sentimentAgent);
builder.AddEdge(inputAgent, keywordAgent);
builder.AddEdge(inputAgent, suggestionAgent);

三个代理同时接收输入
并行处理，提高效率

结果汇总

builder.AddEdge(sentimentAgent, summaryAgent);
builder.AddEdge(keywordAgent, summaryAgent);
builder.AddEdge(suggestionAgent, summaryAgent);

汇总代理等待所有并行代理完成
整合所有结果生成最终报告

运行结果示例

=== 产品评论分析系统 ===

评论内容：
这款手机的拍照功能非常出色，夜景模式特别好用。
但是电池续航有点短，一天需要充两次电。
另外，系统偶尔会卡顿，希望能优化一下。
总体来说还是值得购买的。

分析中...

分析报告：
【综合分析报告】

1. 情感分析
   - 情感倾向：中性偏正面
   - 情感分数：0.4
   - 说明：用户认可产品优点，但也指出了明显缺点

2. 关键词
   - 拍照功能、夜景模式、电池续航、系统卡顿、值得购买

3. 改进建议
   1. 优化电池管理，提升续航能力
   2. 改进系统性能，减少卡顿现象
   3. 保持相机优势，继续优化拍照体验

示例 3：条件工作流

场景：智能客服路由

根据问题类型，路由到不同的专业代理。

完整代码

using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;

class ConditionalWorkflowExample
{
    public static async Task Main()
    {
        var chatClient = ConfigureChatClient();

        var builder = new WorkflowBuilder();

        // 分类代理：判断问题类型
        var classifierAgent = builder.AddAgent(
            "classifier",
            chatClient,
            instructions: @"分析用户问题，判断类型。
            类型包括：技术问题、销售咨询、投诉建议。
            只输出类型名称，不要其他内容。
            格式：类型：[技术问题/销售咨询/投诉建议]"
        );

        // 技术支持代理
        var techAgent = builder.AddAgent(
            "tech",
            chatClient,
            instructions: @"你是技术支持专家。
            帮助用户解决技术问题。
            提供详细的解决步骤。"
        );

        // 销售咨询代理
        var salesAgent = builder.AddAgent(
            "sales",
            chatClient,
            instructions: @"你是销售顾问。
            回答产品相关问题。
            提供购买建议和优惠信息。"
        );

        // 投诉处理代理
        var complaintAgent = builder.AddAgent(
            "complaint",
            chatClient,
            instructions: @"你是客户关系专员。
            认真倾听客户投诉。
            提供解决方案和补偿建议。"
        );

        // 添加条件边：根据分类结果路由
        builder.AddConditionalEdge(
            classifierAgent,
            async (context, output) =>
            {
                // 解析分类结果
                string classification = output.ToString().ToLower();
                
                if (classification.Contains("技术"))
                    return "tech";
                else if (classification.Contains("销售"))
                    return "sales";
                else if (classification.Contains("投诉"))
                    return "complaint";
                else
                    return "tech"; // 默认路由到技术支持
            },
            new Dictionary<string, IExecutor>
            {
                { "tech", techAgent },
                { "sales", salesAgent },
                { "complaint", complaintAgent }
            }
        );

        var workflow = builder.Build();

        // 测试不同类型的问题
        await TestQuestion(workflow, "我的手机无法连接WiFi，怎么办？");
        await TestQuestion(workflow, "你们有什么优惠活动吗？我想买一台新手机。");
        await TestQuestion(workflow, "我昨天买的手机有质量问题，要求退货！");
    }

    static async Task TestQuestion(Workflow workflow, string question)
    {
        Console.WriteLine($"\n问题：{question}");
        Console.WriteLine("处理中...");
        
        var result = await workflow.RunAsync(question);
        
        Console.WriteLine($"回复：{result.FinalOutput}\n");
        Console.WriteLine("---");
    }
}

条件路由逻辑

builder.AddConditionalEdge(
    classifierAgent,  // 源代理
    async (context, output) =>  // 路由函数
    {
        // 根据输出决定下一个代理
        string classification = output.ToString().ToLower();
        
        if (classification.Contains("技术"))
            return "tech";
        else if (classification.Contains("销售"))
            return "sales";
        else
            return "complaint";
    },
    new Dictionary<string, IExecutor>  // 目标代理映射
    {
        { "tech", techAgent },
        { "sales", salesAgent },
        { "complaint", complaintAgent }
    }
);

工作流结构图

                        ┌─→ [技术支持代理]
                        │
[分类代理] → [路由判断] ─┼─→ [销售咨询代理]
                        │
                        └─→ [投诉处理代理]

运行结果示例

问题：我的手机无法连接WiFi，怎么办？
处理中...
回复：我来帮您解决WiFi连接问题。请按以下步骤操作：
1. 检查WiFi开关是否打开
2. 重启手机和路由器
3. 忘记网络后重新连接
4. 检查是否输入了正确的密码
如果问题仍未解决，请联系技术支持热线。
---

问题：你们有什么优惠活动吗？我想买一台新手机。
处理中...
回复：感谢您的咨询！我们目前有以下优惠活动：
1. 新品上市，限时9折优惠
2. 以旧换新，最高补贴500元
3. 购机送配件大礼包
您可以访问我们的官网查看详情，或到门店体验。
---

问题：我昨天买的手机有质量问题，要求退货！
处理中...
回复：非常抱歉给您带来不便。我们重视每一位客户的体验。
关于您的退货请求：
1. 7天内可以无理由退货
2. 请保留完整包装和配件
3. 我们将安排上门取件
4. 退款将在3-5个工作日内到账
同时，我们会赠送您一张200元优惠券作为补偿。
---

示例 4：循环工作流

场景：代码生成与优化

生成代码，测试，如果有问题则继续优化，直到通过测试。

完整代码

using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;

class LoopWorkflowExample
{
    public static async Task Main()
    {
        var chatClient = ConfigureChatClient();

        var builder = new WorkflowBuilder();

        // 代码生成代理
        var codeGeneratorAgent = builder.AddAgent(
            "generator",
            chatClient,
            instructions: @"你是一个代码生成专家。
            根据需求生成 C# 代码。
            代码要清晰、规范、可运行。"
        );

        // 代码测试代理
        var codeTesterAgent = builder.AddAgent(
            "tester",
            chatClient,
            instructions: @"你是代码测试专家。
            检查代码是否有语法错误、逻辑问题。
            如果有问题，详细说明问题所在。
            如果没问题，输出：测试通过。"
        );

        // 代码优化代理
        var codeOptimizerAgent = builder.AddAgent(
            "optimizer",
            chatClient,
            instructions: @"你是代码优化专家。
            根据测试反馈优化代码。
            修复问题并改进代码质量。"
        );

        // 连接：生成 → 测试
        builder.AddEdge(codeGeneratorAgent, codeTesterAgent);

        // 条件边：根据测试结果决定是否继续优化
        builder.AddConditionalEdge(
            codeTesterAgent,
            async (context, output) =>
            {
                string testResult = output.ToString();
                
                // 如果测试通过，结束流程
                if (testResult.Contains("测试通过"))
                    return "end";
                
                // 否则继续优化
                return "optimize";
            },
            new Dictionary<string, IExecutor>
            {
                { "optimize", codeOptimizerAgent },
                { "end", null } // null 表示结束
            }
        );

        // 优化后返回测试（形成循环）
        builder.AddEdge(codeOptimizerAgent, codeTesterAgent);

        var workflow = builder.Build();

        // 执行工作流
        Console.WriteLine("=== 代码生成与优化系统 ===\n");
        
        string requirement = "创建一个函数，计算斐波那契数列的第 n 项。";

        Console.WriteLine($"需求：{requirement}\n");
        Console.WriteLine("生成中...\n");

        var result = await workflow.RunAsync(requirement);

        Console.WriteLine($"最终代码：\n{result.FinalOutput}\n");
    }
}

循环控制要点

设置最大迭代次数

var workflowOptions = new WorkflowOptions
{
    MaxIterations = 5  // 最多循环 5 次
};

var workflow = builder.Build(workflowOptions);

明确退出条件

if (testResult.Contains("测试通过"))
    return "end";  // 满足条件，退出循环

避免无限循环
- 设置最大迭代次数
- 设置超时时间
- 确保有明确的成功条件

工作流结构图

[代码生成] → [代码测试] → [通过？]
                 ↑             │
                 │            否
                 │             │
                 │             ↓
                 └─────── [代码优化]

运行结果示例

=== 代码生成与优化系统 ===

需求：创建一个函数，计算斐波那契数列的第 n 项。

生成中...

迭代 1：
- 生成初始代码
- 测试发现：缺少边界条件处理
- 优化中...

迭代 2：
- 优化后的代码
- 测试发现：性能可以改进
- 优化中...

迭代 3：
- 使用动态规划优化
- 测试通过！

最终代码：
```csharp
public class Fibonacci
{
    // 使用动态规划计算斐波那契数列
    public static long Calculate(int n)
    {
        if (n < 0)
            throw new ArgumentException("n 必须是非负整数");
        
        if (n <= 1)
            return n;
        
        long[] dp = new long[n + 1];
        dp[0] = 0;
        dp[1] = 1;
        
        for (int i = 2; i <= n; i++)
        {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        
        return dp[n];
    }
}

## 工作流高级特性

### 1. 状态管理

在工作流执行过程中保存和传递状态：

```csharp
var builder = new WorkflowBuilder();

// 创建带状态的工作流
var workflow = builder
    .WithState(new Dictionary<string, object>
    {
        { "userId", "12345" },
        { "sessionId", Guid.NewGuid() }
    })
    .Build();

// 在代理中访问状态
var agent = builder.AddAgent(
    "myAgent",
    chatClient,
    instructions: "你可以访问用户ID和会话ID",
    onExecute: async (context) =>
    {
        var userId = context.State["userId"];
        var sessionId = context.State["sessionId"];
        
        // 使用状态信息
        Console.WriteLine($"处理用户 {userId} 的请求");
    }
);

2. 错误处理

处理工作流执行中的错误：

var builder = new WorkflowBuilder();

// 添加错误处理
builder.OnError(async (context, exception) =>
{
    Console.WriteLine($"工作流出错：{exception.Message}");
    
    // 可以选择：
    // 1. 重试
    // 2. 跳过当前步骤
    // 3. 终止工作流
    // 4. 路由到错误处理代理
    
    return ErrorHandlingStrategy.Retry;
});

// 为特定代理添加错误处理
var agent = builder.AddAgent(
    "myAgent",
    chatClient,
    instructions: "...",
    onError: async (context, exception) =>
    {
        // 代理级别的错误处理
        Console.WriteLine($"代理出错：{exception.Message}");
        return ErrorHandlingStrategy.Skip;
    }
);

3. 监控和日志

记录工作流执行过程：

var builder = new WorkflowBuilder();

// 添加执行监听器
builder.OnExecutorStart(async (context, executor) =>
{
    Console.WriteLine($"[{DateTime.Now}] 开始执行：{executor.Name}");
});

builder.OnExecutorComplete(async (context, executor, output) =>
{
    Console.WriteLine($"[{DateTime.Now}] 完成执行：{executor.Name}");
    Console.WriteLine($"输出：{output}");
});

// 记录整个工作流的执行时间
var stopwatch = Stopwatch.StartNew();

var result = await workflow.RunAsync(input);

stopwatch.Stop();
Console.WriteLine($"总执行时间：{stopwatch.ElapsedMilliseconds}ms");

4. 动态工作流

根据运行时条件动态构建工作流：

public Workflow BuildDynamicWorkflow(string workflowType)
{
    var builder = new WorkflowBuilder();
    
    var inputAgent = builder.AddAgent("input", chatClient, "接收输入");
    
    if (workflowType == "simple")
    {
        // 简单流程
        var outputAgent = builder.AddAgent("output", chatClient, "输出结果");
        builder.AddEdge(inputAgent, outputAgent);
    }
    else if (workflowType == "complex")
    {
        // 复杂流程
        var agent1 = builder.AddAgent("agent1", chatClient, "处理1");
        var agent2 = builder.AddAgent("agent2", chatClient, "处理2");
        var agent3 = builder.AddAgent("agent3", chatClient, "处理3");
        
        builder.AddEdge(inputAgent, agent1);
        builder.AddEdge(agent1, agent2);
        builder.AddEdge(agent2, agent3);
    }
    
    return builder.Build();
}

5. 子工作流

在工作流中嵌套其他工作流：

// 创建子工作流
var subWorkflowBuilder = new WorkflowBuilder();
var subAgent1 = subWorkflowBuilder.AddAgent("sub1", chatClient, "子任务1");
var subAgent2 = subWorkflowBuilder.AddAgent("sub2", chatClient, "子任务2");
subWorkflowBuilder.AddEdge(subAgent1, subAgent2);
var subWorkflow = subWorkflowBuilder.Build();

// 在主工作流中使用子工作流
var mainBuilder = new WorkflowBuilder();
var mainAgent = mainBuilder.AddAgent("main", chatClient, "主任务");

// 添加子工作流作为一个执行器
var subWorkflowExecutor = mainBuilder.AddSubWorkflow("subWorkflow", subWorkflow);

mainBuilder.AddEdge(mainAgent, subWorkflowExecutor);

var mainWorkflow = mainBuilder.Build();

工作流最佳实践

1. 设计原则

✅ 单一职责：每个代理只做一件事
✅ 松耦合：代理之间通过标准接口通信
✅ 可测试：每个代理可以独立测试
✅ 可观测：记录关键执行信息
✅ 容错性：优雅处理错误

2. 性能优化

// 1. 使用并行处理
builder.AddParallelEdges(inputAgent, new[] { agent1, agent2, agent3 });

// 2. 设置超时
var options = new WorkflowOptions
{
    Timeout = TimeSpan.FromMinutes(5)
};

// 3. 缓存结果
var cacheAgent = builder.AddAgent(
    "cache",
    chatClient,
    instructions: "...",
    cache: new MemoryCache()
);

3. 调试技巧

// 启用详细日志
var builder = new WorkflowBuilder()
    .WithLogging(LogLevel.Debug);

// 添加断点代理
var debugAgent = builder.AddAgent(
    "debug",
    chatClient,
    instructions: "输出当前状态用于调试",
    onExecute: async (context) =>
    {
        Console.WriteLine("=== 调试信息 ===");
        Console.WriteLine($"输入：{context.Input}");
        Console.WriteLine($"状态：{JsonSerializer.Serialize(context.State)}");
        Console.WriteLine("================");
    }
);

// 在关键位置插入调试代理
builder.AddEdge(agent1, debugAgent);
builder.AddEdge(debugAgent, agent2);

4. 测试工作流

[Test]
public async Task TestWorkflow()
{
    // 使用模拟的 ChatClient
    var mockChatClient = new MockChatClient();
    
    var builder = new WorkflowBuilder();
    var agent = builder.AddAgent("test", mockChatClient, "测试代理");
    var workflow = builder.Build();
    
    // 执行测试
    var result = await workflow.RunAsync("测试输入");
    
    // 验证结果
    Assert.AreEqual("预期输出", result.FinalOutput);
}

常见问题

Q1：工作流执行很慢怎么办？

A：考虑以下优化：

使用并行工作流
减少不必要的代理调用
优化代理的提示词
使用缓存避免重复计算

Q2：如何处理工作流中的错误？

A：

使用 OnError 添加错误处理
为关键代理添加重试机制
设置合理的超时时间
记录详细的错误日志

Q3：工作流可以保存和恢复吗？

A：

保存工作流状态到数据库
使用检查点机制
实现工作流的序列化和反序列化

Q4：如何监控工作流的执行？

A：

使用 OpenTelemetry 集成
添加自定义日志
使用执行监听器
集成 Application Insights

小结

本章我们学习了：

顺序工作流：按顺序执行任务
并行工作流：同时执行多个任务
条件工作流：根据条件选择路径
循环工作流：重复执行直到满足条件
高级特性：状态管理、错误处理、监控等
最佳实践：设计原则、性能优化、调试技巧

掌握这些知识后，你就可以构建复杂的多代理系统了！

练习

创建一个文档处理工作流：提取 → 分析 → 总结
实现一个智能问答系统，根据问题类型路由到不同的专家代理
构建一个内容审核工作流，包含多个并行的审核代理

A2A 协议（Agent-to-Agent Protocol）

什么是 A2A 协议？

简单理解

想象一下两个人通过电话交流：

他们需要共同的语言（中文或英文）
需要标准的格式（问候、正文、结束语）
需要清晰的信息（谁在说话、说什么、期望什么回应）

A2A 协议就是代理之间通信的"标准语言"，让不同的代理能够互相理解和协作。

正式定义

A2A（Agent-to-Agent）协议是一个标准化的通信协议，定义了：

消息格式：代理之间如何交换信息
通信规则：何时发送、如何响应
元数据：代理的能力、状态等信息
错误处理：如何处理通信失败

为什么需要 A2A 协议？

没有标准协议的问题

如果每个代理都用自己的方式通信：

❌ 兼容性差：不同代理无法互相理解
❌ 维护困难：每次添加新代理都要修改现有代码
❌ 扩展性差：难以集成第三方代理
❌ 调试复杂：通信问题难以定位

使用 A2A 协议的优势

✅ 标准化：所有代理使用统一的通信格式
✅ 互操作性：不同来源的代理可以协作
✅ 可扩展性：轻松添加新代理
✅ 可维护性：清晰的通信结构
✅ 可观测性：便于监控和调试

A2A 协议的核心概念

1. 代理卡片（Agent Card）

代理卡片是代理的"名片"，描述代理的基本信息和能力。

{
  "id": "weather-agent",
  "name": "天气查询代理",
  "description": "提供全球天气信息查询服务",
  "version": "1.0.0",
  "capabilities": [
    "查询当前天气",
    "查询未来7天预报",
    "查询历史天气"
  ],
  "endpoints": {
    "query": "https://api.example.com/weather/query"
  },
  "authentication": {
    "type": "api-key",
    "required": true
  }
}

2. 消息格式

A2A 消息包含以下关键信息：

{
  "messageId": "msg-12345",
  "timestamp": "2024-01-15T10:30:00Z",
  "sender": {
    "agentId": "agent-001",
    "agentName": "分析代理"
  },
  "receiver": {
    "agentId": "agent-002",
    "agentName": "报告代理"
  },
  "content": {
    "type": "text",
    "data": "这是分析结果..."
  },
  "metadata": {
    "conversationId": "conv-789",
    "priority": "normal"
  }
}

3. 通信模式

请求-响应模式（Request-Response）

[代理A] ──请求──> [代理B]
[代理A] <──响应── [代理B]

发布-订阅模式（Publish-Subscribe）

[代理A] ──发布消息──> [消息总线]
                        │
        ┌───────────────┼───────────────┐
        │               │               │
        ↓               ↓               ↓
    [代理B]         [代理C]         [代理D]
    (订阅者)        (订阅者)        (订阅者)

流式通信（Streaming）

[代理A] ──数据流──> [代理B]
         (持续发送)

在 Microsoft Agent Framework 中使用 A2A

安装 A2A 包

dotnet add package Microsoft.Agents.AI.A2A

示例 1：创建 A2A 代理

using Microsoft.Agents.AI;
using Microsoft.Agents.AI.A2A;
using Microsoft.Extensions.AI;

class A2AAgentExample
{
    public static async Task Main()
    {
        // 配置 ChatClient
        var chatClient = ConfigureChatClient();

        // 创建 A2A 代理
        var weatherAgent = new A2AAgent(
            agentId: "weather-agent",
            name: "天气查询代理",
            description: "提供天气信息查询服务",
            chatClient: chatClient,
            instructions: @"你是一个天气查询助手。
            根据用户提供的城市名称，返回天气信息。
            格式：城市：[城市名]，天气：[天气状况]，温度：[温度]"
        );

        // 创建另一个 A2A 代理
        var travelAgent = new A2AAgent(
            agentId: "travel-agent",
            name: "旅行建议代理",
            description: "根据天气提供旅行建议",
            chatClient: chatClient,
            instructions: @"你是一个旅行顾问。
            根据天气信息，提供旅行建议和注意事项。"
        );

        // 代理间通信
        Console.WriteLine("=== A2A 代理通信示例 ===\n");

        // 步骤 1：用户向天气代理查询
        var weatherQuery = "北京的天气怎么样？";
        Console.WriteLine($"用户查询：{weatherQuery}\n");

        var weatherResponse = await weatherAgent.RunAsync(weatherQuery);
        Console.WriteLine($"天气代理回复：{weatherResponse.Output}\n");

        // 步骤 2：天气代理将结果发送给旅行代理
        var travelQuery = $"根据以下天气信息提供旅行建议：{weatherResponse.Output}";
        var travelResponse = await travelAgent.RunAsync(travelQuery);
        Console.WriteLine($"旅行代理回复：{travelResponse.Output}\n");
    }
}

示例 2：使用 A2A 协议进行远程通信

using Microsoft.Agents.AI.A2A;
using System.Net.Http;

class RemoteA2AExample
{
    public static async Task Main()
    {
        // 创建 A2A 客户端
        var httpClient = new HttpClient();
        var a2aClient = new A2AClient(httpClient);

        // 远程代理的端点
        var remoteAgentUrl = "https://api.example.com/agents/weather";

        // 创建 A2A 请求
        var request = new A2ARequest
        {
            MessageId = Guid.NewGuid().ToString(),
            Timestamp = DateTime.UtcNow,
            Sender = new AgentInfo
            {
                AgentId = "local-agent",
                AgentName = "本地代理"
            },
            Content = new MessageContent
            {
                Type = "text",
                Data = "上海的天气如何？"
            }
        };

        // 发送请求到远程代理
        var response = await a2aClient.SendAsync(remoteAgentUrl, request);

        Console.WriteLine($"远程代理回复：{response.Content.Data}");
    }
}

示例 3：创建 A2A 服务器

using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using Microsoft.Agents.AI.A2A;

class A2AServerExample
{
    public static void Main()
    {
        var builder = WebApplication.CreateBuilder();
        
        // 注册 A2A 服务
        builder.Services.AddA2AServices();
        
        var app = builder.Build();

        // 注册代理端点
        app.MapA2AAgent("/agents/weather", async (A2ARequest request) =>
        {
            // 处理请求
            var query = request.Content.Data.ToString();
            
            // 调用天气 API 或代理
            var weatherInfo = await GetWeatherInfo(query);
            
            // 返回 A2A 响应
            return new A2AResponse
            {
                MessageId = Guid.NewGuid().ToString(),
                Timestamp = DateTime.UtcNow,
                InReplyTo = request.MessageId,
                Sender = new AgentInfo
                {
                    AgentId = "weather-agent",
                    AgentName = "天气代理"
                },
                Content = new MessageContent
                {
                    Type = "text",
                    Data = weatherInfo
                }
            };
        });

        app.Run();
    }

    static async Task<string> GetWeatherInfo(string query)
    {
        // 实际实现中，这里会调用天气 API
        return "北京：晴天，温度 15°C";
    }
}

A2A 协议的高级特性

1. 代理发现（Agent Discovery）

自动发现可用的代理：

using Microsoft.Agents.AI.A2A;

class AgentDiscoveryExample
{
    public static async Task Main()
    {
        var discoveryClient = new A2ADiscoveryClient();

        // 发现所有可用的代理
        var agents = await discoveryClient.DiscoverAgentsAsync();

        Console.WriteLine("可用的代理：");
        foreach (var agent in agents)
        {
            Console.WriteLine($"- {agent.Name} ({agent.Id})");
            Console.WriteLine($"  描述：{agent.Description}");
            Console.WriteLine($"  能力：{string.Join(", ", agent.Capabilities)}");
            Console.WriteLine();
        }

        // 根据能力查找代理
        var weatherAgents = await discoveryClient.FindAgentsByCapabilityAsync("天气查询");
        
        Console.WriteLine("支持天气查询的代理：");
        foreach (var agent in weatherAgents)
        {
            Console.WriteLine($"- {agent.Name}");
        }
    }
}

2. 会话管理（Conversation Management）

管理多轮对话：

using Microsoft.Agents.AI.A2A;

class ConversationExample
{
    public static async Task Main()
    {
        var a2aClient = new A2AClient(new HttpClient());
        
        // 创建会话
        var conversationId = Guid.NewGuid().ToString();
        
        // 第一轮对话
        var request1 = new A2ARequest
        {
            MessageId = Guid.NewGuid().ToString(),
            ConversationId = conversationId,
            Content = new MessageContent { Data = "北京的天气怎么样？" }
        };
        
        var response1 = await a2aClient.SendAsync("https://api.example.com/agent", request1);
        Console.WriteLine($"代理：{response1.Content.Data}");
        
        // 第二轮对话（延续上下文）
        var request2 = new A2ARequest
        {
            MessageId = Guid.NewGuid().ToString(),
            ConversationId = conversationId,  // 使用相同的会话ID
            Content = new MessageContent { Data = "那明天呢？" }
        };
        
        var response2 = await a2aClient.SendAsync("https://api.example.com/agent", request2);
        Console.WriteLine($"代理：{response2.Content.Data}");
    }
}

3. 流式响应（Streaming Response）

处理长时间运行的任务：

using Microsoft.Agents.AI.A2A;

class StreamingExample
{
    public static async Task Main()
    {
        var a2aClient = new A2AClient(new HttpClient());
        
        var request = new A2ARequest
        {
            MessageId = Guid.NewGuid().ToString(),
            Content = new MessageContent { Data = "生成一篇长文章" },
            StreamingEnabled = true  // 启用流式响应
        };
        
        Console.WriteLine("接收流式响应：\n");
        
        await foreach (var chunk in a2aClient.StreamAsync("https://api.example.com/agent", request))
        {
            // 逐块接收和处理数据
            Console.Write(chunk.Content.Data);
        }
        
        Console.WriteLine("\n\n流式响应完成。");
    }
}

4. 错误处理和重试

using Microsoft.Agents.AI.A2A;
using Polly;

class ErrorHandlingExample
{
    public static async Task Main()
    {
        var httpClient = new HttpClient();
        var a2aClient = new A2AClient(httpClient);
        
        // 配置重试策略
        var retryPolicy = Policy
            .Handle<HttpRequestException>()
            .WaitAndRetryAsync(
                retryCount: 3,
                sleepDurationProvider: attempt => TimeSpan.FromSeconds(Math.Pow(2, attempt)),
                onRetry: (exception, timeSpan, retryCount, context) =>
                {
                    Console.WriteLine($"重试 {retryCount} 次，等待 {timeSpan.TotalSeconds} 秒");
                }
            );
        
        var request = new A2ARequest
        {
            MessageId = Guid.NewGuid().ToString(),
            Content = new MessageContent { Data = "查询天气" }
        };
        
        try
        {
            var response = await retryPolicy.ExecuteAsync(async () =>
            {
                return await a2aClient.SendAsync("https://api.example.com/agent", request);
            });
            
            Console.WriteLine($"成功：{response.Content.Data}");
        }
        catch (Exception ex)
        {
            Console.WriteLine($"失败：{ex.Message}");
            
            // 发送错误通知
            var errorNotification = new A2ARequest
            {
                MessageId = Guid.NewGuid().ToString(),
                Content = new MessageContent
                {
                    Type = "error",
                    Data = $"通信失败：{ex.Message}"
                }
            };
            
            // 通知监控系统或其他代理
        }
    }
}

5. 安全和认证

using Microsoft.Agents.AI.A2A;
using System.Net.Http.Headers;

class SecurityExample
{
    public static async Task Main()
    {
        var httpClient = new HttpClient();
        
        // 添加认证头
        var apiKey = Environment.GetEnvironmentVariable("A2A_API_KEY");
        httpClient.DefaultRequestHeaders.Authorization = 
            new AuthenticationHeaderValue("Bearer", apiKey);
        
        var a2aClient = new A2AClient(httpClient);
        
        // 创建带签名的请求
        var request = new A2ARequest
        {
            MessageId = Guid.NewGuid().ToString(),
            Sender = new AgentInfo
            {
                AgentId = "secure-agent",
                AgentName = "安全代理"
            },
            Content = new MessageContent { Data = "敏感查询" },
            Security = new SecurityInfo
            {
                Signature = GenerateSignature("敏感查询", apiKey),
                Timestamp = DateTime.UtcNow
            }
        };
        
        var response = await a2aClient.SendAsync("https://api.example.com/agent", request);
        
        // 验证响应签名
        if (VerifySignature(response))
        {
            Console.WriteLine($"验证通过：{response.Content.Data}");
        }
        else
        {
            Console.WriteLine("签名验证失败！");
        }
    }
    
    static string GenerateSignature(string data, string key)
    {
        // 实现签名生成逻辑
        using var hmac = new System.Security.Cryptography.HMACSHA256(
            System.Text.Encoding.UTF8.GetBytes(key));
        var hash = hmac.ComputeHash(System.Text.Encoding.UTF8.GetBytes(data));
        return Convert.ToBase64String(hash);
    }
    
    static bool VerifySignature(A2AResponse response)
    {
        // 实现签名验证逻辑
        return true;
    }
}

实战案例：构建 A2A 代理网络

场景：智能客服系统

构建一个由多个专业代理组成的客服系统，使用 A2A 协议进行通信。

系统架构

                    [路由代理]
                        │
        ┌───────────────┼───────────────┐
        │               │               │
        ↓               ↓               ↓
  [技术支持代理]   [销售代理]    [投诉处理代理]
        │               │               │
        └───────────────┼───────────────┘
                        │
                        ↓
                  [知识库代理]

完整实现

using Microsoft.Agents.AI;
using Microsoft.Agents.AI.A2A;
using Microsoft.Extensions.AI;

class CustomerServiceSystem
{
    private readonly Dictionary<string, A2AAgent> _agents;
    private readonly A2AClient _a2aClient;

    public CustomerServiceSystem()
    {
        _agents = new Dictionary<string, A2AAgent>();
        _a2aClient = new A2AClient(new HttpClient());
        
        InitializeAgents();
    }

    private void InitializeAgents()
    {
        var chatClient = ConfigureChatClient();

        // 1. 路由代理
        _agents["router"] = new A2AAgent(
            agentId: "router-agent",
            name: "路由代理",
            description: "分析客户问题并路由到合适的专业代理",
            chatClient: chatClient,
            instructions: @"分析客户问题，判断类型。
            类型：技术问题、销售咨询、投诉建议。
            只输出类型，格式：类型：[技术/销售/投诉]"
        );

        // 2. 技术支持代理
        _agents["tech"] = new A2AAgent(
            agentId: "tech-agent",
            name: "技术支持代理",
            description: "处理技术问题",
            chatClient: chatClient,
            instructions: @"你是技术支持专家。
            提供详细的技术解决方案。
            如果需要查询知识库，请说明。"
        );

        // 3. 销售代理
        _agents["sales"] = new A2AAgent(
            agentId: "sales-agent",
            name: "销售代理",
            description: "处理销售咨询",
            chatClient: chatClient,
            instructions: @"你是销售顾问。
            提供产品信息和购买建议。"
        );

        // 4. 投诉处理代理
        _agents["complaint"] = new A2AAgent(
            agentId: "complaint-agent",
            name: "投诉处理代理",
            description: "处理客户投诉",
            chatClient: chatClient,
            instructions: @"你是客户关系专员。
            认真处理客户投诉，提供解决方案。"
        );

        // 5. 知识库代理
        _agents["knowledge"] = new A2AAgent(
            agentId: "knowledge-agent",
            name: "知识库代理",
            description: "提供知识库查询服务",
            chatClient: chatClient,
            instructions: @"你是知识库助手。
            根据问题搜索相关文档和解决方案。"
        );
    }

    public async Task<string> HandleCustomerQuery(string query)
    {
        Console.WriteLine($"\n客户问题：{query}\n");

        // 步骤 1：路由代理分析问题
        var routerRequest = new A2ARequest
        {
            MessageId = Guid.NewGuid().ToString(),
            ConversationId = Guid.NewGuid().ToString(),
            Sender = new AgentInfo { AgentId = "system", AgentName = "系统" },
            Receiver = new AgentInfo { AgentId = "router-agent", AgentName = "路由代理" },
            Content = new MessageContent { Type = "text", Data = query }
        };

        var routerResponse = await _agents["router"].ProcessA2ARequestAsync(routerRequest);
        var category = ExtractCategory(routerResponse.Content.Data.ToString());
        
        Console.WriteLine($"路由结果：{category}\n");

        // 步骤 2：转发到专业代理
        string targetAgentId = category switch
        {
            "技术" => "tech",
            "销售" => "sales",
            "投诉" => "complaint",
            _ => "tech"
        };

        var specialistRequest = new A2ARequest
        {
            MessageId = Guid.NewGuid().ToString(),
            ConversationId = routerRequest.ConversationId,
            Sender = new AgentInfo { AgentId = "router-agent", AgentName = "路由代理" },
            Receiver = new AgentInfo { AgentId = $"{targetAgentId}-agent", AgentName = _agents[targetAgentId].Name },
            Content = new MessageContent { Type = "text", Data = query }
        };

        var specialistResponse = await _agents[targetAgentId].ProcessA2ARequestAsync(specialistRequest);
        var answer = specialistResponse.Content.Data.ToString();

        Console.WriteLine($"{_agents[targetAgentId].Name}回复：{answer}\n");

        // 步骤 3：如果需要，查询知识库
        if (answer.Contains("查询知识库") || answer.Contains("需要更多信息"))
        {
            var knowledgeRequest = new A2ARequest
            {
                MessageId = Guid.NewGuid().ToString(),
                ConversationId = routerRequest.ConversationId,
                Sender = new AgentInfo { AgentId = $"{targetAgentId}-agent", AgentName = _agents[targetAgentId].Name },
                Receiver = new AgentInfo { AgentId = "knowledge-agent", AgentName = "知识库代理" },
                Content = new MessageContent { Type = "text", Data = query }
            };

            var knowledgeResponse = await _agents["knowledge"].ProcessA2ARequestAsync(knowledgeRequest);
            var knowledgeInfo = knowledgeResponse.Content.Data.ToString();

            Console.WriteLine($"知识库信息：{knowledgeInfo}\n");

            // 将知识库信息返回给专业代理
            var finalRequest = new A2ARequest
            {
                MessageId = Guid.NewGuid().ToString(),
                ConversationId = routerRequest.ConversationId,
                Sender = new AgentInfo { AgentId = "knowledge-agent", AgentName = "知识库代理" },
                Receiver = new AgentInfo { AgentId = $"{targetAgentId}-agent", AgentName = _agents[targetAgentId].Name },
                Content = new MessageContent { Type = "text", Data = $"原问题：{query}\n知识库信息：{knowledgeInfo}" }
            };

            var finalResponse = await _agents[targetAgentId].ProcessA2ARequestAsync(finalRequest);
            answer = finalResponse.Content.Data.ToString();

            Console.WriteLine($"最终回复：{answer}\n");
        }

        return answer;
    }

    private string ExtractCategory(string routerOutput)
    {
        if (routerOutput.Contains("技术"))
            return "技术";
        else if (routerOutput.Contains("销售"))
            return "销售";
        else if (routerOutput.Contains("投诉"))
            return "投诉";
        else
            return "技术";
    }

    public static async Task Main()
    {
        var system = new CustomerServiceSystem();

        // 测试不同类型的问题
        await system.HandleCustomerQuery("我的手机无法连接WiFi");
        await system.HandleCustomerQuery("你们有什么优惠活动？");
        await system.HandleCustomerQuery("我要投诉，产品质量太差了！");
    }

    private static IChatClient ConfigureChatClient()
    {
        var endpoint = Environment.GetEnvironmentVariable("AZURE_OPENAI_ENDPOINT");
        var apiKey = Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY");
        var deploymentName = Environment.GetEnvironmentVariable("AZURE_OPENAI_DEPLOYMENT");

        return new AzureOpenAIClient(new Uri(endpoint), new ApiKeyCredential(apiKey))
            .AsChatClient(deploymentName);
    }
}

运行结果

客户问题：我的手机无法连接WiFi

路由结果：技术

技术支持代理回复：我来帮您解决WiFi连接问题。请按以下步骤操作：
1. 检查WiFi开关是否打开
2. 重启手机和路由器
3. 忘记网络后重新连接
如果问题仍未解决，需要查询知识库获取更多解决方案。

知识库信息：根据知识库，WiFi连接问题的常见原因包括：
- 路由器设置问题
- 手机系统版本过旧
- WiFi模块硬件故障
建议先更新系统，如果仍有问题，请联系售后检测硬件。

最终回复：综合知识库信息，建议您：
1. 先尝试基本排查步骤
2. 检查并更新手机系统到最新版本
3. 如果问题持续，可能是硬件问题，建议到售后服务中心检测
我们提供免费的硬件检测服务。

A2A 协议最佳实践

1. 消息设计

✅ 使用唯一的消息ID

MessageId = Guid.NewGuid().ToString()

✅ 包含时间戳

Timestamp = DateTime.UtcNow

✅ 明确发送者和接收者

Sender = new AgentInfo { AgentId = "agent-001", AgentName = "分析代理" }
Receiver = new AgentInfo { AgentId = "agent-002", AgentName = "报告代理" }

✅ 使用会话ID关联多轮对话

ConversationId = conversationId  // 保持相同的会话ID

2. 错误处理

try
{
    var response = await a2aClient.SendAsync(url, request);
    
    if (response.Status == "error")
    {
        Console.WriteLine($"代理返回错误：{response.ErrorMessage}");
        // 处理错误
    }
}
catch (HttpRequestException ex)
{
    Console.WriteLine($"网络错误：{ex.Message}");
    // 重试或使用备用代理
}
catch (TimeoutException ex)
{
    Console.WriteLine($"请求超时：{ex.Message}");
    // 取消请求或通知用户
}

3. 性能优化

使用连接池

var httpClient = new HttpClient(new SocketsHttpHandler
{
    PooledConnectionLifetime = TimeSpan.FromMinutes(2),
    MaxConnectionsPerServer = 10
});

批量请求

var requests = new List<A2ARequest> { request1, request2, request3 };
var responses = await a2aClient.SendBatchAsync(url, requests);

异步处理

var tasks = agents.Select(agent => agent.ProcessAsync(request));
var results = await Task.WhenAll(tasks);

4. 监控和日志

// 记录所有 A2A 通信
builder.Services.AddA2AServices(options =>
{
    options.EnableLogging = true;
    options.LogLevel = LogLevel.Information;
    options.OnMessageSent = (request) =>
    {
        Console.WriteLine($"[发送] {request.Sender.AgentName} -> {request.Receiver.AgentName}");
    };
    options.OnMessageReceived = (response) =>
    {
        Console.WriteLine($"[接收] {response.Sender.AgentName} 的回复");
    };
});

5. 安全考虑

验证代理身份

if (!IsAuthorizedAgent(request.Sender.AgentId))
{
    return new A2AResponse
    {
        Status = "error",
        ErrorMessage = "未授权的代理"
    };
}

加密敏感数据

var encryptedData = EncryptData(sensitiveInfo);
request.Content = new MessageContent
{
    Type = "encrypted",
    Data = encryptedData
};

限流保护

builder.Services.AddA2AServices(options =>
{
    options.RateLimiting = new RateLimitOptions
    {
        MaxRequestsPerMinute = 60,
        MaxConcurrentRequests = 10
    };
});

A2A vs 传统 API 对比

特性	A2A 协议	传统 REST API
标准化	统一的消息格式	各自定义格式
元数据	丰富的代理信息	有限的元数据
会话管理	内置支持	需要自己实现
代理发现	支持自动发现	需要硬编码端点
流式通信	原生支持	需要特殊处理
互操作性	高	中

常见问题

Q1：A2A 协议和 HTTP API 有什么区别？

A：

A2A 是专门为代理间通信设计的协议
包含更丰富的元数据（代理信息、能力等）
支持代理发现和动态路由
更适合构建复杂的多代理系统

Q2：如何处理代理不可用的情况？

A：

实现健康检查机制
使用备用代理
设置合理的超时时间
记录失败日志并告警

Q3：A2A 协议支持哪些传输方式？

A：

HTTP/HTTPS（最常用）
WebSocket（实时通信）
gRPC（高性能场景）
消息队列（异步通信）

Q4：如何调试 A2A 通信？

A：

启用详细日志
使用 A2A Inspector 工具
记录所有请求和响应
使用 Postman 等工具测试端点

小结

本章我们学习了：

A2A 协议是代理间通信的标准协议
核心概念包括代理卡片、消息格式、通信模式
实现方式包括本地通信和远程通信
高级特性包括代理发现、会话管理、流式响应
最佳实践包括消息设计、错误处理、性能优化
实战案例展示了如何构建完整的多代理系统

掌握 A2A 协议后，你就可以构建可扩展、可维护的多代理系统了！

第07章练习题

通过以下练习题，巩固你对多代理工作流的理解和应用能力。

练习 1：文档处理工作流（初级）

题目描述

创建一个文档处理工作流，包含以下步骤：

提取代理：从文档中提取关键信息
分析代理：分析文档的主题和要点
总结代理：生成简洁的摘要

要求使用顺序工作流实现。

输入示例

文档内容：
人工智能（AI）是计算机科学的一个分支，致力于创建能够执行通常需要人类智能的任务的系统。
这些任务包括视觉感知、语音识别、决策制定和语言翻译等。
近年来，深度学习技术的突破使得 AI 在图像识别、自然语言处理等领域取得了显著进展。
AI 技术正在改变各行各业，从医疗诊断到自动驾驶，从金融分析到客户服务。

预期输出

关键信息：
- 主题：人工智能
- 关键技术：深度学习、图像识别、自然语言处理
- 应用领域：医疗、自动驾驶、金融、客户服务

分析结果：
- 文档类型：技术介绍
- 主要内容：AI 的定义、技术进展、应用场景
- 语气：客观、说明性

摘要：
人工智能是计算机科学的重要分支，通过深度学习等技术在多个领域取得突破，
正在广泛应用于医疗、自动驾驶、金融等行业。

提示

使用 WorkflowBuilder 创建工作流
为每个代理编写清晰的 instructions
使用 AddEdge 连接代理
测试每个代理的输出是否符合预期

参考答案

点击查看参考答案

using Microsoft.Agents.AI;
using Microsoft.Agents.AI.Workflows;
using Microsoft.Extensions.AI;

class DocumentProcessingWorkflow
{
    public static async Task Main()
    {
        var chatClient = ConfigureChatClient();
        var builder = new WorkflowBuilder();

        // 提取代理
        var extractorAgent = builder.AddAgent(
            "extractor",
            chatClient,
            instructions: @"从文档中提取关键信息。
            包括：主题、关键技术、应用领域。
            格式：
            关键信息：
            - 主题：...
            - 关键技术：...
            - 应用领域：..."
        );

        // 分析代理
        var analyzerAgent = builder.AddAgent(
            "analyzer",
            chatClient,
            instructions: @"分析文档的类型、主要内容和语气。
            格式：
            分析结果：
            - 文档类型：...
            - 主要内容：...
            - 语气：..."
        );

        // 总结代理
        var summarizerAgent = builder.AddAgent(
            "summarizer",
            chatClient,
            instructions: @"根据提取的信息和分析结果，生成简洁的摘要。
            摘要应该在 2-3 句话内概括文档的核心内容。"
        );

        // 连接代理
        builder.AddEdge(extractorAgent, analyzerAgent);
        builder.AddEdge(analyzerAgent, summarizerAgent);

        var workflow = builder.Build();

        // 执行工作流
        string document = @"人工智能（AI）是计算机科学的一个分支...";
        
        var result = await workflow.RunAsync(document);
        Console.WriteLine(result.FinalOutput);
    }
}

练习 2：产品评审系统（中级）

题目描述

创建一个产品评审工作流，同时从多个角度评审产品：

功能评审代理：评估产品功能是否完整
性能评审代理：评估产品性能是否达标
用户体验代理：评估产品的易用性
综合评审代理：汇总所有评审结果，给出最终评分

要求使用并行工作流实现。

输入示例

产品描述：
一款智能手表，支持心率监测、运动追踪、消息通知。
电池续航 2 天，充电时间 1.5 小时。
采用触摸屏操作，支持语音助手。

预期输出

功能评审：
- 基础功能完整（心率、运动、通知）
- 缺少睡眠监测功能
- 评分：7/10

性能评审：
- 续航时间偏短
- 充电速度一般
- 评分：6/10

用户体验：
- 触摸屏操作直观
- 语音助手提升便利性
- 评分：8/10

综合评审：
总体评分：7/10
优点：功能齐全，操作便捷
改进建议：提升续航能力，增加睡眠监测功能

提示

创建一个输入代理接收产品描述
创建三个并行的评审代理
创建一个综合代理汇总结果
注意并行代理的连接方式

参考答案

点击查看参考答案

var builder = new WorkflowBuilder();

var inputAgent = builder.AddAgent("input", chatClient, "接收产品描述");

var functionAgent = builder.AddAgent(
    "function",
    chatClient,
    "评估产品功能完整性，给出评分（1-10）"
);

var performanceAgent = builder.AddAgent(
    "performance",
    chatClient,
    "评估产品性能指标，给出评分（1-10）"
);

var uxAgent = builder.AddAgent(
    "ux",
    chatClient,
    "评估产品用户体验，给出评分（1-10）"
);

var summaryAgent = builder.AddAgent(
    "summary",
    chatClient,
    "汇总所有评审结果，计算总体评分，提供改进建议"
);

// 并行连接
builder.AddEdge(inputAgent, functionAgent);
builder.AddEdge(inputAgent, performanceAgent);
builder.AddEdge(inputAgent, uxAgent);

// 汇总连接
builder.AddEdge(functionAgent, summaryAgent);
builder.AddEdge(performanceAgent, summaryAgent);
builder.AddEdge(uxAgent, summaryAgent);

var workflow = builder.Build();

练习 3：智能问答路由系统（中级）

题目描述

创建一个智能问答系统，根据问题类型路由到不同的专家代理：

分类代理：判断问题类型（编程、数学、历史）
编程专家代理：回答编程问题
数学专家代理：回答数学问题
历史专家代理：回答历史问题

要求使用条件工作流实现。

测试用例

问题1：如何在 C# 中创建一个列表？
预期：路由到编程专家

问题2：求解方程 2x + 5 = 15
预期：路由到数学专家

问题3：第一次世界大战是哪一年爆发的？
预期：路由到历史专家

提示

使用 AddConditionalEdge 实现条件路由
在路由函数中解析分类结果
创建代理映射字典
测试不同类型的问题

参考答案

点击查看参考答案

var builder = new WorkflowBuilder();

var classifierAgent = builder.AddAgent(
    "classifier",
    chatClient,
    "分析问题类型。只输出：编程、数学、历史 之一"
);

var programmingAgent = builder.AddAgent(
    "programming",
    chatClient,
    "你是编程专家，回答编程相关问题"
);

var mathAgent = builder.AddAgent(
    "math",
    chatClient,
    "你是数学专家，回答数学问题"
);

var historyAgent = builder.AddAgent(
    "history",
    chatClient,
    "你是历史专家，回答历史问题"
);

builder.AddConditionalEdge(
    classifierAgent,
    async (context, output) =>
    {
        string category = output.ToString();
        
        if (category.Contains("编程"))
            return "programming";
        else if (category.Contains("数学"))
            return "math";
        else if (category.Contains("历史"))
            return "history";
        else
            return "programming"; // 默认
    },
    new Dictionary<string, IExecutor>
    {
        { "programming", programmingAgent },
        { "math", mathAgent },
        { "history", historyAgent }
    }
);

var workflow = builder.Build();

练习 4：内容创作优化循环（高级）

题目描述

创建一个内容创作工作流，包含质量检查和优化循环：

创作代理：根据主题生成文章
质量检查代理：检查文章质量（语法、逻辑、可读性）
优化代理：根据反馈优化文章
如果质量不达标，返回优化代理继续改进
最多循环 3 次

要求使用循环工作流实现。

输入示例

主题：人工智能在教育中的应用
要求：500字左右，包含具体案例

提示

设置最大迭代次数
在质量检查代理中明确通过标准
使用条件边实现循环
记录每次迭代的改进

参考答案

点击查看参考答案

var builder = new WorkflowBuilder();

var writerAgent = builder.AddAgent(
    "writer",
    chatClient,
    "根据主题和要求创作文章"
);

var qualityAgent = builder.AddAgent(
    "quality",
    chatClient,
    @"检查文章质量。评估：
    1. 语法是否正确
    2. 逻辑是否清晰
    3. 是否包含具体案例
    如果全部满足，输出：质量合格
    否则，详细说明问题"
);

var optimizerAgent = builder.AddAgent(
    "optimizer",
    chatClient,
    "根据质量反馈优化文章"
);

builder.AddEdge(writerAgent, qualityAgent);

builder.AddConditionalEdge(
    qualityAgent,
    async (context, output) =>
    {
        if (output.ToString().Contains("质量合格"))
            return "end";
        return "optimize";
    },
    new Dictionary<string, IExecutor>
    {
        { "optimize", optimizerAgent },
        { "end", null }
    }
);

builder.AddEdge(optimizerAgent, qualityAgent);

var workflow = builder.Build(new WorkflowOptions
{
    MaxIterations = 3
});

练习 5：A2A 多代理协作系统（高级）

题目描述

使用 A2A 协议创建一个旅行规划系统：

协调代理：接收用户需求，协调其他代理
天气代理：查询目的地天气
景点代理：推荐旅游景点
酒店代理：推荐住宿
行程代理：根据所有信息生成完整行程

要求：

使用 A2A 协议进行代理间通信
实现会话管理
记录所有通信日志

输入示例

用户需求：
目的地：北京
时间：3天
预算：中等
兴趣：历史文化

预期输出

【旅行规划】

天气信息：
未来3天北京天气晴朗，温度 15-25°C，适合出行

推荐景点：
1. 故宫博物院（历史文化）
2. 长城（历史遗迹）
3. 天坛公园（古建筑）

推荐酒店：
1. XX酒店（四星，¥500/晚，近故宫）
2. YY酒店（三星，¥300/晚，交通便利）

完整行程：
第1天：上午游览故宫，下午参观天坛
第2天：全天长城游览
第3天：上午自由活动，下午返程

预算估算：¥3000-4000

提示

为每个代理创建 A2AAgent
使用 A2ARequest 和 A2AResponse
使用相同的 ConversationId 关联对话
实现协调代理的调度逻辑

参考答案

点击查看参考答案

class TravelPlanningSystem
{
    private readonly Dictionary<string, A2AAgent> _agents;
    
    public TravelPlanningSystem()
    {
        _agents = new Dictionary<string, A2AAgent>();
        InitializeAgents();
    }
    
    private void InitializeAgents()
    {
        var chatClient = ConfigureChatClient();
        
        _agents["coordinator"] = new A2AAgent(
            "coordinator-agent",
            "协调代理",
            "协调其他代理，生成旅行规划",
            chatClient,
            "你负责协调其他代理，收集信息后生成完整规划"
        );
        
        _agents["weather"] = new A2AAgent(
            "weather-agent",
            "天气代理",
            "提供天气信息",
            chatClient,
            "根据目的地和时间提供天气预报"
        );
        
        _agents["attraction"] = new A2AAgent(
            "attraction-agent",
            "景点代理",
            "推荐旅游景点",
            chatClient,
            "根据目的地和兴趣推荐景点"
        );
        
        _agents["hotel"] = new A2AAgent(
            "hotel-agent",
            "酒店代理",
            "推荐住宿",
            chatClient,
            "根据预算和位置推荐酒店"
        );
        
        _agents["itinerary"] = new A2AAgent(
            "itinerary-agent",
            "行程代理",
            "生成完整行程",
            chatClient,
            "根据所有信息生成详细的旅行行程"
        );
    }
    
    public async Task<string> PlanTrip(string requirements)
    {
        var conversationId = Guid.NewGuid().ToString();
        
        // 1. 查询天气
        var weatherRequest = CreateA2ARequest(
            conversationId,
            "coordinator",
            "weather",
            requirements
        );
        var weatherResponse = await _agents["weather"]
            .ProcessA2ARequestAsync(weatherRequest);
        
        // 2. 推荐景点
        var attractionRequest = CreateA2ARequest(
            conversationId,
            "coordinator",
            "attraction",
            requirements
        );
        var attractionResponse = await _agents["attraction"]
            .ProcessA2ARequestAsync(attractionRequest);
        
        // 3. 推荐酒店
        var hotelRequest = CreateA2ARequest(
            conversationId,
            "coordinator",
            "hotel",
            requirements
        );
        var hotelResponse = await _agents["hotel"]
            .ProcessA2ARequestAsync(hotelRequest);
        
        // 4. 生成行程
        var itineraryRequest = CreateA2ARequest(
            conversationId,
            "coordinator",
            "itinerary",
            $@"需求：{requirements}
            天气：{weatherResponse.Content.Data}
            景点：{attractionResponse.Content.Data}
            酒店：{hotelResponse.Content.Data}"
        );
        var itineraryResponse = await _agents["itinerary"]
            .ProcessA2ARequestAsync(itineraryRequest);
        
        return itineraryResponse.Content.Data.ToString();
    }
    
    private A2ARequest CreateA2ARequest(
        string conversationId,
        string senderId,
        string receiverId,
        string content)
    {
        return new A2ARequest
        {
            MessageId = Guid.NewGuid().ToString(),
            ConversationId = conversationId,
            Timestamp = DateTime.UtcNow,
            Sender = new AgentInfo
            {
                AgentId = $"{senderId}-agent",
                AgentName = _agents[senderId].Name
            },
            Receiver = new AgentInfo
            {
                AgentId = $"{receiverId}-agent",
                AgentName = _agents[receiverId].Name
            },
            Content = new MessageContent
            {
                Type = "text",
                Data = content
            }
        };
    }
}