1. 复现目标先定死：你要的是显存曲线，还是计费曲线
切到 TaoToken 之后，如果你想复现 V4.1-Flash 的 KV cache 内存曲线，第一步不是跑 benchmark，而是先把调用入口固定下来：去 TaoToken 官网 https://taotoken.net/?utm_source=taotoken_aicg_blog_end&utm_content=kv_cache_repro_intro 拿一个 Key，并把所有工具的 Base URL 统一指向 https://taotoken.net/api。这一步做完，你的实验才有可比性——否则不同工具走不同网关，采样出来的曲线只能算噪声。
V4.1-Flash 这类模型对外宣称的核心卖点是压缩 KV cache、降低长上下文处理开销，但「压缩」这两个字落到工程上会分裂成两条完全不同的曲线：
第一条是显存曲线。只有当模型权重跑在你自己的 GPU 上时，nvidia-smi采到的 used memory 才真实包含 KV cache。这时你可以直接做长度扫描，观察每增加 1K token，显存涨了多少 MB，斜率就是 KV cache 的边际成本。
第二条是计费曲线。当你通过 API 调用时，KV cache 跑在服务端，你本地看不到任何显存变化。你能观测到的只有响应体里的 usage 字段：prompt_tokens、completion_tokens，以及缓存命中/未命中的 token 数。这时「内存曲线」实际上是「token 成本曲线」。
很多复现实验失败，是因为把这两条曲线混在一起看：一边调 API，一边盯本地 GPU 显存，发现显存纹丝不动，就得出「压缩效果显著」的结论——这完全是误判。本文把两条路径拆开写，最后再做一次对照，回答那个真正重要的问题：长上下文请求里，到底是谁在消耗 Token。
复现实验的核心产出有三样：一份可跑的显存采样脚本、一组按上下文长度排列的 KV cache 曲线、一张 Token 消耗与并发数的对照表。下面按顺序来。
2. 在 TaoToken 拿到 Key 并固定 Base URL
实验开始前先把入口和环境变量定死。这一步很枯燥，但它是后面所有曲线可比的前提。
打开 TaoToken 官网 https://taotoken.net/?utm_source=taotoken_aicg_blog_end&utm_content=kv_cache_repro_env ，进入控制台创建 API Key。Key 只在创建时完整展示一次，建议直接写进本机的环境变量文件而不是散落在脚本里。
创建 Key 的入口在这里：https://taotoken.net/console/api-keys?utm_source=taotoken_aicg_blog_end&utm_content=kv_cache_repro_key
拿到 Key 之后，固定两件事：
# ~/.config/taotoken/env.sh export TAOTOKEN_API_KEY="YOUR_API_KEY" export TAOTOKEN_BASE_URL="https://taotoken.net/api" export TAOTOKEN_MODEL="deepseek-v4.1-flash" # 具体模型 ID 以控制台模型列表为准chmod 600 ~/.config/taotoken/env.sh echo 'source ~/.config/taotoken/env.sh' >> ~/.bashrc source ~/.config/taotoken/env.sh注意 Base URL 就写到https://taotoken.net/api为止，不要自己在后面拼/v1再去试错。OpenAI 兼容路径的拼接方式以你控制台文档给出的为准，脚本里把 BASE 和 PATH 分开写，改起来只动一行：
BASE_URL = "https://taotoken.net/api" CHAT_PATH = "/v1/chat/completions" # 若控制台给出别的路径前缀，改这里先做一个最小连通性验证，别急着跑长上下文：
curl -sS "${TAOTOKEN_BASE_URL}/v1/chat/completions" \ -H "Authorization: Bearer ${TAOTOKEN_API_KEY}" \ -H "Content-Type: application/json" \ -d '{ "model": "'"${TAOTOKEN_MODEL}"'", "messages": [{"role": "user", "content": "reply with ok"}], "max_tokens": 8 }' | head -c 400能返回 JSON 且带 usage 字段，说明链路通了。顺手把 usage 的结构记下来，后面整套实验都靠它。
3. Claude Code / Codex / CC Switch 三件套：把请求固定到同一条链路
复现实验最怕「同一份 prompt 换了个工具，token 数就变了」。原因是不同客户端会往 system prompt 里塞不同的东西：工具 schema、项目上下文、历史轮次压缩策略都不一样。所以要让 Claude Code、Codex 这些工具都走同一条链路，且尽量保持请求结构一致。
Claude Code 走 ANTHROPIC_ 系列环境变量，写进~/.claude/settings.json：
{ "env": { "ANTHROPIC_BASE_URL": "https://taotoken.net/api", "ANTHROPIC_AUTH_TOKEN": "YOUR_API_KEY", "ANTHROPIC_MODEL": "deepseek-v4.1-flash", "ANTHROPIC_SMALL_FAST_MODEL": "deepseek-v4.1-flash", "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1" } }这里ANTHROPIC_AUTH_TOKEN填的就是上面创建的 Key。CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC这个开关建议打开，否则客户端会在后台发一些与实验无关的请求，污染你的 token 统计。
Codex 走的是 config.toml，不要套用 ANTHROPIC_ 变量。它用的是 OpenAI 兼容协议，配置写进~/.codex/config.toml：
model = "deepseek-v4.1-flash" model_provider = "taotoken" [model_providers.taotoken] name = "TaoToken" base_url = "https://taotoken.net/api" env_key = "TAOTOKEN_API_KEY" wire_api = "chat"env_key指向的是环境变量名，不是 Key 本身，所以上面那份env.sh必须先 source 过。
CC Switch 三件套用来在多个 provider 之间来回切，避免手改配置文件。它的核心就三样：provider 配置文件、环境变量文件、切换脚本。
# 1) provider 配置：~/.cc-switch/providers/taotoken.json { "name": "taotoken", "base_url": "https://taotoken.net/api", "model": "deepseek-v4.1-flash", "env_key": "TAOTOKEN_API_KEY" }# 2) 环境变量文件：~/.cc-switch/env/taotoken.env export ANTHROPIC_BASE_URL="https://taotoken.net/api" export ANTHROPIC_AUTH_TOKEN="YOUR_API_KEY" export TAOTOKEN_API_KEY="YOUR_API_KEY"# 3) 切换脚本：~/.cc-switch/switch.sh #!/usr/bin/env bash set -euo pipefail PROFILE="${1:-taotoken}" ENV_FILE="$HOME/.cc-switch/env/${PROFILE}.env" [ -f "$ENV_FILE" ] || { echo "profile not found: $PROFILE" >&2; exit 1; } # shellcheck disable=SC1090 source "$ENV_FILE" echo "active profile: $PROFILE" echo "base_url: ${ANTHROPIC_BASE_URL:-$TAOTOKEN_BASE_URL}"chmod +x ~/.cc-switch/switch.sh source ~/.cc-switch/switch.sh taotoken三件套的好处是：实验中途要换 provider 做对照，只改一处，Claude Code 和 Codex 同时生效，不会出现「Claude Code 已经切了、Codex 还在旧网关」这种脏数据。
4. 采样脚本：把显存和请求侧指标一起采
现在写采样脚本。核心思路是两条时间线对齐：一条是 GPU 显存时间线，一条是请求生命周期时间线。
先写本地显存采样器。用nvidia-smi查询模式而不是pynvml，依赖更少、跨版本更稳：
# vram_sampler.py import csv import subprocess import sys import time QUERY = "index,memory.used,memory.total,utilization.gpu" def sample_once(): out = subprocess.run( ["nvidia-smi", f"--query-gpu={QUERY}", "--format=csv,noheader,nounits"], capture_output=True, text=True, check=True ).stdout.strip() rows = [] for line in out.splitlines(): idx, used, total, util = [x.strip() for x in line.split(",")] rows.append({ "ts": time.time(), "gpu": int(idx), "mem_used_mb": int(used), "mem_total_mb": int(total), "util_pct": int(util), }) return rows def main(out_path, interval_ms, duration_s): deadline = time.time() + duration_s with open(out_path, "w", newline="") as f: writer = csv.DictWriter( f, fieldnames=["ts", "gpu", "mem_used_mb", "mem_total_mb", "util_pct"] ) writer.writeheader() while time.time() < deadline: for row in sample_once(): writer.writerow(row) time.sleep(interval_ms / 1000.0) if __name__ == "__main__": main(sys.argv[1], int(sys.argv[2]), float(sys.argv[3]))采样频率建议 50ms 到 200ms。太密会让nvidia-smi自身变成负载，曲线上出现周期性毛刺；太疏会漏掉请求首尾的显存台阶。长上下文实验用 100ms 起步。
再写请求侧记录器，把每次请求的长度、耗时、usage 全打到一份 CSV：
# probe.py import json import time import csv import os import requests BASE_URL = os.environ["TAOTOKEN_BASE_URL"] API_KEY = os.environ["TAOTOKEN_API_KEY"] MODEL = os.environ.get("TAOTOKEN_MODEL", "deepseek-v4.1-flash") CHAT_PATH = "/v1/chat/completions" def build_prompt(target_tokens: int) -> str: # 用固定词表构造可控长度的 prompt，保证复现性 unit = "the quick brown fox jumps over the lazy dog " approx_tokens_per_unit = 11 repeat = max(1, target_tokens // approx_tokens_per_unit) return unit * repeat def one_call(target_tokens: int, max_tokens: int = 64, tag: str = ""): payload = { "model": MODEL, "messages": [{"role": "user", "content": build_prompt(target_tokens)}], "max_tokens": max_tokens, "temperature": 0, } t0 = time.perf_counter() resp = requests.post( f"{BASE_URL}{CHAT_PATH}", headers={ "Authorization": f"Bearer {API_KEY}", "Content-Type": "application/json", }, data=json.dumps(payload), timeout=300, ) t1 = time.perf_counter() resp.raise_for_status() body = resp.json() usage = body.get("usage", {}) return { "ts": time.time(), "tag": tag, "target_tokens": target_tokens, "latency_s": round(t1 - t0, 4), "prompt_tokens": usage.get("prompt_tokens", -1), "completion_tokens": usage.get("completion_tokens", -1), "cached_tokens": usage.get("prompt_cache_hit_tokens", usage.get("cached_tokens", -1)), } def run_scan(lengths, out_csv): with open(out_csv, "w", newline="") as f: writer = csv.DictWriter(f, fieldnames=[ "ts", "tag", "target_tokens", "latency_s", "prompt_tokens", "completion_tokens", "cached_tokens", ]) writer.writeheader() for n in lengths: row = one_call(n, tag="scan") writer.writerow(row) f.flush() print(row) if __name__ == "__main__": run_scan([4096, 16384, 32768, 65536, 131072], "scan_result.csv")cached_tokens这个字段因网关而异，有的叫prompt_cache_hit_tokens，有的在prompt_tokens_details里。脚本里做了兜底取值，返回 -1 说明该字段没透出，这时候缓存命中率只能靠「同一前缀重复请求时 prompt_tokens 是否变化」来间接判断。
跑之前先把 Key 配好。如果这个最小脚本报 401，先回去检查 Key：https://taotoken.net/console/api-keys?utm_source=taotoken_aicg_blog_end&utm_content=kv_cache_repro_key
5. 长度扫描：4K 到 128K 的 KV cache 曲线怎么跑出来
有了两个采样器，正式开跑。长度为 4K / 16K / 32K / 64K / 128K 五档，每档重复三次取中位数，避免单次抖动。
路径 A：本地自托管，采真实显存。
顺序很重要：先起服务、等显存稳定、记录基线，再发请求。
# 1) 起服务并等待权重加载完成 python -m your_engine.serve --model deepseek-v4.1-flash --max-model-len 131072 & # 2) 等显存基线稳定，记录 base_mem nvidia-smi --query-gpu=memory.used --format=csv,noheader,nounits # 3) 开始采样，同时发请求 python vram_sampler.py vram_scan.csv 100 600 & python probe.py停下来之后，把vram_scan.csv的mem_used_mb减去基线，得到净增显存。真正的 KV cache 曲线是这条净增曲线在请求稳态阶段的平台值。
路径 B：走 TaoToken API，采 Token 曲线。
这时候本地显存不会动，观测的是probe.py写出的scan_result.csv。重点看三列：prompt_tokens是否随目标长度线性增长、latency_s的增长形态、cached_tokens的变化。
怎么读这两条曲线。
第一条曲线的斜率 ΔMB/ΔToken 是 KV cache 的边际成本。如果官方宣称有压缩效果，你会发现斜率明显低于同规模「标准 MHA 架构」的经验值——但具体低多少，必须以你自己机器上的测量为准，不要照搬宣传口径。
第二条曲线的形态更有意思。长上下文推理的耗时通常不是线性的，它的形状取决于两件事：一是 prefill 阶段的注意力计算量，二是 KV cache 的显存带宽。如果你看到延迟在某档长度后突然上翘，那大概率是某一层开始放不下、触发了换出或者分块注意力，而不是模型本身的问题。
**一个容易忽略的细节：**长度扫描时每档都要用全新的请求，不要复用上一档的会话。复用会让缓存命中，测出来的不是首轮 prefill 成本。反过来，如果你想测缓存命中带来的收益，那就故意复用前缀，这是另一个实验。
**采样数据的后处理。**把vram_scan.csv和scan_result.csv按时间戳对齐，能拿到「某次请求期间显存净增峰值」。把这个峰值和该次请求的prompt_tokens做成散点图，拟合斜率，就是你要的 KV cache 边际内存。散点如果离散度很大，说明采样窗口没对齐或者并发没控干净。
6. 谁在消耗 Token：把 prompt 拆成四段来看
曲线跑出来之后，绝大多数人会发现一个反直觉的结果：prompt_tokens 远大于自己写进去的那段文本长度。
原因在于，一次长上下文请求的 token 账单其实由四段构成：
第一段是 system prompt。Claude Code 这类工具的基础系统提示本身就不短，再加上行为规范、输出格式约束，几千 token 起步很常见。
第二段是工具 schema。你注册了多少个工具，就序列化多少份 JSON Schema。有些工具描述写得很详细，单个工具就是几百 token，注册十几个之后，这部分开销能顶上一大段正文。
第三段是历史轮次。多轮对话里，客户端通常会把之前的完整历史重新发一遍。这一段的增长是最快的，因为它随轮次线性叠加，而且几乎总是命中不了缓存——只要前缀里有一点变化，比如时间戳、文件内容、工具返回结果，缓存就整个失效。
第四段才是你真正关心的业务内容，比如代码片段、RAG 召回的文档、日志。
复现实验的价值就在这里：把这四段分别量化，你才知道「长上下文成本高」到底高在哪一段。
做法很简单，构造四组请求，每组只改变一个变量：
# 变体 1：只有 system prompt # 变体 2：system prompt + 工具 schema # 变体 3：变体 2 + 10 轮历史 # 变体 4：变体 3 + 32K 业务正文每组记录prompt_tokens，差值就是该段的实际开销。工具 schema 那段经常是最容易被低估的，尤其是工具数量多的时候。
还有一个更隐蔽的消耗点：**工具返回结果也被算进下一轮的 prompt。**比如一次文件读取返回了 8K token 的内容，它不只在当前轮计费，还会作为历史进入后续每一轮。如果你在一个长会话里连续读了几十个文件，历史段的体积会指数级膨胀。这也是为什么很多 Agent 任务在十几轮之后成本突然失控——不是模型变贵了，是历史在滚雪球。
7. 并发对照实验：缓存命中率随并发怎么变
单请求的曲线跑通之后，加一层并发，观察指标的衰减。
并发档位取 1 / 2 / 4 / 8，每档固定跑 60 秒，观测三个指标：缓存命中率、首 token 延迟（TTFT）的 P50 和 P95、总吞吐（tokens/s）。
#!/usr/bin/env bash set -euo pipefail for C in 1 2 4 8; do echo "=== concurrency ${C} ===" python vram_sampler.py "vram_c${C}.csv" 100 70 & SAMPLER=$! python load_gen.py --concurrency "$C" --duration 60 --out "load_c${C}.csv" wait $SAMPLER done对照表大致长这样（数值是示意，以你自己的实测为准）：
并发 缓存命中率 TTFT-P50 TTFT-P95 吞吐(tokens/s) 1 ~ 高 低 低 基线 2 ~ 高 略升 略升 ~2x 4 开始下滑 明显上升 明显上升 < 4x 8 明显下滑 高 很高 增长趋缓甚至下降**怎么解读这张表。**并发升高时，吞吐增长会先于延迟恶化见顶。见顶的位置取决于服务端的显存余量和调度策略。如果你看到并发从 4 到 8 时吞吐几乎不动、而 P95 延迟翻倍，说明已经进入排队区，继续加并发只会拉高成本。
**缓存命中率为什么随并发掉。**因为并发请求的前缀大概率不同，服务端需要在显存里同时驻留多份 KV cache。显存吃紧时，调度器会优先保住活跃请求、淘汰冷前缀，于是原本能命中的请求变成未命中，prompt_tokens 的计费口径随之变化。这就是「谁在消耗 Token」在并发场景下的真实答案：不是某个请求特别长，而是并发把缓存挤掉了。
实验控制要点。
第一，负载生成器要保证每个并发 worker 的 prompt 长度一致，否则对照没有意义。
第二，客户端并发不等于服务端并发。连接池大小、HTTP keep-alive 设置都会影响实际到达服务端的请求数，脚本里显式设好。
第三，每档之间留 30 秒冷却，让缓存自然失效，避免上一档的残留影响下一档。
8. 曲线不合预期时的排查清单
实验跑完，如果你的曲线和预期差得比较远，按这个顺序排查：
现象一：本地显存完全没变化。你走的是 API 路径，模型不在本地，显存当然不动。这时候该看scan_result.csv而不是vram_scan.csv。如果两条都在看，先确认自己到底在测哪条路径。
现象二：prompt_tokens和输入文本严重不成比例。按第 6 节的四段拆解法逐段量化。先关掉所有工具再测一次，差值就是工具 schema 的开销。
现象三：同一段 prompt 两次请求的prompt_tokens不一样。通常是客户端在某处注入了动态内容，比如当前时间、随机 ID、会话标识。把客户端日志打开，把请求体完整打出来比对，差异通常一眼可见。
现象四：延迟曲线在某档长度后突然上翘。先用采样器看这段时间的显存利用率。如果显存接近上限，说明跌进了换出区间；如果显存有余量但利用率打满，那是计算瓶颈，跟 KV cache 无关。
现象五：缓存命中率一直是 -1。说明响应体没透出缓存字段。换个判断方式：连发两次完全相同前缀的请求，看第二次的prompt_tokens是否下降。或者去控制台看用量明细，有的网关在控制台侧提供缓存统计。
现象六：并发一加就 429 或超时。先确认 Key 的配额和并发限制，再看客户端连接池。两者都正常的话，把并发档位降到 2 重测一遍，确认是容量问题还是配置问题。
排查过程中如果怀疑是 Key 或配额的问题，直接去控制台核对：https://taotoken.net/console/api-keys?utm_source=taotoken_aicg_blog_end&utm_content=kv_cache_repro_troubleshoot
9. 把复现链路固化下来
这套实验真正有价值的部分不是某一次曲线好不好看，而是链路本身可以反复跑。固化下来的东西有三样：
采样脚本要版本化。vram_sampler.py和probe.py放进仓库，采样间隔、持续时间、长度档位写成配置而不是硬编码，这样下次换模型或换并发策略，只需要改配置。
基线数据要留档。每次换模型、换网关、换客户端版本，都先跑一遍基线，把 CSV 存下来。有了基线，你才能判断某次性能波动是模型变化导致的，还是自己环境动过。
对照表要定期重跑。缓存命中率和并发的关系不是静态的，它会随服务端调度策略变化。每月跑一次，用自己的数据替代任何二手结论。
复现这件事还有一个常被忽略的收益：你会非常清楚地知道自己的 Agent 到底在哪一环烧钱。是工具 schema 太肥，是历史轮次没做裁剪，还是 RAG 召回塞得太多。这三个问题定位清楚之后，优化空间通常比换模型大得多。
想直接对比不同模型在同样 prompt 下的表现，可以在模型对话页里手动试几轮，快速建立直觉：https://taotoken.net/models/detail/chat?utm_source=taotoken_aicg_blog_end&utm_content=kv_cache_repro_chat
如果你打算把 Claude Code 这类工具长期挂在同一条链路上跑，Coding Plan 的配额模型比按量计费更好做实验规划，至少不用每次跑扫描都担心额度跳变：https://taotoken.net/coding-plan?utm_source=taotoken_aicg_blog_end&utm_content=kv_cache_repro_plan
实验开始前记得先把 Key 建好，脚本里所有YOUR_API_KEY都替换成真实值：https://taotoken.net/console/api-keys?utm_source=taotoken_aicg_blog_end&utm_content=kv_cache_repro_cta
Claude Code 的完整配置项和ANTHROPIC_*变量说明在这里，改settings.json之前建议先对一遍：https://taotoken.net/doc/ClaudeCodeAnthropic?utm_source=taotoken_aicg_blog_end&utm_content=kv_cache_repro_doc
最后再强调一遍顺序：先固定 Base URL 为 https://taotoken.net/api ，再建 Key，再跑基线，最后才开始做长度扫描和并发对照。顺序错了，后面所有曲线都得重跑。
