适用场景与目标

过去 24 小时的最强信号（与 6/22 AI 快报主线 呼应）：

• 6 月 18 日 08:02 UTC：用户 openclaw 在 openai/codex#28879 提交完整 session 日志：6 月 12 日 57K-token 提示 + 3.6K reasoning 消耗 5h 预算的 1%；6 月 18 日 20K-token 提示 + 0 reasoning 消耗 5h 预算的 10–27%。per-token limit cost 涨 10–20×，Plus/Pro/Pro Lite/Hermes 多档用户全部实证。
• 截至 6 月 22 日 01:45 UTC：issue reactions 282（9 倍增长）、评论 100+、OpenAI 官方 0 回应；OpenAI status page 自 6 月 16 日起挂有 degraded incident 持续 6 天仍未关闭。
• 同周对照：Ars Technica 6/19 报道 Anthropic 「暂停」Claude Agent SDK token 计费——5/13 公告涨、6/15 生效、6/16 在用户抗议下 pause；同周 [GitHub Copilot 4 月涨价] 完成「订阅制 → token 制」迁移。
• TechCrunch 6/18：OpenAI 已秘密提交 IPO 招股书——Q2 2026 营收压力测试 + 估值支撑 = H2 进一步涨价的强信号。

6/18 + 6/19 + 6/20 + 6/21 + 6/22 的工程化推论：

时间	信号	工程化产物
6/18	Codex per-token cost 涨 10–20×	「订阅预算实测」必须跑一次
6/19	Anthropic pause Claude Agent SDK	「跨厂商备份」必须建
6/20	HN 全网讨论「cancel my subscription」	「API 兜底」必须接入
6/21	OpenAI IPO 招股书	「自托管兜底」必须评估
6/22	openai/codex#28879 6 天无回应	「本周必须重构主力 AI 环境为三层兜底」

这篇不讨论「要不要继续订阅 ChatGPT Plus」。这篇解决「ChatGPT Plus / Claude Pro / Cursor Pro 任一家被悄悄砍半预算 / 突然降级 / 突然涨价时，主力 AI 开发环境如何在 30 分钟内无感切换到「订阅主力 + API 兜底 + 自托管」三层兜底架构，把单点依赖风险从「业务连续性事故」降到「后台自动降级」。

适用场景：

• 你在用 ChatGPT Plus / Claude Pro / Cursor Pro / GitHub Copilot Pro / Windsurf Pro 任一款订阅当主力 Coding Agent / IDE AI 助手 / 文档 Agent
• 你在跑 Codex CLI / Claude Code CLI / Cline / Continue.dev / Aider 任一款 CLI Coding Agent——Agent 自动循环调用 = 单次 session 消耗 5h 预算 10–27% = 一周可能跑满 weekly cap
• 你的团队在用 ChatGPT Team / Claude Team / Cursor Business 多人共享——单家订阅降级 = 整个团队 AI 工具断供
• 你在做 AI 自动化 / RAG / Agent Pipeline 跑生产——订阅制 weekly cap 不适用于生产 SLA
• 你的公司在做 AI 采购 / 成本核算 / 续约决策——单家订阅 > 50% 团队 AI 预算 = 单点依赖风险
• 你在做 企业内部 AI 数据合规——敏感数据能不能走 OpenAI API？要不要本地模型兜底？
• 你的 AI 编码环境依赖某个订阅 tier 名义 budget——今天起「实际 budget = 名义 budget × 50%」必须写进成本模型

核心目标（一周）：

1. D+0（今天，3 小时）：跑「真实 prompt 预算实测」，把今天 5 个最常用 prompt × 3 家订阅的实测 budget 写进表格
2. D+1：接入 API 兜底——给 OpenAI / Anthropic 各开 1 个 API key，按 token 付费，无 weekly cap
3. D+2：部署 自托管兜底——本机 / 内网 GPU 跑 Ollama + Qwen3-30B-A3B / DeepSeek-V3 / Llama-3.3-70B
4. D+3：用 LiteLLM Router 把「订阅 → API → 自托管」三层串成统一 endpoint，客户端无感
5. D+4：建 成本 dashboard（OpenTelemetry + Grafana / 自建 SQLite + Streamlit），实时看「订阅 budget 剩余 / API 月度 cost / 自托管 GPU 利用率」
6. D+5：跑 断网演练——强制关掉 ChatGPT Plus 流量，验证 API + 自托管是否能在 30 分钟内顶上
7. D+6：写 runbook——「ChatGPT Plus 降级 → API 顶上」「OpenAI API 限速 → 自托管顶上」「GPU 节点宕机 → 切回订阅」三套切换手册
8. D+7：产出**「AI 主力环境三层兜底架构 v1.0 + 成本 dashboard + 切换 runbook + 30/90 天路线图」**，给 VP Eng / CTO walkthrough

---

最小可行方案（MVP）步骤

下面这套流程对照 openai/codex#28879 主帖证据 + Ars Technica 6/19 + LiteLLM 官方文档 + Ollama 官方文档 验证；前 3 步 1 天内可完成。

阶段 0：先跑真实预算实测（Day 0，3 小时）

不要直接重构三层兜底，先回答三个问题——openai/codex#28879 教会的第一课就是「先测，再重构」：

# 1) 选 5 个你最常用的真实 prompt（不要拿 benchmark 凑数）
#    a) 代码生成: "给这个 TypeScript 函数加单元测试"
#    b) 长文摘要: "把这 50 页 PDF 摘要成 500 字"
#    c) 数据分析: "从这 1000 行 CSV 找异常值"
#    d) 翻译: "把这 30 段英文技术文档翻成中文"
#    e) 文档改写: "把这个 README 改成博客风格"

# 2) 每个 prompt 在 ChatGPT Plus / Claude Pro / Cursor Pro 各跑 10 次
#    用 browser dev tools / network panel 抓每次响应的 token_count + rate_limits payload
#    记录到 /tmp/budget-benchmark.csv：
#    prompt_id,provider,plan,date,prompt_tokens,completion_tokens,reasoning_tokens,budget_pct_used

