Kimi K2 Thinking：开源大模型指南、基准测试与工具

一款开源模型以极低成本在主要基准上超越了 GPT-5 和 Claude Sonnet 4.5。这款模型就是 Kimi K2 Thinking，Moonshot AI 于 2025 年 11 月发布的推理版本。

Kimi K2 Thinking 能自主执行 200–300 次连续工具调用，非常适合 复杂的代理式工作流。它还通过专用的 API 字段公开其推理过程，您可以清楚地看到它如何思考并解决问题。

本教程将演示如何使用 Kimi K2 Thinking API 处理推理任务。您将实现工具调用工作流，构建一个对比聊天应用以将 K2 与 GPT-5 和 Claude 进行测试，并了解在何种情况下 K2 的优势会让它成为更佳选择。 如果您希望进一步学习如何用大语言模型构建应用，建议参加Developing LLM Applications with LangChain 课程。您也可以查看我们关于 GPT-5.1-Codex 和 Qwen3-Max-Thinking 的其他项目。此外，推荐阅读我们关于全新 Kimi K2.5 的 Agent Swarm 指南。

以下是应用预览：

在动手实践之前，先了解一下 K2 Thinking 与传统语言模型的不同之处。

什么是 Kimi K2 Thinking？

大多数语言模型会立即生成回复。K2 Thinking 则不同。它专为需要模型自主规划、推理与行动的多步骤问题而构建。

架构与设计

该模型采用专家混合（MoE）架构，总参数量 1 万亿。对于任一输入，仅有 320 亿参数被激活。这让 K2 具备超大模型的能力，却避免了高昂的推理成本。其 256,000 令牌的上下文窗口意味着您可以在不切分的情况下输入完整代码库、长文档或大量对话历史。

Moonshot AI 发布了两个版本。 K2 Instruct 适用于文本生成、分类与简单问答等直截了当的任务，注重速度；而 K2 Thinking 面向复杂推理任务。

两大亮点能力

K2 Thinking 的首要特性是推理透明。您可以看到它如何拆解问题、评估选项并得出结论。

第二个特性是工具编排。K2 能处理远超多数模型的长序列工具调用。它会自行决定使用哪些工具、何时使用、如何整合结果，而无需您在每个步骤介入。

其他特性

K2 针对不同部署需求提供了相应功能。在对准确性要求极高的生产场景中，Heavy Mode 会并行运行 8 条推理路径并选出最佳答案，但计算成本更高。 

对于延迟敏感的应用，INT4 量化可在几乎不损失精度的情况下将推理速度提升一倍，使其适用于高吞吐量环境。

Kimi K2 Thinking vs GPT-5 vs Claude Sonnet 4.5 vs DeepSeek

以下是 K2 与 GPT-5、Claude Sonnet 4.5 和 DeepSeek V3.2 的对比。

基准简要定义：HLE 测试研究生水平知识，AIME25 使用竞赛数学题，BrowseComp 与 Frames 测试网页浏览与信息综合，SWE-bench Verified 衡量开源代码中的缺陷修复，LiveCodeBench 测试代码生成，GPQA 涵盖研究生层次的科学问题。

K2 的工具训练优势在代理式基准上尤为明显。Heavy Mode 因并行运行 8 条推理路径，在 HLE 上领先 GPT-5 9 分。Claude 的代码训练让其在 SWE-bench Verified 上占优，因此是软件工程项目的首选。

在纯推理任务上，这三款模型表现大致相当。差异在引入工具后显现。K2 的 200–300 次工具调用能力让其能够在无需您逐步干预的情况下，完成自主研究工作流、调试流水线以及多步骤数据分析。

各模型的适用场景

• 当代理式工作流需要大规模工具编排、网页研究与信息综合，或您需要用于调试或合规的透明推理链时，选择 K2 Thinking。
• 当您需要 400k 令牌的最大上下文窗口，或在成熟生态支持下获得各任务的均衡表现时，选择 GPT-5。
• 当项目以软件工程为主，调试与代码修复最为重要时，选择 Claude Sonnet 4.5。
• 当预算优先，且需要 MIT 许可的开源要求时，选择 DeepSeek。

