9Router 深度实战：当 AI 编程助手学会「智能路由」——从 Token 节省 40% 到零成本无限编程的完全指南（2026）

你每个月花 $20-200 订阅 Claude Pro、GitHub Copilot、Cursor，却总在关键时刻碰速率限制；你的额度在月底白白过期，而下个月又要重新付钱；你想试试不同的模型，却得在五六个工具里分别改配置——如果你也被这些破事折磨过，9Router 就是为你写的。

引言：AI 编程助手的「订阅地狱」

2026 年，一个重度使用 AI 编程助手的开发者，面临的真实困境：

困境一：订阅额度白白浪费

你付了 Claude Pro 的 $20/月，每周有 5 小时的高速率窗口。但周二你加班到凌晨，额度用完了；周三你休息，额度在白白过期。月底结算，实际用了不到 40% 的订阅价值。

困境二：速率限制卡住工作流

你用 Cursor 写到一半，突然弹出「速率限制已达上限，请等待 2 小时」。你的工作流被迫中断。如果你同时用 Claude Code、Codex、Cursor，每个工具有各自的速率限制，管理起来是一场噩梦。

困境三：模型切换成本极高

想在 Claude Code 里试试 GPT-5.5？需要在 Anthropic、OpenAI、Gemini 三个平台分别获取 API Key，然后在配置文件里改来改去。每次切换模型都要改一次配置。

困境四：API 账单失控

如果你不用订阅，而是直接按量付费 API，一个月下来账单可以到 $200-500。主要烧钱的地方：工具输出（git diff、grep 结果、文件内容）占据 30-50% 的 Token 消耗。

这就是 9Router 要解决的核心问题：作为一个智能路由代理，在你的 AI 编程工具和 40+ AI 提供商之间架起一座桥梁——自动路由、自动回退、自动节省 Token。

9Router 不是又一个 AI 编程工具，而是一个本地运行的智能路由器——它理解你的配额状态、成本策略、和故障回退需求，在后台自动调度一切。

本文将从第一性原理出发，深度剖析 9Router 的架构设计、三层智能回退机制、RTK Token 节省器、格式翻译层，以及如何将它集成到你的 AI 编程工作流。全程配可运行的配置示例。

第一部分：9Router 是什么？——核心定位与价值主张

1.1 项目速览

1.2 核心功能矩阵

9Router 提供了 10 大核心功能，覆盖从成本优化到高可用性的全方位需求：

1.3 架构总览

你的 CLI 工具
（Claude Code / Cursor / Codex / OpenClaw / Cline...）
        │
        │  Tool: http://localhost:20128/v1
        ▼
┌──────────────────────────────────────────────────────┐
│  9Router（智能路由器）                               │
│                                                      │
│  ┌──────────────────────────────────────────────┐    │
│  │  RTK Token Saver（工具输出压缩）              │    │
│  └──────────────────┬───────────────────────────┘    │
│                     ▼                               │
│  ┌──────────────────────────────────────────────┐    │
│  │  Format Translation（格式翻译层）             │    │
│  │  OpenAI ↔ Claude ↔ Gemini ↔ Cursor          │    │
│  └──────────────────┬───────────────────────────┘    │
│                     ▼                               │
│  ┌──────────────────────────────────────────────┐    │
│  │  Smart 3-Tier Fallback（三层智能回退）       │    │
│  │                                               │    │
│  │  [Tier 1] Subscription                     │    │
│  │    └─ Claude Code, Codex, GitHub Copilot  │    │
│  │        │ quota exhausted?                     │    │
│  │        ▼                                     │    │
│  │  [Tier 2] Cheap                           │    │
│  │    └─ GLM ($0.6/1M), MiniMax ($0.2/1M) │    │
│  │        │ budget limit?                       │    │
│  │        ▼                                     │    │
│  │  [Tier 3] FREE                            │    │
│  │    └─ Kiro AI, OpenCode Free, Vertex      │    │
│  └──────────────────┬───────────────────────────┘    │
│                     ▼                               │
│            真正的 AI 提供商 API                    │
└──────────────────────────────────────────────────────┘

第二部分：RTK Token Saver —— 20-40% 的 Token 节省是如何实现的？

2.1 问题：工具输出在「偷」你的 Token

