MoreRSS

site iconLixueduan | 李学端修改

博客 编程
博客名：指月小筑。专注云原生，Go，坚持分享最佳实践、经验干货。
RSS: https://www.lixueduan.com/index.xml
请复制 RSS 到你的阅读器，或快速订阅到 :

Inoreader Feedly Follow Feedbin Local Reader

Lixueduan | 李学端的 RSS 预览

月之暗面最强模型 Kimi-K2.6 正式开源 —— 附 vLLM 部署实战

2026-04-23 04:00:00

deploy-kimi-k2.6-by-vllm.jpeg

Kimi-K2.6 是 Moonshot AI 在 4 月 20 日正式发布并开源的旗舰大语言模型，具备强大的长上下文推理、多模态理解和工具调用能力。本文将详细介绍如何使用 vLLM 部署 Kimi-K2.6 模型，并附上性能基准测试。

1. 模型速览

根据各大榜单排名以及实测表现，Kimi-K2.6 在多项评测中表现出色，是当前开源模型中的佼佼者。

在 Artificial Analysis Intelligence Index 中得分如下： kimi-k2.6-rank.png

详细专项能力测评： kimi-k2.6-bench.jpeg

Arena AI Code Arena-WebDev 得分如下： kimi-k2.6-arena.jpeg

从榜单数据来看，Kimi-K2.6 和 GLM-5.1 各有千秋，二者也都基本达到了 Claude Opus 4.6 的水平。

2. 测试环境

本文所有测试均在以下环境完成：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

+-----------------------------------------------------------------------------------------+
| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |
|=========================================+========================+======================|
| 0 NVIDIA GB200 On | 00000008:01:00.0 Off | 0 |
| N/A 42C P0 395W / 1200W | 175750MiB / 189471MiB | 0% Default |
+-----------------------------------------+------------------------+----------------------+
| 1 NVIDIA GB200 On | 00000009:01:00.0 Off | 0 |
| N/A 42C P0 369W / 1200W | 175366MiB / 189471MiB | 0% Default |
+-----------------------------------------+------------------------+----------------------+
| 2 NVIDIA GB200 On | 00000018:01:00.0 Off | 0 |
| N/A 41C P0 354W / 1200W | 175366MiB / 189471MiB | 0% Default |
+-----------------------------------------+------------------------+----------------------+
| 3 NVIDIA GB200 On | 00000019:01:00.0 Off | 0 |
| N/A 42C P0 375W / 1200W | 179133MiB / 189471MiB | 0% Default |
+-----------------------------------------+------------------------+----------------------+

3. 模型下载

3.1 安装 HuggingFace CLI

首先安装 HuggingFace CLI 工具用于下载模型：

1

curl -LsSf https://hf.co/cli/install.sh | bash

3.2 下载模型

Kimi-K2.6 原生提供 Int4 精度版本，模型权重约需 595 GB 显存，加上推理时的 KV Cache，官方推荐最低显存为 714 GB。

H100 80G × 8 也能跑起来，但由于总显存只有 640 GB，余量较紧，上下文长度会受到一定限制。

1
2
3
4
5

# --local-dir 指定下载目录
hf download moonshotai/Kimi-K2.6 --local-dir /raid/lixd/models/kimi-k2.6

# 下载 EAGLE-3 投机解码模型
hf download lightseekorg/kimi-k2.6-eagle3 --local-dir /raid/lixd/models/kimi-k2.6-eagle3

4. vLLM 部署

4.1 Kubernetes 部署

由于单机多卡即可运行，因此在 Kubernetes 中可以直接使用 Deployment 进行部署：

使用 vllm/vllm-openai:v0.19.1-cu130 镜像即可

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

apiVersion: resource.k8s.io/v1
kind: ResourceClaimTemplate
metadata:
 name: kimi-k26-gpu-claim
 namespace: default
spec:
 spec:
 devices:
 requests:
 - name: gpu
 exactly:
 deviceClassName: gpu.nvidia.com # 匹配前面的 DeviceClass
 allocationMode: ExactCount
 count: 4 # 数量
---
apiVersion: apps/v1
kind: Deployment
metadata:
 name: kimi-k26
 namespace: default
spec:
 replicas: 1
 selector:
 matchLabels:
 app: kimi-k26
 template:
 metadata:
 labels:
 app: kimi-k26
 spec:
 containers:
 - name: vllm-server
 image: vllm/vllm-openai:v0.19.1-cu130
 command: ["/bin/bash"]
 args:
 - "-c"
 - |
 vllm serve /app/model \
 --tensor-parallel-size 4 \
 --tool-call-parser kimi_k2 \
 --reasoning-parser kimi_k2 \
 --enable-auto-tool-choice \
 --served-model-name Kimi-K2.6 \
 --trust-remote-code \
 --gpu-memory-utilization 0.90 \
 --attention-config.use_trtllm_ragged_deepseek_prefill=True \
 --speculative-config '{"model":"/app/eagle-model","method":"eagle3","num_speculative_tokens":3}' \
 --host 0.0.0.0 \
 --port 8000
 resources:
 claims:
 - name: gpu
 limits:
 memory: "256Gi"
 cpu: "32"
 requests:
 memory: "128Gi"
 cpu: "16"
 ports:
 - containerPort: 8000
 name: http
 volumeMounts:
 - name: model-storage
 mountPath: /app/model
 readOnly: true
 - name: eagle-model-storage
 mountPath: /app/eagle-model
 readOnly: true
 resourceClaims:
 - name: gpu
 resourceClaimTemplateName: kimi-k26-gpu-claim
 volumes:
 - name: model-storage
 hostPath:
 path: /raid/lixd/models/kimi-k2.6
 type: Directory
 - name: eagle-model-storage
 hostPath:
 path: /raid/lixd/models/kimi-k2.6-eagle3
 type: Directory
---
apiVersion: v1
kind: Service
metadata:
 name: kimi-k26
 namespace: default
spec:
 selector:
 app: kimi-k26
 ports:
 - port: 8000
 targetPort: 8000
 nodePort: 30180
 type: NodePort

部署要点：

  • 使用 ResourceClaimTemplate 声明 4 块 GPU，由 DRA 调度器自动分配
  • 主模型和 EAGLE-3 投机解码模型分别通过 hostPath 挂载到 /app/model 和 /app/eagle-model
  • Service 使用 NodePort 暴露，外部可通过节点 IP + 30180 访问

4.2 关键参数说明

参数 说明
--tensor-parallel-size 张量并行数，通常等于 GPU 数量
--attention-config.use_trtllm_ragged_deepseek_prefill 启用 TRT-LLM 优化的不规则 prefill，加速长上下文处理
--tool-call-parser kimi_k2 使用 Kimi-K2.6 工具调用解析器
--reasoning-parser kimi_k2 启用 Kimi-K2.6 推理能力解析
--enable-auto-tool-choice 启用自动工具选择
--trust-remote-code 信任模型中的远程代码
--gpu-memory-utilization GPU 显存利用率，建议 0.85–0.95
--speculative-config 启用 EAGLE-3 投机解码（测试显示当前版本效果不佳，接受率仅 1.28%）

5. 服务验证

5.1 基础验证

部署完成后，验证服务是否正常运行：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# 查看可用模型列表
curl http://10.108.198.155:8000/v1/models

# 基础对话测试
curl http://10.108.198.155:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "Kimi-K2.6",
 "messages": [
 {"role": "user", "content": "你好，请介绍一下你自己"}
 ],
 "max_tokens": 100,
 "temperature": 0.7
 }'

5.2 思考模式控制

Kimi-K2.6 支持开启/关闭思考模式，通过 chat_template_kwargs 参数控制。

1

"chat_template_kwargs": {"thinking": false}

开启思考模式（默认）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

curl http://10.108.198.155:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "Kimi-K2.6",
 "messages": [
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "Summarize Kimi-K2.6 in one sentence."}
 ],
 "temperature": 1,
 "max_tokens": 4096
 }'

关闭思考模式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

curl http://10.108.198.155:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "Kimi-K2.6",
 "messages": [
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "Summarize Kimi-K2.6 in one sentence."}
 ],
 "temperature": 1,
 "max_tokens": 4096,
 "chat_template_kwargs": {"thinking": false}
 }'

