深度推理系统构建教程：状态化推理循环与工具调用架构

深度推理系统不会在单次前向传播中直接得出答案。它们会规划、分解、反思，通常还会调用外部工具，然后才返回最终结果。如果你正在构建一个能写代码、执行多步分析或解决开放式研究任务的 Agent，你需要一种将推理视为有状态循环而非无状态补全的架构。本教程将带你了解深度推理系统的核心组件，展示如何在 Python 中实现一个最小化但可扩展的推理循环，并解释为什么长上下文推理的经济性应该影响你的基础设施选择。

架构概述

生产级系统通常将关注点分离为五个区域：

推理引擎（Reasoning engine）。负责生成思维链、决定何时行动并综合结论的模型。

工作记忆（Working memory）。适应上下文窗口的消息历史、工具输出和中间草稿。

工具注册表（Tool registry）。模型可调用的可执行函数，如计算器、搜索 API 或代码解释器。

控制器（Controller）。重复调用推理引擎、分发工具并将观察结果追加回工作记忆的编排循环。

验证器（Verifier）。一个可选的批判层，在最终答案返回前检查一致性、正确性或完整性。

控制器是大多数开发者自己构建的部分。其他四个部分主要由你的推理提供商和模型选择决定。

选择推理引擎

并非每个模型都适合深度推理。你需要一个能暴露显式思维链或针对 Agent 执行微调的基础模型。Oxlo.ai 提供了多个不同权衡的相关选项：

• DeepSeek R1 671B MoE——用于深度推理和复杂编码任务
• DeepSeek V4 Flash——高效的 MoE 模型，拥有 100 万 token 上下文窗口，接近最先进的开源推理能力
• Kimi K2.6——支持高级推理、Agent 编码、视觉能力和 131K 上下文
• Kimi K2 Thinking 和 Kimi K2.5——用于高级思维链推理
• GLM 5——744B MoE，专为长周期 Agent 任务设计
• Qwen 3 32B——用于多语言推理和 Agent 工作流

由于 Oxlo.ai 完全兼容 OpenAI SDK，在这些模型之间切换只需在客户端配置中更改一个字符串。热门模型没有冷启动问题，所以会话中的第一个请求与后续请求行为一致。

实现推理循环

深度推理的经典模式是 ReAct 风格循环：模型推理、选择动作、控制器执行动作，然后将观察结果反馈回去。以下是一个使用 Oxlo.ai API 端点的最小化但完整的示例。

import os
import json
from openai import OpenAI

client = OpenAI(
    base_url="https://api.oxlo.ai/v1",
    api_key=os.environ["OXLO_API_KEY"]
)

MODEL = "deepseek-r1-671b"  # or kimi-k2.6, deepseek-v4-flash, glm-5, etc.

tools = [
    {
        "type": "function",
        "function": {
            "name": "calculate",
            "description": "Evaluate a mathematical expression safely.",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {"type": "string"}
                },
                "required": ["expression"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "search",
            "description": "Run a web search and return top snippets.",
            "parameters": {
                "type": "object",
                "properties": {
                    "query": {"type": "string"}
                },
                "required": ["query"]
            }
        }
    }
]

def dispatch_tool(name: str, args: dict) -> str:
    if name == "calculate":
        # In production, run inside a sandbox, not eval.
        try:
            return str(eval(args["expression"]))
        except Exception as e:
            return f"Error: {e}"
    if name == "search":
        # Replace with real search integration.
        return "No results."
    return "Unknown tool."

def deep_reason(user_query: str, max_iterations: int = 5) -> str:
    messages = [
        {"role": "system", "content": "You are a careful reasoning agent. Think step by step, and use tools when facts or calculations are required."},
        {"role": "user", "content": user_query}
    ]

    for _ in range(max_iterations):
        response = client.chat.completions.create(
            model=MODEL,
            messages=messages,
            tools=tools,
            tool_choice="auto"
        )

        message = response.choices[0].message
        messages.append(message)

        # If the model did not request tools, we have a final answer.
        if not message.tool_calls:
            return message.content

        # Otherwise, execute each tool and append observations.
        for tool_call in message.tool_calls:
            name = tool_call.function.name
            arguments = json.loads(tool_call.function.arguments)
            observation = dispatch_tool(name, arguments)
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call.id,
                "name": name,
                "content": observation
            })

    return "Reached maximum reasoning depth without a final answer."

