智能体设计模式（六）资源感知优化-推理技术-评估与监控

智能体设计模式（六）资源感知优化-推理技术-评估与监控

本文是"智能体设计模式"系列的第六篇，涵盖第16、17、19章：资源感知优化、推理技术、评估与监控。

系列文章：

• 智能体设计模式（一）提示链-路由-并行化
• 智能体设计模式（二）反思-工具使用-规划
• 智能体设计模式（三）多智能体协作-记忆管理-学习与适应
• 智能体设计模式（四）模型上下文协议-目标设定与监控-异常处理与恢复
• 智能体设计模式（五）人机协同-知识检索RAG-智能体间通信
• 智能体设计模式（六）资源感知优化-推理技术-评估与监控（本文）
• ...

---

第16章：资源感知优化 ------ AI的"精打细算"

一句话定位：资源感知优化就是让AI学会"精打细算"，根据任务难度和预算限制，智能选择用"豪华版"还是"经济版"模型，既省钱又高效。

---

一、秒懂定位（30秒版）

这个知识解决什么问题：

AI调用不是免费的！
- GPT-4贵但聪明
- GPT-3.5便宜但简单
- 所有任务都用GPT-4？太贵！
- 所有任务都用GPT-3.5？效果差！

资源感知优化 = 看菜吃饭
简单问题用便宜模型
复杂问题用强力模型

一句话精华：

资源感知优化 = 智能选择 + 动态调整
让AI根据任务难度和资源限制
自动选择最合适的处理方式

适合谁学 ：需要控制AI成本、优化性能的开发者
不适合谁：不在乎成本、只追求最好效果的场景

---

二、核心框架（知识骨架）

生活化比喻：AI的"出行选择"

想象你要出门办事，有多种交通方式：

🚶 步行（便宜模型）：
   - 免费，但慢
   - 适合：去楼下便利店

🚌 公交（中等模型）：
   - 便宜，速度适中
   - 适合：日常通勤

🚕 打车（高级模型）：
   - 贵，但快
   - 适合：赶时间、重要会议

🚁 直升机（顶级模型）：
   - 超贵，超快
   - 适合：紧急救援

资源感知优化 = 根据目的地和紧急程度
自动选择最合适的交通方式！

关键概念速查表

概念	大白话解释	生活比喻	一句话记忆
动态模型切换	根据任务选模型	看菜吃饭	简单用便宜的
路由Agent	判断任务难度的AI	分诊台护士	决定谁来处理
后备机制	主模型挂了用备用	备胎	保证服务不中断
Token计费	按使用量收费	水电费	用多少付多少
延迟敏感	对响应时间有要求	急性子	快比好更重要
成本优化	花最少钱办最多事	精打细算	省钱是硬道理

知识地图

用户请求 → [路由Agent判断]
              ↓
         任务复杂度？
         ├─ 简单 → [便宜模型] → 快速响应
         ├─ 中等 → [中等模型] → 平衡处理
         └─ 复杂 → [高级模型] → 精准回答
              ↓
         [评论Agent评估]
              ↓
         质量达标？
         ├─ 是 → 返回结果
         └─ 否 → 升级模型重试

---

三、深入浅出讲解（教学版）

开场钩子

"老板说：'这个月AI账单怎么这么高？！'你一看，所有问题都用GPT-4回答，包括'今天星期几'这种问题...这时候你就需要资源感知优化了------让AI学会'该省省，该花花'！"

核心讲解

【概念1：动态模型切换 ------ 看菜吃饭】

一句话是什么：根据任务的复杂程度，自动选择合适的模型。

生活化比喻：

想象你是一家医院的分诊台：

🤒 小感冒（简单问题）：
   - 去普通门诊
   - 挂号费便宜
   - 等待时间短

🤕 骨折（中等问题）：
   - 去骨科专家
   - 费用适中
   - 需要一定时间

🚑 心脏病发作（复杂问题）：
   - 直接进ICU
   - 费用最高
   - 但必须这样

AI也是一样：
- "今天天气怎么样" → 用便宜模型
- "帮我分析这份报告" → 用中等模型
- "帮我写一个复杂算法" → 用高级模型

代码示例：

from google.adk.agents import Agent

# 定义不同级别的Agent
gemini_flash_agent = Agent(
    name="快速助手",
    model="gemini-2.5-flash",  # 便宜、快速
    description="处理简单查询",
    instruction="你是一个快速助手，处理简单问题。"
)

gemini_pro_agent = Agent(
    name="专家助手",
    model="gemini-2.5-pro",  # 贵、强大
    description="处理复杂问题",
    instruction="你是一个专家助手，处理复杂问题。"
)

---

【概念2：路由Agent ------ 智能分诊台】

一句话是什么：一个专门判断任务难度、决定用哪个模型的Agent。

生活化比喻：

想象一个智能客服系统：

用户问题进来 → 路由Agent判断
                ↓
         "这个问题难不难？"
                ↓
         ├─ 简单（查余额）→ 自动回复
         ├─ 中等（投诉）→ 普通客服
         └─ 复杂（法律纠纷）→ 专家客服

代码示例：

class QueryRouterAgent:
    """智能路由Agent"""
    
    def route(self, user_query):
        # 简单判断：根据问题长度和关键词
        query_length = len(user_query.split())
        
        # 包含复杂关键词？
        complex_keywords = ["分析", "算法", "优化", "设计", "架构"]
        is_complex = any(kw in user_query for kw in complex_keywords)
        
        if query_length < 10 and not is_complex:
            return "flash"  # 用便宜模型
        elif query_length < 50 and not is_complex:
            return "standard"  # 用中等模型
        else:
            return "pro"  # 用高级模型
    
    def process(self, user_query):
        model_type = self.route(user_query)
        
        if model_type == "flash":
            return self.flash_agent.run(user_query)
        elif model_type == "standard":
            return self.standard_agent.run(user_query)
        else:
            return self.pro_agent.run(user_query)

更智能的路由：

# 用LLM来判断任务复杂度
def classify_query(query):
    """用LLM分类查询"""
    
    system_prompt = """
    你是一个分类器，判断用户问题的类型：
    - simple: 简单事实查询，不需要推理
    - reasoning: 需要逻辑推理或多步思考
    - internet_search: 需要最新信息
    
    只返回类型，不要解释。
    """
    
    response = llm.chat(system_prompt, query)
    return response.strip()  # "simple" / "reasoning" / "internet_search"

