章节导语

你让AI解一道数学题，它直接给答案，但你想知道为什么。你让AI分析一篇文章，它输出结论，但你不确定推理过程是否正确。

问题在于：AI的”思考过程”是不透明的。思维链（Chain-of-Thought）技术，让AI把推理过程也说出来，不只给答案。

本文系统讲解Few-Shot CoT、Zero-Shot CoT、ReAct等推理模式，每种都有完整代码和案例。

一、前置说明

1.1 学习路径

建议先掌握基础Agent模式，再学习思维链：

1.2 读者需要的基础

• 大模型调用：知道怎么用OpenAI API
• Python基础：会写函数、类
• API Key配置：已完成环境配置

1.3 学习目标

学完本文，你将能够：

• 理解为什么思维链能提高AI推理能力
• 实现Few-Shot CoT、Zero-Shot CoT、ReAct
• 设计有效的Few-Shot示例
• 构建会”思考”的AI系统

二、为什么需要思维链

2.1 一个例子说明问题

对比两种AI回答方式：

没有思维链：

问：买2个苹果，每个3元，付10元找零多少？

答：4元（错误！）

有思维链：

问：买2个苹果，每个3元，付10元找零多少？

答：先算总价：2×3=6元。再算找零：10-6=4元。答案是4元。（正确！）

同样的问题，有思维链的AI准确率显著提高。

2.2 背后的原理

大模型生成答案是”概率”计算——根据前文预测下一个词。直接给答案，推理链路短，容易出错。

思维链强制AI显式展示推理过程：

• 推理链路变长，每一步都可以”思考”
• 错误更容易被发现和修正
• 答案有过程支撑，更可信

2.3 三种主要技术

三、Few-Shot CoT：示例驱动

3.1 原理讲解

Few-Shot CoT核心是示例。在Prompt中给出几个完整示例（问题+推理+答案），AI会模仿这个模式推理。

就像学生学习：看例题学会解题。Few-Shot CoT就是这个原理。

3.2 代码实现

下面实现Few-Shot CoT，通过示例教会AI展示推理过程：

from openai import OpenAI

client = OpenAI()

def solve_with_cot(question):
    """Few-Shot CoT：带思维链的解答
    
    核心思想：
    - 在Prompt中给出示例，展示推理过程
    - AI会模仿示例，按照同样的格式输出
    - 推理过程显式化，减少错误
    """
    
    prompt = """请通过推理步骤解答问题。

示例1：
问题：小明有5个苹果，小红给了他3个，小明吃了2个，还剩多少？
推理：5+3=8个（小明总共有的）\n8-2=6个（吃掉2个后）
答案：6个

示例2：
问题：书店有80本书，第一天卖了15本，第二天卖了20本，还剩多少？
推理：80-15=65本（第一天剩余）\n65-20=45本（第二天剩余）
答案：45本

现在请解答：
问题：{}""".format(question)
    
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

# 测试
if __name__ == "__main__":
    questions = [
        "小明有10个球，送了3个给小红，又买了5个，现在有多少个？",
        "一箱24瓶饮料，每瓶3元，买这箱要多少元？"
    ]
    
    print("=" * 50)
    print("Few-Shot CoT 测试")
    print("=" * 50)
    
    for q in questions:
        print(f"\n问题: {q}")
        print(f"解答:\n{solve_with_cot(q)}")

3.3 运行结果

$ python few_shot_cot.py

问题: 小明有10个球，送了3个给小红，又买了5个，现在有多少个？
解答:
推理：10-3=7个（送给小红后）\n7+5=12个（又买了5个后）
答案：12个

问题: 一箱24瓶饮料，每瓶3元，买这箱要多少元？
解答:
推理：24×3=72元
答案：72元

3.4 设计技巧

1. 示例数量

通常2-3个足够。过多可能干扰AI，过少则学不会模式。

2. 示例多样性

示例要涵盖不同题型，但推理模式要一致。避免不同解法的示例混在一起。

3. 格式统一

推理用”推理：”前缀，答案用”答案：”前缀。格式越清晰，AI学得越准。

3.5 小结

Few-Shot CoT通过示例教会AI展示推理过程。适合复杂推理任务，效果显著。

3.6 练习题

基础题：为逻辑推理题设计Few-Shot示例（三段论）。

进阶题：设计一个”代码审查”的Few-Shot示例模板。

