模型智能路由：从三档选型到Advisor策略全实战

flowchart TD
    A[收到新任务] --> B{需要深度推理？}
    B -->|否| C{代码量>100行？}
    B -->|是| D{涉及架构决策？}
    C -->|否| E{格式化/重命名/排序？}
    C -->|是| F{逻辑复杂度高？}
    E --> G[Haiku 4.5]
    F -->|否| H[Sonnet 4.6]
    F -->|是| I[Sonnet + Advisor]
    D -->|是| J[Opus 4.6]
    D -->|否| K{多文件重构？}
    K -->|是| I
    K -->|否| H

    style G fill:#4CAF50,color:#fff
    style H fill:#2196F3,color:#fff
    style I fill:#FF9800,color:#fff
    style J fill:#9C27B0,color:#fff

> 你好，请帮我重构这个模块

> /model
? Select a model:
  ○ sonnet (Claude Sonnet 4.6) ← 默认
  ○ opus (Claude Opus 4.6)
  ○ haiku (Claude Haiku 4.5)

# 或者直接指定
> /model opus
✓ Model switched to claude-opus-4-6

> 请分析这个架构的问题...

# 用Haiku做快速文件整理
claude --model haiku "整理src目录下的所有import语句"

# 用Opus做深度架构分析
claude --model opus "分析这个项目的架构瓶颈，给出优化方案"

# -p模式（print mode）中指定模型
claude -p --model haiku "列出所有TODO注释" < src/main.ts

// .claude/settings.json（项目级别）
{
  "model": "claude-sonnet-4-6",
  "smallModel": "claude-haiku-4-5"
}

// ~/.claude/settings.json（用户级别）
{
  "model": "claude-sonnet-4-6"
}

# 使用别名（自动跟随最新）
claude --model sonnet

# 锁定特定版本
claude --model claude-sonnet-4-6-20260515

# 查看当前解析到的具体版本
claude config get model

传统模式：  [用户] → [单一模型] → [输出]
Advisor模式：[用户] → [执行者(Sonnet/Haiku)] ⇄ [顾问(Opus)] → [输出]

> /advisor
✓ Advisor enabled: Sonnet will consult Opus when needed

{
  "model": "claude-sonnet-4-6",
  "advisorModel": "claude-opus-4-6"
}

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=4096,
    tools=[{
        "type": "advisor",
        "name": "advisor"
    }],
    messages=[{
        "role": "user",
        "content": "实现一个高效的LRU缓存，支持并发访问"
    }]
)

sequenceDiagram
    participant User as 用户
    participant Sonnet as Sonnet执行者
    participant Opus as Opus顾问

    User->>Sonnet: 重构认证模块
    Sonnet->>Sonnet: 分析代码结构
    Sonnet->>Sonnet: 生成重构方案
    Sonnet->>Opus: advisor: 请审查此方案的安全风险
    Opus->>Sonnet: 发现JWT刷新时存在竞态条件
    Sonnet->>Sonnet: 修正方案
    Sonnet->>Opus: advisor: 确认修正后的方案
    Opus->>Sonnet: 方案可行，建议增加rate limiting
    Sonnet->>User: 输出最终重构代码

# 启用Fast模式
/fast

# 效果：
# - 首Token延迟降低约60%
# - 输出速度提升约2.5x
# - 模型权重不变（同一Opus 4.6）
# - 成本略微增加（优先队列费用）

# 场景1：紧急Bug修复，需要Opus的深度推理+速度
/fast
> 生产环境出现并发死锁，请快速分析这个锁的持有顺序问题

# 场景2：限时Code Review
/fast
> 审查这PR的所有变更，重点关注安全隐患

# 场景3：快速原型设计
/fast
> 设计一个事件驱动架构的微服务通信方案，画图说明

项目结构：
smart-router/
├── .claude/
│   └── settings.json
├── CLAUDE.md
├── src/
│   ├── router.py
│   ├── analyzer.py
│   └── executor.py
└── tests/
    └── test_router.py

// .claude/settings.json
{
  "model": "claude-sonnet-4-6",
  "advisorModel": "claude-opus-4-6",
  "permissions": {
    "allow": [
      "Bash(python3 *)",
      "Bash(pytest *)",
      "Read(*)",
      "Write(src/*)",
      "Write(tests/*)"
    ]
  }
}

# Smart Router 项目规范

## 模型使用策略
- 简单格式化和样板代码：使用 /model haiku
- 功能开发和Bug修复：使用默认Sonnet
- 架构设计和安全审计：使用 /model opus
- 复杂重构和不确定场景：启用 /advisor