---

【概念3：后备机制 ------ 永不宕机】

一句话是什么：当首选模型不可用时，自动切换到备用模型。

生活化比喻：

想象你开车去上班：

正常情况：走高速（首选）
高速堵车：走国道（备选1）
国道也堵：走小路（备选2）

后备机制就是：
- 首选模型挂了？用备选
- 备选也挂了？用更基础的
- 保证服务不中断

代码示例：

# 使用OpenRouter的后备机制
{
    "models": [
        "anthropic/claude-3.5-sonnet",  # 首选
        "openai/gpt-4",                  # 备选1
        "openai/gpt-3.5-turbo"           # 备选2
    ],
    "messages": [...]
}

# 如果Claude不可用，自动尝试GPT-4
# 如果GPT-4也不可用，自动尝试GPT-3.5

---

【概念4：评论Agent ------ 质量把关】

一句话是什么：评估AI输出质量，决定是否需要升级模型重试。

生活化比喻：

想象一个质检流程：

产品生产出来 → 质检员检查
                ↓
         质量达标？
         ├─ 是 → 出厂
         └─ 否 → 返工（用更好的设备）

评论Agent就是AI的"质检员"：
- 检查回答是否准确
- 检查是否完整
- 不达标就升级模型重试

代码示例：

CRITIC_PROMPT = """
你是质量评估专家，评估AI回答的质量。

评估标准：
1. 准确性：信息是否正确
2. 完整性：是否回答了所有问题
3. 清晰度：是否易于理解
4. 相关性：是否切题

如果质量不达标，说明原因并建议改进。
"""

class CriticAgent:
    def evaluate(self, question, answer):
        prompt = f"""
        问题：{question}
        回答：{answer}
        
        请评估这个回答的质量（1-10分）并说明理由。
        """
        
        result = self.llm.chat(CRITIC_PROMPT, prompt)
        score = extract_score(result)
        
        if score < 7:
            return {"pass": False, "feedback": result}
        return {"pass": True}

---

【概念5：成本优化策略 ------ 省钱大法】

多种优化手段：

策略1：动态模型选择
- 简单问题用便宜模型
- 复杂问题用高级模型
- 节省50%以上成本

策略2：上下文压缩
- 不要把所有历史对话都发给AI
- 只保留相关的部分
- 减少Token消耗

策略3：缓存常见问题
- 相同问题不重复调用
- 用缓存直接返回
- 节省重复调用成本

策略4：批量处理
- 多个小请求合并成一个
- 减少API调用次数
- 降低固定开销

策略5：异步处理
- 不紧急的任务排队处理
- 利用低峰期的便宜价格
- 错峰省钱

---

四、实践示例

示例1：完整的资源感知系统

import os
from openai import OpenAI

client = OpenAI()

def classify_query(query):
    """分类查询复杂度"""
    response = client.chat.completions.create(
        model="gpt-4o",  # 用强模型做分类
        messages=[
            {"role": "system", "content": """
            分类用户查询：
            - simple: 简单事实查询
            - reasoning: 需要推理
            - internet_search: 需要最新信息
            只返回类型。
            """},
            {"role": "user", "content": query}
        ]
    )
    return response.choices[0].message.content.strip()

def generate_response(query, classification):
    """根据分类选择模型生成回答"""
    
    if classification == "simple":
        model = "gpt-4o-mini"  # 便宜模型
    elif classification == "reasoning":
        model = "o4-mini"  # 推理模型
    else:
        model = "gpt-4o"  # 高级模型
    
    response = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": query}]
    )
    
    return response.choices[0].message.content, model

def handle_query(query):
    """处理用户查询"""
    # 1. 分类
    classification = classify_query(query)
    
    # 2. 生成回答
    answer, model_used = generate_response(query, classification)
    
    return {
        "classification": classification,
        "model": model_used,
        "answer": answer
    }

# 测试
result = handle_query("澳大利亚的首都是哪里？")
print(f"分类: {result['classification']}")
print(f"模型: {result['model']}")
print(f"回答: {result['answer']}")

示例2：旅行规划的层次化Agent

"""
旅行规划场景：
- 高层规划（理解需求、制定方案）→ 用Pro模型
- 具体执行（查航班、查酒店）→ 用Flash模型
"""

class TravelPlannerSystem:
    def __init__(self):
        # 规划Agent用高级模型
        self.planner = Agent(
            name="旅行规划师",
            model="gemini-2.5-pro",
            instruction="你是资深旅行规划师，负责理解用户需求并制定整体方案。"
        )
        
        # 执行Agent用便宜模型
        self.flight_searcher = Agent(
            name="航班搜索",
            model="gemini-2.5-flash",
            instruction="你负责搜索航班信息。"
        )
        
        self.hotel_searcher = Agent(
            name="酒店搜索",
            model="gemini-2.5-flash",
            instruction="你负责搜索酒店信息。"
        )
    
    def plan_trip(self, user_request):
        # 1. 高级模型理解需求、制定方案
        plan = self.planner.run(f"分析用户需求并制定旅行方案：{user_request}")
        
        # 2. 便宜模型执行具体搜索
        flights = self.flight_searcher.run(f"根据方案搜索航班：{plan}")
        hotels = self.hotel_searcher.run(f"根据方案搜索酒店：{plan}")
        
        # 3. 高级模型整合结果
        final_plan = self.planner.run(f"""
        整合以下信息，生成最终旅行方案：
        方案：{plan}
        航班：{flights}
        酒店：{hotels}
        """)
        
        return final_plan

---

五、精华提炼（去废话版）

核心要点

1. 动态模型切换 = 看菜吃饭

   • 简单问题用便宜模型
   • 复杂问题用高级模型
   • 能省50%以上成本

2. 路由Agent = 智能分诊

   • 判断任务复杂度
   • 决定用哪个模型
   • 可以用规则或LLM判断

3. 后备机制 = 永不宕机

   • 首选不可用时自动切换
   • 保证服务连续性
   • 优雅降级

4. 评论Agent = 质量把关

   • 评估输出质量
   • 不达标就升级重试
   • 保证最终质量

必须记住的

资源感知优化三原则：
1. 简单问题用便宜模型
2. 复杂问题用高级模型
3. 首选不可用时有备选

---

六、行动清单

