9Router 深度解析：一个开源路由器如何让你的 AI 编程成本归零

一、问题根源：为什么 AI 编程工具的账单总在失控？

2026年的开发者，几乎人手一个 AI 编程工具——Claude Code、Cursor、Copilot、Codex、Cline……但一个尴尬的现实是：没有一个工具能覆盖所有场景，每个工具都在吃你的 token 和钞票。

先看一组触目惊心的数据：

这些痛点叠加在一起，催生了一个刚需：能不能有一个智能路由层，自动帮我在多个 AI 供应商之间切换、压缩 token、优化成本？

9Router 就是这个答案。

二、9Router 是什么？架构全景解读

9Router（GitHub: decolua/9router）是一个开源的 AI 编程工具智能路由层，7.8K+ Stars，核心能力可以用一张架构图说清楚：

┌─────────────┐
│  你的 CLI    │  Claude Code / Codex / Cursor / Cline / Copilot / OpenClaw ...
│  工具        │
└──────┬──────┘
       │ http://localhost:20128/v1
       ↓
┌─────────────────────────────────────────────┐
│           9Router（智能路由层）               │
│  ┌─────────────────────────────────────┐    │
│  │ RTK Token Saver（压缩工具输出）       │    │
│  │ - git-diff / grep / find / ls 过滤器 │    │
│  │ - 自动检测 + 无损压缩                │    │
│  │ - 节省 20-40% input tokens          │    │
│  └─────────────────────────────────────┘    │
│  ┌─────────────────────────────────────┐    │
│  │ Caveman Mode（输出压缩）             │    │
│  │ - 注入简洁提示 → LLM 回复精简       │    │
│  │ - 节省最高 65% output tokens        │    │
│  └─────────────────────────────────────┘    │
│  ┌─────────────────────────────────────┐    │
│  │ 格式转换引擎                        │    │
│  │ OpenAI ↔ Claude ↔ Gemini ↔ Kiro    │    │
│  │ ↔ Vertex ↔ Cursor ↔ Ollama        │    │
│  └─────────────────────────────────────┘    │
│  ┌─────────────────────────────────────┐    │
│  │ 配额追踪 + OAuth 自动刷新           │    │
│  └─────────────────────────────────────┘    │
└──────┬──────────────────────────────────┘    │
       │                                       │
       ├─→ [Tier 1: SUBSCRIPTION] Claude Code, Codex, GitHub Copilot
       │    ↓ 配额耗尽
       ├─→ [Tier 2: CHEAP] GLM ($0.6/1M), MiniMax ($0.2/1M)
       │    ↓ 预算上限
       └─→ [Tier 3: FREE] Kiro, OpenCode Free, Vertex ($300 credits)

核心思路极其清晰：你的 CLI 工具只连 9Router，9Router 负责压缩 token、翻译格式、追踪配额、自动降级。你永远不需要手动切换供应商，也永远不会因为配额限制而中断编码。

三、RTK Token Saver：如何让每一次请求省下 20-40% 的 token？

这是 9Router 最具技术深度的特性。RTK（Request Token Kompressor）是内置的 token 压缩引擎，基于 rtk-ai/rtk（40K Stars）实现。

3.1 问题分析：工具输出为什么那么大？

AI 编程工具的工作流程中，模型需要反复读取工具的输出：

// 一个典型的 Claude Code 请求
{
  "messages": [
    {"role": "user", "content": "帮我修复这个 bug"},
    {"role": "assistant", "content": "让我看看代码差异", "tool_calls": [...]},
    {"role": "tool", "content": "git diff 输出——47,231 个 token 的差异内容"}
  ]
}

一个大型项目的 git diff 动辄几万 token，grep -r 的搜索结果同样恐怖。这些内容对 LLM 来说信息密度很低——大量的空行、重复的 import 语句、格式化空白。

3.2 RTK 压缩策略：9 个内置过滤器

RTK 内置了 9 个智能过滤器，每个都针对一种特定的工具输出模式：

3.3 自动检测机制：零配置的秘密

RTK 的核心设计哲学是零配置——你不需要告诉它"这是 git diff 输出，用 git-diff 过滤器"。它是怎么做到的？