5.3 多模态推理

Kimi-K2.6 支持视觉-语言多模态输入：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

curl http://10.108.198.155:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d ' {
 "model": "Kimi-K2.6",
 "messages": [
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": [
 {"type": "text", "text": "请描述这张图片的内容，并提取其中的关键信息。"},
 {"type": "image_url", "image_url": {"url": "https://ofasys-multimodal-wlcb-3-toshanghai.oss-accelerate.aliyuncs.com/wpf272043/keepme/image/receipt.png"}}
 ]}
 ],
 "temperature": 1,
 "max_tokens": 4096
 } '

6. 性能基准测试

6.1 测试方法

使用 vLLM 内置的 benchmark 工具进行测试：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Prompt-heavy benchmark (8k input / 1k output)
vllm bench serve \
 --model /app/model \
 --served_model_name Kimi-K2.6 \
 --dataset-name random \
 --random-input 8000 \
 --random-output 1024 \
 --request-rate 10 \
 --num-prompts 32 \
 --trust-remote-code \
 --ignore-eos

6.2 测试结果 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

tip: install termplotlib and gnuplot to plot the metrics
============ Serving Benchmark Result ============
Successful requests: 32
Failed requests: 0
Request rate configured (RPS): 10.00
Benchmark duration (s): 27.73
Total input tokens: 256000
Total generated tokens: 32768
Request throughput (req/s): 1.15
Output token throughput (tok/s): 1181.84
Peak output token throughput (tok/s): 1376.00
Peak concurrent requests: 32.00
Total token throughput (tok/s): 10414.96
---------------Time to First Token----------------
Mean TTFT (ms): 162.09
Median TTFT (ms): 142.44
P99 TTFT (ms): 296.55
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms): 24.35
Median TPOT (ms): 24.46
P99 TPOT (ms): 24.62
---------------Inter-token Latency----------------
Mean ITL (ms): 24.35
Median ITL (ms): 24.33
P99 ITL (ms): 50.53
==================================================

关键指标解读：

指标 含义 测试结果
TTFT Time To First Token，首 token 延迟 平均 162 ms
TPOT Time Per Output Token，每个 token 的生成时间 平均 24.4 ms
吞吐量 Output token throughput 1182 tok/s

6.3 开启推测解码的测试

在 vLLM 启动参数中添加 --speculative-config 启用 EAGLE-3 投机解码：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

vllm serve /app/model \
 --tensor-parallel-size 4 \
 --tool-call-parser kimi_k2 \
 --reasoning-parser kimi_k2 \
 --enable-auto-tool-choice \
 --served-model-name Kimi-K2.6 \
 --trust-remote-code \
 --gpu-memory-utilization 0.90 \
 --attention-config.use_trtllm_ragged_deepseek_prefill=True \
 --speculative-config '{"model":"/app/eagle-model","method":"eagle3","num_speculative_tokens":3}' \
 --host 0.0.0.0 \
 --port 8000

在此配置下再次运行基准测试：

测试结果：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

============ Serving Benchmark Result ============
Successful requests: 32
Failed requests: 0
Request throughput (req/s): 0.62
Output token throughput (tok/s): 631.18
Peak output token throughput (tok/s): 672.00
---------------Time to First Token----------------
Mean TTFT (ms): 206.96
Median TTFT (ms): 197.77
P99 TTFT (ms): 315.71
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms): 46.52
Median TPOT (ms): 48.22
P99 TPOT (ms): 48.52
---------------Speculative Decoding---------------
Acceptance rate (%): 1.28
Acceptance length: 1.04
Drafts: 31529
Draft tokens: 94587
Accepted tokens: 1212
==================================================

结果分析：

开启推测解码后，性能反而下降约 46%（吞吐量从 1182 tok/s 降至 631 tok/s）。根本原因是 EAGLE-3 投机模型的接受率仅 1.28%，远低于有效阈值（通常需要 60%+ 才有正收益）。

过低的接受率直接导致：

  1. 无效验证开销过大：94K+ 的 draft tokens 中只有 1.2K 被接受，大量 rejected drafts 的验证计算成为纯开销
  2. TPOT 翻倍：平均 TPOT 从 24.4 ms 增至 46.5 ms，每个 token 的生成时间被验证过程拉长

ps：本次测试开启推测解码后产生负收益，推测是当前 EAGLE-3 模型与 Kimi-K2.6 的适配参数或配置方式存在问题（1.28% 的接受率明显异常）。在官方给出更明确的配置指引前，不建议开启 推测解码功能。

7. 小结

Kimi-K2.6 是一个综合能力非常强的开源模型，长上下文、多模态、工具调用、推理能力都具备，部署起来也不算复杂，单机多卡就能跑。

对于编码任务来说，模型选择也比较简单：

  • 对于纯代码生成任务，Claude 仍表现最佳；
  • 若工作流需要频繁处理截图或 UI 视觉信息，Kimi-K2.6 的原生多模态能力是更自然的选择；
  • 而 GLM-5.1 在后端复杂逻辑推理上稍有优势。

从榜单数据来看，Kimi-K2.6 和 GLM-5.1 各有千秋，二者也都基本达到了 Claude Opus 4.6 的水平。 当然，各家发布时都喜欢标榜「超越 Claude」，但真落到实际使用上，Claude 的体感依旧是目前最稳的——不过最近网上关于 Claude “降智” 的吐槽也不少。

最后再扯一句题外话。从 GLM-5 到 GLM-5.1 再到这次的 Kimi-K2.6，国产大模型的迭代速度确实肉眼可见。虽然跟 OpenAI、Anthropic、Google 这”御三家”比，整体差距还在，但也算是”能够干活”了。

哦对，DeepSeek V4 什么时候发？（手动狗头）

搭建你的 AI 模型服务平台：这个开源项目帮你搞定聚合、计费、运营

2026-04-16 04:00:00

new-api.png

你是否遇到过这样的困扰：手头有 OpenAI、Claude、本地部署的多个 AI 模型：

  • 每个都要单独管理 API Key；
  • 团队成员都在用，却无法追踪谁用了多少、花了多少钱；
  • 想把这些能力开放给外部用户并收费，却苦于没有现成的计费系统？

New API 就是来解决这些问题的。

New API 是什么？

Next-Generation LLM Gateway and AI Asset Management System

New API 是新一代 AI 基座平台，为您的 AI 应用提供统一的基础设施。承载所有 AI 应用，管理您的数字资产，连接未来的统一接口平台。

核心特性：

  • 统一接口：一个 API 端点接入所有 AI 服务，兼容 OpenAI 标准格式
  • 智能路由：多渠道负载均衡、故障自动切换、加权随机分发
  • 精细计费：支持按次数/按量计费、预付费充值、多倍率配置
  • 安全管控：令牌权限管理、模型访问控制、API 调用审计
  • 数据洞察：实时数据看板、用量统计、成本分析
  • 多租户架构：完美适配个人开发者、团队协作与企业级部署

技术架构：

technical-architecture.svg

New API vs LiteLLM

上一篇文章 LiteLLM：打造统一 AI 网关 介绍了 LiteLLM——一个轻量的多模型聚合网关，可以通过统一的 API 接口调用 OpenAI、Claude、Gemini 等各种模型，还提供了 SDK，非常适合在 Python 项目中直接集成使用。

两者都是优秀的多模型聚合网关，但定位不同：

特性 New API LiteLLM
定位 企业级 AI 平台 开发者工具
用户管理 ✅ 完整的用户体系 ❌ 无
计费系统 ✅ 内置支付和计费 ⚠️ 仅成本追踪
权限控制 ✅ 令牌分组、模型限制 ⚠️ 基础权限
可视化界面 ✅ 完整管理后台 ✅ 使用监控
SDK 集成 ❌ 无 ✅ Python SDK
适用场景 对外提供 AI 服务 代码内集成调用

选择建议：

  • 需要搭建企业级 AI 平台、对外提供服务 → New API
  • Python 项目内集成多模型调用 → LiteLLM

1. 部署

1.1 使用 Docker Compose（推荐） 

1
2
3
4
5
6
7
8
9