配置 Kimi K2 Thinking API 访问

访问 K2 Thinking 有两种方式：直接通过 Moonshot AI 的platform.moonshot.ai，或通过统一 API 网关 OpenRouter。我们将使用 OpenRouter，因为它用一个 API 密钥即可访问 K2、GPT-5、Claude 等数十种模型。在后续构建对比聊天应用时，这种统一访问尤为关键。OpenRouter 还会自动处理限流与故障切换，免去您维护多个服务商账户的麻烦。

首先前往 openrouter.ai 创建账户。您可以使用 Google 或 GitHub 注册。登录后，前往控制台的“Keys”部分生成新的 API 密钥。 

注册后 OpenRouter 将提供 5 美元的免费额度，足以在若干查询上测试 K2 Thinking。如果需要更多额度，可在“Credits”部分添加支付方式。

复制您的 API 密钥并妥善保存。稍后会用到。请勿将此密钥提交到版本控制或公开分享，因为任何持有密钥的人都能以您的账户发起 API 调用。

现在来配置 Python 环境。您需要 OpenAI Python SDK，它与 OpenRouter 的 API 兼容（因其保持了 OpenAI 兼容性）。同时建议使用 python-dotenv 安全管理 API 密钥。安装如下：

!pip install openai python-dotenv技术支持

在项目目录创建 .env 文件，并添加您的 OpenRouter API 密钥：

OPENROUTER_API_KEY=your_key_here技术支持

如果您使用 git，请将 .env 加入 .gitignore，以免不慎提交您的凭据。

以下是快速测试以验证一切正常：

import os
from openai import OpenAI
from dotenv import load_dotenv

# Load API key from .env file
load_dotenv()

# Configure client for OpenRouter
client = OpenAI(
   base_url="https://openrouter.ai/api/v1",
   api_key=os.getenv("OPENROUTER_API_KEY")
)

# Test call to K2 Thinking
response = client.chat.completions.create(
   model="moonshotai/kimi-k2-thinking",
   messages=[
       {"role": "user", "content": "What is 15 * 24?"}
   ]
)

print(response.choices[0].message.content)技术支持

输出：

15 * 24 = **360**技术支持

如果您看到答案，说明配置成功。

理解 Kimi K2 的 Thinking 模式

前文我们提到过 K2 的推理透明。现在来看看如何在代码中访问并使用它。K2 Thinking 会通过专用 API 字段自动公开其推理过程。 

与某些需要手动启用思维模式的模型不同，K2 默认在每次响应中都包含推理内容。

如何访问推理内容

当您调用 K2 Thinking 的 API 时，响应包含两个字段。content 字段是最终答案，reasoning 字段展示逐步的思考过程。以下是一个需要多步计算折扣的示例：

import os
from openai import OpenAI
from dotenv import load_dotenv

load_dotenv()

client = OpenAI(
   base_url="https://openrouter.ai/api/v1",
   api_key=os.getenv("OPENROUTER_API_KEY")
)

response = client.chat.completions.create(
   model="moonshotai/kimi-k2-thinking",
   messages=[
       {"role": "user", "content": "A laptop costs $850. There's a 20% discount today, then 8% sales tax applies to the discounted price. What's the final amount I pay?"}
   ],
   temperature=1.0
)

print("Final answer:")
print(response.choices[0].message.content)
print("\nReasoning process:")
print(response.choices[0].message.reasoning)技术支持

输出：

Final answer:
The final amount you pay is **$734.40**.

Here's the breakdown:

1. **Discount:** 20% of $850 = $170
2. **Discounted price:** $850 - $170 = $680
3. **Sales tax:** 8% of $680 = $54.40
4. **Final amount:** $680 + $54.40 = **$734.40**技术支持

推理过程（为便于阅读已截断）：

The user wants to know the final amount they will pay for a laptop with a discount and then sales tax applied.