# 3) 计算 "per-prompt budget cost" = budget_pct_used / prompts_per_session
#    对照 openai/codex#28879 主帖:
#    - 6/12 normal: 57K-token prompt = 1% budget (per-token cost = 1/57K = 1.75e-5)
#    - 6/18 broken: 20K-token prompt = 10-27% budget (per-token cost = 5e-4 to 1.35e-3)
#    - ratio: 28-77 倍 per-token 单价暴涨

# 4) 用今天的实测数据 × 10-20× 系数做 "3 个月后预算压力测试"
#    公式: projected_budget_pct = today_budget_pct × (1 + 10) = 11x
#    如果 projected > 100%, 立即降级该订阅 tier 或换 API

实测模板：

prompt_id,provider,plan,date,prompt_tokens,completion_tokens,reasoning_tokens,budget_pct_used,per_token_cost
code-gen-001,chatgpt,plus,2026-06-22,1200,800,0,0.8,4.0e-7
code-gen-001,chatgpt,plus,2026-06-22,1500,950,0,0.95,3.9e-7
...
long-summary-001,claude,pro,2026-06-22,48000,1200,0,3.2,6.6e-8
long-summary-001,claude,pro,2026-06-22,51000,1500,0,3.5,6.7e-8

判断标准：

• 任何订阅 tier per_token_cost 单日波动 > 5× → 立刻降级或换 API（说明厂商在悄悄调权重）
• 任何订阅 tier 3 个月压力测试后 budget_pct > 100% → 立刻重构为三层兜底
• 任何 prompt 实测 budget_pct > 厂商文档声称的 2× → 写进团队 SOP「该 prompt 不走订阅，走 API」

阶段 1：接入 API 兜底（Day 1，2 小时）

API 是唯一没有 weekly cap 的兜底——按 token 付费，账单可控，SLA 由厂商保证。

# 1) OpenAI API key（按 token 付费，无 5h/weekly 预算）
#    https://platform.openai.com/api-keys
#    建议: 创建 1 个 "fallback-only" key，单独计费，配 hard monthly cap
export OPENAI_API_KEY=sk-proj-...
#    在 OpenAI dashboard 设 usage limit = 月度 AI 预算的 50%（防止失控）

# 2) Anthropic API key
#    https://console.anthropic.com/settings/keys
export ANTHROPIC_API_KEY=sk-ant-...

# 3) Google Gemini API key（第三家兜底，避免双点故障）
#    https://aistudio.google.com/apikey
export GEMINI_API_KEY=AIza...

# 4) 把三个 key 写进 ~/.ai-fallback/.env（权限 600，不要进 git）
mkdir -p ~/.ai-fallback && chmod 700 ~/.ai-fallback
cat > ~/.ai-fallback/.env <<'EOF'
OPENAI_API_KEY=sk-proj-...
ANTHROPIC_API_KEY=sk-ant-...
GEMINI_API_KEY=AIza...
EOF
chmod 600 ~/.ai-fallback/.env

API 兜底的核心原则：

• 按 token 付费 = 100% 可见成本——每月账单 = 调用次数 × avg tokens × 单价，没有任何「per-token cost 悄悄涨 10×」的盲区
• OpenAI / Anthropic / Gemini 三家都开——任何一家涨价 / 限速 / 故障，另两家立刻顶上
• 月度 hard cap——OpenAI dashboard 设 hard limit（如 200 USD/月），超额自动 429，不会失控
• 不要把生产 API key 写进 chat client 配置——用 LiteLLM 统一路由（阶段 3）

阶段 2：部署自托管兜底（Day 2-3，4-8 小时）

自托管是唯一不依赖任何厂商的兜底——GPU + 本地模型 + 内网推理，SLA 由你控制。

# 1) 本机 GPU 检查（最低 24GB VRAM 跑 Qwen3-30B-A3B 量化版）
nvidia-smi --query-gpu=name,memory.total,memory.free --format=csv
#    24GB → Qwen3-30B-A3B-Q4_K_M (~18GB)
#    48GB → Qwen3-32B-Q4_K_M (~20GB) 或 Llama-3.3-70B-Q4_K_M (~40GB)
#    80GB → DeepSeek-V3-Q4 (~45GB) 或 Qwen3-235B-A22B-Q4

# 2) 安装 Ollama（最简的本地 LLM runtime）
curl -fsSL https://ollama.com/install.sh | sh
ollama --version

# 3) Pull 一个 "兜底主力" 模型——Qwen3-30B-A3B（MoE 架构，激活 3B，性能接近 30B）
ollama pull qwen3:30b-a3b-q4_K_M
#    备选: ollama pull deepseek-v3:q4_K_M (需要 48GB+ VRAM)
#    备选: ollama pull llama3.3:70b-q4_K_M (需要 48GB+ VRAM)

# 4) 启动 Ollama 服务（默认监听 127.0.0.1:11434）
ollama serve &
#    验证:
curl http://127.0.0.1:11434/api/tags | jq .

# 5) 测试推理
curl http://127.0.0.1:11434/api/generate -d '{
  "model": "qwen3:30b-a3b-q4_K_M",
  "prompt": "用一句话解释 per-token rate limit cost 是什么"
}'

无 GPU 机器的备选：

# 选项 A: CPU 推理（慢但能用）
ollama pull qwen3:1.7b-q4_K_M
#    1.7B 模型在 CPU 上能跑到 10-20 tokens/s，日常编码辅助够用

# 选项 B: 云 GPU spot instance（vLLM）
#    AWS p4d.24xlarge / Lambda 8xA100 spot / RunPod / Vast.ai
#    按小时付费 ~$1-3/h，比 OpenAI API 便宜 70-90%
pip install vllm
vllm serve Qwen/Qwen3-30B-A3B-Instruct --quantization awq --gpu-memory-utilization 0.9

# 选项 C: Apple Silicon（M-series Mac）
ollama pull qwen3:30b-a3b-q4_K_M
#    M3 Max 128GB 跑 30B-Q4 能到 15-25 tokens/s

⚠️ 避坑：自托管模型性能 < GPT-4o / Claude Sonnet——复杂推理 / 长代码生成 / 多轮 agent 循环可能要 2-3 次重试才能拿到等价结果。自托管只兜底「文档改写 / 简单生成 / 离线补全」，不兜底「复杂 agent 循环」。

阶段 3：用 LiteLLM 统一路由三层（Day 3，3 小时）