当你用 Claude Code 做一个常规任务时，Token 消耗的构成大约是：

总 Token 消耗（约 47K tokens）:
├── 系统提示词（固定）: ~8K tokens (17%)
├── 对话历史: ~12K tokens (26%)
├── 用户消息: ~3K tokens (6%)
├── 工具输出: ~20K tokens (43%)  ← 最大消耗源！
│   ├── git diff 输出: ~8K
│   ├── grep 搜索结果: ~5K
│   ├── ls / find 文件列表: ~3K
│   └── 文件内容读取: ~4K
└── 模型回复: ~4K tokens (8%)

工具输出占据了 43% 的 Token 消耗——而这些内容里，大部分是冗余的、可被智能压缩的。

2.2 RTK 的解决方案

RTK（可能是 "Response Token Kompressor" 的缩写）是 9Router 内置的 Token 节省器，它在请求到达 LLM 之前，对工具输出做智能压缩。

核心原理：

// 9Router 的 RTK 处理逻辑（简化版）
function rtkCompress(toolResult: string, toolName: string): string {
  // Step 1: 根据工具名选择压缩策略
  const strategy = getCompressionStrategy(toolName);
  
  // Step 2: 应用压缩
  let compressed: string;
  switch (strategy) {
    case 'git-diff':
      compressed = compressGitDiff(toolResult);
      break;
    case 'grep':
      compressed = compressGrepResult(toolResult);
      break;
    case 'ls':
      compressed = compressFileList(toolResult);
      break;
    case 'read':
      compressed = compressFileContent(toolResult);
      break;
    default:
      compressed = toolResult; // 不压缩未知工具
  }
  
  // Step 3: 安全保护 —— 如果压缩后反而更大，保留原文
  if (compressed.length > toolResult.length * 1.1) {
    return toolResult; // 压缩失败，返回原文
  }
  
  return compressed;
}

// Git Diff 压缩策略示例
function compressGitDiff(diff: string): string {
  const lines = diff.split('\n');
  let compressed = '';
  let skippedOld = 0;
  
  for (let i = 0; i < lines.length; i++) {
    const line = lines[i];
    
    if (line.startsWith('index ') || line.startsWith('--- ') || line.startsWith('+++ ')) {
      // 保留文件头
      compressed += line + '\n';
    } else if (line.startsWith('@@ ')) {
      // 保留 hunk 头（包含行号信息）
      compressed += line + '\n';
    } else if (line.startsWith('+') || line.startsWith('-')) {
      // 保留变更行
      compressed += line + '\n';
    } else {
      // 跳过上下文行（以空格开头的未变更行）
      skippedOld++;
      // 但每 20 行保留 1 行作为「锚点」
      if (skippedOld % 20 === 0) {
        compressed += '...\n'; // 锚点标记
      }
    }
  }
  
  return compressed;
}

实际效果：

关键设计决策：

1. 无损压缩：压缩后的内容保留所有「语义信息」，LLM 仍然能理解变更的内容
2. 失败安全：如果压缩失败或压缩后更大，自动回退到原文
3. 通用性：在格式翻译之前运行，因此适用于所有 CLI 工具

2.3 Caveman Mode —— 让 LLM 回复更简洁

除了压缩输入，9Router 还支持 Caveman Mode（猿人模式）——通过注入特殊提示词，让 LLM 的回复更简洁。

// Caveman Mode 的提示词注入（简化版）
function enableCavemanMode(messages: Message[]): Message[] {
  const cavemanPrompt = `
You are now in Caveman Mode. Reply in terse, technical language.
- NO pleasantries, NO explanations, NO markdown formatting unless requested
- Answer DIRECTLY in code or raw text
- If code is the answer, output ONLY the code block
- Max 3 sentences for any non-code answer
`.trim();

  return [
    { role: 'system', content: cavemanPrompt },
    ...messages
  ];
}

效果：输出 Token 减少 up to 65%。适合「我知道我要什么，别废话」的场景。

第三部分：三层智能回退 —— 永不停止的编程体验

3.1 为什么需要「智能回退」？

传统 AI 编程工具的问题：订阅额度用完了 → 速率限制 → 工作流中断。

9Router 的解决方案：预先配置三层回退链，当主模型不可用时，自动切换到备用模型。

你的请求
    │
    ▼