Step 1: Calculate the discount amount.
Discount amount = $850 * 0.20 = $170

Step 2: Calculate the discounted price.
Discounted price = $850 - $170 = $680

Step 3: Calculate the sales tax amount.
Sales tax amount = $680 * 0.08 = $54.40

Step 4: Calculate the final amount to pay.
Final amount = $680 + $54.40 = $734.40

Let me double-check the calculations...
[verification steps omitted]

The final amount is $734.40技术支持

content 字段提供用户可见的整洁答案。reasoning 字段展示 K2 的推理过程，帮助您判断模型是否真正通过推理得出答案，而非碰巧答对。

K2 在推理时即时生成思维令牌，而非事后补写。这意味着模型会先思考再给出答案，类似您在草稿纸上演算后再写最终解答。推理在生成过程中实时进行。

Thinking 模式的参数建议

使用 K2 Thinking 时，设置 temperature=1.0。较低温度会限制模型的推理探索，背离 Thinking 模式的初衷。还建议将 max_tokens=4096 或更高，因为推理链会在最终答案开始前就占用令牌。

response = client.chat.completions.create(
   model="moonshotai/kimi-k2-thinking",
   messages=[{"role": "user", "content": "Your question here"}],
   temperature=1.0,
   max_tokens=4096
)技术支持

现在您已了解思维模式，接下来探索 K2 的另一项关键能力：工具调用。尽管许多模型都支持基础工具使用，但 K2 的规模与自主性与众不同。

Kimi K2 的工具调用能力

工具调用让 K2 能在推理过程中执行函数。您以 JSON 模式定义工具，描述各函数的作用及所需参数。当 K2 需要外部数据或计算时，它会调用合适的工具并等待结果。

这会形成往返循环：K2 读取您的提示并进行推理。如果需要工具，它会返回 finish_reason: "tool_calls"。您执行函数，使用 role: "tool" 将结果返回，K2 继续推理。该过程重复，直到 K2 返回 finish_reason: "stop" 给出最终答案。

该模式遵循 OpenAI 的格式，包括名称、描述和参数。K2 会读取这些信息来判断何时使用各工具。清晰的描述非常重要，因为它们会引导模型做出正确决策。

构建 CSV 分析工具

我们来构建一个实用工具用于分析 CSV 文件，这是数据科学中的常见任务。该工具读取 CSV，提取列信息并返回摘要统计。它演示了 K2 如何在推理中访问外部数据，这对数据驱动应用至关重要。

以下是完整实现：

import csv
import os
import json

# Define the tool schema
tools = [
   {
       "type": "function",
       "function": {
           "name": "analyze_csv",
           "description": "Read and analyze the first few rows of a CSV file. Returns columns, sample rows, total row count, and file size.",
           "parameters": {
               "type": "object",
               "properties": {
                   "filepath": {
                       "type": "string",
                       "description": "Path to the CSV file"
                   },
                   "num_rows": {
                       "type": "integer",
                       "description": "Number of rows to read",
                       "default": 10
                   }
               },
               "required": ["filepath"]
           }
       }
   }
]技术支持

该模式按照 OpenAI 的格式定义了一个函数工具。description 字段告诉 K2 工具的作用，并引导其判断何时使用。 

parameters 对象指定输入：filepath 为必填，num_rows 为可选，默认 10。清晰的描述有助于 K2 判断工具是否符合用户需求。

以下实现负责实际的文件处理：

# Implement the function
def analyze_csv(filepath: str, num_rows: int = 10) -> dict:
   if not os.path.exists(filepath):
       return {"error": f"File not found: {filepath}"}

   try:
       with open(filepath, 'r') as f:
           reader = csv.DictReader(f)
           columns = reader.fieldnames
           sample_rows = [dict(row) for i, row in enumerate(reader) if i < num_rows]
           f.seek(0)
           total_rows = sum(1 for _ in f) - 1

       return {
           "columns": list(columns),
           "sample_rows": sample_rows,
           "total_rows": total_rows,
           "file_size_kb": round(os.path.getsize(filepath) / 1024, 2)
       }
   except Exception as e:
       return {"error": str(e)}技术支持