立即可做（5分钟内）

• 理解动态模型切换的价值
• 了解不同模型的价格差异

本周实践

• 实现一个简单的路由Agent
• 给现有系统加上后备机制

进阶挑战

• 实现完整的资源感知系统
• 加入评论Agent做质量把关

---

七、常见误区

误区1："便宜模型效果一定差"

真相：

对于简单任务，便宜模型效果可能一样好：
- "今天星期几" → GPT-3.5和GPT-4回答一样
- "1+1等于几" → 便宜模型完全够用
- "北京的首都是哪里" → 不需要高级模型

关键是匹配：
- 简单任务 + 便宜模型 = 高性价比
- 复杂任务 + 高级模型 = 必要投入

误区2："路由判断本身也要花钱"

真相：

路由判断的成本远低于节省的成本：
- 路由判断：几个Token
- 节省的成本：可能是几千Token

就像：
- 花1块钱判断该坐公交还是打车
- 可能省下100块打车费
- 这1块钱花得值！

误区3："后备机制会降低质量"

真相：

后备机制是"保底"，不是"降级"：
- 首选可用时，用首选
- 首选不可用时，用备选
- 总比服务中断强

而且可以设计智能后备：
- 备选模型也可以很强
- 只是可能贵一点或慢一点
- 关键是保证服务不中断

---

八、学习检查

基础知识

• 能解释动态模型切换的原理
• 理解路由Agent的作用
• 知道后备机制的重要性

实践能力

• 能实现简单的路由逻辑
• 能配置后备模型
• 能评估成本节省效果

进阶理解

• 能设计完整的资源感知系统
• 能平衡成本和质量
• 能处理各种边缘情况

---

九、金句收藏

原文金句：

"资源感知优化使智能体能够在运行过程中动态监控和管理计算、时间和财务资源，
在指定的资源预算内实现目标或优化效率。"

我的总结金句：

"AI不是越贵越好，而是越合适越好；
资源感知优化让AI学会'该省省，该花花'。"

---

十、画龙点睛（收尾）

总结升华

资源感知优化不仅仅是省钱，更是一种智能的资源管理思维：

• 不是所有问题都需要最强的模型
• 合适的才是最好的
• 智能分配资源，才能可持续发展

就像一个聪明的管理者：

• 不是所有任务都派最贵的员工
• 而是根据任务难度分配合适的人
• 既保证质量，又控制成本

悬念预告

学会了资源优化，AI能省钱了。但AI是怎么"思考"的？怎么让AI的推理更可靠？下一章"推理技术"，我们来揭秘！

一句话带走

资源感知优化 = AI的"精打细算"
简单问题用便宜模型，复杂问题用高级模型，
既省钱又高效！

---

十一、延伸资源

想深入学习

• OpenRouter：统一的多模型API
• LiteLLM：模型切换库

想教给别人

• 用"出行选择"的比喻解释动态模型切换
• 用"医院分诊"的比喻解释路由Agent

---

第17章：推理技术 ------ AI的"思考方式"

一句话定位：推理技术就是教AI"怎么想问题"，从简单的"一步到位"升级到"步步为营"，让AI像人类专家一样深思熟虑。

---

一、秒懂定位（30秒版）

这个知识解决什么问题：

AI回答问题有时候"想都不想"就给答案
结果经常出错，尤其是复杂问题

推理技术 = 让AI"慢下来想一想"
- 把大问题拆成小步骤
- 一步一步推导
- 最后得出可靠答案

一句话精华：

推理技术 = 让AI学会"思考过程"
不是直接给答案，而是展示怎么得出答案

适合谁学 ：需要AI处理复杂推理、数学计算、逻辑分析的开发者
不适合谁：只需要AI做简单问答的场景

---

二、核心框架（知识骨架）

生活化比喻：AI的"解题过程"

想象你在做数学题：

❌ 不好的学生（传统AI）：
   题目：小明有5个苹果，给了小红3个，又买了2个，现在有几个？
   答案：4个！（直接写答案，不写过程）
   老师：过程呢？怎么算的？
   学生：我就是知道...

✅ 好的学生（推理AI）：
   题目：同上
   思考过程：
   1. 小明原来有5个苹果
   2. 给了小红3个，剩下5-3=2个
   3. 又买了2个，现在有2+2=4个
   答案：4个

推理技术就是让AI像好学生一样
展示思考过程，而不是直接给答案！

关键概念速查表

概念	大白话解释	生活比喻	一句话记忆
Chain-of-Thought	一步步推理	解题过程	想一步写一步
Tree-of-Thought	多条路径探索	下棋看多步	想多种可能
Self-Correction	自我检查纠错	检查作业	做完再检查
ReAct	边想边做	实验验证	想到就试试
RLVR	强化学习推理	刷题提高	越练越强

知识地图

用户问题 → [选择推理策略]
              ↓
         问题类型？
         ├─ 简单 → [直接回答]
         ├─ 需要推理 → [Chain-of-Thought]
         ├─ 多种可能 → [Tree-of-Thought]
         └─ 需要验证 → [ReAct]
              ↓
         [生成推理过程]
              ↓
         [自我检查]
              ↓
         输出答案

---

三、深入浅出讲解（教学版）

开场钩子

"你问AI：'9.11和9.9哪个大？'AI说：'9.11大！'------等等，这不对啊！这就是AI'不过脑子'的典型表现。推理技术就是要让AI学会'过脑子'！"

核心讲解

【概念1：Chain-of-Thought（思维链）------ 一步步来】

一句话是什么：让AI把思考过程写出来，一步一步推导到答案。

生活化比喻：

想象你是数学老师，批改学生作业：

❌ 差学生的作业：
   题目：计算 (3+5) × 2
   答案：16
   （没有过程，不知道对不对）

✅ 好学生的作业：
   题目：计算 (3+5) × 2
   步骤1：先算括号里的 3+5=8
   步骤2：再算乘法 8×2=16
   答案：16
   （过程清晰，容易检查）

Chain-of-Thought就是让AI像好学生一样
把每一步都写出来！

引经据典：

"不积跬步，无以至千里" ------ 荀子

在AI推理中：
"不积小步，无以得正解"

复杂问题必须拆解成小步骤
一步一步来，才能得到正确答案！

代码示例：