# 克隆项目
git clone https://github.com/QuantumNous/new-api.git
cd new-api

# 编辑 docker-compose.yml 配置
nano docker-compose.yml

# 启动服务
docker-compose up -d

1.2 使用 Docker 命令

使用 SQLite（默认）：

1
2
3
4
5

docker run --name new-api -d --restart always \
 -p 3000:3000 \
 -e TZ=Asia/Shanghai \
 -v ./data:/data \
 calciumion/new-api:latest

使用 MySQL：

1
2
3
4
5
6

docker run --name new-api -d --restart always \
 -p 3000:3000 \
 -e SQL_DSN="root:123456@tcp(localhost:3306)/newapi" \
 -e TZ=Asia/Shanghai \
 -v ./data:/data \
 calciumion/new-api:latest

1.3 常用环境变量

变量名 说明 默认值
SESSION_SECRET 会话密钥（多机部署必填） -
SQL_DSN 数据库连接字符串 SQLite
REDIS_CONN_STRING Redis 连接字符串 -
STREAMING_TIMEOUT 流式超时时间（秒） 300

2. 初始化配置

2.1 初始化管理员账号

浏览器访问 http://ip:3000/ 进入界面，首次访问需要初始化管理员账号。

init.png

设置完成后使用管理员账号登录。

2.2 渠道管理

渠道是 New API 与上游模型服务的连接配置。

channel.png

添加渠道：

在「渠道管理」页面添加新的渠道：

  • 类型：选择模型提供商（如 OpenAI、Azure、自定义等）
  • 名称：渠道标识
  • Base URL：API 地址（如 vLLM 的地址）
  • 密钥：API Key
  • 模型：支持的模型列表

例如添加本地 vLLM 部署的 GLM-5：

  • 类型：自定义
  • Base URL：http://vllm-server:8000/v1
  • 密钥：your-api-key
  • 模型：glm-5

模型映射：

可以为模型设置别名，方便统一管理：

1
2
3

实际模型名 -> 显示名称
glm-5 -> GLM-5.1
qwen2.5 -> Qwen3.5

2.3 模型管理与价格设置

model.png

模型配置：

如果使用自定义模型，需要在「模型管理」中配置：

  • 模型名称
  • 计费方式（按 Token 计费）
  • 输入价格（每 1M Token）
  • 输出价格（每 1M Token）

价格设置示例：

price.png

模型 输入价格 输出价格
GLM-5.1 $1.00/1M $4.00/1M
Qwen3.5 $0.50/1M $2.00/1M

2.4 令牌管理

令牌是用户调用 API 的凭证。

token.png

创建令牌：

在「令牌管理」页面创建令牌：

  • 名称：令牌标识
  • 额度：设置使用额度
  • 过期时间：可选
  • 模型权限：限制可访问的模型

创建后会生成一个 API Key，格式如：sk-xxxxxxxxxxxx

令牌权限控制：

可以为令牌设置：

  • 额度限制
  • 模型白名单
  • 有效期
  • 分组归属

3. 使用 API

usage.png

3.1 获取接入信息

在首页可以看到：

  • API 地址：http://your-domain:3000
  • 令牌：之前创建的 API Key
  • 可用模型列表

3.2 调用示例 

1
2
3
4
5
6
7
8

curl -X POST http://your-domain:3000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -H "Authorization: Bearer sk-xxxxxxxxxxxx" \
 -d '{
 "model": "glm-5",
 "messages": [{"role": "user", "content": "你好"}],
 "temperature": 0.7
 }'

3.3 Python 示例 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

from openai import OpenAI

client = OpenAI(
 api_key="sk-xxxxxxxxxxxx",
 base_url="http://your-domain:3000/v1"
)

response = client.chat.completions.create(
 model="glm-5",
 messages=[{"role": "user", "content": "你好"}]
)
print(response.choices[0].message.content)

4. 小结

本文介绍了 New API 的部署和基本使用：

功能 说明
一键部署 Docker/Docker Compose 快速启动
多模型聚合 支持 OpenAI、Claude、Gemini 等格式
用户管理 多用户、令牌分组、权限控制
计费系统 在线充值、按量计费、价格策略
可视化管理 完整的 Web 管理后台

New API 适合场景：

  • 企业内部 AI 平台
  • 对外提供 AI 服务
  • 需要多用户管理和计费

New API vs LiteLLM 选型指南：

场景 推荐 原因
对外提供 AI 服务、需要收费 New API 内置用户管理、计费系统
企业内部多用户使用 New API 权限控制、用量统计完善
Python 项目内集成多模型 LiteLLM Python SDK，代码级调用
个人开发测试 LiteLLM 轻量、配置简单

相关文章：

LiteLLM：打造统一 AI 网关

2026-04-08 04:00:00

litellm-ai-gateway.png

为什么需要 LiteLLM？

当你在使用多个 AI 模型时，会遇到这些问题：

  • 每个 Provider 的 API 格式不同，需要维护多套代码
  • 无法统一监控所有模型的调用情况和成本
  • 切换模型需要修改业务代码

LiteLLM 通过统一的 OpenAI 兼容接口解决了这些问题，让你只需修改 model 参数就能切换模型。

核心功能：

  • 统一接口：一套 API 调用 OpenAI、Azure、Anthropic、Google 等多家模型
  • 成本追踪：实时监控各模型的使用量和成本
  • 负载均衡：自动在多个模型间分配请求
  • 速率限制：防止 API 滥用和成本失控

LiteLLM 作为统一网关，接收所有客户端请求，然后根据 model 参数自动路由到对应的后端模型服务。无论是本地部署的 vLLM，还是云端 API（OpenAI、Claude 等），都可以通过同一套接口调用。

本文将介绍如何在 Kubernetes 环境中部署 LiteLLM，并配置 PostgreSQL 作为数据库。

部署完成后，你可以像这样统一调用不同的模型：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# 请求 GLM-5 模型
curl -X POST http://example.com:8080/v1/chat/completions \
 -H "Content-Type: application/json" \
 -H "Authorization: Bearer xxx" \
 -d '{
 "model": "glm5",
 "messages": [{"role": "user", "content": "hello"}],
 "temperature": 0.1,
 "max_tokens": 100
 }'

# 请求 Qwen3.5 模型
curl -X POST http://example.com:8080/v1/chat/completions \
 -H "Content-Type: application/json" \
 -H "Authorization: Bearer xxx" \
 -d '{
 "model": "qwen3.5",
 "messages": [{"role": "user", "content": "hello"}],
 "temperature": 0.1,
 "max_tokens": 100
 }'

0. 安全警告：供应链投毒事件

⚠️ 重要安全提醒

ps：主要影响 PyPI 包，如果是 Docker Image 则不受影响。

如果你的环境中有 LiteLLM，请立即检查版本：

1

pip show litellm
  • 1.82.7 / 1.82.8 存在安全问题，可能导致凭证泄露

如果你不幸安装了 1.82.7 或 1.82.8，请假设所有凭证已泄露，立即：

  1. 切换到安全版本
  2. 轮换所有相关 API 密钥和凭证

详细信息请参考官方安全公告：LiteLLM Security Update - March 2026 Github Issue： https://github.com/BerriAI/litellm/issues/24518

1. 部署 PostgreSQL

1.1 部署 LocalPathStorage

PostgreSQL 需要 StorageClass，使用 LocalPathStorage：

1

kubectl apply -f https://raw.githubusercontent.com/rancher/local-path-provisioner/v0.0.35/deploy/local-path-storage.yaml

查看部署状态：

1
2
3
4
5
6
7

$ kubectl -n local-path-storage get po
NAME READY STATUS RESTARTS AGE
local-path-provisioner-567b5f79b9-j2tcw 1/1 Running 0 27m

$ kubectl get sc
NAME PROVISIONER RECLAIMPOLICY VOLUMEBINDINGMODE ALLOWVOLUMEEXPANSION AGE
local-path rancher.io/local-path Delete WaitForFirstConsumer false

1.2 部署 PostgreSQL

使用 Bitnami PostgreSQL Helm Chart 部署：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

REGISTRY_NAME=registry-1.docker.io
REPOSITORY_NAME=bitnamicharts
storageClass="local-path"
# user 为 postgres
adminPassword="Thinkbig1"

