Together AI Blog

Kimi K3: The Complete Developer Guide

8.5内容质量

TL;DR · AI 摘要

Kimi K3是首个2.8万亿参数开源模型,支持1M上下文和高效推理,适用于复杂编程与知识工作。

核心要点

  • Kimi K3参数量达2.8万亿,是首个3万亿参数级开源模型
  • KDA机制实现1M上下文处理,AttnRes提升深度学习效率
  • Together AI提供OpenAI兼容API,支持自动前缀缓存

结构提纲

按章节快速跳转。

  1. 介绍Kimi K3作为Moonshot AI最新模型的突破性意义

  2. 披露2.8万亿参数规模及3万亿参数级开源的行业领先地位

  3. 解析KDA注意力机制与AttnRes残差技术的协同优化

  4. 展示Together AI平台的API接入与基础设施配置方法

  5. 对比GPT-5.6和Claude Fable 5的基准测试结果

  6. 说明模型在编程和智能代理任务中的实际应用场景

思维导图

用一张图看清主题之间的关系。

查看大纲文本(无障碍 / 无 JS 友好)
  • Kimi K3技术解析
    • 架构创新
      • KDA长上下文处理
      • AttnRes深度优化
      • Stable LatentMoE专家调度
    • 部署方案
      • OpenAI兼容API
      • 自动前缀缓存
      • US基础设施
    • 性能指标
      • 2.8万亿参数
      • 1M上下文长度
      • 2%专家激活率

金句 / Highlights

值得收藏与分享的关键句。

#Kimi K3#开源模型#AI架构#Together AI
打开原文

Kimi K3:完整开发者指南

您将学到的内容

  • Kimi K3 是什么,它有何独特之处?
  • 深入解析底层技术:KDA、注意力残差和 Stable LatentMoE 架构
  • 如何使用推理努力度、流式传输、工具调用、视觉能力和 1M 上下文窗口?
  • 如何从首次 API 调用到生产环境部署?
  • Kimi K3 在编码和智能体基准测试中与前沿模型的对比表现
  • 在 Together AI 平台上 Kimi K3 的成本是多少?

Kimi K3 是 Moonshot AI 目前最强大的模型:拥有 2.8 万亿参数,也是全球首个开源的 3 万亿参数级模型。该模型专为前沿智能任务设计,包括长周期编码、端到端知识工作和深度推理。作为首个能与 GPT 5.6 Sol 和 Claude Fable 5 级别竞争的开源权重模型,Together AI 正在与 Moonshot 团队直接合作提供该模型服务。

目前发布的最大开源权重模型

Kimi 团队对模型扩展性有深入研究,成果显著:在 2025 年 7 月至 2026 年 7 月的 12 个月中,有 9 个月 Kimi 模型设定了开源模型规模的上限。如今,拥有 2.8 万亿参数的 K3 成为了有史以来发布的最大开源权重模型。

立即体验

在 Together AI 上运行 Kimi K3

完整 1M 上下文窗口、自动前缀缓存、OpenAI 兼容 API,服务来自美国基础设施。

进入体验区

底层技术解析

K3 的两大架构升级构成了其核心,均旨在提升信息在长序列和深层网络中的流动效率:

  • Kimi Delta Attention (KDA):一种混合线性注意力机制,为跨超长上下文扩展注意力提供了高效基础。这是首个支持 1M 上下文长度的 Kimi 模型。
  • 注意力残差(AttnRes):通过模型深度选择性检索表示,而非统一累积。

来源:Kimi K3

此外,Moonshot 通过 Stable LatentMoE 框架进一步推进了专家混合稀疏性,在 896 个专家中高效激活了 16 个。在这一稀疏级别,每个 token 约激活 2% 的专家,路由和优化成为首要挑战,因此多项支持技术实现了 2.8T 规模的稳定训练:

  • 分位数平衡:直接从路由器得分分位数推导专家分配,消除启发式更新和敏感平衡超参数。
  • 每头 Muon:将 Muon 优化器扩展为独立优化注意力头,实现更大规模的自适应学习。
  • Sigmoid Tanh 单元(SiTU):改进激活控制。
  • 门控 MLA:提升注意力选择性。

如何在 Together AI 上使用 Kimi K3

该 API 兼容 OpenAI。以下代码片段针对 Together AI,使用官方 Together Python SDK。

code
python3 -m pip install --upgrade 'together>=2.0.0'
code
import os
from together import Together