该函数会校验文件路径，然后使用 csv.DictReader 将 CSV 数据解析为以列名为键的字典。它读取前 num_rows 条记录，使用 seek(0) 重置文件指针，并统计总行数。 

返回的字典包含列名、样本数据、行数以及以 KB 计的文件大小。错误处理可在失败时返回有用的反馈。

实现工具执行循环

定义并实现工具后，您需要一个循环来处理 K2 与函数之间的对话。工具调用并非一次性操作。K2 可能需要多次迭代：调用工具、分析结果、决定是否再调用工具，并重复此过程。这需要一个循环来处理这种往返，直至 K2 得出最终答案。

以下是包含真实示例的完整实现：

from openai import OpenAI

client = OpenAI(
   base_url="https://openrouter.ai/api/v1",
   api_key=os.getenv("OPENROUTER_API_KEY")
)

messages = [
   {"role": "user", "content": "Analyze sample_employees.csv and tell me the average salary for Engineering department employees."}
]技术支持

这将初始化配置为 OpenRouter API 的 OpenAI 客户端，并使用用户关于分析员工薪资的请求创建初始消息列表。

while True:
   response = client.chat.completions.create(
       model="moonshotai/kimi-k2-thinking",
       messages=messages,
       tools=tools,
       temperature=1.0
   )

   message = response.choices[0].message
   finish_reason = response.choices[0].finish_reason

   messages.append({
       "role": "assistant",
       "content": message.content,
       "tool_calls": message.tool_calls
   })技术支持

主循环会将对话历史与可用工具一并发送给 K2。提取助手响应与结束原因后，将其追加到消息历史中，以保持对话上下文。

  if finish_reason == "tool_calls":
       for tool_call in message.tool_calls:
           function_name = tool_call.function.name
           arguments = json.loads(tool_call.function.arguments)

           if function_name == "analyze_csv":
               result = analyze_csv(**arguments)

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

   elif finish_reason == "stop":
       print(message.content)
       break技术支持

当 K2 请求工具调用时，我们使用提供的参数执行各函数，并将结果连同匹配的 tool_call_id 追加回对话。K2 完成推理并返回“stop”后，我们打印最终答案并退出循环。

在此示例中，创建一个包含姓名、部门、薪资列的 sample_employees.csv 文件。为 Engineering、Marketing、Sales、HR 等部门准备约 12 名员工用于测试。运行代码时，K2 通常会以 12 或更高的 num_rows 调用 analyze_csv() 以覆盖完整数据，然后识别 Engineering 员工并计算其平均薪资。

输出：

Based on the CSV data, I found 5 Engineering employees in the sample:
- Alice Johnson: $95,000
- Carol White: $110,000
- Eve Davis: $88,000
- Iris Martinez: $102,000
- Kate Thomas: $92,000

The average salary for Engineering department employees is $97,400.技术支持

tool_call_id 将各响应与对应函数调用关联起来。K2 可能在一次响应中请求多个工具，因此每个调用都需要其 ID 以正确匹配。保留完整的对话历史可为 K2 提供跨工具调用的连贯推理所需的上下文。

理解 K2 的独立编排

当您熟悉基础工具调用后，K2 的真正强项将显现：扩展编排。K2 自训练之初便面向工具编排，而非后期外挂。这改变了它处理多步骤任务的方式。多数模型在 20–50 次连续工具调用后性能下滑；K2 则可在 200–300 次内保持连贯推理。

这种能力对于独立工作流至关重要，模型会自行决策、收集信息、验证结果并迭代直至解决问题。设想研究任务：K2 搜索数据库、交叉引用发现、识别空白、优化查询并综合结果；或需要逐步校验的数据流水线；或要检验多种假设的调试流程。

如果您的用例是“执行这一单步操作”，多数模型都能胜任；如果是“持续工作直到解决为止”，K2 的扩展工具能力就成了决胜因素。