LiteLLM 是OpenAI API 兼容的统一代理——把「订阅（OpenAI API 模拟）/ OpenAI API / Anthropic API / Ollama」三层串成 1 个 endpoint，客户端无感切换。

# 1) 安装 LiteLLM
pip install 'litellm[proxy]'  # 用 venv
#    或: pipx install litellm

# 2) 写 config.yaml（三层兜底路由）
cat > ~/.ai-fallback/litellm-config.yaml <<'EOF'
model_list:
  # ---- 主力：OpenAI API（按 token 付费，无 weekly cap）----
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: os.environ/OPENAI_API_KEY
      rpm: 500
      tpm: 200000

  - model_name: gpt-5
    litellm_params:
      model: openai/gpt-5
      api_key: os.environ/OPENAI_API_KEY
      rpm: 200
      tpm: 100000

  - model_name: claude-sonnet
    litellm_params:
      model: anthropic/claude-sonnet-4.5
      api_key: os.environ/ANTHROPIC_API_KEY
      rpm: 400
      tpm: 150000

  # ---- 兜底：本机 Ollama（自托管，无厂商依赖）----
  - model_name: local-qwen
    litellm_params:
      model: ollama/qwen3:30b-a3b-q4_K_M
      api_base: http://127.0.0.1:11434

  - model_name: local-deepseek
    litellm_params:
      model: ollama/deepseek-v3:q4_K_M
      api_base: http://127.0.0.1:11434

# ---- 路由策略：fallbacks（按优先级降级）----
router_settings:
  num_retries: 2
  timeout: 30
  enable_pre_call_checks: true

# ---- Fallback chain：gpt-4o → gpt-5 → claude-sonnet → local-qwen ----
fallbacks:
  - gpt-4o: ["gpt-5", "claude-sonnet", "local-qwen"]
  - gpt-5: ["claude-sonnet", "gpt-4o", "local-qwen"]
  - claude-sonnet: ["gpt-4o", "gpt-5", "local-qwen"]
EOF

# 3) 启动 LiteLLM proxy（默认 127.0.0.1:4000，OpenAI 兼容）
litellm --config ~/.ai-fallback/litellm-config.yaml --port 4000 --num_workers 4
#    验证:
curl http://127.0.0.1:4000/v1/models | jq .

# 4) 客户端接入（任何 OpenAI 兼容 client 都能用）
export OPENAI_API_BASE=http://127.0.0.1:4000
export OPENAI_API_KEY=litellm-fallback  # 任意字符串，LiteLLM 不校验
#    Cursor / Cline / Aider / Claude Code / 自研 client 全部接入这一个 endpoint

⚠️ 避坑：LiteLLM proxy 本身单点故障——必须用 systemd / pm2 守护，崩了自动重启：

# systemd unit
cat > /etc/systemd/system/litellm.service <<'EOF'
[Unit]
Description=LiteLLM AI Fallback Router
After=network.target ollama.service

[Service]
Type=simple
User=claw
EnvironmentFile=/home/claw/.ai-fallback/.env
ExecStart=/usr/local/bin/litellm --config /home/claw/.ai-fallback/litellm-config.yaml --port 4000
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now litellm
sudo systemctl status litellm

阶段 4：建成本 dashboard（Day 4，4 小时）

成本可见是对付「悄悄涨价」的唯一武器——订阅预算 / API cost / 自托管 GPU 成本实时看，任何异常立刻告警。

# /home/claw/.ai-fallback/cost_tracker.py
# 监听 LiteLLM proxy 的 /spend/logs 端点，写 SQLite + 出 Streamlit dashboard

import os, time, sqlite3, requests
from datetime import datetime
from pathlib import Path

DB_PATH = Path.home() / ".ai-fallback" / "cost.db"
LITELLM_BASE = os.environ.get("LITELLM_BASE", "http://127.0.0.1:4000")
LITELLM_KEY = os.environ.get("LITELLM_MASTER_KEY", "sk-litellm-fallback")

def init_db():
    DB_PATH.parent.mkdir(parents=True, exist_ok=True)
    conn = sqlite3.connect(DB_PATH)
    conn.execute("""
        CREATE TABLE IF NOT EXISTS spend (
            ts TEXT, model TEXT, prompt_tokens INT, completion_tokens INT,
            cost_usd REAL, latency_ms INT, fallback_chain TEXT
        )
    """)
    conn.commit()
    return conn

def poll_spend():
    """每 60 秒拉一次 LiteLLM /spend/logs"""
    conn = init_db()
    last_seen = None
    while True:
        try:
            r = requests.get(
                f"{LITELLM_BASE}/spend/logs?start_date={last_seen or '2026-06-22'}",
                headers={"Authorization": f"Bearer {LITELLM_KEY}"},
                timeout=10,
            )
            r.raise_for_status()
            for entry in r.json():
                conn.execute(
                    "INSERT INTO spend VALUES (?,?,?,?,?,?,?)",
                    (
                        entry.get("startTime"),
                        entry.get("model"),
                        entry.get("prompt_tokens", 0),
                        entry.get("completion_tokens", 0),
                        entry.get("spend", 0.0),
                        entry.get("latency_ms", 0),
                        ",".join(entry.get("fallbacks", [])),
                    ),
                )
            conn.commit()
            last_seen = datetime.utcnow().isoformat()
        except Exception as e:
            print(f"[warn] poll failed: {e}")
        time.sleep(60)

if __name__ == "__main__":
    poll_spend()

# /home/claw/.ai-fallback/dashboard.py
# Streamlit 成本 dashboard：订阅 budget 剩余 / API 月度 cost / 自托管 GPU 利用率

import streamlit as st
import sqlite3
import pandas as pd
from pathlib import Path

DB_PATH = Path.home() / ".ai-fallback" / "cost.db"
st.set_page_config(page_title="AI Cost Dashboard", layout="wide")

st.title("🤖 AI 三层兜底 · 成本 dashboard")

conn = sqlite3.connect(DB_PATH)
df = pd.read_sql("SELECT * FROM spend", conn, parse_dates=["ts"])