helm install pgsql oci://$REGISTRY_NAME/$REPOSITORY_NAME/postgresql \
 --set global.storageClass=$storageClass \
 --set global.postgresql.auth.postgresPassword=$adminPassword \
 --set global.postgresql.auth.database=litellm \
 --namespace litellm --create-namespace

查看部署状态：

1
2
3

$ kubectl -n litellm get po
NAME READY STATUS RESTARTS AGE
pgsql-postgresql-0 1/1 Running 0 2m57s

OK，准备工作完成，接下来可以开始部署 LiteLLM 了。

2. 部署 LiteLLM

2.1 配置文件

官方文档：入门指南 - 端到端教程 | liteLLM中文文档

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

# configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
 name: litellm-config
 namespace: litellm
data:
 config.yaml: |
 model_list:
 # GLM-5 模型（本地 vLLM 部署）
 - model_name: glm5
 litellm_params:
 model: openai/glm5
 api_base: http://1.1.1.1:8000/v1
 api_key: "xxx"

 # Qwen3.5 模型（本地 vLLM 部署）
 - model_name: qwen3.5
 litellm_params:
 model: openai/qwen3.5
 api_base: http://2.2.2.2:8000/v1
 api_key: "xxx"

 general_settings:
 master_key: "sk-xxx"
 database_url: "postgresql://postgres:Thinkbig1@pgsql-postgresql:5432/litellm"
 store_model_in_db: true

2.2 Deployment 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

apiVersion: apps/v1
kind: Deployment
metadata:
 name: litellm-proxy
 namespace: litellm
spec:
 replicas: 1
 selector:
 matchLabels:
 app: litellm
 template:
 metadata:
 labels:
 app: litellm
 spec:
 containers:
 - name: litellm-container
 image: ghcr.io/berriai/litellm:v1.82.3-stable
 imagePullPolicy: Always
 args:
 - "--config"
 - "/app/config.yaml"
 - "--port"
 - "4000"
 volumeMounts:
 - name: config-volume
 mountPath: /app/config.yaml
 subPath: config.yaml
 livenessProbe:
 httpGet:
 path: /health/liveliness
 port: 4000
 initialDelaySeconds: 120
 periodSeconds: 15
 successThreshold: 1
 failureThreshold: 3
 timeoutSeconds: 10
 readinessProbe:
 httpGet:
 path: /health/readiness
 port: 4000
 initialDelaySeconds: 120
 periodSeconds: 15
 successThreshold: 1
 failureThreshold: 3
 timeoutSeconds: 10
 volumes:
 - name: config-volume
 configMap:
 name: litellm-config
---
apiVersion: v1
kind: Service
metadata:
 name: litellm
 namespace: litellm
spec:
 selector:
 app: litellm
 ports:
 - port: 4000
 targetPort: 4000
 type: ClusterIP

查看 Pod 状态：

1
2
3
4

kubectl -n litellm get po
# NAME READY STATUS RESTARTS AGE
# litellm-proxy-744c98f4f4-2b6ll 1/1 Running 0 6m15s
# pgsql-postgresql-0 1/1 Running 0 63m

3. 验证

3.1 查看模型列表

LiteLLM 对外提供 OpenAI API 格式的端点，会根据 model 自动路由到不同的后端 Provider 上：

1
2

curl http://10.104.161.89:4000/v1/models \
 -H "Authorization: Bearer sk-xxx"

3.2 请求具体模型 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# 请求 glm5
curl http://3.3.3.3:4000/v1/chat/completions \
 -H "Authorization: Bearer sk-xxx" \
 -H "Content-Type: application/json" \
 -d '{
 "model": "glm5",
 "messages": [{"role": "user", "content": "你好，请介绍一下你自己"}]
 }'

# 请求 qwen3.5
curl http://3.3.3.3:4000/v1/chat/completions \
 -H "Authorization: Bearer sk-xxx" \
 -H "Content-Type: application/json" \
 -d '{
 "model": "qwen3.5",
 "messages": [{"role": "user", "content": "你好，请介绍一下你自己"}]
 }'

3.3 访问 UI

服务启动后，访问 4000 端口，进入 LiteLLM UI 界面：

1

http://3.3.3.3:4000/ui

账号 admin，密码为配置文件中指定的 MASTER_KEY：

litellm-login.png

登录后，跳转到界面上 Usage 页面可以看到不同模型的具体的使用情况：

litellm-usage.png

以及具体请求：

litellm-logs.png

4. 小结

本文详细介绍了 LiteLLM AI Gateway 的 Kubernetes 部署：

  • 供应链投毒事件：注意版本安全，避免使用存在问题的版本
  • 完整部署：从 LocalPathStorage 到 PostgreSQL 再到 LiteLLM 的完整流程
  • 统一管理：通过 LiteLLM 统一管理本地 vLLM 部署的多个模型

LiteLLM 的核心价值：

功能 说明
一行代码切换模型 只需修改 model 参数，无需改业务代码
可视化监控 Web UI 实时查看调用次数、Token 消耗、成本统计
多模型负载均衡 自动在多个模型实例间分配请求
OpenAI 兼容 无缝对接现有使用 OpenAI API 的应用

如果你已经在使用 vLLM 部署本地模型，可以参考我的其他文章：

Qwen3.5 选型 + vLLM 部署实战：从 0.8B 到 397B，哪款最适合你？

2026-03-31 04:00:00

deploy-qwen3.5-by-vllm.jpeg

Qwen3.5 是阿里云最新开源的大语言模型系列，提供了从 0.8B 到 397B 的多种规格，在推理能力和效率之间取得了良好平衡。

面对如此丰富的模型规格，该如何选择？本文将首先分析各规格模型的特点和适用场景，帮助你找到最适合的那一款，然后介绍如何使用 vLLM 在 Kubernetes 环境中部署 Qwen3.5 模型。

根据各大榜单排名以及实测表现，Qwen3.5 系列在性能和质量的权衡上表现出色。

qwen35-rank.png

1. 测试环境

本文所有测试均在以下环境完成：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

+-----------------------------------------------------------------------------------------+
| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |
|=========================================+========================+======================|
| 0 NVIDIA GB200 On | 00000008:01:00.0 Off | 0 |
| N/A 42C P0 395W / 1200W | 175750MiB / 189471MiB | 0% Default |
+-----------------------------------------+------------------------+----------------------+
| 1 NVIDIA GB200 On | 00000009:01:00.0 Off | 0 |
| N/A 42C P0 369W / 1200W | 175366MiB / 189471MiB | 0% Default |
+-----------------------------------------+------------------------+----------------------+
| 2 NVIDIA GB200 On | 00000018:01:00.0 Off | 0 |
| N/A 41C P0 354W / 1200W | 175366MiB / 189471MiB | 0% Default |
+-----------------------------------------+------------------------+----------------------+
| 3 NVIDIA GB200 On | 00000019:01:00.0 Off | 0 |
| N/A 42C P0 375W / 1200W | 179133MiB / 189471MiB | 0% Default |
+-----------------------------------------+------------------------+----------------------+

2. 模型选择

Qwen3.5 已形成从 0.8B 到 397B 的完整开源矩阵，分为三大梯队：

系列 模型 特点
轻量稠密系列 0.8B / 2B / 4B / 9B / 27B 全参数激活，部署简单，适合个人/边缘场景
中型 MoE 系列 35B-A3B / 122B-A10B 激活参数小，速度快成本低，适合企业级服务
旗舰 MoE 系列 397B-A17B 开源旗舰，全场景最强，对标闭源第一梯队

所有模型均支持视觉-语言多模态输入，原生上下文长度 256K tokens，最高可扩展至 1M tokens。

根据官方测评数据，比较推荐下面 4 个规格：

模型 激活参数 综合能力 代码能力 Agent 能力 中文能力
Qwen3.5-27B 27B 88.5 HumanEval 89.1 BFC-Lv4 48.5% 90.5
Qwen3.5-35B-A3B 3B 89.7 HumanEval 87.9 BFC-Lv4 52.3% -
Qwen3.5-122B-A10B 10B 90.8 HumanEval 88.7 BFC-Lv4 50.7% 91.7
Qwen3.5-397B-A17B 17B 91.5 HumanEval 89.3 BFC-Lv4 49.8% 92.3