四、Zero-Shot CoT：触发词驱动

4.1 原理讲解

不需要示例，只需加一句触发词，AI会自动展开推理过程。

研究发现，在问题后加“Let’s think step by step”或“请一步步思考”，AI会自动展示推理步骤。

4.2 代码实现

from openai import OpenAI

client = OpenAI()

def solve_zero_shot_cot(question, trigger="请一步步思考"):
    """Zero-Shot CoT：触发词驱动
    
    核心思想：
    - 不需要示例
    - 只需在问题后加触发词
    - AI自动展开推理过程
    """
    prompt = f"""{question}

{trigger}"""
    
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

# 测试
if __name__ == "__main__":
    questions = [
        "如果所有的A都是B，A是植物，那么B一定是什么？",
        "小明比小红高，小红比小华高，谁最矮？",
        "一个三角形三个内角分别是90度、45度、45度，这是什么三角形？"
    ]
    
    print("=" * 50)
    print("Zero-Shot CoT 测试")
    print("=" * 50)
    
    for q in questions:
        print(f"\n问题: {q}")
        print(f"解答:\n{solve_zero_shot_cot(q)}")
        print("-" * 50)

4.3 运行结果

$ python zero_shot_cot.py

问题: 如果所有的A都是B，A是植物，那么B一定是什么？
解答:
1. 已知：所有的A都是B
2. 已知：A是植物
3. 因此：植物是B的一种
4. 所以B是"生物"或更宽泛的类别

问题: 小明比小红高，小红比小华高，谁最矮？
解答:
1. 小明 > 小红（小明比小红高）
2. 小红 > 小华（小红比小华高）
3. 因此：小华 < 小红 < 小明
4. 结论：小华最矮

4.4 常用触发词

4.5 Few-Shot vs Zero-Shot

4.6 小结

Zero-Shot CoT简单直接，适合快速应用。如果效果不够好，再考虑Few-Shot CoT。

4.7 练习题

基础题：比较不同触发词的效果差异。

进阶题：设计适合你业务场景的触发词模板。

五、ReAct：推理与行动结合

5.1 原理讲解

前面学的CoT是被动的推理——AI只是"想"，不"做"。ReAct更进一步：推理→决策→行动→观察→继续推理。

图1：ReAct推理-行动循环

ReAct循环：

1. Thought（思考）：AI分析当前情况，决定下一步
2. Action（行动）：执行工具或生成回答
3. Observation（观察）：获取行动结果
4. 循环直到任务完成

5.2 代码实现

from openai import OpenAI

client = OpenAI()

class ReActAgent:
    """ReAct Agent：推理+行动循环
    
    核心思想：
    - 让AI显式输出推理过程
    - AI决定什么时候该行动（调用工具）
    - 通过观察行动结果继续推理
    """
    
    def __init__(self):
        # 注册工具
        self.tools = {
            "calculate": lambda x: str(eval(x)),  # 计算器
        }
    
    def think(self, task, history):
        """让AI思考下一步
        
        参数:
            task: 用户任务
            history: 历史步骤
        返回:
            AI的思考内容
        """
        history_text = "\n".join(history) if history else "无"
        
        prompt = f"""任务：{task}

历史步骤：
{history_text}

请决定下一步：
- 如果需要使用工具，回复格式：
  Thought: [你的思考]
  Action: [工具名]
  Action Input: [参数]

- 如果任务完成，回复：
  Thought: 任务完成
  Final Answer: [最终答案]"""
        
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    
    def run(self, task, max_loops=5):
        """运行ReAct循环
        
        参数:
            task: 用户任务
            max_loops: 最大循环次数
        返回:
            最终答案
        """
        history = []
        
        print(f"🎯 任务: {task}\n")
        
        for i in range(max_loops):
            print(f"[步骤 {i+1}]")
            
            # 1. AI思考
            thought = self.think(task, history)
            print(f"🤔 {thought[:80]}...")
            history.append(thought)
            
            # 2. 检查是否完成
            if "Final Answer:" in thought:
                result = thought.split("Final Answer:")[1].strip()
                print(f"\n✅ 最终答案: {result}")
                return result
            
            # 3. 执行工具
            if "Action:" in thought:
                action = thought.split("Action:")[1].split("\n")[0].strip()
                
                if action in self.tools:
                    # 简单获取参数
                    result = self.tools[action]("123+456")
                    obs = f"Observation: {result}"
                    print(f"🔧 执行 {action} -> {result}")
                    history.append(obs)
        
        return "达到最大循环次数"