# 关键指标
col1, col2, col3, col4 = st.columns(4)
col1.metric("今日 spend (USD)", f"${df[df.ts > pd.Timestamp.now() - pd.Timedelta(days=1)]['cost_usd'].sum():.2f}")
col2.metric("本月 spend (USD)", f"${df[df.ts > pd.Timestamp.now() - pd.Timedelta(days=30)]['cost_usd'].sum():.2f}")
col3.metric("本月 call 数", f"{len(df[df.ts > pd.Timestamp.now() - pd.Timedelta(days=30)]):,}")
col4.metric("avg latency (ms)", f"{df['latency_ms'].mean():.0f}")

# 按模型拆分
st.subheader("按模型 spend 分布")
st.bar_chart(df.groupby("model")["cost_usd"].sum())

# Fallback 触发率
st.subheader("Fallback 触发率（悄悄涨价 / 限速时此曲线会飙升）")
df["hit_fallback"] = df["fallback_chain"].str.len() > 0
fallback_rate = df.groupby(pd.Grouper(key="ts", freq="H"))["hit_fallback"].mean()
st.line_chart(fallback_rate)

# 异常告警：per-token cost 单日波动 > 5×
st.subheader("🚨 per-token cost 异常告警")
df["per_token_cost"] = df["cost_usd"] / (df["prompt_tokens"] + df["completion_tokens"]).clip(lower=1)
daily_pivot = df.groupby([pd.Grouper(key="ts", freq="D"), "model"])["per_token_cost"].mean().unstack()
daily_ratio = daily_pivot.div(daily_pivot.iloc[0])  # 对比首日
if (daily_ratio.max().max() > 5):
    st.error(f"⚠️ per-token cost 单日波动 > 5× — 厂商可能在悄悄涨价！立即检查订阅 tier。")
st.dataframe(daily_ratio.tail(7))

# 原始日志
st.subheader("原始 spend log")
st.dataframe(df.tail(100))

# 启动 cost tracker + dashboard
nohup python ~/.ai-fallback/cost_tracker.py > ~/.ai-fallback/cost_tracker.log 2>&1 &
streamlit run ~/.ai-fallback/dashboard.py --server.port 8501 --server.address 127.0.0.1

dashboard 关键指标：

• per-token cost 单日波动 > 5× → 厂商悄悄涨价信号（openai/codex#28879 同款检测）
• Fallback 触发率 > 20% → 主力订阅 budget 不足，立即切 API
• 月度 cost > 团队 AI 预算 80% → 自动告警给财务 + VP Eng

阶段 5：跑断网演练（Day 5，2 小时）

三层兜底建好后必须演练——纸上架构 ≠ 真能切。

# 1) 演练 1：关掉 ChatGPT Plus 流量，验证 API + 自托管顶上
#    在 LiteLLM config 里临时注释掉 gpt-4o 的 litellm_params:
#      - model_name: gpt-4o
#        litellm_params: {model: openai/gpt-4o, ...}
#        ↑ 改成: model: openai/gpt-4o-disabled
sudo systemctl restart litellm

# 2) 跑 20 个最常用 prompt，看是否全部能 fallback 到 gpt-5 / claude-sonnet / local-qwen
for prompt in "写一个 Python 函数" "翻译这段文档" "重构这段代码"; do
  curl -X POST http://127.0.0.1:4000/v1/chat/completions \
    -H "Content-Type: application/json" \
    -d "{\"model\":\"gpt-4o\",\"messages\":[{\"role\":\"user\",\"content\":\"$prompt\"}]}" \
    | jq '.model, .choices[0].message.content[:50]'
done

# 3) 演练 2：OpenAI API 限速（429），验证自托管顶上
#    在 LiteLLM config 里临时把 OpenAI rpm 调到 1:
#      rpm: 1
sudo systemctl restart litellm
#    连发 20 个请求，看是否触发 fallback 到 local-qwen
hey -n 20 -c 5 -m POST -T "application/json" \
  -d '{"model":"gpt-4o","messages":[{"role":"user","content":"hello"}]}' \
  http://127.0.0.1:4000/v1/chat/completions

# 4) 演练 3：GPU 节点宕机，验证订阅 / API 顶上
sudo systemctl stop ollama
#    连发 10 个请求，看是否触发 fallback 到 API
curl -X POST http://127.0.0.1:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"local-qwen","messages":[{"role":"user","content":"hello"}]}' \
  | jq '.model'

# 5) 演练 4：全网断网（极端场景），验证本地模型是最后兜底
sudo iptables -A OUTPUT -p tcp --dport 443 -j DROP  # 阻断所有 HTTPS
curl -X POST http://127.0.0.1:4000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model":"gpt-4o","messages":[{"role":"user","content":"hello"}]}' \
  | jq '.model'
#    应该 fallback 到 local-qwen（因为 Ollama 还在 127.0.0.1:11434）
sudo iptables -D OUTPUT -p tcp --dport 443 -j DROP  # 恢复

断网演练判断标准：

• 任何 fallback 链路 30 秒内未触发 → 调整 LiteLLM timeout 或 num_retries
• 任何 fallback 链路 成功率 < 95% → 调整 fallback chain 顺序（如把 local-qwen 提前）
• 任何 fallback 链路 latency 飙升 > 10× → 检查 fallback 模型配置（如 local-qwen 需要更大 batch）

阶段 6：写切换 runbook（Day 6-7，4 小时）

把三层兜底的所有「什么时候切、切到哪、怎么切」写成 runbook，新人照着做就行：

# AI 三层兜底切换 runbook v1.0

## 场景 1：ChatGPT Plus 5h 预算耗尽（最常见）
**触发条件**：LiteLLM dashboard 显示 fallback_rate > 30%，且 fallback 链首个 = gpt-4o
**自动行为**：LiteLLM 自动 fallback 到 gpt-5 / claude-sonnet / local-qwen（已配置）
**人工动作**：
  1. 看 dashboard 的 "今日 spend" 是否异常
  2. 如果是 per-token cost 异常（悄悄涨价），立即发团队 Slack 通知
  3. 检查 openai/codex 是否有新 issue
**无需操作**：LiteLLM 已自动处理