选型建议：

  • Qwen3.5-27B：稠密架构最强，代码能力出色（HumanEval≈89.1，稠密代码第一），部署简单，适合代码/工程场景
  • Qwen3.5-35B-A3B：Agent/深度推理最强（BFC-Lv4≈52.3%，全系列最高），激活仅 3B，性价比极高
  • Qwen3.5-122B-A10B：接近旗舰性能，知识密集/多模态/视频场景优选，成本比旗舰低 40%
  • Qwen3.5-397B-A17B：开源旗舰，综合能力开源第一（对标 GPT-5.2），中文能力最强（92.3），支持 1M 上下文无损，适合企业级基座

3. 模型下载

3.1 安装 HuggingFace CLI

首先安装 HuggingFace CLI 工具用于下载模型：

1

curl -LsSf https://hf.co/cli/install.sh | bash

常见问题：安装失败

如果遇到 No module named pip 错误，通常是因为虚拟环境损坏：

1
2
3
4
5

# 删除损坏的虚拟环境
rm -rf /root/.hf-cli/venv

# 重新安装
curl -LsSf https://hf.co/cli/install.sh | bash

3.2 下载模型

Qwen3.5 提供多种规格和精度版本，根据你的硬件配置选择：

1
2

# INT4 版本（推荐：显存占用低）
hf download Qwen/Qwen3.5-397B-A17B-GPTQ-Int4 --local-dir /raid/lixd/models/Qwen/Qwen3.5-397B-A17B-GPTQ-Int4

4. Kubernetes 部署

官方文档：https://docs.vllm.ai/projects/recipes/en/latest/Qwen/Qwen3.5.html

以下以 Qwen3.5-397B-A17B-GPTQ-Int4 为例，展示如何在 Kubernetes 中部署：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77

# qwen35-397b-deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
 name: vllm-qwen35-397b
 namespace: default
spec:
 replicas: 1
 selector:
 matchLabels:
 app: vllm-qwen35-397b
 template:
 metadata:
 labels:
 app: vllm-qwen35-397b
 spec:
 nodeSelector:
 kubernetes.io/hostname: gb200-pod2-f06-node05
 containers:
 - name: vllm-server
 image: vllm/vllm-openai:cu130-nightly
 command: ["/bin/bash"]
 args:
 - "-c"
 - |
 vllm serve /Qwen3.5-397B-A17B-GPTQ-Int4 \
 --served-model-name qwen3.5 \
 --port 8000 \
 --tensor-parallel-size 4 \
 --gpu-memory-utilization 0.85 \
 --reasoning-parser qwen3 \
 --enable-auto-tool-choice \
 --max-model-len 262144 \
 --tool-call-parser qwen3_coder \
 --enable-prefix-caching \
 --quantization moe_wna16 \
 --host 0.0.0.0 \
 --api-key "your-api-key"
 resources:
 limits:
 nvidia.com/gpu: 4
 memory: "400Gi"
 cpu: "32"
 requests:
 nvidia.com/gpu: 4
 memory: "200Gi"
 cpu: "16"
 ports:
 - containerPort: 8000
 name: http
 volumeMounts:
 - name: model-storage
 mountPath: /Qwen3.5-397B-A17B-GPTQ-Int4
 readOnly: true
 - name: shm
 mountPath: /dev/shm
 volumes:
 - name: model-storage
 hostPath:
 path: /raid/lixd/models/Qwen3.5-397B-A17B-GPTQ-Int4
 type: Directory
 - name: shm
 emptyDir:
 medium: Memory
 sizeLimit: 64Gi
---
apiVersion: v1
kind: Service
metadata:
 name: vllm-qwen35-397b-service
spec:
 selector:
 app: vllm-qwen35-397b
 ports:
 - port: 8000
 targetPort: 8000
 type: ClusterIP

关键参数说明：

参数 说明
--tensor-parallel-size 张量并行数，通常等于 GPU 数量
--reasoning-parser qwen3 启用 Qwen3 推理能力
--tool-call-parser qwen3_coder 使用 Qwen3 工具调用解析器
--enable-auto-tool-choice 启用自动工具选择
--quantization moe_wna16 MoE 模型量化方式
--max-model-len 262144 最大上下文长度
--enable-prefix-caching 启用前缀缓存加速

5. 服务验证

5.1 基础验证 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

# 查看可用模型列表
curl http://localhost:8000/v1/models \
 -H "Authorization: Bearer your-api-key"

# 基础对话测试
curl http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -H "Authorization: Bearer your-api-key" \
 -d '{
 "model": "qwen3.5",
 "messages": [
 {"role": "user", "content": "你好，请介绍一下你自己"}
 ],
 "max_tokens": 100,
 "temperature": 0.7
 }'

5.2 思考模式控制

Qwen3.5 支持开启/关闭思考模式：

开启思考模式（默认）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

curl http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -H "Authorization: Bearer your-api-key" \
 -d '{
 "model": "qwen3.5",
 "messages": [
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "Summarize Qwen3.5 in one sentence."}
 ],
 "temperature": 1,
 "max_tokens": 4096
 }'

关闭思考模式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

curl http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -H "Authorization: Bearer your-api-key" \
 -d '{
 "model": "qwen3.5",
 "messages": [
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "Summarize Qwen3.5 in one sentence."}
 ],
 "temperature": 1,
 "max_tokens": 4096,
 "chat_template_kwargs": {"enable_thinking": false}
 }'

6. 性能基准测试

6.1 测试方法

使用 vLLM 内置的 benchmark 工具进行测试：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

vllm bench serve \
 --model /Qwen3.5-397B-A17B-GPTQ-Int4 \
 --served_model_name qwen3.5 \
 --dataset-name random \
 --random-input 8000 \
 --random-output 1024 \
 --request-rate 10 \
 --num-prompts 32 \
 --trust-remote-code \
 --ignore-eos

6.2 INT4 版本测试结果 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

============ Serving Benchmark Result ============
Successful requests: 32
Failed requests: 0
Request rate configured (RPS): 10.00
Benchmark duration (s): 32.58
Total input tokens: 256000
Total generated tokens: 32768
Request throughput (req/s): 0.98
Output token throughput (tok/s): 1005.85
Peak output token throughput (tok/s): 1152.00
Peak concurrent requests: 32.00
Total token throughput (tok/s): 8864.01
---------------Time to First Token----------------
Mean TTFT (ms): 308.19
Median TTFT (ms): 287.37
P99 TTFT (ms): 494.26
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms): 29.54
Median TPOT (ms): 29.62
P99 TPOT (ms): 30.58
---------------Inter-token Latency----------------
Mean ITL (ms): 29.54
Median ITL (ms): 28.52
P99 ITL (ms): 30.89
==================================================

关键指标解读：

指标 含义 测试结果
TTFT Time To First Token，首 token 延迟 平均 308ms
TPOT Time Per Output Token，每个 token 生成时间 平均 29.5ms
吞吐量 Output token throughput 1005 tok/s

7. 小结

本文详细介绍了使用 vLLM 部署 Qwen3.5 模型的完整流程：

  • 模型选择：根据需求，推荐选择 27B、35B-A3B、397B-A17B 几种规格
  • Kubernetes 部署：k8s 中通过 Deployment 配置，支持多 GPU 张量并行
  • 性能表现：INT4 版本在 GB200*4 环境下达到 1005 tok/s 的吞吐量

如果你想在 Claude Code 中使用本地部署的模型，可以参考我的另一篇文章《Claude Code 也能跑本地模型？CCR 多模型智能路由》，了解如何通过 Claude Code Router 实现对接。

另外，如果你对 GLM-5 模型的部署感兴趣，也可以参考《vLLM + GLM-5：打造高性能本地大模型推理服务》。

vLLM 部署 GLM-5 实践指南

2026-03-26 04:00:00

deploy-glm5-by-vllm.jpeg

GLM-5 是智谱 AI 最新发布的大语言模型，具备强大的推理能力和工具调用能力。本文将详细介绍如何使用 vLLM 框架在生产环境中部署 GLM-5 模型。