MODEL = "moonshotai/Kimi-K3"

client = Together(
    api_key=os.environ["TOGETHER_API_KEY"],
)

completion = client.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": "用一句话介绍 Kimi K3。"}],
    max_tokens=130_000,
)
print(completion.choices[0].message.content)

推理努力度

K3 可通过顶层 reasoning_effort 字段进行配置。支持三个级别:低、高和最大(默认为最大)。在 Together 平台上,还可通过标准 reasoning={"enabled": False} 开关关闭推理。

code
# 调整深度: "low" | "high" | "max"
completion = client.chat.completions.create(
    model=MODEL,
    reasoning_effort="max",
    messages=[{"role": "user", "content": "证明根号2是无理数。"}],
    max_tokens=8192,
)

# 即时模式,完全不计费思考令牌
fast = client.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": "法国的首都是哪里?"}],
    reasoning={"enabled": False},
    max_tokens=256,
)

流式传输

流式传输响应会分别提供 reasoning_content(思考轨迹)和最终答案内容增量。

code
stream = client.chat.completions.create(
    model=MODEL,
    messages=[{"role": "user", "content": "解释为什么天空是蓝色的。"}],
    max_tokens=4096,
    stream=True,
)

in_answer = False
for chunk in stream:
    if not chunk.choices:
        continue
    delta = chunk.choices[0].delta
    thinking = getattr(delta, "reasoning_content", None) or getattr(delta, "reasoning", None)
    if thinking:
        print(thinking, end="", flush=True)
    if delta.content:
        if not in_answer:
            print("\n--- answer ---")
            in_answer = True
        print(delta.content, end="", flush=True)

视觉输入

可以提供多张图片作为输入。Moonshot 还发布了视觉推理基准 Perception Bench。

code
import base64
from pathlib import Path

# 选项A:通过URL传递图片
IMAGE_URL = "https://raw.githubusercontent.com/pytorch/pytorch/main/docs/source/_static/img/pytorch-logo-dark.png"
image_content = {"type": "image_url", "image_url": {"url": IMAGE_URL}}

# 选项B:通过base64传递本地图片(取消注释以使用)
# image_data = base64.b64encode(Path("image.png").read_bytes()).decode()
# image_content = {"type": "image_url",
#                  "image_url": {"url": f"data:image/png;base64,{image_data}"}}

completion = client.chat.completions.create(
    model=MODEL,
    max_tokens=2048,
    messages=[{
        "role": "user",
        "content": [
            image_content,
            {"type": "text", "text": "描述这张图片。"},
        ],
    }],
)

视觉限制:

  • 图片数量无限制,但整个请求体必须小于100 MB。
  • 推荐最大值:图片分辨率为4K(4096x2160)。更高的分辨率会增加处理时间和令牌成本,但不会提升理解效果。
  • 令牌成本与分辨率成正比。

结构化输出

使用 response_format 配合 json_schema 和 strict: true 可以约束最终的 message.content。

code
import json

completion = client.chat.completions.create(
    model=MODEL,
    max_tokens=4096,
    messages=[{"role": "user", "content": "Ada Lovelace 36岁。"}],
    response_format={
        "type": "json_schema",
        "json_schema": {
            "name": "person",
            "strict": True,
            "schema": {
                "type": "object",
                "properties": {"name": {"type": "string"}, "age": {"type": "integer"}},
                "required": ["name", "age"],
                "additionalProperties": False,
            },
        },
    },
)

person = json.loads(completion.choices[0].message.content)
# -> {'name': 'Ada Lovelace', 'age': 36}
code

更宽松的 {"type": "json_object"} 模式在 Together 上也能正常工作,当你只需要语法正确的 JSON 时。无论采用哪种模式,请务必保持 max_tokens 设置得足够大:在发出第一个符合模式的 token 之前,整个思考过程都会被消耗,因此过紧的限制会导致 JSON 被截断而不是推理过程被限制。

### 工具和 tool_choice

K3 保留了标准的工具选择约束。标准流程:在 tools 中声明函数;当模型返回 tool_calls 时,将完整的助手消息追加到历史记录中,然后为每个调用追加一条带有匹配 tool_call_id 的工具消息,然后再次调用。在第一轮使用 tool_choice="required" 可强制至少一次工具调用,之后切换回 "auto"。更改 tool_choice 不会使前缀缓存失效。

import json