构建多模型对比聊天应用

您已经看到 K2 Thinking 如何借助工具调用与推理透明性处理单个任务。现在将它与竞争对手正面比拼。您将构建一个 Streamlit 应用，同时用相同提示查询 Kimi K2 Thinking、GPT-5 和 Claude Sonnet 4.5。界面会并排显示三者的回复，让您直观比较它们解决同一问题的方式。

您可以在此 GitHub Gist 中找到完整应用脚本。如果您只关心测试结果，可以跳过本节。以下步骤包含对 200 多行脚本的详细拆解，您也可以稍后在有时间跟做时再阅读。话不多说，开始吧。

步骤 1：项目设置与依赖

该对比应用需要访问三种模型的 API。您需要已配置 5 美元免费额度的 OpenRouter 账户，另外可选配置 OpenAI 与 Anthropic 的 API 密钥。OpenRouter 的 5 美元额度足以在多次查询中测试三款模型。如果您只有 OpenRouter 访问权限，仍可在 OpenRouter 可用的范围内对比 K2 与其他模型。

安装用于网页界面的 Streamlit 与用于访问 Claude 的 Anthropic SDK：

pip install streamlit anthropic技术支持

创建名为 model_comparison_chat.py 的文件。整个应用都在这个文件中。先编写导入：

import os
import time
from typing import Dict, List
from concurrent.futures import ThreadPoolExecutor, as_completed
from dotenv import load_dotenv
import streamlit as st
from openai import OpenAI
from anthropic import Anthropic

load_dotenv()技术支持

步骤 2：配置 API 连接

您的 OPENROUTER_API_KEY 已在 .env 中。为 GPT-5 与 Claude 添加密钥：

OPENROUTER_API_KEY=your_openrouter_key  # Already set up
OPENAI_API_KEY=your_openai_key           # Add this
ANTHROPIC_API_KEY=your_anthropic_key     # Add this技术支持

从 platform.openai.com 获取 OpenAI API 密钥，从 console.anthropic.com 获取 Anthropic 密钥。关于 GPT-5 的更多设置细节，请参阅 GPT-5 指南；关于 Claude Sonnet 4.5，请查看 Claude Sonnet 4.5 概览。

初始化三个客户端：

KIMI_CLIENT = OpenAI(
   api_key=os.getenv("OPENROUTER_API_KEY"),
   base_url="https://openrouter.ai/api/v1"
)
GPT_CLIENT = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
CLAUDE_CLIENT = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))技术支持

步骤 3：为各模型创建辅助函数

构建一个统一函数，根据模型名称路由到合适的调用。这能保持代码整洁，并便于后续添加更多模型。

先从 Kimi K2 调用开始：

def call_model(model_name: str, messages: List[Dict], **kwargs) -> Dict:
   """Call any model with unified interface."""
   try:
       start_time = time.time()

       if model_name == "Kimi K2 Thinking":
           enable_thinking = kwargs.get("enable_thinking", True)

           completion = KIMI_CLIENT.chat.completions.create(
               model="moonshotai/kimi-k2-thinking",
               messages=messages,
               temperature=1.0,
               extra_body={"include_reasoning": True}
           )

           message = completion.choices[0].message
           content = message.content

           # Extract reasoning from the dedicated field
           reasoning_content = None
           if enable_thinking and hasattr(message, 'reasoning') and message.reasoning:
               reasoning_content = message.reasoning

           return {
               "content": content,
               "reasoning_content": reasoning_content,
               "response_time": time.time() - start_time,
               "tokens_used": {
                   "input": completion.usage.prompt_tokens,
                   "output": completion.usage.completion_tokens,
                   "total": completion.usage.total_tokens
               },
               "error": None
           }技术支持

