# 任务拆解示例说明

## 📋 示例概述

`21_task_decomposition.rs` 展示了一个完整的**问题拆解 - 分别回答 - 综合总结**的工作流程。

这种模式适用于处理复杂问题，通过让 AI 先拆解问题为子问题，然后独立回答每个子问题，最后综合所有答案形成完整回复。

## 🎯 核心功能

### 1. 问题拆解（TaskDecomposer）
- 分析复杂问题的结构
- 识别核心要点
- 生成 3-5 个独立的子问题
- 确保子问题之间逻辑清晰、相互独立

### 2. 子问题回答（SubQuestionAnswerer）
- 独立回答每个子问题
- 可使用工具（Shell、Echo 等）获取额外信息
- 评估答案置信度（1-5 分）

### 3. 答案综合（AnswerSynthesizer）
- 整合所有子问题的答案
- 消除重复和矛盾的信息
- 生成结构化的综合总结
- 评估整体质量（1-5 分）

## 🏗️ 系统架构

```
┌─────────────────────────────────────────┐
│           复杂问题输入                   │
└─────────────────┬───────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────┐
│         TaskDecomposer                   │
│    (问题拆解专家)                         │
│  - 分析问题结构                          │
│  - 识别核心要点                          │
│  - 生成独立子问题                        │
└─────────────────┬───────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────┐
│    SubQuestion #1    SubQuestion #2 ... │
└─────────────────┬───────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────┐
│      SubQuestionAnswerer                 │
│    (子问题回答专家)                       │
│  - 独立回答每个子问题                    │
│  - 可使用工具获取信息                    │
│  - 评估答案置信度                        │
└─────────────────┬───────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────┐
│      Answer #1    Answer #2    Answer   │
└─────────────────┬───────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────┐
│       AnswerSynthesizer                  │
│    (答案综合专家)                         │
│  - 整合所有答案                          │
│  - 消除重复和矛盾                        │
│  - 生成结构化总结                        │
│  - 评估整体质量                          │
└─────────────────┬───────────────────────┘
                  │
                  ▼
┌─────────────────────────────────────────┐
│         综合总结输出                     │
│    + 质量评分 + 改进建议                 │
└─────────────────────────────────────────┘
```

## 🚀 运行方法

### 环境准备

```bash
# 设置 API Key
export OPENAI_API_KEY=sk-your-key

# 或使用 Ollama（本地）
export OPENAI_BASE_URL=http://localhost:11434
```

### 运行示例

```bash
cargo run --example 21_task_decomposition
```

## 📝 演示任务

示例包含三个演示任务：

### 任务 1: 技术调研
**问题**: 如何设计一个高可用的分布式系统？请从架构设计、容错机制、数据一致性等方面分析。

**拆解示例**:
1. 分布式系统的核心架构模式有哪些？
2. 如何实现系统容错和故障恢复？
3. 数据一致性有哪些保证策略？
4. 负载均衡和伸缩性如何设计？

### 任务 2: 学习计划制定
**问题**: 我想在 3 个月内学会 Rust 编程并能够开发实际项目，请帮我制定详细的学习计划，包括学习资源、实践项目和时间安排。

**拆解示例**:
1. Rust 学习的基础阶段应该包含哪些内容？
2. 有哪些优质的 Rust 学习资源？
3. 应该通过哪些实践项目巩固知识？
4. 如何安排 3 个月的学习时间？

### 任务 3: 产品分析
**问题**: 分析开发一个 AI 驱动的个人知识管理应用需要考虑的关键因素，包括技术选型、用户体验、数据安全等。

**拆解示例**:
1. AI 知识管理应用的技术架构如何设计？
2. 用户体验设计的关键要素有哪些？
3. 数据安全和隐私保护如何实现？
4. 商业模式和盈利策略是什么？

## 💡 使用场景

### 1. 复杂技术咨询
- 需要多角度分析的技术问题
- 架构设计和方案选型
- 技术调研和评估

### 2. 研究报告生成
- 全面调研某个领域
- 竞品分析报告
- 市场趋势分析

### 3. 决策支持
- 权衡利弊分析
- 风险评估
- 方案比较