根据各大榜单排名以及实测表现，GLM-5 在多项评测中表现出色，是当前开源模型中的佼佼者。

glm5-rank.png

本文涵盖以下内容：

  • 模型下载：FP8 和 INT4 两种量化版本
  • 镜像构建：构建支持 GLM-5 的 vLLM 镜像
  • Docker 部署：INT4 版本快速部署
  • 性能测试：INT4 版本基准测试

0.测试环境

本文所有测试均在以下环境完成：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

+-----------------------------------------------------------------------------------------+
| GPU Name Persistence-M | Bus-Id Disp.A | Volatile Uncorr. ECC |
| Fan Temp Perf Pwr:Usage/Cap | Memory-Usage | GPU-Util Compute M. |
|=========================================+========================+======================|
| 0 NVIDIA GB200 On | 00000008:01:00.0 Off | 0 |
| N/A 42C P0 395W / 1200W | 175750MiB / 189471MiB | 0% Default |
+-----------------------------------------+------------------------+----------------------+
| 1 NVIDIA GB200 On | 00000009:01:00.0 Off | 0 |
| N/A 42C P0 369W / 1200W | 175366MiB / 189471MiB | 0% Default |
+-----------------------------------------+------------------------+----------------------+
| 2 NVIDIA GB200 On | 00000018:01:00.0 Off | 0 |
| N/A 41C P0 354W / 1200W | 175366MiB / 189471MiB | 0% Default |
+-----------------------------------------+------------------------+----------------------+
| 3 NVIDIA GB200 On | 00000019:01:00.0 Off | 0 |
| N/A 42C P0 375W / 1200W | 179133MiB / 189471MiB | 0% Default |
+-----------------------------------------+------------------------+----------------------+

1. 模型下载

1.1 安装 HuggingFace CLI

首先安装 HuggingFace CLI 工具用于下载模型：

1

curl -LsSf https://hf.co/cli/install.sh | bash

常见问题：安装失败

如果遇到 No module named pip 错误，通常是因为虚拟环境损坏：

1
2
3
4
5

# 删除损坏的虚拟环境
rm -rf /root/.hf-cli/venv

# 重新安装
curl -LsSf https://hf.co/cli/install.sh | bash

1.2 下载模型

GLM-5 提供了多种精度版本，根据你的硬件配置选择：

1
2
3
4
5

# FP8 版本 - 推荐 H200*8 配置
hf download zai-org/GLM-5-FP8 --local-dir /raid/lixd/models/glm5-fp8

# INT4 量化版本 - 推荐 A100/H100*4 配置
hf download Intel/GLM-5-int4-mixed-AutoRound --local-dir /raid/lixd/models/glm5-int4-mixed-autoround

2. vLLM 部署

官方文档：https://github.com/vllm-project/recipes/blob/main/GLM/GLM5.md

2.1 构建自定义镜像

由于 GLM-5 需要最新版 transformers 支持，官方镜像暂未包含，需要构建自定义镜像。

创建 Dockerfile：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

FROM vllm/vllm-openai:v0.17.1-cu130