## 场景 2：OpenAI API 全站 5xx（[openai/status](https://status.openai.com/) degraded）
**触发条件**：OpenAI API 连续 5 分钟 5xx 率 > 50%
**自动行为**：LiteLLM 自动 fallback 到 claude-sonnet / local-qwen
**人工动作**：
  1. 看 [status.openai.com](https://status.openai.com/) 是否挂了 incident
  2. 临时调高 Claude / Gemini 月度 cap（如 200→500 USD）
  3. 如果 incident > 1 小时，发团队 Slack 通知 "今日主力 = Claude"
**无需操作**：LiteLLM 已自动处理

## 场景 3：Anthropic 涨价 / 限速（同 [6/19 Claude Agent SDK](https://arstechnica.com/ai/2026/06/anthropic-pauses-token-based-billing-for-its-claude-agent-sdk/)）
**触发条件**：Anthropic API 单价上涨 / 限速
**自动行为**：LiteLLM 自动 fallback 到 gpt-4o / local-qwen
**人工动作**：
  1. 看 Anthropic changelog 公告
  2. 评估是否长期涨价 → 调整 LiteLLM fallback chain 优先级
  3. 长期涨价 > 30% → 重写团队 cost model

## 场景 4：自托管 GPU 宕机（硬件故障 / OOM）
**触发条件**：Ollama / vLLM 不可达
**自动行为**：LiteLLM 检测到 local-qwen 不可用，自动跳过 fallback 到 API
**人工动作**：
  1. nvidia-smi 检查 GPU 状态
  2. journalctl -u ollama 看日志
  3. 临时切到云 GPU spot（vLLM on Lambda / RunPod）
  4. 长期 GPU 故障 → 申请新机器 / 用云 GPU 顶上

## 场景 5：全网断网（极端）
**触发条件**：本机完全断网
**自动行为**：LiteLLM 全部 fallback 到 local-qwen（Ollama 仍在 127.0.0.1:11434）
**人工动作**：
  1. 切换到离线模式
  2. 用 local-qwen 跑非关键任务
  3. 等网络恢复

---

关键实现细节

LiteLLM Router：把三层兜底串成一个 endpoint

LiteLLM Router 是整套架构的核心——它把「订阅 / API / 自托管」三层抽象成 OpenAI 兼容的 1 个 endpoint，所有客户端（Cursor / Cline / Aider / Claude Code / 自研 Agent）只配 1 个 OPENAI_API_BASE 就能享受三层兜底。

关键配置：

# ~/.ai-fallback/litellm-config.yaml
model_list:
  # 主力订阅（OpenAI API 按 token 付费 = 订阅制的"无 weekly cap"等价物）
  - model_name: gpt-4o
    litellm_params:
      model: openai/gpt-4o
      api_key: os.environ/OPENAI_API_KEY
      rpm: 500
      tpm: 200000
      # 关键: 设月度 hard cap
      max_budget: 200  # USD
      budget_duration: 30d

  # 第二主力（Anthropic API，避免双点故障）
  - model_name: claude-sonnet
    litellm_params:
      model: anthropic/claude-sonnet-4.5
      api_key: os.environ/ANTHROPIC_API_KEY
      rpm: 400
      tpm: 150000

  # 第三主力（Google Gemini，多家兜底）
  - model_name: gemini-pro
    litellm_params:
      model: gemini/gemini-2.5-pro
      api_key: os.environ/GEMINI_API_KEY

  # 自托管兜底（本机 Ollama，零厂商依赖）
  - model_name: local-qwen
    litellm_params:
      model: ollama/qwen3:30b-a3b-q4_K_M
      api_base: http://127.0.0.1:11434
      rpm: 30  # 本机 GPU 推理上限
      tpm: 10000

# Fallback chain：按优先级降级（核心策略）
router_settings:
  num_retries: 2
  timeout: 30
  enable_pre_call_checks: true
  allowed_fails: 3  # 3 次失败后切下一个
  cooldown_time: 30  # 冷却 30 秒后再试

general_settings:
  master_key: os.environ/LITELLM_MASTER_KEY
  database_url: "sqlite:////home/claw/.ai-fallback/litellm.db"
  # 开启 spend log（喂给 cost dashboard）
  proxy_batch_write_at: 5

litellm_settings:
  drop_params: true
  set_verbose: false
  telemetry: false

# Fallback 链定义
model_group_aliases:
  - name: "primary"
    models: ["gpt-4o", "claude-sonnet", "gemini-pro", "local-qwen"]
  - name: "coding"
    models: ["claude-sonnet", "gpt-4o", "gemini-pro", "local-qwen"]
  - name: "long-context"
    models: ["gemini-pro", "claude-sonnet", "gpt-4o", "local-qwen"]

客户端接入（一行环境变量，所有 IDE / Agent 通用）：

# 任何 OpenAI 兼容 client（Cursor / Cline / Aider / 自研）都能用
export OPENAI_API_BASE=http://127.0.0.1:4000
export OPENAI_API_KEY=litellm-fallback  # 任意字符串

关键代码片段：用 LiteLLM SDK 直接调用（Python）：

from litellm import completion

# 默认走 primary chain（gpt-4o → claude-sonnet → gemini-pro → local-qwen）
response = completion(
    model="primary",
    messages=[{"role": "user", "content": "写一个 TypeScript 函数"}],
)
print(response.choices[0].message.content)
print(f"实际用了: {response.model}")  # 看 fallback 到哪了

# 强制走本地（离线场景）
response = completion(
    model="local-qwen",
    messages=[{"role": "user", "content": "hello"}],
)

# 强制走 coding 专用链
response = completion(
    model="coding",
    messages=[{"role": "user", "content": "重构这段 Python"}],
)

Ollama 自托管：零厂商依赖的最后兜底

Ollama 是当前最简的本地 LLM runtime——一行命令起服务，OpenAI 兼容 API，自动 model 管理。

# 1) 安装（macOS / Linux 一键）
curl -fsSL https://ollama.com/install.sh | sh

# 2) Pull 模型（Qwen3-30B-A3B = MoE 架构，激活 3B 性能接近 30B，VRAM 友好）
ollama pull qwen3:30b-a3b-q4_K_M
#    模型大小对比:
#    - qwen3:1.7b        (1.1GB)   - CPU 推理可用
#    - qwen3:8b          (4.7GB)   - 16GB VRAM
#    - qwen3:30b-a3b     (18GB)    - 24GB VRAM (推荐主力)
#    - qwen3:32b         (20GB)    - 24GB VRAM
#    - llama3.3:70b      (40GB)    - 48GB VRAM
#    - deepseek-v3:q4    (45GB)    - 80GB VRAM
#    - qwen3:235b-a22b   (130GB)   - 4×H100

# 3) 启动服务
ollama serve &
#    默认监听 127.0.0.1:11434，OpenAI 兼容端点: /v1/chat/completions

# 4) 验证 OpenAI 兼容
curl http://127.0.0.1:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3:30b-a3b-q4_K_M",
    "messages": [{"role": "user", "content": "hello"}]
  }'

