思维链与分步推理
使用思维链提示引导模型逐步解决复杂问题，大幅提升其在数学、逻辑和多跳推理任务中的准确率。
思维链与分步推理 是 CoddyKit 上的免费 AI Engineering Academy 课时。 这是第 2 节课，共 4 节。 你可以在下方免费阅读本课时的完整内容 — 然后在浏览器中使用内置代码编辑器和全天候 AI 导师进行实践。 这是 AI Engineering Academy 学习路径的一部分，你的进度在网页和 CoddyKit 应用中同步。 AI Engineering Academy 课程共包含 4 节课。
本课时的部分内容尚未翻译，以英文显示。
What Is Chain-of-Thought Prompting?
Chain-of-Thought (CoT) prompting is a technique where you ask the model to show its reasoning step by step before giving a final answer. Instead of jumping straight to the conclusion, the model produces intermediate reasoning steps that lead to the answer. This simple change dramatically improves accuracy on complex tasks involving math, logic, and multi-step reasoning.
The technique was introduced in a 2022 Google Brain paper that showed CoT prompting could enable large language models to solve math word problems that they completely failed at with direct prompting. The key insight is that generating intermediate steps forces the model to allocate more computation to hard problems.
The Magic of 'Let's Think Step by Step'
The simplest form of chain-of-thought prompting is adding the phrase 'Let's think step by step' to your prompt. This zero-shot CoT trigger was discovered by researchers who found that this single phrase caused models to spontaneously produce reasoning chains even without few-shot examples.
import openai
client = openai.OpenAI()
# Without CoT - the model often gets multi-step math wrong
direct_prompt = 'A store has 48 apples. They sell 3/4 of them, then receive a new shipment of 20. How many apples do they have?'
# With zero-shot CoT
cot_prompt = direct_prompt + "\n\nLet's think step by step."
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': cot_prompt}]
)
print(response.choices[0].message.content)Why CoT Works: Computation Allocation
LLMs generate text one token at a time, and each token is produced with a fixed amount of computation (one forward pass of the model). When you ask for a direct answer, the model must arrive at the correct answer in a single inference step, which is often too little computation for complex problems.
Chain-of-thought gives the model token budget to work with the problem. Each reasoning step is a token, and generating those tokens is equivalent to additional computation. This is why CoT works even on tasks where the model clearly knows all the individual facts — the bottleneck is not knowledge but the ability to combine facts over multiple reasoning steps in a single pass.
Few-Shot Chain-of-Thought
For maximum reliability, combine few-shot examples with chain-of-thought reasoning. Each example shows the full reasoning chain that leads to the correct answer. This teaches the model both the reasoning style you want and the correct format for the final answer.
import openai
client = openai.OpenAI()
prompt = '''Solve these math problems step by step.
Problem: A recipe needs 2.5 cups of flour for 12 cookies. How much flour for 30 cookies?
Reasoning: First, find flour per cookie: 2.5 / 12 = 0.208 cups each.
Then multiply by 30: 0.208 * 30 = 6.25 cups.
Answer: 6.25 cups
Problem: A train travels 180 km in 2.5 hours. At the same speed, how long to travel 270 km?
Reasoning: First, find speed: 180 / 2.5 = 72 km/h.
Time = distance / speed = 270 / 72 = 3.75 hours.
Answer: 3.75 hours
Problem: A shirt costs $45 after a 25% discount. What was the original price?
'''
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}]
)
print(response.choices[0].message.content)CoT for Multi-Hop Reasoning
Chain-of-thought is not limited to math. It dramatically improves performance on multi-hop reasoning tasks where you must connect several facts to answer a question. For example, answering 'Who was the president of the US when the iPhone was invented?' requires knowing when the iPhone was invented, then looking up who was president at that time — two separate knowledge lookups chained together.
Without CoT, the model must short-circuit this chain in a single step and often produces the wrong answer. With CoT, it explicitly retrieves each fact in a reasoning step, dramatically improving accuracy on these tasks.
Structuring the Output with CoT
In production applications, you often want the reasoning to be separate from the final answer so you can parse the answer programmatically. A common pattern is to instruct the model to wrap reasoning in tags and the final answer in its own section, making it easy to extract the answer without parsing the full reasoning text.
import openai
import re
client = openai.OpenAI()
prompt = '''Analyze the following customer complaint and determine the priority level.
First think through the issue, then state your final classification.
Format your response exactly as:
<reasoning>
Your step-by-step analysis here.
</reasoning>
<priority>HIGH | MEDIUM | LOW</priority>
Complaint: "The checkout page crashes every time I try to buy something. I have tried three times and lost my cart each time."
'''
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}]
)
content = response.choices[0].message.content
priority = re.search(r'<priority>(.*?)</priority>', content).group(1)
print('Priority:', priority)Self-Consistency: Vote Across Multiple Chains
Self-consistency is an extension of CoT that generates multiple independent reasoning chains for the same problem using a high temperature, then takes a majority vote over the final answers. The intuition is that correct reasoning paths tend to converge on the same answer, while incorrect paths tend to diverge.
This significantly improves accuracy on math and commonsense reasoning benchmarks at the cost of additional API calls. It is most useful when accuracy matters more than latency or cost, such as in scientific or financial applications where a wrong answer has serious consequences.
import openai
from collections import Counter
client = openai.OpenAI()
def self_consistent_answer(question, n=5):
prompt = question + '\n\nLet\'s think step by step. State your final answer as: Answer: <value>'
answers = []
for _ in range(n):
resp = client.chat.completions.create(
model='gpt-4o-mini',
messages=[{'role': 'user', 'content': prompt}],
temperature=0.7
)
text = resp.choices[0].message.content
# Extract final answer
if 'Answer:' in text:
ans = text.split('Answer:')[-1].strip().split('\n')[0]
answers.append(ans)
# Majority vote
return Counter(answers).most_common(1)[0]
result, count = self_consistent_answer('What is 15% of 240?')
print(f'Answer: {result} (agreed by {count}/5 chains)')Tree of Thought: Exploring Multiple Paths
Tree of Thought (ToT) extends chain-of-thought by exploring multiple reasoning branches simultaneously and evaluating which branch is most promising before continuing. Think of it like a search algorithm: rather than committing to one reasoning path, you generate several partial thoughts, score them, and expand the most promising ones.
This is particularly useful for planning and open-ended problems where the optimal reasoning path is not immediately clear. ToT requires significantly more API calls than basic CoT but can solve problems that linear CoT fails on, such as multi-step puzzles and creative problem-solving tasks.
When Not to Use Chain-of-Thought
CoT adds latency and token cost to every request. It is not always the right choice. Avoid CoT when:
- The task is simple and the model reliably gets it right without reasoning (e.g., single-step classification)
- You need very low latency and cannot afford extra tokens
- The reasoning itself would confuse downstream parsing (though structured output tags solve this)
- You are using a very small model that does not benefit from reasoning steps
CoT provides the most value on complex, multi-step tasks where the model demonstrably fails without it. Always measure before adding it to a production prompt.
CoT for Code and Debugging
Chain-of-thought is highly effective for code generation and debugging tasks. Asking the model to explain its plan before writing code — 'First explain your approach, then write the code' — produces more correct implementations because the planning step catches logical errors before they are encoded in the implementation.
For debugging, prompting the model to 'trace through the code step by step and identify where the output diverges from the expected value' is far more effective than just asking 'what is wrong with this code?' The step-by-step trace acts as a simulation of code execution within the model's reasoning.
Combining CoT with System Prompts
You can encode chain-of-thought instructions permanently in your system prompt so that every user message benefits from step-by-step reasoning without users needing to request it explicitly. This is the standard pattern for production applications where you want reliable CoT behavior across all queries.
import openai
client = openai.OpenAI()
response = client.chat.completions.create(
model='gpt-4o-mini',
messages=[
{
'role': 'system',
'content': ('You are a precise analytical assistant. '
'For any question involving calculation, logic, or multi-step reasoning, '
'always think through the problem step by step before giving your answer. '
'Show your reasoning clearly before stating the final answer.')
},
{
'role': 'user',
'content': 'If I invest $5000 at 7% annual interest compounded annually, how much will I have after 10 years?'
}
]
)
print(response.choices[0].message.content)Quick Check
Test your understanding of AI Engineering concepts from this lesson.
Lesson Recap
In this lesson you learned: chain-of-thought prompting improves accuracy by making the model generate explicit reasoning steps before answering, self-consistency runs multiple chains and takes a majority vote for more reliable results, and CoT is most valuable for math, multi-hop reasoning, and debugging tasks, but adds latency and cost. Next up we explore how to write effective system prompts and define AI personas.
常见问题解答
「思维链与分步推理」课时是免费的吗？
是的 — 「思维链与分步推理」的完整文本可在网页上免费阅读。要进行交互式练习（内置代码编辑器和全天候 AI 导师）并解锁 AI Engineering Academy 课程的其余内容，请升级到 CoddyKit PRO。 AI Engineering Academy 课程共包含 4 节课。
「思维链与分步推理」这节课中我会学到什么？
使用思维链提示引导模型逐步解决复杂问题，大幅提升其在数学、逻辑和多跳推理任务中的准确率。 你通过在浏览器中直接运行的动手代码来练习 AI Engineering Academy，全天候 AI 导师会在你学习这节课的过程中回答你的问题。
学习 AI Engineering Academy 需要有经验吗？
无需任何先前经验。CoddyKit 上的 AI Engineering Academy 课程适合初学者到高级学习者，你可以从这里开始或从头开始，按照自己的节奏学习。 这是第 2 节课，共 4 节。
「思维链与分步推理」课时需要多长时间？
大多数 CoddyKit 课程大约需要 5–10 分钟。每节课都很精短且互动，所以你能稳步进步，并在网页和应用中从离开的地方继续。
我能在这节 AI Engineering Academy 课中编写并运行代码吗？
能。每节 AI Engineering Academy 课都包含内置代码编辑器，你可以在浏览器中直接编写并运行真实代码，并获得即时 AI 反馈 — 无需本地设置。