## 代码规范
- Python 3.11+
- Type hints必须
- 测试覆盖率>80%

# 用Haiku快速生成项目骨架
claude --model haiku -p "
创建一个Python项目的骨架：
1. src/router.py - 任务路由器，包含TaskType枚举和route函数
2. src/analyzer.py - 代码分析器，分析任务复杂度
3. src/executor.py - 执行器，根据路由结果执行任务
4. tests/test_router.py - 路由器单元测试
每个文件只生成基础框架，包含类定义和方法签名。
"

# src/router.py
from enum import Enum
from dataclasses import dataclass

class TaskType(Enum):
    SIMPLE = "simple"        # → Haiku
    MODERATE = "moderate"    # → Sonnet
    COMPLEX = "complex"      # → Opus
    UNCERTAIN = "uncertain"  # → Sonnet + Advisor

@dataclass
class Task:
    description: str
    code_context: str
    complexity: float  # 0.0 - 1.0

def route(task: Task) -> tuple[TaskType, str]:
    """根据任务特征路由到最优模型"""
    ...

> /advisor
✓ Advisor enabled

> 请实现router.py的route函数。
  需要分析任务描述和代码上下文，判断复杂度并路由到合适的模型。
  复杂度评估要考虑：代码行数、嵌套层级、是否有并发/安全需求。

# Sonnet开始实现，在关键决策点咨询Opus：
# - 复杂度评分算法设计
# - 并发任务识别策略
# - 边界条件处理

# src/router.py（完整实现）
from enum import Enum
from dataclasses import dataclass
import re

class TaskType(Enum):
    SIMPLE = "simple"
    MODERATE = "moderate"
    COMPLEX = "complex"
    UNCERTAIN = "uncertain"

@dataclass
class Task:
    description: str
    code_context: str
    complexity: float = 0.0

# 复杂度评估关键词权重
KEYWORD_WEIGHTS = {
    "concurrent": 0.3, "thread": 0.3, "lock": 0.25,
    "security": 0.35, "auth": 0.3, "encrypt": 0.35,
    "refactor": 0.2, "architect": 0.4, "design": 0.3,
    "rename": -0.2, "format": -0.3, "sort": -0.2,
}

def _analyze_description(description: str) -> float:
    """从任务描述中提取复杂度信号"""
    score = 0.5  # 基础分
    desc_lower = description.lower()
    for keyword, weight in KEYWORD_WEIGHTS.items():
        if keyword in desc_lower:
            score += weight
    return max(0.0, min(1.0, score))