[Tier 1] Subscription（订阅层）
    ├── Claude Code (Pro Max) — 优先使用
    ├── Codex (Plus) — 备用
    └── GitHub Copilot — 再备用
    │
    │ 如果所有订阅都额度用尽或报错
    ▼
[Tier 2] Cheap（廉价层）
    ├── GLM-5.1 ($0.6/1M tokens)
    ├── MiniMax M2.7 ($0.2/1M tokens)
    └── Kimi K2.5 ($9/月 flat)
    │
    │ 如果廉价层达到预算上限
    ▼
[Tier 3] FREE（免费层）
    ├── Kiro AI (Claude 4.5 无限免费)
    ├── OpenCode Free (无需认证)
    └── Vertex AI ($300 免费额度)

3.2 配置 Combos（模型组合）

9Router 的核心概念是 Combo（模型组合）——你可以创建任意数量的模型链，并给它们命名。

// 在 9Router Dashboard 里配置 Combo（图形界面）
// 这里用伪代码展示配置逻辑

const combo = {
  name: "maximize-claude",
  description: "最大化利用 Claude 订阅，便宜备用，免费保底",
  
  tiers: [
    {
      tier: 1,
      type: "subscription",
      providers: [
        { name: "cc/claude-opus-4-7", priority: 1 },
        { name: "cc/claude-sonnet-4-6", priority: 2 },
      ],
      fallbackCondition: "quota_exhausted OR rate_limited"
    },
    {
      tier: 2,
      type: "cheap",
      providers: [
        { name: "glm/glm-5.1", budget: "$10/month" },
        { name: "minimax/MiniMax-M2.7", budget: "$5/month" },
      ],
      fallbackCondition: "budget_exhausted"
    },
    {
      tier: 3,
      type: "free",
      providers: [
        { name: "kr/claude-sonnet-4-5" }, // Kiro AI 免费 Claude
        { name: "oc/<auto>" }, // OpenCode Free 自动选择
      ],
      fallbackCondition: "never" // 免费层永不放弃
    }
  ]
};

// 使用 Combo
// 在你的 Claude Code 配置里：
// Endpoint: http://localhost:20128/v1
// Model: combo:maximize-claude

3.3 实时配额追踪

9Router 会实时追踪每个订阅提供商的配额状态：

// 配额追踪的数据结构（简化版）
interface QuotaTracker {
  provider: string;
  totalQuota: number;    // 总配额（如 Claude Pro 的 5 小时窗口）
  usedQuota: number;     // 已用配额
  resetTime: Date;       // 重置时间
  
  // 计算剩余时间和配额
  getRemainingQuota(): number {
    return this.totalQuota - this.usedQuota;
  }
  
  getResetCountdown(): string {
    const ms = this.resetTime.getTime() - Date.now();
    const hours = Math.floor(ms / (1000 * 60 * 60));
    const minutes = Math.floor((ms % (1000 * 60 * 60)) / (1000 * 60));
    return `${hours}h ${minutes}m`;
  }
  
  // 决定是否切换到下一层
  shouldFallback(): boolean {
    return this.getRemainingQuota() <= 0;
  }
}

在 Dashboard 里展示的效果：

┌─────────────────────────────────────┐
│  Quota Tracker                    │
├─────────────────────────────────────┤
│  Claude Code (Pro Max)           │
│  Used: 142K / 200K (5h window) │
│  Reset: 2h 34m                          │
│  [======░░░░░░░░░░░░] 71%       │
├─────────────────────────────────────┤
│  Codex (Plus)                   │
│  Used: 89K / 150K (5h window)  │
│  Reset: 2h 34m                          │
│  [====░░░░░░░░░░░░░░] 59%       │
└─────────────────────────────────────┘

第四部分：格式翻译层 —— 让任何工具都能用任何模型

4.1 问题：每家 AI 提供商的 API 格式都不一样

现实困境：你的 Claude Code 只能发 Claude 格式的请求，但它想调用 GPT-5.5（OpenAI 格式）——直接调用会报格式错误。

4.2 9Router 的格式翻译层

9Router 在中间做了格式翻译，把你的 CLI 工具发出的请求，翻译成目标提供商期望的格式。

Claude Code 发出请求（Claude 格式）
    │
    ▼