tools = [{ "type": "function", "function": { "name": "get_weather", "description": "获取城市的当前天气。", "parameters": { "type": "object", "properties": { "city": {"type": "string", "description": "城市名称,例如巴黎"}, "unit": {"type": "string", "enum": ["celsius", "fahrenheit"]}, }, "required": ["city"], "additionalProperties": False, }, }, }]

def get_weather(city, unit="celsius"): return {"city": city, "temperature": 21, "unit": unit, "conditions": "sunny"}

messages = [{"role": "user", "content": "巴黎的天气如何?"}] choice_mode = "required" # 强制第一轮调用工具

for _ in range(5): response = client.chat.completions.create( model=MODEL, messages=messages, tools=tools, tool_choice=choice_mode, max_tokens=8192, ) choice = response.choices[0] message = choice.message

追加完整的助手消息(包括思考过程)

messages.append(message.model_dump(exclude_none=True))

if choice.finish_reason != "tool_calls" or not message.tool_calls: print(message.content) break

for call in message.tool_calls: try: args = json.loads(call.function.arguments) except json.JSONDecodeError: args = {} messages.append({ "role": "tool", "tool_call_id": call.id, "content": json.dumps(get_weather(**args)), })

choice_mode = "auto" # 强制轮次结束后交还控制权

code

### 动态工具加载

你可以将完整的工具定义(包括全名、描述和参数)放入一个携带 tools 字段且没有内容的系统消息中。从该消息的位置开始,工具将变得可用。

关键规则:

- 动态声明使用与顶级 tools 字段完全相同的格式。

- 它们按请求应用,不会被服务器保留,因此需要自己在后续请求历史中保留该消息。保留消息可以同时保持工具可用性和缓存前缀;删除消息意味着模型将无法再调用该工具,且修改后的前缀可能无法命中缓存。

- 在消息末尾追加动态声明不会影响缓存前缀;删除或修改早期声明可能在修改点之后影响缓存命中率。

大型工具目录的推荐模式:

- 对话开始时:仅声明一个搜索工具函数(由你的后端实现)和几个核心工具,并在系统提示中宣传可搜索的领域标签。

- 首次调用:设置 tool_choice: "required" 以强制在回答前进行检索。

- 按需注入:根据检索结果,通过系统消息插入匹配工具的完整定义。

- 直接调用:模型在后续生成过程中直接使用已加载的工具。

- 成本权衡:在对话开始前决定 reasoning_effort 的值。

代码示例:

CATALOG = { "convert_currency": { "type": "function", "function": { "name": "convert_currency", "description": "将一种货币的金额转换为另一种货币。", "parameters": { "type": "object", "properties": { "amount": {"type": "number"}, "from_currency": {"type": "string"}, "to_currency": {"type": "string"}, }, "required": ["amount", "from_currency", "to_currency"], "additionalProperties": False, }, }, }, }

search_tools = { "type": "function", "function": { "name": "search_tools", "description": "搜索工具目录。标签:金融、旅行、文件。", "parameters": { "type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"], "additionalProperties": False, }, }, }

messages = [{"role": "user", "content": "将 100 美元转换为欧元。"}]

1. 在回答前强制检索

first = client.chat.completions.create( model=MODEL, messages=messages, tools=[search_tools], tool_choice="required", max_tokens=8192, ) call = first.choices[0].message.tool_calls[0] messages.append(first.choices[0].message.model_dump(exclude_none=True)) messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(list(CATALOG))})

2. 在末尾注入匹配定义。仅注入 tools 字段,不包含内容

messages.append({"role": "system", "tools": [CATALOG["convert_currency"]]})

3. 模型直接调用新加载的工具

second = client.chat.completions.create( model=MODEL, messages=messages, tools=[search_tools], tool_choice="auto", max_tokens=8192, ) print(second.choices[0].message.tool_calls)

-> convert_currency({"amount":100,"from_currency":"USD","to_currency":"EUR"})

code

### 1M 上下文与自动缓存

Together 支持完整的 1M 上下文长度,上下文缓存是自动进行的。保持长前缀(系统提示、知识库、仓库转储)在请求之间字节稳定,以便后续调用可以命中缓存。Moonshot 建议将固定的大块上下文(知识文档)放置在消息数组的最开始位置,位于系统消息之前,然后在该位置之后追加问题和回复。

def _get(obj, key, default=None): if obj is None: return default return obj.get(key, default) if isinstance(obj, dict) else getattr(obj, key, default)