# Chain-of-Thought提示词
cot_prompt = """
你是一个信息检索助手。回答问题时请按以下步骤：

1. **分析问题**：理解问题的核心和具体要求
2. **制定搜索策略**：确定需要搜索什么信息
3. **模拟检索**：思考会找到什么相关信息
4. **综合信息**：整合找到的信息
5. **检查答案**：确保答案准确完整

用户问题：解释经典计算机和量子计算机的主要区别

---
思考过程：

**步骤1（分析问题）**：
用户想了解两种计算机的区别，需要解释：
- 基本原理的不同
- 计算能力的不同
- 应用场景的不同

**步骤2（制定搜索策略）**：
需要搜索：
- 经典计算机的工作原理
- 量子计算机的工作原理
- 两者的对比

**步骤3（模拟检索）**：
- 经典计算机：使用比特（0或1），顺序处理
- 量子计算机：使用量子比特，可以叠加态

**步骤4（综合信息）**：
经典计算机用比特处理信息，一次只能是0或1；
量子计算机用量子比特，可以同时处于多种状态（叠加），
还能通过纠缠实现更复杂的计算。

**步骤5（检查答案）**：
- 区别讲清楚了 ✓
- 原理解释了 ✓
- 易于理解 ✓

---
最终答案：
经典计算机使用比特（0或1）顺序处理信息，
而量子计算机使用量子比特，能同时处于多种状态（叠加），
并通过纠缠实现指数级的计算能力提升。
"""

---

【概念2：Tree-of-Thought（思维树）------ 多路探索】

一句话是什么：不只走一条路，而是同时探索多种可能，选最好的。

生活化比喻：

想象你在下象棋：

Chain-of-Thought（思维链）：
- 想一步走一步
- 走了就不回头
- 可能走进死胡同

Tree-of-Thought（思维树）：
- 每一步都想多种可能
- 评估每种可能的结果
- 选择最好的那条路
- 发现不对可以回退

就像高手下棋：
"如果我走这步，对方会怎么走？
 如果对方这样走，我再怎么走？
 让我想想另一种走法..."

图示：

                    问题
                     │
         ┌──────────┼──────────┐
         ↓          ↓          ↓
       方案A      方案B      方案C
         │          │          │
      ┌──┴──┐    ┌──┴──┐    ┌──┴──┐
      ↓     ↓    ↓     ↓    ↓     ↓
     A1    A2   B1    B2   C1    C2
      │     │    │     │    │     │
     评估  评估  评估  评估  评估  评估
      │     │    │     │    │     │
     60分  80分  70分  90分  50分  75分
                       ↑
                   选择B2！

---

【概念3：Self-Correction（自我纠错）------ 检查作业】

一句话是什么：AI生成答案后，自己检查一遍，发现错误就改正。

生活化比喻：

想象你写完一篇文章：

❌ 不检查：
   写完就交
   可能有错别字、逻辑错误
   被老师批评

✅ 自我检查：
   写完后从头读一遍
   发现"的地得"用错了，改！
   发现逻辑不通，调整！
   再检查一遍，OK，交！

Self-Correction就是让AI学会"检查作业"！

代码示例：

SELF_CORRECTION_PROMPT = """
你是一个自我纠错助手。请按以下步骤工作：

1. **理解原始要求**：回顾最初的问题是什么
2. **分析当前回答**：仔细阅读已生成的回答
3. **识别问题**：
   - 准确性：有没有事实错误？
   - 完整性：有没有遗漏重要内容？
   - 清晰度：表达是否清楚？
   - 相关性：是否切题？
4. **提出改进**：针对每个问题提出具体修改
5. **生成修订版**：输出改进后的回答

---
原始问题：写一条社交媒体帖子宣传新产品"GreenTech Gadgets"

初稿：
"我们有新产品。它们是绿色的，科技感十足。现在就买！"

---
自我检查：

**步骤1（理解要求）**：
- 需要：简短、吸引人的社交媒体帖子
- 产品：GreenTech Gadgets（环保科技产品）

**步骤2（分析初稿）**：
"我们有新产品。它们是绿色的，科技感十足。现在就买！"

**步骤3（识别问题）**：
- 吸引力：❌ 太平淡，没有吸引力
- 环保特点：❌ 没有强调环保价值
- 行动号召：⚠️ "现在就买"太生硬
- 情感连接：❌ 缺乏情感共鸣

**步骤4（提出改进）**：
- 加入emoji增加视觉吸引力
- 强调"环保"和"创新"
- 使用更有感染力的行动号召
- 加入相关标签

**步骤5（修订版）**：
🌱 探索GreenTech Gadgets！我们的新环保系列，
将创新与可持续完美融合。选择绿色，选择智慧！
立即体验 → #环保科技 #GreenTech
"""

---

【概念4：ReAct（推理+行动）------ 边想边做】

一句话是什么：AI不只是想，还要行动验证，根据结果调整思路。

生活化比喻：

想象你在做科学实验：

纯思考（Chain-of-Thought）：
- 我觉得A+B会产生C
- 所以答案是C
- （但没有验证）

ReAct（推理+行动）：
- 我觉得A+B会产生C
- 让我试试看...（行动）
- 观察：实际产生了D！
- 思考：为什么不是C？可能是温度问题
- 行动：调整温度再试...
- 观察：这次产生了C！
- 结论：A+B在适当温度下产生C

ReAct = 想 → 做 → 看 → 再想 → 再做...

ReAct循环：

用户问题
    ↓
[思考] 我需要查询什么信息？
    ↓
[行动] 调用搜索工具
    ↓
[观察] 搜索结果是...
    ↓
[思考] 这个信息够吗？还需要什么？
    ↓
[行动] 再查询更多信息
    ↓
[观察] 新的结果是...
    ↓
[思考] 现在可以回答了
    ↓
[输出] 最终答案

---

【概念5：RLVR（强化学习推理）------ 越练越强】

一句话是什么：通过大量练习和反馈，让AI的推理能力越来越强。

生活化比喻：

想象一个学生学数学：

传统方法：
- 老师教一遍
- 学生记住
- 考试时回忆

RLVR方法：
- 给学生大量题目
- 学生尝试解答
- 对答案，对了奖励，错了分析
- 反复练习
- 越来越会做题

RLVR就是让AI通过"刷题"变强！

RLVR的关键：

1. 可验证的问题
   - 数学题：答案可以验证对错
   - 代码题：运行结果可以验证
   - 逻辑题：推理过程可以检查