# 5) 性能监控
watch -n 5 'nvidia-smi --query-gpu=utilization.gpu,memory.used,memory.free --format=csv'

# 6) 模型热切换（不重启服务）
ollama pull qwen3:32b-q4_K_M
#    LiteLLM 配置改 model_name 即可，零停机

生产部署（systemd）：

cat > /etc/systemd/system/ollama.service <<'EOF'
[Unit]
Description=Ollama Local LLM
After=network.target

[Service]
Type=simple
User=claw
Environment="OLLAMA_HOST=127.0.0.1:11434"
Environment="OLLAMA_MODELS=/home/claw/.ollama/models"
ExecStart=/usr/local/bin/ollama serve
Restart=always
RestartSec=5
# GPU 隔离
Environment="NVIDIA_VISIBLE_DEVICES=0"

[Install]
WantedBy=multi-user.target
EOF
sudo systemctl daemon-reload
sudo systemctl enable --now ollama

成本监控：把「悄悄涨价」变成可观测事件

成本 dashboard 的核心价值不是看花了多少钱，而是第一时间发现 per-token cost 单日波动 > 5×——这是 openai/codex#28879 主帖证据的核心信号：per-token limit cost 涨 10–20× 就是悄悄涨价的标志。

# /home/claw/.ai-fallback/alert.py
# per-token cost 异常告警 → Slack / 飞书 / 邮件

import sqlite3, requests
from pathlib import Path
from datetime import datetime, timedelta

DB_PATH = Path.home() / ".ai-fallback" / "cost.db"
SLACK_WEBHOOK = "https://hooks.slack.com/services/..."  # 替换

def check_anomaly():
    conn = sqlite3.connect(DB_PATH)
    cur = conn.cursor()

    # 拉最近 7 天的 per-token cost
    cur.execute("""
        SELECT date(ts) as day, model,
               SUM(cost_usd) / (SUM(prompt_tokens) + SUM(completion_tokens)) as per_token_cost
        FROM spend
        WHERE ts > date('now', '-7 days')
        GROUP BY day, model
    """)
    rows = cur.fetchall()

    # 按模型检查波动
    by_model = {}
    for day, model, ptc in rows:
        by_model.setdefault(model, []).append((day, ptc))

    alerts = []
    for model, series in by_model.items():
        series.sort()
        if len(series) < 2:
            continue
        first = series[0][1]
        last = series[-1][1]
        if first == 0:
            continue
        ratio = last / first
        if ratio > 5:  # 5× 阈值（openai/codex#28879 主帖证据 10-20×）
            alerts.append(f"⚠️ {model} per-token cost 7 天涨 {ratio:.1f}× ({first:.2e} → {last:.2e}) — 厂商可能在悄悄涨价！")

    if alerts:
        requests.post(SLACK_WEBHOOK, json={"text": "\n".join(alerts)})

if __name__ == "__main__":
    check_anomaly()

# crontab 每小时跑一次
crontab -e
0 * * * * /usr/bin/python3 /home/claw/.ai-fallback/alert.py

客户端一键接入模板

Cursor：

// ~/.cursor/config.json
{
  "openai.apiBase": "http://127.0.0.1:4000",
  "openai.apiKey": "litellm-fallback"
}

Cline / Continue.dev：

// VS Code settings.json
{
  "cline.apiProvider": "openai",
  "cline.openAiBaseUrl": "http://127.0.0.1:4000",
  "cline.openAiApiKey": "litellm-fallback"
}

Aider：

# ~/.aider.conf.yml
openai-api-base: http://127.0.0.1:4000
openai-api-key: litellm-fallback
model: primary  # 走 LiteLLM 的 primary chain

Claude Code CLI：

export ANTHROPIC_BASE_URL=http://127.0.0.1:4000
export ANTHROPIC_AUTH_TOKEN=litellm-fallback

Codex CLI：

export OPENAI_API_BASE=http://127.0.0.1:4000
export OPENAI_API_KEY=litellm-fallback

---

常见坑与规避清单

坑 1：LiteLLM proxy 单点故障

症状：LiteLLM 进程崩 → 所有 AI 客户端全部断连。

规避：

• systemd / pm2 守护进程，Restart=always
• 关键路径加 health check：curl http://127.0.0.1:4000/health/liveliness
• 多机部署：LiteLLM proxy 跑在 2 台机器，前端用 keepalived / HAProxy 做 VIP

坑 2：本地模型性能 < 云端，复杂任务频繁重试

症状：qwen3:30b-a3b 在长代码生成 / 多轮 agent 循环上经常出错或超时。

规避：

• local-qwen 只兜底简单任务（文档改写 / 翻译 / 简单生成），不兜底复杂 agent 循环
• LiteLLM fallback chain 把 local-qwen 放在最末位（gpt-4o → claude-sonnet → local-qwen）
• 关键任务直接走 API，不依赖 fallback
• 评估模型：用 lm-eval-harness 跑一次 gsm8k / humaneval 看本地模型真实能力

坑 3：API key 泄露 / 失控

症状：API key 进 git / 月度账单爆炸。

规避：

• API key 全部放 ~/.ai-fallback/.env，权限 600，不进任何 repo
• OpenAI / Anthropic dashboard 设 hard monthly cap（如 200 USD），超额自动 429
• 用 Infisical / Doppler 做密钥管理（团队场景）
• LiteLLM proxy 加 IP 白名单（仅 127.0.0.1 / 内网网段可访问）

坑 4：自托管 GPU 资源争抢

症状：Ollama 跑满 GPU → 本机其他 ML 任务 / 训练任务受影响。

规避：