### 4. 学习规划
- 系统性知识梳理
- 学习路径设计
- 资源整合

## 🔧 关键代码结构

### 数据结构

```rust
// 子问题
struct SubQuestion {
    id: usize,
    question: String,
    description: Option<String>,
}

// 子问题答案
struct SubAnswer {
    question_id: usize,
    question: String,
    answer: String,
    confidence: u8,  // 1-5
}

// 综合结果
struct SynthesizedResult {
    sub_questions: Vec<SubQuestion>,
    sub_answers: Vec<SubAnswer>,
    summary: String,
    quality_score: u8,  // 1-5
}
```

### 核心组件

```rust
// 任务拆解器
struct TaskDecomposer<P> {
    agent: SimpleAgent<P>,
}

// 子问题回答器
struct SubQuestionAnswerer<P> {
    agent: ToolAgent<P>,
}

// 答案综合器
struct AnswerSynthesizer<P> {
    agent: SimpleAgent<P>,
}

// 任务拆解系统
struct TaskDecompositionSystem {
    decomposer_factory: Box<dyn Fn() -> OpenAiProvider + Send + Sync>,
    answerer_factory: Box<dyn Fn() -> OpenAiProvider + Send + Sync>,
    synthesizer_factory: Box<dyn Fn() -> OpenAiProvider + Send + Sync>,
}
```

## 🎓 学习要点

### 1. 问题拆解策略
- 如何识别问题的核心维度
- 确保子问题相互独立（MECE 原则）
- 子问题数量控制在 3-5 个

### 2. 独立回答机制
- 为每个子问题创建独立的 Agent 实例
- 允许使用工具增强回答质量
- 自信度评估帮助识别不确定答案

### 3. 答案综合方法
- 整合信息时消除重复
- 处理矛盾信息
- 结构化组织内容

### 4. 质量评估机制
- 子问题自信度评估
- 综合质量评分
- 改进建议生成

## 🔄 扩展方向

### 1. 并行处理
```rust
// 使用 tokio::join! 并行回答子问题
let answers = tokio::join!(
    answerer.answer(&q1),
    answerer.answer(&q2),
    answerer.answer(&q3),
);
```

### 2. 缓存机制
- 缓存常见子问题的答案
- 避免重复计算
- 提高响应速度

### 3. 迭代优化
- 根据质量评分自动调整拆解策略
- 对低质量答案进行追问
- 多轮迭代改进

### 4. 专家路由
- 根据子问题类型路由到不同专家
- 提高答案专业性
- 多专家协作

## 📊 性能考虑

### 响应时间
- 拆解阶段：~2-5 秒
- 回答阶段：~5-15 秒/子问题（可并行）
- 综合阶段：~3-8 秒

### 优化建议
1. **并行回答**: 使用 `tokio::join!` 并行处理子问题
2. **流式输出**: 实时显示进度
3. **结果缓存**: 缓存常见问题答案
4. **模型选择**: 使用更快的模型（如 gpt-4o-mini）

## 🐛 故障排除

### 1. JSON 解析失败
**现象**: 拆解器返回的内容无法解析为 JSON

**解决方案**:
- 使用更强大的模型
- 优化 System Prompt
- 添加 JSON Schema 约束

### 2. 答案质量低
**现象**: 综合评分低于 3 分

**解决方案**:
- 增加子问题描述
- 调整拆解策略
- 使用更专业的 Agent

### 3. API 调用失败
**现象**: Provider 返回错误

**解决方案**:
- 检查 API Key 配置
- 添加重试机制
- 使用 ResilientProvider

## 📚 相关示例

- `17_supervisor_agent.rs` - 主管模式（多 Agent 协作）
- `18_research_assistant.rs` - 研究助手
- `15_react_agent.rs` - ReAct 模式

## 🎯 最佳实践

1. **明确问题范围**: 确保原始问题清晰具体
2. **合理拆解**: 子问题应该覆盖所有重要方面
3. **独立回答**: 避免子问题之间的依赖
4. **质量把控**: 根据评分决定是否重新生成
5. **结构化输出**: 使用清晰的格式组织内容

---

*创建日期：2026 年 3 月 31 日*