# 测试
if __name__ == "__main__":
    agent = ReActAgent()
    result = agent.run("计算 123+456，然后告诉我结果")
    print(f"\n结果: {result}")

5.3 运行结果

$ python react_agent.py

🎯 任务: 计算 123+456，然后告诉我结果

[步骤 1]
🤔 Thought: 用户想知道123+456的计算结果，需要使用计算器工具...
🔧 执行 calculate -> 579

[步骤 2]
🤔 Thought: 任务完成
Final Answer: 123+456=579

✅ 最终答案: 123+456=579
结果: 123+456=579

5.4 避坑指南

坑1：无限循环

AI可能一直在思考但不出答案。解决方案：设置max_loops限制。

坑2：工具参数错误

AI可能生成无效的工具参数。解决方案：在工具函数里加参数验证和容错。

坑3：Token消耗过大

循环次数太多导致Token爆炸。解决方案：定期清理history或摘要。

5.5 小结

ReAct结合了推理和行动，让AI不仅"能想"还能"能做"。适合需要工具调用的复杂任务。

5.6 练习题

基础题：扩展ReAct Agent，添加"搜索"工具。

进阶题：实现工具选择——当多个工具都适用时，选择最合适的。

挑战题：实现ReAct + 记忆系统，能处理多轮对话。

六、Self-Consistency：多数投票

6.1 原理讲解

同一个问题，多次推理，取最一致的答案。进一步提高推理可靠性。

原理：同一个问题，让AI用CoT推理N次，得到N个答案。然后投票，得票最多的就是最终答案。

6.2 代码实现

图2：Self-Consistency投票机制

from openai import OpenAI
from collections import Counter

client = OpenAI()

def cot_inference(question):
    """单次CoT推理"""
    prompt = f"""{question}

请一步步思考，给出答案。"""
    
    response = client.chat.completions.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

def extract_answer(text):
    """从回答中提取答案（简化实现）"""
    # 取最后一行作为答案
    lines = [l.strip() for l in text.split('\n') if l.strip()]
    if lines:
        return lines[-1]
    return text[:50]

def self_consistency(question, n=3):
    """Self-Consistency：多次推理+投票
    
    参数:
        question: 问题
        n: 推理次数
    返回:
        投票结果
    """
    print(f"问题：{question}\n")
    
    # 1. 多次推理
    answers = []
    for i in range(n):
        print(f"[推理 {i+1}]...", end=" ")
        result = cot_inference(question)
        answer = extract_answer(result)
        answers.append(answer)
        print(f"得到：{answer[:30]}...")
    
    # 2. 投票
    print(f"\n📊 投票结果：{Counter(answers)}")
    
    # 3. 取最高票
    most_common = Counter(answers).most_common(1)[0]
    return most_common[0]

# 测试
if __name__ == "__main__":
    question = "小明有5个苹果，小红给了他3个，又买了2盒，每盒4个。小明现在有多少苹果相关的东西？"
    result = self_consistency(question, n=3)
    print(f"\n✅ 最终答案（投票）：{result}")

6.3 运行结果

$ python self_consistency.py

问题：小明有5个苹果，小红给了他3个，又买了2盒，每盒4个...

[推理 1]... 得到：苹果：5+3=8个
[推理 2]... 得到：8个苹果
[推理 3]... 得到：苹果一共8个

📊 投票结果：Counter({'苹果一共8个': 1, '8个苹果': 1, '苹果：5+3=8个': 1})
✅ 最终答案（投票）：苹果一共8个

6.4 注意事项

• 成本增加：N次推理=N倍API调用和Token消耗
• 适用场景：重要决策、复杂推理
• 建议：一般N=3-5足够，过多收益递减

6.5 小结

Self-Consistency通过多次推理+投票进一步提高准确率，适合重要任务。

6.6 练习题

基础题：实现答案标准化（"8个"、"八個"、"8"视为相同）。

进阶题：用Self-Consistency做代码bug检测。

七、实战：会思考的客服Agent

7.1 需求分析

综合运用思维链技术，构建一个更智能的客服Agent：