# 安装 git 用于从源码安装 transformers
RUN apt-get update && apt-get install -y git && \
 rm -rf /var/lib/apt/lists/*

# 安装最新版 transformers（GLM-5 需要）
RUN pip install --no-cache-dir git+https://github.com/huggingface/transformers.git

WORKDIR /app

ENTRYPOINT ["vllm"]

构建镜像：

1

docker build -t vllm/vllm-openai:glm5 .

已推送到公共仓库：lixd96/vllm-openai:v0.17.1-cu130，可直接拉取使用

2.2 Docker 部署 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

docker run -d \
 --name vllm-glm5 \
 --runtime nvidia \
 --gpus '"device=0,1,2,3"' \
 -p 8000:8000 \
 -v /raid/lixd/models/glm5-int4-mixed-autoround:/app/model \
 --shm-size 16g \
 vllm/vllm-openai:glm5 \
 serve /app/model \
 --tensor-parallel-size 4 \
 --tool-call-parser glm47 \
 --reasoning-parser glm45 \
 --enable-auto-tool-choice \
 --served-model-name glm5 \
 --trust-remote-code \
 --gpu-memory-utilization 0.85 \
 --host 0.0.0.0 \
 --port 8000

关键参数说明：

参数 说明
--tensor-parallel-size 张量并行数，通常等于 GPU 数量
--tool-call-parser glm47 使用 GLM 系列工具调用解析器
--reasoning-parser glm45 启用 GLM 推理能力
--enable-auto-tool-choice 启用自动工具选择
--trust-remote-code 信任模型中的远程代码
--gpu-memory-utilization GPU 显存利用率，建议 0.85-0.95

3. 服务验证

3.1 基础验证

部署完成后，验证服务是否正常运行：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 查看可用模型列表
curl http://localhost:8000/v1/models

# 基础对话测试
curl http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "glm5",
 "messages": [
 {"role": "user", "content": "你好，请介绍一下你自己"}
 ],
 "max_tokens": 100,
 "temperature": 0.7
 }'

# 流式对话测试
curl http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "glm5",
 "messages": [
 {"role": "user", "content": "用一句话解释什么是 Kubernetes"}
 ],
 "max_tokens": 200,
 "stream": true
 }'

3.2 思考模式控制

GLM-5 支持开启/关闭思考模式，通过 chat_template_kwargs 参数控制：

开启思考模式（默认）：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

curl http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "glm5",
 "messages": [
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "Summarize GLM-5 in one sentence."}
 ],
 "temperature": 1,
 "max_tokens": 4096
 }'

关闭思考模式：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

curl http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "glm5",
 "messages": [
 {"role": "system", "content": "You are a helpful assistant."},
 {"role": "user", "content": "Summarize GLM-5 in one sentence."}
 ],
 "temperature": 1,
 "max_tokens": 4096,
 "chat_template_kwargs": {"enable_thinking": false}
 }'

4. 性能基准测试

4.1 测试方法

使用 vLLM 内置的 benchmark 工具进行测试：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Prompt-heavy benchmark (8k input / 1k output)
vllm bench serve \
 --model /app/model \
 --served_model_name glm5 \
 --dataset-name random \
 --random-input 8000 \
 --random-output 1024 \
 --request-rate 10 \
 --num-prompts 32 \
 --trust-remote-code \
 --ignore-eos

4.2 INT4 版本测试结果 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

============ Serving Benchmark Result ============
Successful requests: 32
Failed requests: 0
Request rate configured (RPS): 10.00
Benchmark duration (s): 35.27
Total input tokens: 256000
Total generated tokens: 32768
Request throughput (req/s): 0.91
Output token throughput (tok/s): 929.09
Peak output token throughput (tok/s): 1088.00
Peak concurrent requests: 32.00
Total token throughput (tok/s): 8187.65
---------------Time to First Token----------------
Mean TTFT (ms): 144.10
Median TTFT (ms): 139.03
P99 TTFT (ms): 226.47
-----Time per Output Token (excl. 1st token)------
Mean TPOT (ms): 31.61
Median TPOT (ms): 31.70
P99 TPOT (ms): 31.80
---------------Inter-token Latency----------------
Mean ITL (ms): 31.61
Median ITL (ms): 31.92
P99 ITL (ms): 58.34
==================================================

关键指标解读：

指标 含义 测试结果
TTFT Time To First Token，首 token 延迟，衡量用户等待第一个响应的时间 平均 144ms，响应迅速
TPOT Time Per Output Token，每个 token 的生成时间，反映流式输出的流畅度 平均 31.6ms

5. 小结

本文详细介绍了使用 vLLM 部署 GLM-5 模型的完整流程：

  • 模型下载：提供 FP8 和 INT4 两种版本，按需选择
  • 镜像构建：由于 GLM-5 需要最新 transformers，需自定义镜像
  • Docker 部署：以 INT4 版本为例，快速部署模型服务
  • 性能表现：INT4 版本在 GB200*4 环境下达到 929 tok/s 的吞吐量

如果你想在 Claude Code 中使用本地部署的 GLM-5 模型，可以参考我的另一篇文章《Claude Code 也能跑本地模型？CCR 多模型智能路由》，了解如何通过 Claude Code Router 实现对接。

Claude Code 也能跑本地模型？CCR 多模型 智能路由，成本直降 90%

2026-03-19 04:00:00

claude-code-router.jpeg

Claude Code 是 Anthropic 推出的强大 AI 编程助手，但每月的订阅费用让很多开发者望而却步。

通过 Claude Code Router (CCR)，我们可以：

  • 对接本地模型：部署 GLM5 等开源模型，实现零成本使用
  • 多模型智能路由：根据任务类型自动选择最合适的模型
  • 灵活组合：本地 + 云端混合部署，兼顾隐私、成本和质量

本文将手把手教你搭建这套方案，让你的 AI 编程助手成本降低 90% 以上。

1. 环境准备和工具安装

1.1 安装 Claude Code

首先需要在你的开发机器上安装 Claude Code：

1
2

# 官方安装脚本（需要科学上网）
curl -fsSL https://claude.ai/install.sh | bash

1.2 安装 Claude Code Router

Claude Code Router 是一个 Node.js 包，用于桥接 Claude Code 和本地模型：

1
2

# 需要 Node.js 20+ 版本
npm install -g @musistudio/claude-code-router

1.3 验证安装

安装完成后，验证两个工具是否正常工作：

1
2
3
4
5
6
7

# 检查 Claude Code 版本
❯ claude --version
2.1.51 (Claude Code)

# 检查 CCR 版本
❯ ccr version
claude-code-router version: 2.0.0

2. 模型部署

2.1 模型下载

在服务器上下载 GLM5 模型：

根据硬件配置选择合适的版本

1
2
3
4
5

# 使用 huggingface-cli 下载模型
# FP8 版本 推荐配置：H200*8
hf download zai-org/GLM-5-FP8 --local-dir /raid/lixd/models/glm5-fp8
# INT4 版本
hf download Intel/GLM-5-int4-mixed-AutoRound --local-dir /raid/lixd/models/glm5-int4-mixed-autoround

2.2 vLLM 服务启动

使用 vLLM 框架部署模型服务，确保已安装 GPU 驱动和 NVIDIA Container Toolkit。

由于 GLM5 需要最新版的 transformers 支持，官方镜像暂未包含，需要先构建自定义镜像：

已经推送到 lixd96/vllm-openai:v0.17.1-cu130，直接拉取即可 docker pull lixd96/vllm-openai:v0.17.1-cu130

构建自定义镜像：

创建 Dockerfile：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

FROM vllm/vllm-openai:v0.17.1-cu130

# 安装 git 用于从源码安装 transformers
RUN apt-get update && apt-get install -y git && \
 rm -rf /var/lib/apt/lists/*

# 安装最新版 transformers（GLM5 需要最新版支持）
RUN pip install --no-cache-dir git+https://github.com/huggingface/transformers.git

# 设置工作目录
WORKDIR /app

# 默认启动命令
ENTRYPOINT ["vllm"]

构建并推送镜像：

1
2

# 构建镜像
docker build -t lixd96/vllm-openai:v0.17.1-cu130-ex .

启动服务：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

docker run -d \
 --name vllm-glm5 \
 --runtime nvidia \
 --gpus '"device=0,1,2,3"' \
 -p 8000:8000 \
 -v /raid/lixd/models/glm5-int4-mixed-autoround:/glm5-int4-mixed-autoround \
 --shm-size 16g \
 lixd96/vllm-openai:v0.17.1-cu130 \
 serve /glm5-int4-mixed-autoround \
 --tensor-parallel-size 4 \
 --tool-call-parser glm47 \
 --reasoning-parser glm45 \
 --enable-auto-tool-choice \
 --served-model-name glm5 \
 --trust-remote-code \
 --gpu-memory-utilization 0.85 \
 --api-key "your-api-key" \
 --host 0.0.0.0 \
 --port 8000

关键参数说明：

  • GPU 配置：根据实际 GPU 数量调整 --gpus 和 --tensor-parallel-size 参数
  • 内存共享：--shm-size 16g 确保容器有足够共享内存
  • 工具调用：--enable-auto-tool-choice 启用工具调用功能，--tool-call-parser glm47 使用 GLM 系列的工具调用解析器
  • 推理解析：--reasoning-parser glm45 启用 GLM 的推理能力
  • 信任远程代码：--trust-remote-code 允许加载模型的自定义代码
  • 张量并行：--tensor-parallel-size 4 在多 GPU 上并行处理

2.3 服务验证

部署完成后，验证服务是否正常运行：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# 查看可用模型列表
curl http://localhost:8000/v1/models

# 基础对话测试
curl http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "glm5",
 "messages": [
 {"role": "user", "content": "你好，请介绍一下你自己"}
 ],
 "max_tokens": 100,
 "temperature": 0.7
 }'

# 流式对话测试
curl http://localhost:8000/v1/chat/completions \
 -H "Content-Type: application/json" \
 -d '{
 "model": "glm5",
 "messages": [
 {"role": "user", "content": "用一句话解释什么是 Kubernetes"}
 ],
 "max_tokens": 200,
 "stream": true
 }'

如果一切正常，你应该能看到模型的响应输出。

2.4 配置 Claude Code Router

配置说明

核心配置文件如下：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

{
 // LLM 提供商
 "Providers": [
 {
 "name": "openai",
 "baseUrl": "https://api.openai.com/v1",
 "apiKey": "$OPENAI_API_KEY",
 "models": ["gpt-4", "gpt-3.5-turbo"]
 }
 ],

// 路由
{
 "Router": {
 "default": "openai,gpt-4",
 "background": "openai,gpt-3.5-turbo",
 "think": "openai,gpt-4",
 "longContext": "anthropic,claude-3-opus"
 }
}}
  • Providers：对接不同供应商提供的不同模型
  • Router：则是将模型分类 https://musistudio.github.io/claude-code-router/zh-CN/docs/server/config/routing
    • default：默认路由
    • background：后台任务，推荐用轻量级模型
    • think：思考密集型任务，推荐用能力强的模型
    • longContext：长上下文时会使用该模型
    • webSearch：网络搜索任务
    • image：图像任务

完整配置

创建或编辑配置文件 ~/.claude-code-router/config.json：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87

{
 "LOG": true,
 "LOG_LEVEL": "debug",
 "CLAUDE_PATH": "",
 "HOST": "127.0.0.1",
 "PORT": 3456,
 "APIKEY": "",
 "API_TIMEOUT_MS": "600000",
 "PROXY_URL": "",
 "transformers": [],
 "Providers": [
 {
 "name": "vllm",
 "api_base_url": "http://your-server-ip:8000/v1/chat/completions",
 "api_key": "your-api-key",
 "models": [
 "glm5"
 ],
 "transformer": {
 "use": [
 "enhancetool",
 [
 "sampling",
 {
 "temperature": "0.7",
 "top_p": "0.8",
 "top_k": "20",
 "repetition_penalty": "1.05"
 }
 ]
 ]
 }
 }
 ],
 "StatusLine": {
 "enabled": true,
 "currentStyle": "default",
 "default": {
 "modules": []
 },
 "powerline": {
 "modules": [
 {
 "type": "workDir",
 "icon": "󰉋",
 "text": "{{workDirName}}",
 "color": "bright_blue"
 },
 {
 "type": "gitBranch",
 "icon": "🌿",
 "text": "{{gitBranch}}",
 "color": "bright_green"
 },
 {
 "type": "model",
 "icon": "🤖",
 "text": "{{model}}",
 "color": "bright_yellow"
 },
 {
 "type": "usage",
 "icon": "📊",
 "text": "{{inputTokens}} → {{outputTokens}}",
 "color": "bright_magenta"
 },
 {
 "type": "script",
 "icon": "📜",
 "text": "Script Module",
 "color": "bright_cyan",
 "scriptPath": ""
 }
 ]
 }
 },
 "Router": {
 "default": "vllm,glm5",
 "background": "vllm,glm5",
 "think": "vllm,glm5",
 "longContext": "vllm,glm5",
 "longContextThreshold": 102400,
 "webSearch": "vllm,glm5",
 "image": ""
 },
 "CUSTOM_ROUTER_PATH": ""
}

配置说明：

  • API 地址：将 your-server-ip 替换为实际的服务器 IP 地址
  • API 密钥：设置与 vLLM 启动时相同的 API 密钥
  • 路由配置：将所有任务类型都指向本地模型
  • 状态栏：启用自定义状态栏显示工作目录、Git 分支、模型信息等
  • 日志级别：调试阶段可设为 debug，生产环境建议改为 info

3. 开始使用

3.1 启动 Claude Code Router

使用 ccr code 替代原来的 claude 命令：

效果如下： ccr-demo.png

启动后，在 claude 界面输入以下命令切换模型

1

/model vllm,glm5

之后就可以正常使用了。

ps: 不切换模型也可以，只是终端会一直显示用的 Claude 的模型。

4. 进阶：多模型智能路由

前面我们介绍了单一模型的配置方式，但在实际使用中，不同类型的任务对模型能力的要求各不相同。
Claude Code Router 的强大之处在于支持对接多个模型，并根据任务类型自动路由到最合适的模型。

4.1 为什么需要多模型路由？

不同任务对模型的需求差异很大：

任务类型 特点 推荐模型策略
日常对话 频率高、响应快 轻量级模型，节省资源
代码生成 需要准确性和逻辑性 中等能力模型
复杂推理 需要深度思考 顶级能力模型
长文本处理 需要大上下文窗口 支持长上下文的模型
图像理解 需要多模态能力 视觉语言模型

通过合理配置，可以实现：

  • 成本优化：简单任务用便宜模型，复杂任务才用昂贵模型
  • 性能平衡：快速响应与高质量输出的权衡
  • 资源利用：充分利用不同模型的优势

4.2 多模型配置示例

以下是一个对接多个模型服务商的完整配置：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

{
 "LOG": true,
 "LOG_LEVEL": "info",
 "HOST": "127.0.0.1",
 "PORT": 3456,
 "API_TIMEOUT_MS": "600000",
 "Providers": [
 {
 "name": "local-glm5",
 "api_base_url": "http://192.168.1.100:8000/v1/chat/completions",
 "api_key": "your-local-key",
 "models": ["glm5"],
 "transformer": {
 "use": ["enhancetool"]
 }
 },
 {
 "name": "deepseek",
 "api_base_url": "https://api.deepseek.com/v1/chat/completions",
 "api_key": "$DEEPSEEK_API_KEY",
 "models": ["deepseek-chat", "deepseek-reasoner"]
 },
 {
 "name": "openai",
 "api_base_url": "https://api.openai.com/v1/chat/completions",
 "api_key": "$OPENAI_API_KEY",
 "models": ["gpt-4o", "gpt-4o-mini"]
 },
 {
 "name": "zhipu",
 "api_base_url": "https://open.bigmodel.cn/api/paas/v4/chat/completions",
 "api_key": "$ZHIPU_API_KEY",
 "models": ["glm-4-plus", "glm-4-flash"]
 }
 ],
 "Router": {
 "default": "local-glm5,glm5",
 "background": "zhipu,glm-4-flash",
 "think": "deepseek,deepseek-reasoner",
 "longContext": "local-glm5,glm5",
 "longContextThreshold": 64000,
 "webSearch": "openai,gpt-4o-mini",
 "image": "openai,gpt-4o"
 }
}

4.3 路由策略详解

default（默认路由）

  • 用途：常规对话和代码编写
  • 建议：选择性价比高的主力模型
  • 示例：本地 GLM5 或 DeepSeek Chat

background（后台任务）

  • 用途：自动触发的辅助任务，如代码审查、状态检查
  • 特点：频率高、对质量要求相对较低
  • 建议：使用轻量快速模型，如 GLM-4-Flash、GPT-4o-mini
  • 成本优势：可节省 80% 以上的 API 费用

think（思考密集型）

  • 用途：复杂算法设计、架构决策、疑难问题排查
  • 特点：需要深度推理能力
  • 建议：使用最强推理模型，如 DeepSeek Reasoner、Claude Opus
  • 注意：这类模型响应较慢，但输出质量最高

longContext（长上下文）

  • 用途：分析大型代码库、处理长文档
  • 触发条件：当上下文超过 longContextThreshold 时自动切换
  • 建议：选择支持 64K+ 上下文的模型
  • 示例：GLM5（200K）、Claude（200K）

webSearch（网络搜索）

  • 用途：联网查询资料
  • 建议：选择支持工具调用的模型
  • 示例：GPT-4o、DeepSeek Chat

image（图像任务）

  • 用途：截图分析、图表解读
  • 建议：使用多模态模型
  • 示例：GPT-4o、Claude 3.5 Sonnet

4.4 最佳实践建议

工作原理

Claude Code Router 的核心原理是通过启动一个 HTTP 中转服务，在不修改 Claude Code 源码的情况下完成请求的转发和格式转换。

Claude Code 使用 Anthropic API 规范进行通信，而大多数模型服务商（如 OpenAI、DeepSeek 等）使用 OpenAI API 规范。CCR 的作用就是：

  1. 接收请求：CCR 启动一个 HTTP 服务（默认端口 3456），监听 Claude Code 的请求
  2. 格式转换：将 Anthropic API 格式的请求转换为 OpenAI API 格式
  3. 智能路由：根据任务类型将请求分发到不同的模型服务商
  4. 响应转换：将模型的响应转换回 Anthropic API 格式返回给 Claude Code
 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

┌─────────────────────────────────────────────────────────────┐
│ Claude Code │
│ (使用 Anthropic API 规范通信) │
└─────────────────────────┬───────────────────────────────────┘
 │ Anthropic API 格式
 ▼
 ┌─────────────────────┐
 │ CCR HTTP 服务 │
 │ (Express.js) │
 │ │
 │ • 格式转换 │
 │ • 智能路由 │
 │ • 请求重写 │
 └──────────┬──────────┘
 │ OpenAI API 格式
 ┌─────────────────┼─────────────────┐
 │ │ │
 ┌────▼────┐ ┌─────▼─────┐ ┌─────▼─────┐
 │ 本地 │ │ 云端 │ │ 云端 │
 │ GLM5 │ │ DeepSeek │ │ OpenAI │
 │ (default)│ │ (think) │ │ (image) │
 └─────────┘ └───────────┘ └───────────┘

按需分配，降低成本

CCR 的核心优势在于可以根据任务特点选择最合适的模型，实现成本与质量的平衡：

任务类型 特点 推荐策略
日常开发 频率高、响应要求快 性价比高的主力模型
复杂推理 需要深度思考 推理能力强的模型
图像理解 需要多模态能力 支持视觉的模型
后台任务 自动触发、频率高 轻量快速模型
长文本 需要大上下文 支持长上下文的模型

成本对比：

1
2
3
4
5
6
7
8

┌────────────────────────────────────────────────┐
│ Claude Max Plan │
│ $200 / 月 │
├────────────────────────────────────────────────┤
│ CCR 多模型路由 │
│ 日常任务用便宜模型 + 复杂任务用强模型 │
│ ~$20 / 月 │
└────────────────────────────────────────────────┘

通过合理配置路由策略，将高频低难度任务分配给低成本模型，仅在必要时调用高端模型，月成本可降低 90% 以上。

5. 常见问题与解决方案

5.1 “Unable to connect to Anthropic services” 错误

如果运行 ccr code 时报错：“Unable to connect to Anthropic services”，可以修改 ~/.claude.json 文件，在最外层添加以下配置：

1
2
3

{
 "hasCompletedOnboarding": true
}

保存后重新运行即可。

6. 小结

本文介绍了如何通过 Claude Code Router 打破 Claude Code 的使用限制：

  • 本地部署：通过 vLLM 部署 GLM5 模型，实现零成本使用
  • 多模型路由：根据任务类型智能分发，高频任务用便宜模型，复杂任务用强模型
  • 成本优化：相比 Claude Max Plan，合理配置后成本可降低 90% 以上

CCR 还支持对接更多 Provider，如 DeepSeek、智谱 AI、OpenAI 等，可根据实际需求灵活组合。如果你也在寻找高性价比的 AI 编程方案，不妨试试这套配置。