9Router 格式翻译层
    │
    ├── 检测目标提供商（根据 Combo 配置）
    │
    ├── 把 Claude 格式 → OpenAI 格式（如果目标是 OpenAI）
    │   ├── 把 `system` 字段合并到 `messages[0]`
    │   ├── 把 `content` 数组（多类型）扁平化为字符串
    │   └── 添加 `tool_calls` 字段
    │
    ├── 把 Claude 格式 → Gemini 格式（如果目标是 Gemini）
    │   ├── 把 `messages` 转换为 `contents`（roles 映射）
    │   ├── 把 `system` 放到 `systemInstruction`
    │   └── 处理 `tools` → `tools` (Gemini 格式)
    │
    └── 发送翻译后的请求到目标提供商

代码实战：用 Claude Code 调用 GPT-5.5（通过 9Router）

# 1. 安装并启动 9Router
npm install -g 9router
9router

# 2. Dashboard 自动打开（http://localhost:20128）
# 在 Dashboard 里：
#   - 连接 OpenAI（添加 API Key）
#   - 创建一个 Combo: "claude-to-gpt"
#     Tier 1: cx/gpt-5.5

# 3. 配置 Claude Code 使用 9Router
# ~/.claude.json
{
  "anthropic_api_url": "http://localhost:20128/v1",
  "anthropic_api_key": "9router_dummy_key",  // 9Router 不需要真实 Key
  "model": "combo:claude-to-gpt"  // 使用 Combo
}

# 4. 现在，Claude Code 发出的请求会被 9Router 拦截，
#    翻译成 OpenAI 格式，然后发给 GPT-5.5

# 测试：
claude "用 Python 写一个快速排序"
# 这个请求：Claude Code → 9Router → OpenAI GPT-5.5
# 回复会正常返回给 Claude Code（9Router 还会把 OpenAI 的回复格式翻译回 Claude 格式）

第五部分：集成实战 —— 从安装到生产级部署

5.1 安装与启动

# 方式一：npm 全局安装（推荐）
npm install -g 9router
9router
# Dashboard 自动打开：http://localhost:20128

# 方式二：从源码运行
git clone https://github.com/decolua/9router.git
cd 9router
cp .env.example .env
npm install
PORT=20128 NEXT_PUBLIC_BASE_URL=http://localhost:20128 npm run dev

# 方式三：Docker 部署
docker pull decolua/9router
docker run -p 20128:20128 decolua/9router

5.2 连接免费提供商（零成本启动）

推荐的第一个配置：连接 Kiro AI（免费无限 Claude 4.5）

1. 打开 Dashboard: http://localhost:20128/dashboard
2. 点击 "Providers" → "Connect Kiro AI"
3. 选择认证方式（AWS Builder ID / Google / GitHub）
4. 完成 OAuth 登录
5. 完成！你现在有了免费无限的 Claude 4.5
6. 在你的 CLI 工具里配置：
   Endpoint: http://localhost:20128/v1
   API Key: [从 Dashboard 里复制]
   Model: kr/claude-sonnet-4-5

其他免费选项：

• OpenCode Free：无需认证，直接连接
• Vertex AI：新 Google Cloud 账户有 $300 免费额度
• Gemini CLI：18万/月免费（但注意：非 CLI 工具使用可能触发封号）

5.3 集成到主流 AI 编程工具

Claude Code 集成

# ~/.claude/settings.json
{
  "apiUrl": "http://localhost:20128/v1",
  "apiKey": "your-9router-key",
  "model": "combo:your-combo-name"
}

Cursor 集成

1. 打开 Cursor Settings → Features → Models
2. 点击 "Add Model"
3. 填写：
   - Model Name: 9router/combo:your-combo
   - Base URL: http://localhost:20128/v1
   - API Key: [从 Dashboard 复制]
4. 保存，现在 Cursor 可以通过 9Router 调用任何模型

OpenClaw 集成

# ~/.openclaw/config.yaml
models:
  default: "combo:your-combo"
  api_base: "http://localhost:20128/v1"
  api_key: "your-9router-key"

Cline（VS Code 插件）集成

1. 打开 VS Code → Cline 面板 → Settings
2. 选择 "OpenAI Compatible" 作为 Provider
3. 填写：
   - Base URL: http://localhost:20128/v1
   - API Key: [从 Dashboard 复制]
   - Model: combo:your-combo