usage = completion.usage reasoning_tokens = _get(_get(usage, "completion_tokens_details"), "reasoning_tokens", 0) cached_tokens = _get(_get(usage, "prompt_tokens_details"), "cached_tokens", _get(usage, "cached_tokens", 0))

print(f"prompt={usage.prompt_tokens} cached={cached_tokens} " f"completion={usage.completion_tokens} thinking={reasoning_tokens}")

-> prompt=86 cached=64 completion=133 thinking=111

code

### 采样参数

采样参数是固定的,请求中应省略这些参数。模型是使用这些参数进行训练的,不支持设置其他替代参数:

- temperature = 1.0
- top_p = 0.95
- n = 1
- presence_penalty = 0
- frequency_penalty = 0

### 保留思考过程

K3 是以保留思考历史模式进行训练的,因此跟踪信息是下一个回合依赖的状态。使用以下方式从上一回合保留思考令牌并传递给后续回合:

SECRET = "48213" TRACE = "For the session codeword I will use 48213. Committing to 48213 as the codeword."

messages = [ {"role": "user", "content": "Pick a 5-digit codeword for our session and remember it. " "Reply with exactly: OK"},

The trace rides along on the assistant turn. No flag needed.

{"role": "assistant", "content": "OK", "reasoning_content": TRACE}, {"role": "user", "content": "What codeword did you pick? Reply with just the number."}, ]

completion = client.chat.completions.create( model=MODEL, messages=messages, max_tokens=4000, chat_template_kwargs={"preserve_thinking": True} ) print(completion.choices[0].message.content) # -> 48213

code

删除 reasoning_content 行后,相同的调用每次都会返回一个不同的新生成数字。在实际代码中,你永远不会手动编写跟踪信息;而是重放模型生成的内容,即工具循环中的一行:

第一回合 - 让 K3 进行思考。

first = client.chat.completions.create( model=MODEL, messages=[{"role": "user", "content": "Pick a random 5-digit number and commit to it. " "Do not tell me. Reply with exactly: OK"}], max_tokens=4000, )

重放助手回合的完整内容。model_dump 会将 reasoning_content 与 content 一同保留。

history = [ {"role": "user", "content": "Pick a random 5-digit number and commit to it. " "Do not tell me. Reply with exactly: OK"}, first.choices[0].message.model_dump(exclude_none=True), {"role": "user", "content": "What number did you pick? Reply with just the number."}, ]

second = client.chat.completions.create(model=MODEL, messages=history, max_tokens=4000) print(second.choices[0].message.content)

code

## Kimi K3 定价

Kimi K3 按 token 计费,包含一个奖励稳定前缀的缓存命中输入层级:

Kimi K3 定价

层级 | 每百万 tokens 价格
--- | ---
输入(缓存命中) | $0.30
输入(缓存未命中) | $3.00
输出 | $15.00

上下文窗口:1,048,576 tokens(1M)。思考 token 按输出计费。

需要理解的两个成本方面:

- 缓存是你手中的杠杆。在编码工作负载中,如果保持前缀稳定,缓存命中率超过 90% 时,有效输入成本将趋于 $0.30 的下限。但若重构早期消息或工具声明,将破坏这一效果。

- 思考过程按输出计费且可调节。思考 token 以 $15/M 的价格计为输出 token,且无法完全禁用思考,但 reasoning_effort 现在有三个级别。max 仍是默认值,因此一个从不设置该字段的流水线会在每次调用(包括简单调用)中支付最大推理费用。

## Kimi K3 基准测试

在评估套件中,Kimi K3展现出前沿水平的性能。它在多个编码和智能体基准测试中(SWE Marathon、BrowseComp、DeepSearchQA、AutomationBench、OmniDocBench)领先行业,与其他基准测试中最强的专有模型保持竞争力,同时明显优于其他测试的开源模型GLM-5.2。在少数基准测试中,其表现略逊于Claude Fable 5和GPT 5.6 Sol,这与Moonshot对模型自身定位的描述一致。

以下所有Kimi K3结果均使用最大推理努力值。

Kimi K3基准测试

推理努力值:最大

基准测试

Kimi K3

max

Claude Fable 5

max,备用方案

GPT 5.6 Sol

Claude Opus 4.8

GLM-5.2

编码

DeepSWE

67.5

70.0

73.0

59.0

46.2

Program Bench

77.8

76.8

