Marico's space

最近在整理 AI API 的生产级用法，DeepSeek-R1 是一个绕不开的节点。

原因很简单：它是目前唯一将思维链（Chain-of-Thought）作为「一等公民」暴露给开发者的主流推理模型。大多数模型是黑盒——你问，它答，中间的推理过程对它自己都是一个谜。但 R1 不一样。它会把「我怎么想到这个答案」也一并还给你。

这有什么实际价值？三个最直接的场景：

• 错误溯源：当模型给了错误答案时，可以顺着思维链找到逻辑断裂点，而不是抓瞎调 Prompt。
• 可信度构建：在需要向用户解释「为什么」的场景下（客服、医疗建议、金融分析），推理步骤本身就是最好的信任状。
• Agent 调试：当 Agent 选错了工具或走进了死胡同，思维链能告诉你它「在想什么」，而不是只能看到最终结果的对错。

当然，代价也有：思维链需要生成额外的 tokens，延迟通常是标准模型的 2-4 倍。R1 不是万能药——适合需要推理透明度的场景，不适合实时对话这类对延迟敏感的场景。

这篇文章涵盖：reasoning tokens 的工作机制、三个生产级代码模式（日志记录、Agent 循环、推理验证），以及边界情况的处理方案。

---

DeepSeek-R1 与其他模型最大的不同，在于它把推理过程作为 API 的原生组成部分还给你。

当你调用 deepseek-reasoner 端点时，模型会在生成最终答案之前产生明确的推理步骤：

• 问题分解 — 将问题拆分为子问题
• 假设生成 — 形成待验证的初步答案
• 验证循环 — 检查中间结果的一致性
• 回溯 — 发现矛盾时修订之前的步骤

这种透明度对生产系统很重要。当推理模型给出错误答案时，可以检查 chain-of-thought 来定位逻辑断裂点。当它给出正确答案时，可以用推理步骤为用户生成解释。

权衡是延迟。生成 reasoning tokens 通常比标准 completion 多 2-4 倍时间。对于交互式应用，R1 最适合异步任务、批处理，或用户明确请求详细解释的场景。

Token 流向是这样的：用户 prompt → Reasoning tokens（对你可见）→ 最终答案 tokens。

Reasoning tokens 计入 output token 限额。一个生成 500 个 reasoning tokens 和 200 个 answer tokens 的请求，总共消耗 700 个 output tokens。按 DeepSeek 定价 $0.42/M output tokens 计算，每次请求约 $0.000294，对大多数应用来说可以忽略不计。

获取 Reasoning 内容

DeepSeek 的 API 兼容 OpenAI SDK，reasoning 内容出现在一个特殊字段中：

from openai import OpenAI

client = OpenAI(
    api_key="sk-xxx",
    base_url="https://api.deepseek.com/v1"
)

response = client.chat.completions.create(
    model="deepseek-reasoner",
    messages=[{"role": "user", "content": "Solve: 3x + 7 = 22"}]
)

reasoning = response.choices[0].message.reasoning_content
print("Reasoning:", reasoning)

answer = response.choices[0].message.content
print("Answer:", answer)

reasoning_content 字段包含模型的内部独白——在最终答案之前通常是 200-800 个 token 的逐步思考。

流式输出 Reasoning Tokens

对于生产应用，几乎总是需要流式处理。它减少感知延迟，让你实时向用户展示推理步骤：

stream = client.chat.completions.create(
    model="deepseek-reasoner",
    messages=[{"role": "user", "content": "Explain the halting problem"}],
    stream=True
)

reasoning_buffer = []
answer_buffer = []
in_reasoning = True

for chunk in stream:
    delta = chunk.choices[0].delta

    if hasattr(delta, 'reasoning_content') and delta.reasoning_content:
        reasoning_buffer.append(delta.reasoning_content)
        print(f"[Reasoning] {delta.reasoning_content}", end="")

    if delta.content:
        if in_reasoning:
            print("\n--- Final Answer ---\n")
            in_reasoning = False
        answer_buffer.append(delta.content)
        print(delta.content, end="")