4. 保存

5.4 生产级部署（团队共享）

如果你在团队环境中使用 9Router，可以把它部署到一台服务器上，让整个团队共享：

# docker-compose.yml（生产部署）
version: '3.8'

services:
  9router:
    image: decolua/9router:latest
    ports:
      - "20128:20128"
    environment:
      - PORT=20128
      - HOSTNAME=0.0.0.0
      - NEXT_PUBLIC_BASE_URL=http://your-server-ip:20128
      - BASE_URL=http://your-server-ip:20128
      - CLOUD_URL=https://your-cloud-sync-endpoint.com
    volumes:
      - ./data:/app/data  # 持久化配置
    restart: unless-stopped

  # 可选：Redis 用于多实例会话共享
  redis:
    image: redis:alpine
    ports:
      - "6379:6379"
    volumes:
      - ./redis-data:/data
    restart: unless-stopped

团队成员的配置：

# 团队成员的 Claude Code 配置
export ANTHROPIC_BASE_URL="http://your-server-ip:20128/v1"
export ANTHROPIC_API_KEY="team-shared-key"

第六部分：高级玩法 —— Combos、多账户、云同步

6.1 创建高级 Combos

场景一：成本优先 Combo（月成本 < $10）

const costFirstCombo = {
  name: "cost-first",
  tiers: [
    {
      tier: 3,  // 直接用免费层
      providers: [
        { name: "kr/claude-sonnet-4-5" },  // Kiro 免费 Claude
        { name: "kr/glm-5" },              // Kiro 免费 GLM
        { name: "oc/<auto>" }                // OpenCode Free
      ]
    }
  ]
};

场景二：质量优先 Combo（用最好的模型，成本次之）

const qualityFirstCombo = {
  name: "quality-first",
  tiers: [
    {
      tier: 1,
      providers: [
        { name: "cc/claude-opus-4-7", quota: "5h-window" },
        { name: "cx/gpt-5.5", quota: "5h-window" }
      ]
    },
    {
      tier: 2,
      providers: [
        { name: "glm/glm-5.1", budget: "$20/month" }
      ]
    },
    {
      tier: 3,
      providers: [
        { name: "kr/claude-sonnet-4-5" }  // 免费保底
      ]
    }
  ]
};

场景三：特定任务 Combo（为不同任务创建不同 Combo）

// 代码生成任务：用 Claude Opus（最强代码模型）
const codegenCombo = {
  name: "codegen",
  tiers: [
    { tier: 1, providers: [{ name: "cc/claude-opus-4-7" }] },
    { tier: 3, providers: [{ name: "kr/claude-sonnet-4-5" }] }
  ]
};

// 文档撰写任务：用 GPT-5.5（最强英文写作）
const docWritingCombo = {
  name: "doc-writing",
  tiers: [
    { tier: 1, providers: [{ name: "cx/gpt-5.5" }] },
    { tier: 2, providers: [{ name: "glm/glm-5.1" }] }
  ]
};

// 在你的 CLI 工具里，按需切换 Model 字段
// Model: combo:codegen  → 代码生成任务
// Model: combo:doc-writing → 文档撰写任务

6.2 多账户支持（负载均衡）

如果你有多个 Anthropic 账户（比如团队账户），9Router 可以在它们之间做轮询：

// Dashboard 配置：添加多个账户
const multiAccountConfig = {
  provider: "anthropic",
  accounts: [
    { name: "personal-pro-max", apiKey: "sk-ant-...", priority: 1 },
    { name: "team-account", apiKey: "sk-ant-...", priority: 2 },
    { name: "backup-account", apiKey: "sk-ant-...", priority: 3 }
  ],
  routingStrategy: "round-robin" // 或 "priority-first"
};

6.3 云同步（跨设备配置同步）

9Router 支持云同步——你的 Providers、Combos、设置可以在所有设备间自动同步。

// .env 配置
CLOUD_URL=https://your-cloud-sync-endpoint.com
CLOUD_API_KEY=your-sync-api-key