if __name__ == "__main__":
    answer = deep_reason("What is the square root of 1764 multiplied by the population of Iceland?")
    print(answer)

这个循环是大多数 Agent 系统的基础架构。模型决定何时有足够的信息来回答，控制器则对领域逻辑保持无感知。

使用 JSON Mode 结构化推理

如果你想提取模型的内部计划或以编程方式路由动作，非结构化文本很难解析。Oxlo.ai 支持 JSON mode，允许你将输出约束到某个 schema。你可以让模型输出一个包含 thought、action 和 action_input 字段的对象，然后在分发工具之前可靠地解析它。

要使用 JSON mode，在请求中设置 response_format={"type": "json_object"}，并在系统提示中包含 schema 描述。当你想让控制器（而非模型）决定如何验证工具参数时，这与推理循环配合得很好。

管理上下文和记忆

深度推理痕迹增长很快。每个想法、工具调用和观察都会消耗 token，多轮 Agent 工作负载可能将上下文窗口推到数十万 token。对于按 token 计费的提供商，成本随输入长度线性增长，这意味着长推理会话会变得极其昂贵。

Oxlo.ai 使用按请求计费：每个 API 请求统一收费，不限提示词长度。与 Together AI、Fireworks AI、OpenRouter、Replicate 和 Anyscale 等按 token 计费的提供商不同，Oxlo.ai 不会因为你将完整历史、大型检索文档或冗长的思维链带入每一轮而惩罚你。对于 Agent 和长上下文工作负载，这可以使深度推理更加经济。你可以在 Oxlo.ai 定价页查看详细信息。

由于成本与上下文长度解耦，你可以在压缩或总结之前在工作记忆中保留更多轮次。当你确实需要压缩时，一个简单的策略是将超过某个阈值的轮次总结为一条系统消息，同时保留最近的原始交换以保持准确性。

添加反思和验证

单次推理可能产生幻觉事实或算术错误。稳健的系统会添加验证步骤。在循环产生草稿答案后，发送第二个请求，让模型批判自己的作品。

def verify(question: str, draft: str) -> str:
    prompt = (
        f"Question: {question}\n"
        f"Proposed Answer: {draft}\n\n"
        "Critique this answer. Identify any factual errors, logical gaps, or unstated assumptions. "
        "Respond with CORRECT if it is fully accurate, or explain the flaw."
    )
    response = client.chat.completions.create(
        model=MODEL,
        messages=[{"role": "user", "content": prompt}]
    )
    return response.choices[0].message.content

如果验证器发现问题，你可以将批评追加到工作记忆中并重新启动推理循环。这种自我修正模式在 Oxlo.ai 模型（如 DeepSeek R1 671B MoE 和 Kimi K2 Thinking）上特别有效，这些模型针对扩展推理链进行了明确调优。

流式响应和生产部署

在生产环境中，用户期望看到进展。Oxlo.ai 支持流式响应，因此你可以在推理 token 生成时直接发出，而不是阻塞直到完整响应准备就绪。

stream = client.chat.completions.create(
    model=MODEL,
    messages=messages,
    tools=tools,
    tool_choice="auto",
    stream=True
)

for chunk in stream:
    delta = chunk.choices[0].delta
    if delta.content:
        print(delta.content, end="")

由于热门模型没有冷启动，即使在空闲期后，第一个 chunk 也会立即到达。如果你需要保证吞吐量或专用 GPU，Oxlo.ai 提供企业计划，具有定制规格和专用基础设施。

构建深度推理系统的本质是循环推理、管理长上下文，并在你拥有的控制器下集成工具。你选择的基础设施应该奖励复杂性而非对其征税。Oxlo.ai 提供了模型深度，从 DeepSeek R1 和 V4 Flash 到 Kimi K2.6 和 GLM 5，以及保持长推理痕迹可负担的按请求计费模式。凭借完全兼容 OpenAI SDK，你可以将现有客户端指向 https://api.oxlo.ai/v1，专注于架构而非计费。