def _analyze_code(code: str) -> float:
    """从代码上下文中提取复杂度信号"""
    if not code.strip():
        return 0.5
    lines = code.split('\n')
    max_indent = 0
    for line in lines:
        indent = len(line) - len(line.lstrip())
        max_indent = max(max_indent, indent // 4)
    line_score = min(len(lines) / 200, 0.3)
    nest_score = min(max_indent / 5, 0.3)
    return min(line_score + nest_score + 0.4, 1.0)

def route(task: Task) -> tuple[TaskType, str]:
    """路由到最优模型，返回(任务类型, 模型建议)"""
    desc_score = _analyze_description(task.description)
    code_score = _analyze_code(task.code_context)
    task.complexity = (desc_score * 0.6 + code_score * 0.4)

    if task.complexity < 0.3:
        return (TaskType.SIMPLE, "claude-haiku-4-5")
    elif task.complexity < 0.6:
        return (TaskType.MODERATE, "claude-sonnet-4-6")
    elif task.complexity < 0.8:
        return (TaskType.UNCERTAIN, "claude-sonnet-4-6+advisor")
    else:
        return (TaskType.COMPLEX, "claude-opus-4-6")

> /model opus
✓ Model switched to claude-opus-4-6

> 审查router.py的route函数实现。
  重点关注：
  1. 复杂度评分算法是否有盲区
  2. 边界条件处理是否完善
  3. 是否有性能隐患
  4. 给出改进建议

# Opus发现：
# - 关键词匹配没有处理否定语境（"不需要并发"会被误判）
# - 缺少对正则/解析类任务的特殊处理
# - 建议增加task_type字段让用户显式指定

claude --model haiku -p "
基于src/router.py中的route函数，编写tests/test_router.py。
覆盖以下场景：
1. 简单任务路由到Haiku
2. 中等任务路由到Sonnet
3. 复杂任务路由到Opus
4. 不确定任务路由到Advisor
5. 边界值测试
使用pytest。
"

cd smart-router && python3 -m pytest tests/ -v

tests/test_router.py::test_simple_task PASSED
tests/test_router.py::test_moderate_task PASSED
tests/test_router.py::test_complex_task PASSED
tests/test_router.py::test_uncertain_task PASSED
tests/test_router.py::test_boundary_values PASSED
======================== 5 passed in 0.12s ========================

flowchart LR
    subgraph 输入
        T1[格式化/重命名]
        T2[功能开发]
        T3[Bug修复]
        T4[代码审查]
        T5[架构设计]
        T6[大规模重构]
        T7[安全审计]
    end

    subgraph 路由
        R1[Haiku]
        R2[Sonnet]
        R3[Sonnet+Advisor]
        R4[Opus]
        R5[Opus+Fast]
    end

    T1 --> R1
    T2 --> R2
    T3 --> R3
    T4 --> R3
    T5 --> R4
    T6 --> R3
    T7 --> R5

    style R1 fill:#4CAF50,color:#fff
    style R2 fill:#2196F3,color:#fff
    style R3 fill:#FF9800,color:#fff
    style R4 fill:#9C27B0,color:#fff
    style R5 fill:#E91E63,color:#fff

# 一行搞定，Haiku足够
claude --model haiku -p "格式化所有Python文件：排序import、统一引号风格" \
  --glob "src/**/*.py"

# 交互模式，Sonnet是最佳平衡
claude --model sonnet
> 实现用户注册API，包含邮箱验证和密码强度检查

> /model sonnet
> /advisor
> 修复issue #42：在高并发下购物车数量计算不准确
# Sonnet负责定位和修复，遇到并发策略选择时咨询Opus

> /advisor
> 审查feat/payment分支的所有变更
# Sonnet做逐行审查，Opus在安全敏感处提供深度分析

claude --model opus
> 设计一个可扩展的事件溯源架构，支撑百万级TPS
> 要求：画出架构图、列出核心组件、给出技术选型理由

> /advisor
> 将这个Monolith应用拆分为3个微服务
> 第一阶段：识别模块边界，生成拆分计划
# Sonnet执行具体代码修改，Opus在架构决策点介入

> /model opus
> /fast
> 对认证和授权模块做全面安全审计
> 检查：OWASP Top 10、注入、越权、会话管理
# 需要Opus的深度推理+Fast的速度

// .claude/settings.json
{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash(git commit*)",
        "command": "echo '/model haiku' > /tmp/claude-model-hint"
      },
      {
        "matcher": "Bash(pytest*--complex*)",
        "command": "echo '/model opus' > /tmp/claude-model-hint"
      }
    ]
  }
}

> 请同时执行以下任务：
  1. 用Haiku生成所有CRUD接口的单元测试骨架
  2. 用Sonnet实现用户模块的业务逻辑
  3. 用Opus审查整体架构设计

Task 1: subagent_type=general-purpose, model=haiku
Task 2: subagent_type=general-purpose, model=sonnet
Task 3: subagent_type=general-purpose, model=opus

# .github/workflows/ai-review.yml
name: AI Code Review

on: [pull_request]

jobs:
  review:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Determine model
        id: model
        run: |
          CHANGES=$(git diff --stat origin/main...HEAD | tail -1 | awk '{print $4+$6}')
          if [ "$CHANGES" -lt 100 ]; then
            echo "model=haiku" >> $GITHUB_OUTPUT
          elif [ "$CHANGES" -lt 500 ]; then
            echo "model=sonnet" >> $GITHUB_OUTPUT
          else
            echo "model=opus" >> $GITHUB_OUTPUT
          fi

      - name: AI Review
        env:
          ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}
        run: |
          claude -p --model ${{ steps.model.outputs.model }} \
            "审查这个PR的所有变更，给出改进建议"

> /advisor
> 这个重构涉及分布式事务，请确保在关键决策点咨询Advisor

# 不好的Haiku提示
> 重构这个模块

# 好的Haiku提示
> 将src/utils.py中所有以get_开头的函数重命名为fetch_开头，
> 更新所有调用处，不要改变函数逻辑

{
  "model": "claude-sonnet-4-6",
  "smallModel": "claude-haiku-4-5"
}

# 检查余额
claude config get model

# 降级到Haiku完成紧急任务
claude --model haiku -p "完成当前的紧急修复"

法则1：默认Sonnet，80%的任务不需要更贵的选择
法则2：简单任务用Haiku，省钱且快
法则3：复杂任务用Advisor，而非直接上Opus
法则4：只有架构设计和安全审计才需要纯Opus
法则5：需要Opus+速度时用Fast，而非切Sonnet
法则6：用CLAUDE.md和settings.json固化策略，避免手动选择
法则7：在CI/CD中用代码行数或文件数自动路由模型