GPT-5 使用不同的 responses 端点，并可配置推理强度：

      elif model_name == "GPT-5":
           reasoning_effort = kwargs.get("reasoning_effort", "medium")
           input_messages = [
               {"role": m["role"], "content": m["content"]}
               for m in messages
           ]

           response = GPT_CLIENT.responses.create(
               model="gpt-5",
               input=input_messages,
               reasoning={
                   "effort": reasoning_effort,
                   "summary": "auto"
               }
           )

           # Parse response structure
           reasoning_text = None
           content_text = ""

           for item in response.output:
               if item.type == "reasoning" and hasattr(item, "summary"):
                   summaries = [s.text for s in item.summary if hasattr(s, "text")]
                   reasoning_text = "\n\n".join(summaries) if summaries else None
               elif item.type == "message" and hasattr(item, "content"):
                   content_text += "".join(c.text for c in item.content if hasattr(c, "text"))

           return {
               "content": content_text,
               "reasoning_content": reasoning_text,
               "response_time": time.time() - start_time,
               "tokens_used": {
                   "input": getattr(response.usage, "input_tokens", 0),
                   "output": getattr(response.usage, "output_tokens", 0),
                   "total": getattr(response.usage, "total_tokens", 0)
               },
               "error": None
           }技术支持

GPT-5 提供四档推理强度：minimal、low、medium、high。其响应结构将推理摘要与消息内容分开，您需要分别解析后按与 Kimi K2 相同的标准字典格式返回。

Claude Sonnet 4.5 则通过令牌预算实现扩展思维模式：

    else:  # Claude Sonnet 4.5
           enable_thinking = kwargs.get("enable_thinking", True)
           params = {
               "model": "claude-sonnet-4-5",
               "max_tokens": 10000,
               "messages": messages
           }
           if enable_thinking:
               params["thinking"] = {
                   "type": "enabled",
                   "budget_tokens": 5000
               }

           message = CLAUDE_CLIENT.messages.create(**params)

           # Extract content and thinking blocks
           content_text = ""
           thinking_text = None

           for block in message.content:
               if block.type == "thinking":
                   thinking_text = block.thinking
               elif block.type == "text":
                   content_text += block.text

           return {
               "content": content_text,
               "reasoning_content": thinking_text,
               "response_time": time.time() - start_time,
               "tokens_used": {
                   "input": message.usage.input_tokens,
                   "output": message.usage.output_tokens,
                   "total": message.usage.input_tokens + message.usage.output_tokens
               },
               "error": None
           }

   except Exception as e:
       return {
           "content": None,
           "reasoning_content": None,
           "response_time": 0,
           "tokens_used": {"input": 0, "output": 0, "total": 0},
           "error": f"{model_name} Error: {str(e)}"
       }技术支持

Claude 会为内部推理分配令牌预算，再生成最终答案。响应包含多个内容块，您需遍历并将 thinking 块与 text 块分别提取。末尾的错误处理会返回相同的标准字典结构与错误信息，确保 API 调用失败不会破坏界面。

步骤 4：构建 Streamlit 界面

API 层就绪后，即可构建网页界面。先配置 Streamlit 页面：

def main():
   st.set_page_config(
       page_title="Multi-Model Comparison Chat",
       page_icon="🤖",
       layout="wide",
       initial_sidebar_state="expanded"
   )

   st.session_state.setdefault("messages", [])
   st.session_state.setdefault("model_responses", [])技术支持

宽屏布局为三列并排展示提供空间。Session state 可在 Streamlit 反复运行脚本时保留对话历史与模型响应。

添加页面标题与侧边栏控件：

st.title("🤖 Multi-Model Comparison Chat")
   st.markdown("""
   Compare **Kimi K2 Thinking**, **GPT-5**, and **Claude Sonnet 4.5** side-by-side.
   All three models support reasoning modes - see how they approach problems differently.
   """)

   with st.sidebar:
       st.header("⚙️ Settings")

       st.subheader("Thinking Mode")
       kimi_thinking = st.checkbox("Enable Kimi K2 Thinking", value=True)
       gpt5_reasoning = st.selectbox(
           "GPT-5 Reasoning Effort",
           options=["minimal", "low", "medium", "high"],
           index=2
       )
       claude_thinking = st.checkbox("Enable Claude Thinking", value=True)技术支持