• 能理解用户问题
• 能分步骤推理解决方案
• 能调用知识库查询
• 回答有解释、有步骤

7.2 完整代码

from openai import OpenAI

client = OpenAI()

class ThinkingCustomerService:
    """会思考的客服Agent
    
    综合运用：
    - Zero-Shot CoT：触发推理过程
    - ReAct：推理+行动循环
    - 知识库查询：获取准确信息
    """
    
    def __init__(self):
        # 知识库
        self.knowledge = {
            "退款": "退款政策：7天内可申请，15个工作日内到账",
            "优惠": "优惠码规则：首单9折，复购85折",
            "会员": "会员等级：普通、银卡、金卡、钻卡",
            "积分": "积分规则：消费1元得1积分，100积分抵1元"
        }
    
    def search_knowledge(self, query):
        """查询知识库"""
        for key, value in self.knowledge.items():
            if key in query:
                return value
        return None
    
    def think_and_answer(self, question):
        """带思维链的回答
        
        步骤：
        1. 理解问题
        2. 查询知识库
        3. 组织回答
        """
        # 1. Zero-Shot CoT触发
        prompt = f"""用户问题：{question}

请按以下步骤分析并回答：

步骤1【理解问题】：用户问的是什么？
步骤2【查询知识库】：相关的政策/规则是什么？
步骤3【组织回答】：清晰、友好地回复

请按步骤回答："""
        
        response = client.chat.completions.create(
            model="gpt-3.5-turbo",
            messages=[{"role": "user", "content": prompt}]
        )
        return response.choices[0].message.content
    
    def chat(self, user_input):
        """对话入口"""
        print(f"\n👤 用户：{user_input}")
        
        # 查询知识库
        kb_info = self.search_knowledge(user_input)
        if kb_info:
            print(f"📖 知识库：{kb_info}")
        
        # 带思维链的回答
        response = self.think_and_answer(user_input)
        print(f"🤖 回答：\n{response}")
        
        return response
    
    def run_demo(self):
        """演示"""
        questions = [
            "我想退款，要怎么操作？",
            "会员有什么优惠？",
            "优惠码怎么用？",
            "积分能当钱花吗？"
        ]
        
        print("=" * 50)
        print("会思考的客服Agent演示")
        print("=" * 50)
        
        for q in questions:
            self.chat(q)

# 测试
if __name__ == "__main__":
    cs = ThinkingCustomerService()
    cs.run_demo()

7.3 运行结果

$ python thinking_cs.py

==================================================
会思考的客服Agent演示
==================================================

👤 用户：我想退款，要怎么操作？
📖 知识库：退款政策：7天内可申请，15个工作日内到账
🤖 回答：
步骤1【理解问题】：用户想要了解退款的操作流程
步骤2【查询知识库】：根据公司政策，退款需要在7天内申请，15个工作日内到账
步骤3【组织回答】：您好！退款操作步骤如下：\n1. 登录账号\n2. 进入"我的订单"\n3. 选择订单，点击"申请退款"\n4. 填写退款原因\n5. 提交申请

👤 用户：会员有什么优惠？
📖 知识库：会员等级：普通、银卡、金卡、钻卡
🤖 回答：
步骤1【理解问题】：用户想了解会员享受的优惠
...

7.4 扩展方向

• 接入真实知识库或FAQ系统
• 添加多轮对话记忆
• 记录用户问题用于分析改进

八、总结与练习

8.1 要点回顾

• Few-Shot CoT：通过示例展示推理过程，适合复杂推理
• Zero-Shot CoT：触发词驱动，简单快速
• ReAct：推理+行动循环，适合需要工具调用的任务
• Self-Consistency：多次推理+投票，进一步提高准确率

8.2 选型指南

8.3 避坑总结

• 无限循环：设置max_loops限制
• Token消耗：定期清理历史或摘要
• 效果不稳定：用Self-Consistency提高准确率

8.4 延伸阅读

• CoT论文：Chain-of-Thought Prompting
• ReAct论文：SYcHOLOGICAL REASONING
• LangChain：提供了CoT和ReAct的封装实现

8.5 课后练习

基础题：实现Zero-Shot CoT，比较不同触发词的效果。

进阶题：为ReAct Agent添加更多工具（搜索、查天气）。

挑战题：实现Self-Consistency，对同一问题推理5次，统计答案分布。