// RTK 自动检测逻辑（简化版）
function detectFilter(content: string): FilterType {
  // 只 peek 前 1KB 内容
  const peek = content.slice(0, 1024);

  // 特征匹配
  if (/^diff --git a\//m.test(peek)) return 'git-diff';
  if (/^On branch /m.test(peek) || /^Changes not staged/m.test(peek)) return 'git-status';
  if (/^\d+:/m.test(peek) && /\.\w+:\d+:/.test(peek)) return 'grep';
  if (/^\.\/|^\/home|^\/Users/m.test(peek) && /\.\w+$/m.test(peek)) return 'find';
  if (/^total \d+/m.test(peek) || /^d[rwx-]{9}/m.test(peek)) return 'ls';
  if (/^├──|^└──/m.test(peek) || /^├─|^└─/m.test(peek)) return 'tree';

  // 连续行去重检测
  const lines = peek.split('\n');
  const uniqueRatio = new Set(lines).size / lines.length;
  if (uniqueRatio < 0.3) return 'dedup-log';

  return 'smart-truncate'; // 兜底
}

关键设计决策：

1. 只读前 1KB：避免对大输出全文扫描的性能开销
2. 安全兜底：如果过滤器失败或压缩后更大，静默保留原文，绝不破坏请求
3. 格式无关：在格式转换之前运行，对 OpenAI / Claude / Gemini 格式一视同仁

3.4 实战效果对比

# 没有 RTK
→ 发送 47,231 tokens 到 LLM
→ Claude Sonnet 输入: $3/1M → 单次请求 $0.14
→ 8小时编码 → 约 120 次请求 → $16.8

# 有 RTK（40% 压缩）
→ 发送 28,338 tokens 到 LLM
→ 单次请求 $0.085
→ 8小时编码 → 约 120 次请求 → $10.2
→ 日省 $6.6，月省约 $140

四、Caveman Mode：反向压缩输出 Token 的黑科技

如果说 RTK 是压缩"输入"，Caveman Mode 就是在压缩"输出"。它基于 JuliusBrussee/caveman（52K Stars）实现。

4.1 原理：让 LLM 说"人话"

LLM 默认的回复风格是这样的：

好的，我来帮您分析这段代码。首先，让我看一下这个函数的主要逻辑。
这个函数的主要问题是它在处理边界条件时没有进行充分的检查。具体来说，
当输入参数为空或者负数时，函数会抛出未处理的异常。为了修复这个问题，
我建议您在函数的开头添加以下检查代码……

Caveman Mode 在请求中注入一段"洞穴人提示"，让 LLM 用最精简的方式回复：

修复：添加边界检查。
```diff
+ if (input == null || input < 0) throw new ArgumentError();

**节省最高 65% 的输出 token**，技术实质完全保留。

### 4.2 在 9Router 中启用

```bash
# Dashboard → Endpoint Settings → Caveman Mode: ON
# 或通过环境变量
CAVEMAN_MODE=true

Caveman Mode 与 RTK 叠加使用，综合 token 节省可达 50-70%。

五、三层自动降级：永不断线的编程体验

9Router 最核心的用户价值是"Never stop coding"——永远不会因为配额或限速而中断。这通过三层自动降级实现：

5.1 三层降级架构

Tier 1: SUBSCRIPTION（你已付费的订阅）
├── Claude Code Pro/Max ($20-200/月)
├── Codex Plus/Pro ($20-200/月)
└── GitHub Copilot ($10-19/月)
    ↓ 配额耗尽 / 429 限速

Tier 2: CHEAP（低成本备选）
├── GLM-5.1 / GLM-4.7 ($0.6/1M tokens)
├── MiniMax M2.7 ($0.2/1M tokens)
└── Kimi K2.5 ($9/月 10M tokens)
    ↓ 预算上限 / 错误

Tier 3: FREE（完全免费）
├── Kiro AI (Claude 4.5 + GLM-5 + MiniMax 免费)
├── OpenCode Free (无需认证，自动获取模型)
└── Vertex AI ($300 GCP 新账户额度)

5.2 降级策略配置

9Router 引入了"Combo"概念——自定义模型组合：

// Combo 配置示例
{
  "name": "my-coding-stack",
  "models": [
    {
      "id": "cc/claude-opus-4-6",
      "tier": "subscription",
      "priority": 1,
      "description": "主力编码模型"
    },
    {
      "id": "glm/glm-4.7",
      "tier": "cheap",
      "priority": 2,
      "cost": "$0.6/1M",
      "description": "低成本备选"
    },
    {
      "id": "if/kimi-k2-thinking",
      "tier": "free",
      "priority": 3,
      "description": "免费兜底"
    }
  ],
  "fallback_rules": {
    "on_quota_exhausted": "next_tier",
    "on_rate_limit": "retry_after_cooldown_then_next",
    "on_error": "immediate_next",
    "cooldown_seconds": 30
  }
}

5.3 配额追踪：精确到每个供应商

9Router 实时追踪每个供应商的 token 消耗和配额重置时间：

Dashboard 实时显示：

┌──────────────────────────────────────────────────┐
│  📊 Quota Tracker                                │
├──────────────────────────────────────────────────┤
│  Claude Code Pro                                 │
│  ████████████░░░░  78% used  │  Resets in 2h 13m │
│                                                   │
│  GLM-4.7                                         │
│  ██░░░░░░░░░░░░░  12% used │  Resets at 10:00   │
│                                                   │
│  Kiro AI                                         │
│  ∞ Unlimited                                     │
└──────────────────────────────────────────────────┘

六、格式转换引擎：消除 AI 工具之间的"巴别塔"

不同 AI 供应商的 API 格式互不兼容，这是多模型路由最大的技术挑战。

6.1 格式矩阵

9Router 的格式转换引擎支持以下格式之间的双向转换：

OpenAI ↔ Claude ↔ Gemini ↔ Cursor ↔ Kiro ↔ Vertex ↔ Antigravity ↔ Ollama ↔ OpenAI Responses

这意味着你可以用 Claude Code 的请求格式发送，9Router 自动翻译成目标供应商的原生格式。

6.2 关键转换差异

6.3 转换引擎的核心代码逻辑

// 格式转换核心（简化版）
async function translateRequest(
  sourceFormat: ApiFormat,
  targetFormat: ApiFormat,
  request: any
): Promise<any> {
  // 1. 提取统一中间表示
  const unified = toUnified(sourceFormat, request);

  // 2. 处理特殊字段
  // Claude thinking → OpenAI: 丢弃或转为 metadata
  if (sourceFormat === 'claude' && targetFormat === 'openai') {
    unified.messages = unified.messages.filter(
      m => m.content?.type !== 'thinking'
    );
  }

  // 3. 转换为目标格式
  return fromUnified(targetFormat, unified);
}

// Claude tool_use → OpenAI tool_calls
function claudeToOpenaiToolUse(content: any): any {
  if (content.type === 'tool_use') {
    return {
      type: 'function',
      id: content.id,
      function: {
        name: content.name,
        arguments: JSON.stringify(content.input)
      }
    };
  }
  // ...
}

七、多账户轮询：一个供应商的配额不够？那就用两个

9Router 支持为同一个供应商添加多个账户，实现负载均衡和冗余。

7.1 配置方式

{
  "provider": "anthropic",
  "accounts": [
    {
      "name": "personal",
      "api_key": "sk-ant-xxx...",
      "priority": 1
    },
    {
      "name": "work",
      "api_key": "sk-ant-yyy...",
      "priority": 2
    }
  ],
  "routing_strategy": "round-robin"  // 或 "priority"
}

7.2 轮询策略

// Round-robin 轮询
function selectAccount(accounts: Account[]): Account {
  const available = accounts.filter(a => !a.isQuotaExhausted());
  if (available.length === 0) {
    // 所有账户配额耗尽，触发降级到下一 Tier
    return null;
  }
  // 轮询选择
  const idx = (this.roundRobinIndex++) % available.length;
  return available[idx];
}

7.3 OAuth 自动刷新

对于使用 OAuth 认证的供应商（如 Claude Code），9Router 自动管理 token 刷新：

// OAuth Token 刷新流程
async function refreshToken(account: Account): Promise<void> {
  if (account.tokenExpiry > Date.now() + 5 * 60 * 1000) {
    return; // 还没过期，不需要刷新
  }

  const newToken = await oauthRefresh({
    refresh_token: account.refreshToken,
    client_id: account.clientId,
  });

  account.accessToken = newToken.access_token;
  account.tokenExpiry = Date.now() + newToken.expires_in * 1000;
  // 静默刷新，用户无感知
}

八、实战：从零搭建 AI 编程的"永不断线"工作流

8.1 一键安装

# 全局安装
npm install -g 9router

# 启动
9router

# Dashboard 自动打开：http://localhost:20128

8.2 连接免费供应商（零成本启动）

在 Dashboard 中：

1. 进入 Providers 页面
2. 点击 Connect Kiro AI（免费 Claude 无限使用）
3. 或点击 Connect OpenCode Free（无需认证）
4. 完成！

8.3 配置 Claude Code 使用 9Router

# 设置环境变量
export ANTHROPIC_BASE_URL=http://localhost:20128/v1
export ANTHROPIC_API_KEY=your-9router-key

# 启动 Claude Code
claude

现在 Claude Code 的所有请求都经过 9Router：自动压缩 token → 优先使用订阅 → 配额不足自动降级。

8.4 配置 Cursor 使用 9Router

在 Cursor 设置中：

{
  "cursor.general.aiProvider": "custom",
  "cursor.general.customEndpoint": "http://localhost:20128/v1",
  "cursor.general.customApiKey": "your-9router-key",
  "cursor.general.customModel": "kr/claude-sonnet-4.5"
}

8.5 创建最优 Combo

{
  "name": "budget-killer",
  "models": [
    {"id": "cc/claude-sonnet-4-5", "tier": "subscription"},
    {"id": "glm/glm-4.7", "tier": "cheap"},
    {"id": "kr/claude-sonnet-4-5", "tier": "free"}
  ]
}

这个 Combo 的效果：

• 有 Claude Pro 订阅时 → 用自己的订阅
• 订阅配额用完 → 自动切到 GLM-4.7（$0.6/1M，几乎免费）
• 预算也到上限 → 自动切到 Kiro 免费 Claude

8.6 启用 RTK + Caveman 双重压缩

# .env 配置
RTK_ENABLED=true
CAVEMAN_MODE=true

综合效果：输入 token 减少 20-40%，输出 token 减少最高 65%，总成本降低 50-70%。

九、Docker 部署：生产级配置

对于团队使用，推荐 Docker 部署：

# docker-compose.yml
version: '3.8'
services:
  9router:
    image: decolua/9router:latest
    ports:
      - "20128:20128"
    environment:
      - PORT=20128
      - NEXT_PUBLIC_BASE_URL=http://your-server:20128
      - RTK_ENABLED=true
      - CAVEMAN_MODE=true
    volumes:
      - ./config:/app/config
      - ./data:/app/data
    restart: unless-stopped

# 启动
docker-compose up -d

# 团队成员连接
export ANTHROPIC_BASE_URL=http://your-server:20128/v1
export ANTHROPIC_API_KEY=team-9router-key

Cloudflare Workers 部署

9Router 还支持部署到 Cloudflare Workers，利用全球边缘网络：

# 构建 Workers 版本
npm run build:worker

# 部署
npx wrangler deploy

十、40+ 供应商完整清单与选型建议

10.1 供应商矩阵

10.2 选型建议矩阵

预算 $0/月：    Kiro AI + OpenCode Free + RTK → 永久免费
预算 $10/月：   Kimi K2.5 + 免费层 → 固定成本
预算 $20/月：   Claude Code Pro + 免费降级 → 高质量 + 兜底
预算 $50/月：   Claude Code + GLM 备选 + RTK → 最优体验
团队预算：      Docker 部署 + 多账户轮询 → 共享降级

十一、进阶：9Router 与其他方案的对比

9Router 的核心差异化在于：它不只是路由，而是一个完整的 AI 编程成本优化平台。RTK + Caveman + 三层降级的组合，在任何其他方案中都找不到。

十二、源码级分析：9Router 的核心技术实现

12.1 请求处理流水线

// 9Router 请求处理核心流水线（简化版）
async function handleRequest(req: Request): Promise<Response> {
  const startTime = Date.now();

  // Step 1: RTK Token 压缩（在格式转换之前）
  let processedReq = req;
  if (config.rtkEnabled) {
    processedReq = await rtkCompress(processedReq);
    // 记录压缩率
    logCompression(req.id, {
      original: req.tokenCount,
      compressed: processedReq.tokenCount,
      saved: (1 - processedReq.tokenCount / req.tokenCount) * 100
    });
  }

  // Step 2: 格式检测与转换
  const sourceFormat = detectFormat(processedReq);
  const targetFormat = getProviderFormat(currentProvider);
  if (sourceFormat !== targetFormat) {
    processedReq = await translateRequest(sourceFormat, targetFormat, processedReq);
  }

  // Step 3: Caveman Mode 注入
  if (config.cavemanMode) {
    processedReq = injectCavemanPrompt(processedReq);
  }

  // Step 4: 选择账户（多账户轮询）
  const account = selectAccount(currentProvider);
  if (!account) {
    // 所有账户配额耗尽，降级到下一 Tier
    currentProvider = fallbackToNextTier();
    return handleRequest(req); // 递归重试
  }

  // Step 5: 发送请求
  try {
    const response = await fetch(providerEndpoint, {
      method: 'POST',
      headers: withAuth(processedReq.headers, account),
      body: JSON.stringify(processedReq.body),
    });

    if (response.status === 429) {
      // 速率限制，冷却后重试或降级
      await cooldown(30);
      currentProvider = fallbackToNextTier();
      return handleRequest(req);
    }

    // Step 6: 追踪配额消耗
    trackQuota(currentProvider, response.usage);

    return response;
  } catch (error) {
    // 网络错误，立即降级
    currentProvider = fallbackToNextTier();
    return handleRequest(req);
  }
}

12.2 Next.js 架构

9Router 基于 Next.js 构建，技术栈：

• 前端：Next.js App Router + TailwindCSS
• 后端：Next.js API Routes
• 存储：本地 JSON 文件 + Cloud Sync
• 代理：Node.js http-proxy
• 端口：默认 20128

9router/
├── app/
│   ├── dashboard/        # Dashboard 页面
│   ├── api/
│   │   ├── v1/          # OpenAI 兼容 API 端点
│   │   ├── providers/   # 供应商管理 API
│   │   ├── combos/      # Combo 管理 API
│   │   └── sync/        # Cloud Sync API
│   └── layout.tsx
├── lib/
│   ├── rtk/            # RTK Token 压缩引擎
│   ├── caveman/        # Caveman Mode
│   ├── translator/     # 格式转换引擎
│   ├── quota/          # 配额追踪
│   ├── fallback/       # 降级策略
│   └── oauth/          # OAuth 管理
├── public/
│   └── providers/      # 供应商图标
└── Dockerfile

十三、安全考量与最佳实践

13.1 API Key 安全

9Router 在本地运行，API Key 存储在本地配置文件中。但请注意：

• 不要将 .env 文件提交到 Git
• 团队部署时使用环境变量而非配置文件
• 9Router Dashboard 应绑定到 127.0.0.1，避免暴露到公网

13.2 数据隐私

9Router 的所有请求处理都在本地完成，不会将你的代码或对话发送到 9Router 的服务器。Cloud Sync 功能使用加密传输，且是可选的。

13.3 最佳实践清单

1. ✅ 始终启用 RTK Token Saver（默认开启）
2. ✅ 为每个供应商至少配置 2 个账户
3. ✅ 创建至少 3 个 Tier 的 Combo
4. ✅ 启用配额追踪，避免浪费订阅额度
5. ✅ 使用 Docker 部署时添加健康检查
6. ⚠️ Kiro AI 等免费服务可能有使用限制，不要完全依赖单一免费层
7. ⚠️ Caveman Mode 可能影响某些需要详细解释的场景，按需开关

十四、总结：9Router 重新定义了 AI 编程的成本方程

9Router 的出现，解决了一个被长期忽视的问题：AI 编程工具的碎片化成本。

在 9Router 之前：

• 你要么忍受单一供应商的限制和高价
• 要么手动在多个工具之间切换
• 要么被 429 错误打断工作流

在 9Router 之后：

• RTK 让你每次请求省 20-40% token
• 三层降级让你永不断线
• Caveman Mode 让你最多省 65% 输出 token
• 40+ 供应商让你永远有免费选项
• 格式转换让你用任何工具连任何模型

最关键的是：9Router 本身完全免费。它不收取任何费用，你只需要为你选择使用的付费供应商付费。Dashboard 中显示的"cost"只是等价估算，展示你通过免费模型节省了多少钱。

对于一个每天使用 AI 编程 8 小时的开发者，9Router 的 ROI 计算如下：

月度成本对比（重度用户）：
├── 无 9Router：Claude Pro $100 + Cursor $20 + Copilot $19 = $139/月
├── 有 9Router：Claude Pro $100 + RTK 省 30% = 有效 $70 + 免费降级兜底
└── 月省 $30-70，年省 $360-840

月度成本对比（轻度用户）：
├── 无 9Router：Claude Pro $20 + 偶尔超限
├── 有 9Router：Kiro 免费 + RTK = $0
└── 月省 $20，年省 $240

9Router 不是另一个 AI 工具，而是你所有 AI 工具的"操作系统"。它让开发者从"被供应商锁定"走向"自由选择最优模型"，从"被 token 账单绑架"走向"成本可控的 AI 编程"。

开源地址：https://github.com/decolua/9router
官网：https://9router.com

本文基于 9Router v1.x 版本分析，项目仍在快速迭代中，部分功能可能随版本更新而变化。