侧边栏为用户提供对思维模式的控制。Kimi K2 与 Claude 是二选一开关；GPT-5 因其 API 暴露细粒度控制，提供四档推理强度。

在思维控制下方，添加 API 状态指示，便于用户了解哪些服务已连接：

st.subheader("API Status")
       st.markdown(f"""
       - Kimi K2: {"✅" if os.getenv("OPENROUTER_API_KEY") else "❌"}
       - GPT-5: {"✅" if os.getenv("OPENAI_API_KEY") else "❌"}
       - Claude: {"✅" if os.getenv("ANTHROPIC_API_KEY") else "❌"}
       """)技术支持

当环境变量存在时显示对勾；红叉表示需要在 .env 中添加相应密钥。

步骤 5：实现对比逻辑

下面是核心功能。当用户提交消息时，您将并行调用三款模型并并排展示结果。

def call_models_parallel(messages: List[Dict], selected_models: List[str],
                       kimi_thinking: bool, gpt5_reasoning: str,
                       claude_thinking: bool) -> Dict[str, Dict]:
   """Call multiple models in parallel."""
   model_kwargs = {
       "Kimi K2 Thinking": {"enable_thinking": kimi_thinking},
       "GPT-5": {"reasoning_effort": gpt5_reasoning},
       "Claude Sonnet 4.5": {"enable_thinking": claude_thinking}
   }

   with ThreadPoolExecutor(max_workers=3) as executor:
       futures = {
           executor.submit(call_model, m, messages, **model_kwargs[m]): m
           for m in selected_models if m in model_kwargs
       }
       return {futures[f]: f.result() for f in as_completed(futures)}技术支持

该函数会同时提交三次 API 调用，并在各自完成时收集结果。串行调用可能耗时 15–30 秒，并行能缩短至 5–10 秒，因为您只需等待最慢的一个模型。

将并行执行整合进聊天界面：

   if prompt := st.chat_input("Ask a question to all models..."):
       st.session_state.messages.append({"role": "user", "content": prompt})

       with st.chat_message("user"):
           st.markdown(prompt)

       api_messages = [
           {"role": m["role"], "content": m["content"]}
           for m in st.session_state.messages
       ]

       with st.spinner("🤔 Models are thinking..."):
           responses = call_models_parallel(
               api_messages,
               ["Kimi K2 Thinking", "GPT-5", "Claude Sonnet 4.5"],
               kimi_thinking,
               gpt5_reasoning,
               claude_thinking
           )

       cols = st.columns(3)
       for idx, (model_name, response_data) in enumerate(responses.items()):
           with cols[idx]:
               st.markdown(f"### {model_name}")
               if response_data["reasoning_content"]:
                   with st.expander("🧠 Thinking Process", expanded=False):
                       st.markdown(response_data["reasoning_content"])
               st.markdown(response_data["content"])技术支持

这会创建三列，并在各自列中展示对应模型的回应。思维过程默认折叠，用户先看到最终答案，需要时再展开查看推理。

步骤 6：测试与完善

用以下命令运行应用：

streamlit run model_comparison_chat.py技术支持

从基础测试开始，确认一切正常：

What is 2+2?技术支持

三款模型应在数秒内响应。这验证了您的 API 连接与并行执行是否生效。应用在本地运行，您可完全控制何时发起 API 调用。每次查询都会产生 API 成本（每次三模型对比约 $0.01–0.05，取决于响应长度），但本地运行意味着何时花费由您决定。

用复杂提示测试应用

您已经构建了对比应用，并用简单问题验证了其可用性。但这些模型真正的差异会在更高难度时显现。为展示这些差异，我用复杂提示测试了三款模型。您也可以在自己的应用中运行相同测试，亲自查看结果。以下是关键洞见。

测试提示

我们选择了三个不同挑战，以测试不同的推理能力。

测试 1：高级数学推理