• Ollama 用专用 GPU（NVIDIA_VISIBLE_DEVICES=0）
• 训练任务用 CUDA_VISIBLE_DEVICES=1
• 限制 Ollama 并发：OLLAMA_NUM_PARALLEL=2
• 显存不足时自动降级模型：qwen3:30b → qwen3:8b

坑 5：Fallback 链配置错误（fallback 到了更贵的模型）

症状：gpt-4o fallback 到 gpt-5，月度账单涨 10×。

规避：

• Fallback chain 按 单价从低到高 排：gpt-4o-mini → gpt-4o → claude-sonnet → gpt-5
• cost dashboard 设告警：单日 spend > 月度预算 5% 立刻通知
• 关键 prompt 强制 model：completion(model="primary", ...) 而不是 completion(model="gpt-4o", ...)，让 primary chain 自己做 cost-aware fallback

坑 6：忽视”悄悄涨价”的延迟信号

症状：openai/codex#28879 主帖提交 6 天后才看到——已经多付了 1 周账单。

规避：

• 订阅 openai/codex GitHub issues RSS / HN RSS
• cost dashboard 加 per-token cost 单日波动 > 5× 告警
• 每周一跑一次「真实 prompt 预算实测」（阶段 0 模板），把 per-token cost 写进趋势图
• 加入社区：r/ChatGPTPro、r/ClaudeAI、HN——悄悄涨价一般在用户社区先被发现

坑 7：本地模型数据合规风险（敏感数据外发）

症状：把公司敏感代码 / 客户数据发到 OpenAI / Anthropic API。

规避：

• 敏感数据任务（涉密代码 / 客户 PII / 财务数据）强制走 local-qwen
• LiteLLM 加 tags 路由：completion(model=“primary”, metadata={“sensitive”: True}) → 强制 fallback 到 local-qwen
• 用 Microsoft Presidio 做 PII 脱敏后再发 API
• 公司内网部署：API key 仅内网 IP 可用，外网断网也能跑 local-qwen

坑 8：忽略了 LiteLLM 的 Spend Log 延迟

症状：dashboard 显示的 cost 滞后 5-10 分钟，告警不及时。

规避：

• LiteLLM 设 proxy_batch_write_at: 1（1 秒写一次）
• 或者直接监听 LiteLLM 的 Prometheus /metrics 端点，Prometheus 抓取延迟 < 15 秒

---

成本/性能/维护权衡

成本对比（per 1M tokens，2026 年 6 月）

方案	输入单价	输出单价	月度 100K call 成本（假设 avg 2K input + 500 output）	优势	劣势
ChatGPT Plus 订阅	$0（订阅 $20/月）	$0	$20（但 5h budget 限制 + per-token cost 悄悄涨 10-20×）	固定成本	budget 不稳定、per-token cost 不可见
Claude Pro 订阅	$0（订阅 $20/月）	$0	$20（但 5/13 公告涨、6/15 生效、6/16 pause 风险）	固定成本	同上
OpenAI API (gpt-4o)	$2.50	$10.00	$1,250	无 cap、成本可见、随时扩缩	按 token 计费，密集调用贵
Anthropic API (claude-sonnet)	$3.00	$15.00	$1,350	同上	同上
Ollama 本地 (qwen3:30b)	$0（一次性 GPU $2-3K）	$0	~$30（电费 + 折旧 / 月）	零厂商依赖、数据本地	性能弱、需 GPU 维护
Ollama 本地 (qwen3:1.7b)	$0（CPU 可跑）	$0	~$5（电费 / 月）	零 GPU 需求	性能更弱，只适合简单任务
云 GPU spot (vLLM, 8xA100)	$0（按小时 $2-3/h）	$0	~$50（spot 实例 / 月）	性能接近 gpt-4o	需运维、按小时付费

推荐组合（团队 10 人 AI 开发环境）：

• 主力：ChatGPT Plus / Claude Pro 订阅 = 每人 $20/月 = $200/月（日常 prompt 实测主力）
• API 兜底：OpenAI + Anthropic API = $500-1000/月（生产 / 自动化 / 长任务）
• 自托管兜底：1 台 48GB GPU 服务器 = $3000 一次性 + $30/月电费（敏感数据 / 离线兜底）
• 三层总成本：~$1500-2000/月（10 人），相比纯订阅 $200/月贵 7-10×，但业务连续性从「50%」升到「99.9%」

性能对比（latency，2026 年 6 月）

方案	TTFT (time to first token)	tokens/s (生成速度)	适用场景
ChatGPT Plus	200-500ms	50-100	实时对话
Claude Pro	300-600ms	40-80	长文档
OpenAI API (gpt-4o)	300-800ms	60-120	生产
Anthropic API (claude-sonnet)	400-900ms	50-100	长上下文
Ollama 本地 (qwen3:30b, RTX 4090)	100-300ms	30-60	离线兜底
Ollama 本地 (qwen3:30b, H100)	50-150ms	80-150	性能最强自托管
Ollama 本地 (qwen3:1.7b, CPU)	500-1500ms	10-20	极简兜底

性能权衡：

• 实时对话主力：ChatGPT Plus / Claude Pro（订阅延迟最低，因为走厂商优化路径）
• 生产 SLA：API（按 SLA 付费，可控）
• 离线兜底：本地模型（性能最差但零依赖）

维护成本

组件	维护频率	维护成本（人时 / 月）	自动化程度
LiteLLM proxy	配置更新 / 故障排查	2-4 小时	中（systemd + 健康检查）
Ollama 本地模型	模型升级 / GPU 维护	2-4 小时	中（systemd + nvidia-smi 监控）
API key 管理	续期 / 权限审计	1-2 小时	高（密钥管理工具）
成本 dashboard	新指标 / 告警调优	2-4 小时	高（Streamlit + crontab）
切换 runbook	演练 / 更新	1-2 小时	中（季度演练）
总计	—	8-16 小时 / 月	—

自动化建议：

• LiteLLM 用 systemd + health check 自动重启
• 成本 dashboard 用 Grafana + Prometheus 替代 Streamlit（生产级）
• Fallback chain 用 CI/CD 管理（config 进 git，每次变更 PR review）
• 每月跑一次断网演练（cron + 自动化脚本）

---

一周内可执行行动清单

D+0（今天，3 小时）