关键模式：reasoning tokens 在流中总是先于 answer tokens 出现。一旦看到第一个 content token（非 reasoning_content），推理阶段就完成了。

生产级推理模式

模式一：推理日志记录器

对于审计跟踪和调试，需要在记录最终答案的同时记录推理链：

import json
import time
from dataclasses import dataclass, asdict
from datetime import datetime

@dataclass
class ReasoningLog:
    timestamp: str
    request_id: str
    model: str
    prompt_tokens: int
    reasoning_tokens: int
    answer_tokens: int
    reasoning_content: str
    final_answer: str
    latency_ms: float

def call_with_logging(client, messages, request_id=None):
    request_id = request_id or f"req_{int(time.time() * 1000)}"
    start = time.time()

    response = client.chat.completions.create(
        model="deepseek-reasoner",
        messages=messages
    )

    latency = (time.time() - start) * 1000

    log = ReasoningLog(
        timestamp=datetime.utcnow().isoformat(),
        request_id=request_id,
        model="deepseek-reasoner",
        prompt_tokens=response.usage.prompt_tokens,
        reasoning_tokens=len(response.choices[0].message.reasoning_content.split()),
        answer_tokens=response.usage.completion_tokens,
        reasoning_content=response.choices[0].message.reasoning_content,
        final_answer=response.choices[0].message.content,
        latency_ms=latency
    )

    with open("reasoning_logs.jsonl", "a") as f:
        f.write(json.dumps(asdict(log)) + "\n")

    return response

这提供了完整的审计跟踪。当用户对答案提出争议时，可以拉取推理链展示模型得出结论的完整过程。

模式二：推理感知的 Agent 循环

推理模型在 Agent 工作流中表现出色，因为你可以看到它们为什么选择特定工具：

import json
from openai import OpenAI

client = OpenAI(api_key="sk-xxx", base_url="https://api.deepseek.com/v1")

tools = [{
    "type": "function",
    "function": {
        "name": "calculate",
        "description": "Evaluate a mathematical expression",
        "parameters": {
            "type": "object",
            "properties": {
                "expression": {"type": "string", "description": "Math expression to evaluate"}
            },
            "required": ["expression"]
        }
    }
}]

def reasoning_agent(user_message, max_steps=5):
    messages = [{"role": "user", "content": user_message}]
    step = 0

    while step < max_steps:
        response = client.chat.completions.create(
            model="deepseek-reasoner",
            messages=messages,
            tools=tools
        )

        msg = response.choices[0].message
        reasoning = getattr(msg, 'reasoning_content', '')

        print(f"\n[Step {step + 1} Reasoning]\n{reasoning}\n")

        if msg.tool_calls:
            messages.append(msg)

            for tool_call in msg.tool_calls:
                func_name = tool_call.function.name
                args = json.loads(tool_call.function.arguments)

                print(f"[Tool Call] {func_name}({args})")

                if func_name == "calculate":
                    import ast
                    result = ast.literal_eval(args["expression"])
                else:
                    result = {"error": "Unknown tool"}

                messages.append({
                    "role": "tool",
                    "tool_call_id": tool_call.id,
                    "content": str(result)
                })

            step += 1
        else:
            print(f"[Final Answer] {msg.content}")
            return msg.content

    return "Agent reached max steps"

关键优势：当 Agent 做出错误的 tool call 时，可以阅读推理链来理解它为什么做出那个选择，并相应改进工具描述。

模式三：推理验证器

使用更便宜的模型在接收 R1 的答案之前验证其推理，以十分之一的成本捕获推理错误：