77.6

71.9

63.7

Terminal Bench 2.1

88.3

84.6

88.8

82.7

FrontierSWE

81.2

86.6

71.3

66.7

67.3

SWE Marathon

42.0

35.0

39.0

40.0

13.0

PostTrain Bench

36.6

41.4

34.6

34.1

34.3

MLS Bench

48.3

49.9

42.8

40.4

Kimi Code Bench 2.0(内部)

72.9

76.9

64.8

71.7

64.2

智能体

GDPval-AA v2(Elo)

1668

1760

1748

1600

1514

BrowseComp

91.2

88.0

90.4

84.3

N/A

DeepSearchQA(F1)

95.0

94.2

93.1

Toolathlon-Verified

73.2

77.9

74.9

76.2

59.9

MCP Atlas

84.2

84.7

83.6

82.6

Automation Bench

30.8

29.1

29.7

27.2

12.9

Job Bench

52.9

57.4

46.5

48.4

43.4

AA-Briefcase(Elo)

1548

1583

1495

1354

1260

APEX-Agents

41.0

43.3

39.9

39.4

35.6

Office QA Pro

63.3

69.9*

63.2*

63.9*

SpreadsheetBench 2

34.8

34.7*

32.4*

31.6*

28.1

DECK-Bench(内部)

73.5

74.7

66.9

68.6

推理与知识

GPQA-Diamond

93.5

92.6

94.1

91.0

HLE-Full

43.5

53.3

44.5

49.8*

HLE-Full w/ tools

56.0

63.0

58.0

57.9*

视觉

MMMU-Pro

81.6

83.0

78.9

MMMU-Pro w/ python

83.4

86.5

CharXiv(RQ)

84.8

88.9

80.5

CharXiv(RQ)w/ python

91.3

89.1

89.9

MathVision

94.3

94.8

95.8

86.7

MathVision w/ python

97.8

98.6

97.1

BabyVision w/ python

85.7

90.5

ZeroBench_main(pass@5)

23.0

17.0

ZeroBench_main w/ python(pass@5)

46.0

34.0

WorldVQA ForceAnswer

51.0

56.7

41.8

39.1

OmniDocBench

91.1

89.8

85.8

87.9

PerceptionBench

58.5

57.2

59.7

47.2

所有Kimi K3结果均使用最大推理努力值。标注星号(*)的数值是在与基准运行条件不同的情况下报告的——例如,引用自外部来源或不同测试框架。N/A表示未发布分数。阴影单元格标记该行的领先结果。有关每个基准测试的具体方法,请参阅原始报告。来源:Kimi K3。

## Kimi K3 与前沿模型的对比

汇总基准测试表格只能提供有限信息。为了深入了解成本、编码质量和路由行为,我们在DeepSWE上对Kimi K3与领先的专有模型进行了对比:

- Kimi K3 与 GPT 5.6 Sol 在 DeepSWE 上的对比:成本、编码和路由
- Kimi K3 与 Claude Fable 5 在 DeepSWE 上的对比:成本和编码

## 常见问题

Kimi K3 是什么?Kimi K3 是 Moonshot AI 的旗舰 2.8 万亿参数模型,也是首个 3 万亿参数级别的开源模型,专为长周期编码、知识工作和推理而设计。

### Kimi K3 是开源的吗?

是的。它作为开源权重模型发布,Together AI 直接与 Moonshot 团队合作提供服务。

### Kimi K3 的上下文窗口有多大?

100万 tokens(1,048,576),在 Together AI 上完全支持并附带自动上下文缓存。

### 在 Together AI 上使用 Kimi K3 的成本是多少?

每100万次缓存命中输入令牌0.30美元,每100万次缓存未命中输入令牌3.00美元,每100万次输出令牌15.00美元。

### 能否在Kimi K3上关闭思考功能?

在Together AI平台上,可以通过设置reasoning={"enabled": False}来禁用思考功能,或通过将reasoning_effort参数设为low、high或max来调整推理深度。

### Kimi K3是否支持视觉功能?

支持。Kimi K3具备原生视觉能力,单次请求可接受多张图片,只要总请求体不超过100 MB。

## Kimi K3现已上线Together AI。立即运行并部署到生产环境。

将K3纳入你的系统只需一次API调用即可。

- 运行Kimi K3推理:[Kimi K3 API on Together AI](https://example.com)
- 开始使用API开发:[阅读文档](https://example.com/docs)