一个长方形花园长 24 英尺、宽 18 英尺。花园外围有一条宽 2 英尺的小径。Sarah 以每平方英尺 4 株的密度在花园里种花，随后决定在已种区域的 30% 铺设装饰石（并移除这些花）。还剩多少株花？另外，小径的总面积（平方英尺）是多少？

测试 2：多步逻辑推理

四位朋友——Alice、Bob、Carol 和 David——需要排成一行拍照。需遵循以下规则：

1. Alice 必须站在 Bob 旁边

2. Carol 不能站在两端

3. David 必须站在 Alice 的左侧

列出所有从左到右的有效排列。

测试 3：带约束的代码生成

编写一个 Python 函数，用于检查字符串是否为有效 IPv4 地址，要求如下：

1. 必须校验格式（四个以点分隔的八位段）

2. 每个八位段必须在 0–255 之间（除“0”本身外不得有前导零）

3. 必须拒绝无效格式（空字符串、八位段过多/过少、非数字字符）

4. 时间复杂度必须为 O(n)，其中 n 为字符串长度

5. 包含完整的文档字符串与示例

6. 为所有参数与返回值添加类型注解

7. 处理边界情况（空字符串、None、特殊字符）

同时解释您的校验方法及其为何是 O(n)。

结果

三款模型都正确解决了每个问题，但采取的路径差异很大。以下是性能概览：

以下是各模型在这段时间内的实际做法。

Kimi K2 的方式

它不断探索并自我质疑。在花园问题中，它先进行可视化，再完成计算，然后停下来表示“等等，让我再核对一下……”再继续。对于排队问题，它逐条验证约束，对每种可能性都“展示过程”。 

IPv4 校验器耗时超过 3 分钟，因为它逐个考虑边界情况，给出 O(n) 复杂度证明，并多次验证逻辑。您会看到一个“边想边说、及时自检、每一步都核对”的过程。

GPT-5 的方式

它方法有序、条理清晰。花园问题被拆分为清晰的部分，分步编号并按序推进。排队问题则以位置为序构造，逐步核查规则。 

生成的代码配有清晰解释与良好文档。它不像 K2 那样频繁自我怀疑，也不像 Claude 那样追求极速。您会获得在详尽与简洁之间较为平衡的思考脉络。

Claude 的方式

它速度很快。每项测试都能迅速识别解题路径并干净利落地执行。对于排队问题，它按情形分类，逐一推进，不做过多停留。IPv4 代码简洁、注释充分，但更快到达要点。 

Claude 会展示思考过程，但不会过多停留在验证步骤。它的速度来自于对路径的信心与最小化回溯。

这些不同方法形成了清晰的取舍：当您需要详尽推理用于学习、调试或审计时，选 K2；当速度优先且您无需细查推理链时，选 Claude；当您需要在 K2 的详尽与 Claude 的速度之间取得平衡时，选 GPT-5。

注意：请谨慎解读上述测试结果，因为它们无法全面覆盖三款模型的全部能力。

结语

您已通过 OpenRouter 完成 Kimi K2 Thinking 的配置，探索了其推理能力，构建了工具调用工作流，并搭建了对比应用将其与 GPT-5 和 Claude 进行测试。K2 的优势在于独立的工具编排与推理透明，非常适合需要验证模型决策的复杂工作流。

K2 的能力与性价比让这一切更为可行。它能执行远超多数竞品的长序列工具调用，并通过 reasoning_content 字段公开每一步思考。输出令牌成本约为 GPT-5 的 1/4、Claude 的 1/6，您可以在不必过多担心预算的情况下进行大规模实验。

您所构建的对比应用将为这些取舍提供直观证据。用您的问题与工作流进行测试，以形成直觉判断：K2 的详尽推理是否值得更长的响应时间。针对具体用例的真实测试，往往能揭示通用基准无法体现的模式。

如需进一步拓展，请查看 DataCamp 的 OpenRouter 教程（管理多家 LLM 服务商）、 GPT-5 指南（了解推理强度分级），以及 Claude Sonnet 4 指南（了解扩展思维模式）。