2. 奖励机制
   - 答对了：正向奖励
   - 答错了：负向反馈
   - 推理过程好：额外奖励

3. 自我进化
   - 不需要人类标注每一步
   - AI自己探索最佳推理方式
   - 越练越强

---

四、实践示例

示例1：Chain-of-Thought数学推理

# CoT提示词模板
COT_MATH_PROMPT = """
请一步一步解决这个数学问题，展示完整的推理过程。

问题：{question}

解答过程：
"""

def solve_math_with_cot(question):
    prompt = COT_MATH_PROMPT.format(question=question)
    
    response = llm.chat(
        messages=[{"role": "user", "content": prompt}]
    )
    
    return response

# 测试
question = "一个水池有两个进水管，A管单独注满需要6小时，B管单独注满需要4小时。两管同时开，多久能注满？"

answer = solve_math_with_cot(question)
print(answer)

# AI会输出：
# 步骤1：计算A管每小时注水量 = 1/6
# 步骤2：计算B管每小时注水量 = 1/4
# 步骤3：两管同时开，每小时注水量 = 1/6 + 1/4 = 2/12 + 3/12 = 5/12
# 步骤4：注满需要时间 = 1 ÷ (5/12) = 12/5 = 2.4小时
# 答案：2.4小时（或2小时24分钟）

示例2：ReAct模式的Agent

from google.adk.agents import Agent
from google.adk.tools import google_search

# 创建ReAct风格的Agent
react_agent = Agent(
    name="研究助手",
    model="gemini-2.0-flash",
    instruction="""
    你是一个研究助手，使用ReAct模式回答问题。
    
    对于每个问题，请按以下格式：
    
    思考：我需要了解什么？
    行动：使用搜索工具查询
    观察：搜索结果显示...
    思考：这个信息是否足够？
    ...（重复直到有足够信息）
    答案：基于以上信息，答案是...
    """,
    tools=[google_search]
)

# 使用
response = react_agent.run("2024年诺贝尔物理学奖得主是谁？他们的贡献是什么？")

示例3：自我纠错流程

class SelfCorrectingAgent:
    def __init__(self, llm):
        self.llm = llm
    
    def generate_and_correct(self, question, max_iterations=3):
        # 第一次生成
        answer = self.generate(question)
        
        for i in range(max_iterations):
            # 自我评估
            evaluation = self.evaluate(question, answer)
            
            if evaluation["is_good"]:
                return answer
            
            # 根据反馈改进
            answer = self.improve(question, answer, evaluation["feedback"])
        
        return answer
    
    def generate(self, question):
        return self.llm.chat(f"请回答：{question}")
    
    def evaluate(self, question, answer):
        prompt = f"""
        评估以下回答的质量：
        问题：{question}
        回答：{answer}
        
        请检查：
        1. 准确性
        2. 完整性
        3. 清晰度
        
        返回JSON：{{"is_good": true/false, "feedback": "改进建议"}}
        """
        return self.llm.chat(prompt)
    
    def improve(self, question, answer, feedback):
        prompt = f"""
        根据反馈改进回答：
        问题：{question}
        原回答：{answer}
        反馈：{feedback}
        
        请生成改进后的回答：
        """
        return self.llm.chat(prompt)

---

五、精华提炼（去废话版）

核心要点

1. Chain-of-Thought = 一步步来

   • 把思考过程写出来
   • 复杂问题拆成小步骤
   • 提高准确性和可解释性

2. Tree-of-Thought = 多路探索

   • 同时考虑多种可能
   • 评估每条路径
   • 选择最优解

3. Self-Correction = 自我检查

   • 生成后检查
   • 发现问题就改
   • 迭代提升质量

4. ReAct = 边想边做

   • 思考→行动→观察→再思考
   • 根据实际结果调整
   • 适合需要工具的任务

必须记住的

推理技术核心：
让AI"慢下来想一想"
而不是"想都不想就回答"

---

六、行动清单

立即可做（5分钟内）

• 理解Chain-of-Thought的基本原理
• 尝试在提示词中加入"请一步步思考"

本周实践

• 实现一个CoT提示词模板
• 尝试Self-Correction流程

进阶挑战

• 实现Tree-of-Thought多路探索
• 构建ReAct模式的Agent

---

七、常见误区

误区1："所有问题都需要CoT"

真相：

简单问题不需要CoT：
- "今天星期几" → 直接回答
- "1+1等于几" → 不需要推理过程

CoT适合的场景：
- 多步骤计算
- 逻辑推理
- 复杂分析

过度使用CoT反而浪费Token！

误区2："CoT一定能提高准确性"

真相：

CoT的效果取决于：
- 问题类型：推理类问题效果好
- 模型能力：弱模型可能"推理"出错误结论
- 提示词质量：引导方式很重要

CoT不是万能药，要根据场景选择！

误区3："推理过程越长越好"

真相：

推理过程要"恰到好处"：
- 太短：可能跳过关键步骤
- 太长：可能引入错误，浪费资源

好的推理过程：
- 每一步都有意义
- 逻辑清晰连贯
- 不冗余不遗漏

---

八、学习检查

基础知识

• 能解释Chain-of-Thought的原理
• 理解Tree-of-Thought和CoT的区别
• 知道ReAct的工作流程

实践能力

• 能写出有效的CoT提示词
• 能实现简单的自我纠错流程
• 能判断什么场景适合什么推理技术

进阶理解

• 理解RLVR的训练原理
• 能设计复杂的推理流程
• 能评估推理质量

---

九、金句收藏

原文金句：

"Chain-of-Thought通过模仿逐步思考的过程，
显著增强了大语言模型的复杂推理能力。"

我的总结金句：

"AI不是不会想，而是需要被教会怎么想；
推理技术就是教AI'过脑子'的方法。"

---

十、画龙点睛（收尾）

总结升华

推理技术的本质是让AI从"直觉反应"升级到"深思熟虑"：

• 不是直接给答案，而是展示思考过程
• 不是一条路走到黑，而是探索多种可能
• 不是做完就交，而是检查后再提交

就像培养一个优秀的学生：

• 不只要答案对，还要过程对
• 不只会做题，还要会检查
• 不只会一种方法，还要会多种方法

悬念预告