// 同步逻辑（简化版）
async function syncConfig() {
  // 1. 从云端拉取最新配置
  const remoteConfig = await fetch(`${CLOUD_URL}/config`).then(r => r.json());
  
  // 2. 与本地配置合并（以最新修改时间为准）
  const merged = mergeConfig(localConfig, remoteConfig);
  
  // 3. 保存合并后的配置
  saveConfig(merged);
  
  // 4. 推送本地变更到云端
  await fetch(`${CLOUD_URL}/config`, {
    method: 'POST',
    body: JSON.stringify(merged)
  });
}

// 每 5 分钟自动同步一次
setInterval(syncConfig, 5 * 60 * 1000);

第七部分：与竞品深度对比

7.1 9Router vs. OpenRouter

结论：OpenRouter 更适合「需要访问大量模型但不关心成本优化」的场景；9Router 更适合「重度 AI 编程用户，需要精细控制成本和回退策略」的场景。

7.2 9Router vs. LiteLLM

结论：LiteLLM 是给开发者在代码里集成多模型能力用的；9Router 是给 AI 编程工具的终端用户用的，零代码改动。

第八部分：生产环境落地建议

8.1 个人开发者配置推荐

// Combo: "free-forever"
// 月成本：$0
{
  tiers: [
    {
      tier: 3,
      providers: [
        { name: "kr/claude-sonnet-4-5" },  // Kiro 免费 Claude
        { name: "kr/glm-5" },              // Kiro 免费 GLM-5
        { name: "oc/<auto>" }                // OpenCode Free
      ]
    }
  ],
  features: {
    rtkTokenSaver: true,   // 开启 RTK
    cavemanMode: false       // 关闭（需要详细回复时）
  }
}

8.2 小团队配置推荐（5-10 人）

// 部署：共享服务器 + 团队订阅
// 月成本：~$100（Claude Code 团队订阅 × 2-3 个账户）

{
  // 服务器部署 9Router
  // 团队成员都指向 http://team-server:20128/v1
  
  tiers: [
    {
      tier: 1,
      providers: [
        { name: "cc/claude-opus-4-7", account: "team-account-1" },
        { name: "cc/claude-opus-4-7", account: "team-account-2" },
        { name: "cx/gpt-5.5", account: "team-openai" }
      ],
      routingStrategy: "round-robin"
    },
    {
      tier: 2,
      providers: [
        { name: "glm/glm-5.1", budget: "$50/month" }
      ]
    },
    {
      tier: 3,
      providers: [
        { name: "kr/claude-sonnet-4-5" }  // 免费保底
      ]
    }
  ]
}

8.3 企业级配置推荐（50+ 人）

// 部署：高可用集群（多实例 9Router + Redis 会话共享）
// 月成本：~$1000（企业订阅 + 按量付费预算）

{
  // 高可用部署
  // - 2+ 个 9Router 实例（负载均衡）
  // - Redis 用于会话状态和配额追踪
  // - 监控：Prometheus + Grafana
  
  tiers: [
    {
      tier: 1,
      providers: [
        // 企业订阅账户（多个，负载均衡）
        ...enterpriseAccounts.map(acc => ({
          name: `cc/claude-opus-4-7`,
          account: acc.id,
          quota: acc.quota
        }))
      ],
      fallbackCondition: "quota_exhausted OR error_rate > 10%"
    },
    {
      tier: 2,
      providers: [
        { name: "glm/glm-5.1", budget: "$500/month" },
        { name: "minimax/MiniMax-M2.7", budget: "$200/month" }
      ]
    },
    {
      tier: 3,
      providers: [
        { name: "kr/claude-sonnet-4-5" }  // 免费保底
      ]
    }
  ],
  
  // 企业级功能
  features: {
    auditLog: true,        // 审计日志
    costTracking: true,     // 成本追踪（按用户/部门）
    rateLimitPerUser: true,  // 每用户速率限制
    failoverPolicy: "aggressive"  // 积极回退策略
  }
}

第九部分：常见问题与排障指南

9.1 问题：9Router Dashboard 打不开

可能原因：端口 20128 被占用。

解决方案：

# 更换端口
PORT=30128 NEXT_PUBLIC_BASE_URL=http://localhost:30128 9router

# 或者在 .env 里配置
echo "PORT=30128" >> .env
echo "NEXT_PUBLIC_BASE_URL=http://localhost:30128" >> .env
9router

9.2 问题：RTK Token Saver 没效果