• 跑「真实 prompt 预算实测」——5 个 prompt × 3 家订阅 × 10 次重复，写进 /tmp/budget-benchmark.csv
• 计算 per-token cost，对比 openai/codex#28879 主帖 的 10-20× 系数
• 识别”今日高风险订阅”——per_token_cost 单日波动 > 5× 的立刻降级或换 API
• 给 3 家订阅（ChatGPT Plus / Claude Pro / Cursor Pro）各跑一次 HN / Reddit 反馈检查

D+1（明天，2 小时）

• 开 OpenAI / Anthropic / Google Gemini 各 1 个 API key（hard monthly cap = 月度 AI 预算 50%）
• 写进 ~/.ai-fallback/.env（权限 600）
• 在 OpenAI / Anthropic dashboard 设 usage limit + 邮箱告警
• 测试 3 个 API key 都能正常调用（用 curl 或 LiteLLM playground）

D+2（第 3 天，4-8 小时）

• 检查本机 GPU：nvidia-smi --query-gpu=name,memory.total --format=csv
• 安装 Ollama：curl -fsSL https://ollama.com/install.sh | sh
• Pull qwen3:30b-a3b-q4_K_M（24GB VRAM）或 qwen3:1.7b-q4_K_M（CPU）
• 启动 ollama serve，验证 curl http://127.0.0.1:11434/api/tags
• 测试生成 1 个真实 prompt，记录 latency + 输出质量

D+3（第 4 天，3 小时）

• 安装 LiteLLM：pip install 'litellm[proxy]'（用 venv）
• 写 ~/.ai-fallback/litellm-config.yaml（三层兜底 + fallback chain）
• 启动 litellm --config ~/.ai-fallback/litellm-config.yaml --port 4000
• 用 systemd 守护：/etc/systemd/system/litellm.service
• 验证 curl http://127.0.0.1:4000/v1/models

D+4（第 5 天，4 小时）

• 写 cost_tracker.py（监听 LiteLLM /spend/logs → SQLite）
• 写 dashboard.py（Streamlit 成本 dashboard + per-token cost 异常告警）
• 启动 dashboard：streamlit run dashboard.py --server.port 8501
• 写 alert.py + crontab（per-token cost > 5× → Slack 通知）

D+5（第 6 天，2 小时）

• 跑断网演练 1：关掉 gpt-4o 流量，验证 fallback 链
• 跑断网演练 2：OpenAI rpm 调到 1，验证 local-qwen 顶上
• 跑断网演练 3：Ollama 宕机，验证 API 顶上
• 跑断网演练 4：全网断网，验证 local-qwen 是最后兜底
• 记录每条链路的 latency + 成功率，调整 timeout / retry

D+6（第 7 天，4 小时）

• 写切换 runbook v1.0（5 个场景：订阅耗尽 / API 5xx / 厂商涨价 / GPU 宕机 / 全网断网）
• 接入所有客户端（Cursor / Cline / Aider / Claude Code / Codex CLI）到 LiteLLM endpoint
• 给 VP Eng / CTO 发 walkthrough 邮件，附 dashboard 截图 + runbook 链接

D+7（本周结束）

• 产出**「AI 主力环境三层兜底架构 v1.0 + 成本 dashboard + 切换 runbook + 30/90 天路线图」**
• 给团队做 30 分钟 walkthrough
• 提交 PR 到内部 wiki / Notion
• 设定月度复盘节奏（每月 1 号跑一次断网演练 + 看 per-token cost 趋势）

30 天路线图（Q3 2026）

• Week 2-3：把成本 dashboard 接入 Grafana + Prometheus（生产级监控）
• Week 4：评估是否上云 GPU spot（vLLM on Lambda / RunPod）做”按需扩容”兜底
• Day 30：跑月度复盘，看 per-token cost 趋势，识别”下一个悄悄涨价信号”

90 天路线图（Q4 2026）

• Week 5-8：评估 Apertus / Llama 4 等新模型，看是否替换 Ollama 主力
• Week 9-12：评估自研 / 微调小模型（用公司内部 codebase 微调 Qwen3-8B）做”领域专用兜底”
• Day 90：Q4 复盘，对比 6/22 的三层兜底架构 vs 现状，迭代 v2.0

---

待观察

• openai/codex#28879 是否有 OpenAI 官方回应？Plus/Pro 5h 预算单价是否会在 6 月 30 日前恢复？——reactions 282、评论 100+、OpenAI 0 回应持续 6 天。
• OpenAI 招股书是否把「Plus/Pro 5h 预算调整作为 Q2 营收增长贡献项」披露？——H2 进一步涨价的强信号。
• Anthropic Claude Agent SDK「暂停」是永久取消还是延后到 7 月恢复？——Ars Technica 6/19 用词「pauses」 暗示涨价理由未解决。
• GitHub Copilot 4 月涨价后是否进一步收紧 budget？——Ars Technica 6/19 提到 GitHub Copilot 4 月已完成订阅制 → token 制迁移。
• Cursor / Windsurf / JetBrains AI / Tabnine 等次梯队是否同步涨价？——H2 2026 AI 编程预算集体上涨 50-100% 的可能。
• LiteLLM / Ollama / vLLM 生态：是否有更成熟的「跨厂商 + 自托管」统一框架替代 LiteLLM？

---

本文为每日技术热点落地文。事件核心事实（openai/codex#28879 主帖证据：6 月 12 日 57K-token × 3.6K reasoning 消耗 1% 预算 → 6 月 18 日 20K-token × 0 reasoning 消耗 10–27% 预算、per-token cost 涨 10–20×、Plus/Pro/Pro Lite/Hermes 多档用户实证、reactions 282 / 评论 100+ / OpenAI 0 回应、6 月 16 日起 status page degraded incident 持续 6 天 + Anthropic「暂停」Claude Agent SDK token 计费（Ars Technica 6/19） + OpenAI 秘密提交 IPO 招股书（TechCrunch 6/18））均来自上述来源的交叉印证。所有代码片段（LiteLLM / Ollama / cost dashboard）均来自官方文档（LiteLLM docs、Ollama docs），未独立验证在你的硬件 / 网络环境下的实际表现。OpenAI 官方对 openai/codex#28879 0 回应的状态截至 2026-06-22 01:45 UTC，后续变化需独立确认。