学会了推理技术，AI能"想"了。但怎么知道AI想得对不对？怎么监控AI的表现？下一章"评估与监控"，我们来揭秘！

一句话带走

推理技术 = 教AI"怎么想问题"
让AI从"脱口而出"变成"深思熟虑"！

---

十一、延伸资源

想深入学习

• OpenAI的推理模型（o1系列）
• Google的Gemini思考模式

想教给别人

• 用"解题过程"的比喻解释CoT
• 用"下棋"的比喻解释ToT

---

第19章：评估与监控 ------ AI的"体检报告"

一句话定位：评估与监控就是给AI智能体做"定期体检"，确保它不仅能干活，还能干好活、持续干好活。

---

一、秒懂定位（30秒版）

这个知识解决什么问题：

AI智能体部署上线后，怎么知道它表现好不好？
- 回答准确吗？
- 速度够快吗？
- 成本可控吗？
- 有没有"跑偏"？

评估与监控 = AI的"健康监测系统"
让你随时掌握AI的"身体状况"

一句话精华：

评估与监控 = 给AI装上"仪表盘"
实时监控性能，及时发现问题，持续优化改进

适合谁学 ：需要在生产环境部署AI智能体的开发者、运维人员
不适合谁：只是玩玩Demo、不关心长期运行的场景

---

二、核心框架（知识骨架）

生活化比喻：AI的"健康管理"

想象你开了一家餐厅，雇了一个AI厨师：

❌ 不做评估监控：
   AI厨师做菜...
   顾客投诉："这菜太咸了！"
   你："啊？我不知道啊..."
   顾客投诉："等了一小时才上菜！"
   你："啊？我也不知道啊..."
   餐厅倒闭...

✅ 做好评估监控：
   AI厨师做菜...
   监控系统："菜品满意度98%，平均出餐时间8分钟"
   监控系统："警告！今天盐用量超标20%"
   你："收到，调整配方！"
   监控系统："顾客A等待超过15分钟，建议优先处理"
   你："好的，马上安排！"
   餐厅越来越火...

评估与监控就是给AI装上"眼睛"和"耳朵"
让你随时知道AI在干什么、干得怎么样！

关键概念速查表

概念	大白话解释	生活比喻	一句话记忆
响应准确性	AI回答对不对	考试分数	答案正确率
延迟监控	AI响应快不快	上菜速度	别让顾客等太久
Token使用	AI消耗多少资源	用了多少食材	成本控制
LLM-as-Judge	用AI评价AI	请美食评论家打分	专业评审
轨迹分析	AI的思考过程	做菜步骤记录	过程比结果重要
漂移检测	AI性能是否下降	厨艺是否退步	定期复查

知识地图

AI智能体运行
      ↓
[评估与监控系统]
      ├─ 准确性评估 → 回答对不对？
      ├─ 延迟监控 → 响应快不快？
      ├─ 成本追踪 → 花费多不多？
      ├─ 轨迹分析 → 过程合理吗？
      └─ 漂移检测 → 性能稳定吗？
      ↓
[反馈与改进]
      ├─ 发现问题 → 及时修复
      ├─ A/B测试 → 对比优化
      └─ 持续迭代 → 越来越好

---

三、深入浅出讲解（教学版）

开场钩子

"你的AI智能体上线一个月了，老板问你：'它表现怎么样？'你说：'挺好的吧...'老板：'具体数据呢？'你：'呃...'------这就是没有评估监控的尴尬！"

核心讲解

【概念1：响应准确性评估 ------ AI的"考试成绩"】

一句话是什么：检查AI的回答是否正确、是否有用。

生活化比喻：

想象你是老师，批改学生作业：

简单批改（精确匹配）：
- 标准答案："巴黎是法国的首都"
- 学生答案："法国的首都是巴黎"
- 结果：❌ 错误（字符串不一样）
- 问题：明明意思一样，却判错了！

智能批改（语义理解）：
- 标准答案："巴黎是法国的首都"
- 学生答案："法国的首都是巴黎"
- 结果：✅ 正确（意思一样）
- 这才是我们需要的评估方式！

代码示例：

def evaluate_response_accuracy(agent_output: str, expected_output: str) -> float:
    """简单的精确匹配评估（基础版）"""
    # 这是最简单的方法，但有局限性
    return 1.0 if agent_output.strip().lower() == expected_output.strip().lower() else 0.0

# 测试
agent_response = "法国的首都是巴黎。"
ground_truth = "巴黎是法国的首都。"
score = evaluate_response_accuracy(agent_response, ground_truth)
print(f"准确性分数: {score}")  # 输出: 0.0（但其实意思是对的！）

# 更好的方法：使用语义相似度或LLM-as-Judge

常见误区：

❌ 只用精确匹配：
   "巴黎" vs "Paris" → 判错（但其实是对的）

✅ 应该用多种方法：
   - 语义相似度（Embedding比较）
   - 关键词检查
   - LLM-as-Judge（让AI评价AI）

---

【概念2：延迟监控 ------ AI的"响应速度"】

一句话是什么：测量AI处理请求需要多长时间。

生活化比喻：

想象你在餐厅点餐：

❌ 没有延迟监控：
   顾客点餐...
   等了30分钟...
   顾客走了...
   你还不知道发生了什么

✅ 有延迟监控：
   顾客点餐 → 计时开始
   5分钟后 → "正常，继续"
   10分钟后 → "警告：超过平均时间"
   15分钟后 → "紧急：需要干预！"
   
延迟监控 = 给每个请求装上"秒表"

为什么重要：

用户体验：
- 响应 < 1秒 → 感觉很快
- 响应 1-3秒 → 可以接受
- 响应 > 5秒 → 开始不耐烦
- 响应 > 10秒 → 可能放弃

实时应用（如客服机器人）：
延迟太高 = 用户流失！

---

【概念3：Token使用追踪 ------ AI的"账单"】

一句话是什么：记录AI消耗了多少Token，控制成本。

生活化比喻：

想象你开了一家用电大户的工厂：

❌ 不追踪用电：
   月底电费单：10万！
   你：怎么这么多？哪里用的？
   不知道...

✅ 追踪用电：
   生产线A：用电3万
   生产线B：用电2万
   空调系统：用电4万（异常！）
   照明：用电1万
   
   发现问题：空调系统漏电，修复后省了2万！

Token追踪 = AI的"电表"
知道钱花在哪里，才能省钱！