def validated_reasoning(user_prompt, validator_model="deepseek/deepseek-v3.2"):
    r1_response = client.chat.completions.create(
        model="deepseek-reasoner",
        messages=[{"role": "user", "content": user_prompt}]
    )

    reasoning = r1_response.choices[0].message.reasoning_content
    answer = r1_response.choices[0].message.content

    validation_prompt = f"""Review this reasoning chain for errors:

Reasoning: {reasoning}

Answer: {answer}

Is the reasoning correct? Respond with ONLY "VALID" or "INVALID: [explanation]"."""

    validation = client.chat.completions.create(
        model=validator_model,
        messages=[{"role": "user", "content": validation_prompt}],
        max_tokens=100
    )

    validation_text = validation.choices[0].message.content.strip()

    if validation_text.startswith("VALID"):
        return {"status": "accepted", "answer": answer, "reasoning": reasoning}
    else:
        return {"status": "rejected", "reasoning": reasoning, "validation_error": validation_text}

这个两步模式增加约 30% 延迟，但能捕获复杂数学和逻辑问题中约 15-20% 的推理错误。

边界情况处理

空推理链：有些 prompt 会产生最少或空的推理，需要优雅处理：

reasoning = getattr(response.choices[0].message, 'reasoning_content', '') or "No explicit reasoning provided"

超长推理：复杂问题可能生成 2000+ 个 reasoning tokens，如果存储这些内容，考虑截断：

MAX_REASONING_TOKENS = 1500
reasoning = response.choices[0].message.reasoning_content
if len(reasoning.split()) > MAX_REASONING_TOKENS:
    reasoning = " ".join(reasoning.split()[:MAX_REASONING_TOKENS]) + "... [truncated]"

成本计算：reasoning tokens 是 output token 计数的一部分。包含 500 个 reasoning tokens 和 100 个 answer tokens 的响应计费为 600 个 output tokens：

total_output_tokens = response.usage.completion_tokens
reasoning_tokens = len(response.choices[0].message.reasoning_content.split())
answer_tokens = total_output_tokens - reasoning_tokens
print(f"Reasoning: {reasoning_tokens} | Answer: {answer_tokens} | Total: {total_output_tokens}")

何时用 R1 vs 标准模型

经验法则：当推理过程本身有价值时使用 R1——无论是用于验证、解释还是调试。对于只关心最终输出的任务使用标准模型。

• 数学问题 — 使用 R1：明确的推理步骤可以捕获错误
• 代码调试 — 使用 R1：Chain-of-thought 显示调试逻辑
• 多步骤规划 — 使用 R1：推理透明度有助于验证
• 简单分类 — 不使用：标准模型更快，准确率相同
• 实时聊天 — 不使用：推理延迟对交互式使用太高
• 创意写作 — 不使用：推理对开放式生成价值不大
• Agent 工具选择 — 使用 R1：可以看到为什么选择特定工具

监控推理质量

在生产中跟踪这些指标：

from dataclasses import dataclass

@dataclass
class ReasoningMetrics:
    avg_reasoning_tokens: float
    avg_answer_tokens: float
    reasoning_to_answer_ratio: float
    validation_pass_rate: float
    avg_latency_ms: float

健康的生产部署通常显示：

• 推理与答案比例在 2:1 到 4:1 之间
• 验证通过率高于 85%
• 90th percentile 延迟低于 10 秒

总结

DeepSeek-R1 暴露的 chain-of-thought 是一个真正的差异化因素。价格为 $0.28/M tokens——大约是 GPT-5.4 的 1/9——使推理透明度在大规模应用中变得可负担。

生产成功的关键是在流式解析器中正确处理 reasoning tokens，构建验证管道来捕获推理错误，并为每个任务使用正确的模型，而非默认对所有事情都使用推理模型。

R1 的核心价值不是「更聪明」，而是「更透明」。当 AI 进入生产环境，可观测性比能力更重要——需要的不是只知道答案对错，而是能追溯为什么错了、在哪一步错的。

---

本文是对社区原文的整理转写，原文可参阅 dev.to 社区文章。