可能原因：RTK 默认开启，但某些工具输出没被识别。

解决方案：

# 在 Dashboard → Endpoint Settings 里检查 RTK 状态
# 确保 "RTK Token Saver" 是开启的

# 手动测试 RTK 效果
# 在 9Router 的 Debug 模式里查看请求日志
# 对比压缩前后的 Token 数

9.3 问题：格式翻译失败（某些工具报错）

可能原因：某些 CLI 工具用了非标准的 API 调用方式。

解决方案：

# 在 Dashboard → Debug Mode 里查看完整请求/响应日志
# 找到失败的请求，检查格式翻译是否正确

# 如果某个工具不兼容，可以禁用格式翻译（直接用原始格式）
# 在 Provider 设置里关闭 "Format Translation"

第十部分：总结与展望

10.1 9Router 的技术亮点回顾

1. 智能路由：不只是简单的负载均衡，而是理解配额状态、成本策略、和故障回退需求
2. Token 节省：RTK 内置，20-40% 的 Token 节省是无感的（开发者不需要做任何事）
3. 格式翻译：让任何工具都能用任何模型，彻底打破厂商锁定
4. 零成本选项：Kiro AI + OpenCode Free 组合可以实现完全免费的 AI 编程
5. 开源免费：软件本身免费，永远不会收费

10.2 AI 编程工具的未来趋势

9Router 的成功，反映了一个重要趋势：AI 编程工具正在从「单一模型、单一提供商」走向「多模型、多提供商、智能调度」。

2026 年底，我们可能会看到：

• AI 编程工具原生支持多模型路由（就像 9Router 的功能，但内置到工具里）
• 模型市场：开发者可以像选插件一样，为每个任务选择最优模型
• 成本优化成为核心竞争力：谁能帮开发者省更多钱，谁就能赢得市场

10.3 实践建议

如果你正在使用 AI 编程工具，以下是我的建议：

1. 从免费层开始：先连接 Kiro AI 或 OpenCode Free，体验 9Router 的价值主张
2. 开启 RTK Token Saver：这是「无感节省」，不需要做任何额外配置
3. 创建多个 Combos：为不同任务（代码生成、文档撰写、Bug 修复）创建不同的模型组合
4. 监控你的成本：用 Dashboard 的 Usage Analytics 了解你的 Token 消耗模式
5. 参与社区：9Router 是开源项目，你的反馈可以影响项目方向

附录：快速上手 Checklist

A. 零成本启动（5 分钟）

# 1. 安装
npm install -g 9router

# 2. 启动
9router
# Dashboard 自动打开

# 3. 连接免费提供商
# Dashboard → Providers → Connect Kiro AI → OAuth 登录

# 4. 配置 Claude Code（或其他工具）
# Endpoint: http://localhost:20128/v1
# API Key: [从 Dashboard 复制]
# Model: kr/claude-sonnet-4-5

# 5. 完成！开始免费无限编程

B. 成本优化启动（15 分钟）

# 1. 连接多个提供商
# Dashboard → Providers → 连接：
#   - Kiro AI（免费）
#   - OpenCode Free（免费）
#   - GLM（便宜，$0.6/1M）
#   - MiniMax（最便宜，$0.2/1M）

# 2. 创建 Combo
# Dashboard → Combos → Create New
#   - Name: "cost-optimized"
#   - Tier 1: Kiro AI（免费）
#   - Tier 2: GLM-5.1（便宜）
#   - Tier 3: MiniMax（最便宜）

# 3. 开启 RTK Token Saver
# Dashboard → Endpoint Settings → Enable RTK

# 4. 配置 CLI 工具使用这个 Combo
# Model: combo:cost-optimized

# 5. 完成！你的 AI 编程成本将降低 70-100%

参考资源

• 项目主页：https://github.com/decolua/9router
• 官方网站：https://9router.com
• npm 包：https://www.npmjs.com/package/9router
• Docker 镜像：https://hub.docker.com/r/decolua/9router
• 中文文档：https://github.com/decolua/9router/blob/master/i18n/README.zh-CN.md

本文基于 9Router 项目截至 2026 年 6 月的公开文档撰写，最新详情请查阅官方文档。

如果你用 9Router 实现了零成本 AI 编程，别忘了给项目点一个 GitHub Star ⭐