代码示例：

class LLMInteractionMonitor:
    """LLM交互监控器"""
    def __init__(self):
        self.total_input_tokens = 0
        self.total_output_tokens = 0
        self.interaction_count = 0

    def record_interaction(self, prompt: str, response: str):
        # 实际应用中应使用LLM API的token计数器
        input_tokens = len(prompt.split())  # 简化示例
        output_tokens = len(response.split())
        
        self.total_input_tokens += input_tokens
        self.total_output_tokens += output_tokens
        self.interaction_count += 1
        
        print(f"本次交互: 输入{input_tokens}tokens, 输出{output_tokens}tokens")

    def get_stats(self):
        return {
            "总输入tokens": self.total_input_tokens,
            "总输出tokens": self.total_output_tokens,
            "交互次数": self.interaction_count,
            "平均每次输入": self.total_input_tokens / max(1, self.interaction_count),
            "平均每次输出": self.total_output_tokens / max(1, self.interaction_count)
        }

# 使用示例
monitor = LLMInteractionMonitor()
monitor.record_interaction("法国的首都是哪里？", "法国的首都是巴黎。")
monitor.record_interaction("讲个笑话", "为什么程序员喜欢黑暗？因为Light吸引Bug！")
print(monitor.get_stats())

---

【概念4：LLM-as-Judge ------ 用AI评价AI】

一句话是什么：让一个LLM来评估另一个LLM的输出质量。

生活化比喻：

想象你要评价一道菜：

方法1：机器检测
- 盐分含量：5g ✓
- 温度：65°C ✓
- 重量：200g ✓
- 结论：合格
- 问题：但可能很难吃！

方法2：请美食评论家
- 色：金黄诱人 ★★★★
- 香：香气扑鼻 ★★★★★
- 味：鲜美可口 ★★★★
- 意：创意独特 ★★★
- 结论：值得推荐！

LLM-as-Judge = 请"AI美食评论家"
评估那些机器难以量化的"主观质量"

代码示例：

# LLM-as-Judge评估提示词
JUDGE_PROMPT = """
你是一个严格但公正的评审专家。请评估以下AI回答的质量。

用户问题：{question}
AI回答：{answer}

请从以下维度评分（1-5分）：
1. 准确性：信息是否正确？
2. 完整性：是否回答了所有问题？
3. 清晰度：表达是否清楚易懂？
4. 有用性：对用户是否有帮助？

请以JSON格式输出：
{
    "准确性": <分数>,
    "完整性": <分数>,
    "清晰度": <分数>,
    "有用性": <分数>,
    "总评": <1-10分>,
    "评语": "<简短评价>"
}
"""

def judge_response(question, answer, judge_llm):
    """使用LLM评估回答质量"""
    prompt = JUDGE_PROMPT.format(question=question, answer=answer)
    judgment = judge_llm.generate(prompt)
    return judgment

三种评估方法对比：

评估方法	优势	劣势
人工评估	能捕捉细微差别	成本高、难扩展、耗时
LLM-as-Judge	一致、高效、可扩展	可能忽略中间步骤，受LLM能力限制
自动化指标	可扩展、高效、客观	可能无法捕捉完整能力

---

【概念5：智能体轨迹分析 ------ AI的"行动记录"】

一句话是什么：分析AI完成任务的每一步，而不只是看最终结果。

生活化比喻：

想象你是侦探，调查一个案件：

只看结果：
- 嫌疑人说："我没做！"
- 结论：无法判断

分析轨迹：
- 8:00 嫌疑人在A地（有监控）
- 8:30 嫌疑人在B地（有证人）
- 9:00 案发时间，嫌疑人在C地（有打卡记录）
- 结论：不在场证明成立！

轨迹分析 = 看AI的"行动轨迹"
不只看结果，还要看过程！

为什么重要：

传统软件测试：
- 输入 → 输出
- 结果可预测
- 通过/失败很明确

AI智能体测试：
- 输入 → [思考] → [行动] → [观察] → ... → 输出
- 结果有概率性
- 需要评估整个过程

轨迹分析关注：
1. 选择了正确的工具吗？
2. 步骤顺序合理吗？
3. 有没有多余的步骤？
4. 有没有遗漏关键步骤？

轨迹比较方法：

预期轨迹（Ground Truth）：
1. 理解用户意图
2. 搜索数据库
3. 分析结果
4. 生成报告

实际轨迹：
1. 理解用户意图 ✓
2. 搜索数据库 ✓
3. 搜索网页（多余！）
4. 分析结果 ✓
5. 生成报告 ✓

评估结果：
- 精确匹配：❌（有多余步骤）
- 顺序匹配：✓（关键步骤顺序正确）
- 召回率：100%（所有必要步骤都有）
- 精确率：80%（5步中4步是必要的）

---

四、实践示例

示例1：综合监控系统

import time
from datetime import datetime

class AgentMonitor:
    """AI智能体综合监控系统"""
    
    def __init__(self):
        self.metrics = {
            "total_requests": 0,
            "successful_requests": 0,
            "failed_requests": 0,
            "total_latency": 0,
            "total_tokens": 0,
            "errors": []
        }
    
    def record_request(self, start_time, end_time, success, tokens_used, error=None):
        """记录一次请求"""
        latency = end_time - start_time
        
        self.metrics["total_requests"] += 1
        self.metrics["total_latency"] += latency
        self.metrics["total_tokens"] += tokens_used
        
        if success:
            self.metrics["successful_requests"] += 1
        else:
            self.metrics["failed_requests"] += 1
            if error:
                self.metrics["errors"].append({
                    "time": datetime.now().isoformat(),
                    "error": str(error)
                })
    
    def get_dashboard(self):
        """获取监控仪表盘数据"""
        total = self.metrics["total_requests"]
        if total == 0:
            return "暂无数据"
        
        return {
            "总请求数": total,
            "成功率": f"{self.metrics['successful_requests']/total*100:.1f}%",
            "平均延迟": f"{self.metrics['total_latency']/total:.2f}秒",
            "总Token消耗": self.metrics["total_tokens"],
            "平均Token/请求": self.metrics["total_tokens"] // total,
            "最近错误数": len(self.metrics["errors"])
        }
    
    def check_alerts(self):
        """检查是否需要告警"""
        alerts = []
        total = self.metrics["total_requests"]
        
        if total > 0:
            # 成功率低于95%告警
            success_rate = self.metrics["successful_requests"] / total
            if success_rate < 0.95:
                alerts.append(f"⚠️ 成功率过低: {success_rate*100:.1f}%")
            
            # 平均延迟超过5秒告警
            avg_latency = self.metrics["total_latency"] / total
            if avg_latency > 5:
                alerts.append(f"⚠️ 延迟过高: {avg_latency:.1f}秒")
        
        return alerts if alerts else ["✅ 一切正常"]

# 使用示例
monitor = AgentMonitor()

# 模拟一些请求
monitor.record_request(0, 1.2, True, 150)
monitor.record_request(0, 0.8, True, 120)
monitor.record_request(0, 2.5, False, 200, "API超时")
monitor.record_request(0, 1.0, True, 130)

print("=== 监控仪表盘 ===")
for k, v in monitor.get_dashboard().items():
    print(f"{k}: {v}")

print("\n=== 告警检查 ===")
for alert in monitor.check_alerts():
    print(alert)

示例2：轨迹评估器

class TrajectoryEvaluator:
    """智能体轨迹评估器"""
    
    def __init__(self):
        pass
    
    def exact_match(self, expected: list, actual: list) -> bool:
        """精确匹配：轨迹必须完全一致"""
        return expected == actual
    
    def in_order_match(self, expected: list, actual: list) -> bool:
        """顺序匹配：关键步骤按顺序出现，允许额外步骤"""
        expected_idx = 0
        for step in actual:
            if expected_idx < len(expected) and step == expected[expected_idx]:
                expected_idx += 1
        return expected_idx == len(expected)
    
    def calculate_precision_recall(self, expected: list, actual: list):
        """计算精确率和召回率"""
        expected_set = set(expected)
        actual_set = set(actual)
        
        true_positives = len(expected_set & actual_set)
        precision = true_positives / len(actual_set) if actual_set else 0
        recall = true_positives / len(expected_set) if expected_set else 0
        
        return {
            "精确率": f"{precision*100:.1f}%",
            "召回率": f"{recall*100:.1f}%",
            "F1分数": f"{2*precision*recall/(precision+recall)*100:.1f}%" if (precision+recall) > 0 else "0%"
        }

# 使用示例
evaluator = TrajectoryEvaluator()

# 预期轨迹
expected = ["理解意图", "搜索数据库", "分析结果", "生成报告"]

# 实际轨迹（有一个额外步骤）
actual = ["理解意图", "搜索数据库", "搜索网页", "分析结果", "生成报告"]

print("=== 轨迹评估 ===")
print(f"预期轨迹: {expected}")
print(f"实际轨迹: {actual}")
print(f"精确匹配: {evaluator.exact_match(expected, actual)}")
print(f"顺序匹配: {evaluator.in_order_match(expected, actual)}")
print(f"精确率/召回率: {evaluator.calculate_precision_recall(expected, actual)}")

---

五、精华提炼（去废话版）

核心要点

1. 响应准确性 = 考试成绩

   • 不只是字符串匹配
   • 要考虑语义相似度
   • LLM-as-Judge更智能

2. 延迟监控 = 响应速度

   • 用户体验的关键
   • 设置合理的阈值
   • 超时要告警

3. Token追踪 = 成本控制

   • 知道钱花在哪里
   • 优化提示词省钱
   • 设置预算上限

4. 轨迹分析 = 过程审计

   • 不只看结果，还看过程
   • 发现低效和错误
   • 持续优化流程

必须记住的

评估监控核心：
"不能测量的，就不能改进"
给AI装上仪表盘，才能持续优化！

---

六、行动清单

立即可做（5分钟内）

• 理解评估监控的基本概念
• 给你的AI加上简单的延迟记录

本周实践

• 实现一个基础的监控类
• 尝试LLM-as-Judge评估

进阶挑战

• 构建完整的监控仪表盘
• 实现轨迹分析和告警系统

---

七、常见误区

误区1："上线后就不用管了"

真相：

AI智能体会"漂移"：
- 数据分布变化 → 性能下降
- 用户行为变化 → 效果变差
- 模型更新 → 可能引入问题

必须持续监控，及时发现问题！

误区2："只看准确率就够了"

真相：

准确率高不代表好用：
- 准确率99%，但延迟10秒 → 用户跑了
- 准确率99%，但成本爆炸 → 公司亏了
- 准确率99%，但过程混乱 → 难以维护

要综合评估多个维度！

误区3："人工评估最准确"

真相：

人工评估的问题：
- 成本高：每次都要人看
- 不一致：不同人标准不同
- 难扩展：数据量大就崩了

LLM-as-Judge + 自动化指标 = 更实用的方案

---

八、学习检查

基础知识

• 能解释为什么需要评估监控
• 理解延迟、Token、准确率的含义
• 知道LLM-as-Judge的原理

实践能力

• 能实现基础的监控功能
• 能设计合理的评估指标
• 能分析智能体轨迹

进阶理解

• 理解"承包商"模式的价值
• 能设计多智能体的评估方案
• 能构建完整的监控体系

---

九、金句收藏

原文金句：

"评估智能体需要超越传统测试，
持续测量其在动态环境中的有效性、效率和合规性。"

我的总结金句：

"不监控的AI就像没有仪表盘的汽车，
你永远不知道它什么时候会出问题。"

---

十、画龙点睛（收尾）

总结升华

评估与监控的本质是建立"信任"：

• 对AI的信任：它真的在好好工作吗？
• 对系统的信任：出问题能及时发现吗？
• 对未来的信任：能持续改进吗？

就像管理一个团队：

• 不是不信任员工，而是要有反馈机制
• 不是要微观管理，而是要有预警系统
• 不是要追究责任，而是要持续改进

从"智能体"到"承包商"的进化，

是AI从"能用"到"可靠"的关键一步。

悬念预告

学会了评估监控，AI能被"管理"了。但当任务太多、资源有限时，AI该先做什么？下一章"优先级排序"，我们来揭秘！

一句话带走

评估与监控 = AI的"健康管理系统"
让AI不仅能干活，还能持续干好活！

---

十一、延伸资源

想深入学习

• Google ADK的评估功能
• LangSmith监控平台

想教给别人

• 用"餐厅管理"的比喻解释监控
• 用"体检报告"的比喻解释评估

---