关键代码验证

技术研究人工智能 AI Agent

{ models { glm-4.7 { provider zhipu, model glm-4.7, api_key ${ZHIPU_API_KEY}, base_url https//open.bigmodel.cn/api/paas/v4, temperature 0.7, max_tokens 8192 }, kimi-2.5 { provider ...

oh-my-opencode 模型配置示例

基础配置文件

以下是在 opencode.json 中配置多模型的基础结构：

{
  "models": {
    "glm-4.7": {
      "provider": "zhipu",
      "model": "glm-4.7",
      "api_key": "${ZHIPU_API_KEY}",
      "base_url": "https://open.bigmodel.cn/api/paas/v4",
      "temperature": 0.7,
      "max_tokens": 8192
    },
    "kimi-2.5": {
      "provider": "moonshot",
      "model": "kimi-k2.5",
      "api_key": "${MOONSHOT_API_KEY}",
      "base_url": "https://api.moonshot.cn/v1",
      "temperature": 0.6,
      "max_tokens": 16384
    },
    "minimax-2.5": {
      "provider": "minimax",
      "model": "MiniMax-M2.5",
      "api_key": "${MINIMAX_API_KEY}",
      "base_url": "https://api.minimaxi.com/v1",
      "temperature": 0.7,
      "max_tokens": 8192
    }
  }
}

Agent-模型映射配置

方案一：能力优先型配置

{
  "agents": {
    "Sisyphus": {
      "model": "minimax-2.5",
      "temperature": 0.7,
      "system_prompt": "你是一个任务协调器，负责理解用户需求并分发给合适的 Agent。"
    },
    "Oracle": {
      "model": "kimi-2.5",
      "temperature": 0.4,
      "system_prompt": "你是架构顾问，专注于复杂系统设计和深度技术咨询。"
    },
    "Librarian": {
      "model": "minimax-2.5",
      "temperature": 0.3,
      "system_prompt": "你是资料检索专家，擅长搜索和整合外部信息。"
    },
    "Developer": {
      "model": "minimax-2.5",
      "temperature": 0.2,
      "system_prompt": "你是代码开发专家，专注于高质量的代码实现。"
    },
    "Designer": {
      "model": "glm-4.7",
      "temperature": 0.6,
      "system_prompt": "你是 UI/UX 设计专家，擅长创造美观且实用的界面。"
    }
  }
}

方案二：成本优化型配置

{
  "agents": {
    "Sisyphus": {
      "model": "glm-4.7",
      "temperature": 0.7
    },
    "Oracle": {
      "model": "kimi-2.5",
      "temperature": 0.4
    },
    "Librarian": {
      "model": "minimax-2.5",
      "temperature": 0.3
    },
    "Developer": {
      "model": "glm-4.7",
      "temperature": 0.2
    },
    "Designer": {
      "model": "glm-4.7",
      "temperature": 0.6
    }
  }
}

场景自适应路由配置

实现基于任务类型的动态模型选择：

# agent_router.py
from enum import Enum
from typing import Optional

class TaskType(Enum):
    SIMPLE = "simple"           # 简单任务
    CODING = "coding"           # 编程任务
    RESEARCH = "research"       # 研究/探索
    ARCHITECTURE = "architecture"  # 架构设计
    UI_DESIGN = "ui_design"     # UI/UX 设计

class ModelSelector:
    def __init__(self):
        self.model_mapping = {
            # 简单任务 -> 成本最低
            (TaskType.SIMPLE, None): "minimax-2.5",
            
            # 编程任务 -> 根据复杂度
            (TaskType.CODING, "complex"): "kimi-2.5",
            (TaskType.CODING, "normal"): "minimax-2.5",
            (TaskType.CODING, "frontend"): "glm-4.7",
            
            # 研究任务 -> 根据上下文长度
            (TaskType.RESEARCH, "long_context"): "kimi-2.5",
            (TaskType.RESEARCH, "normal"): "minimax-2.5",
            
            # 架构设计 -> 最强推理
            (TaskType.ARCHITECTURE, None): "kimi-2.5",
            
            # UI 设计 -> 美学优化
            (TaskType.UI_DESIGN, None): "glm-4.7",
        }
    
    def select_model(self, task_type: TaskType, 
                     complexity: Optional[str] = None) -> str:
        """根据任务类型和复杂度选择模型"""
        key = (task_type, complexity)
        
        if key in self.model_mapping:
            return self.model_mapping[key]
        
        # 回退到默认配置
        return self.model_mapping.get((task_type, None), "minimax-2.5")

# 使用示例
selector = ModelSelector()

# 简单查询
model = selector.select_model(TaskType.SIMPLE)
print(f"简单任务使用模型: {model}")  # minimax-2.5

# 复杂算法设计
model = selector.select_model(TaskType.CODING, "complex")
print(f"复杂编码使用模型: {model}")  # kimi-2.5

# 前端开发
model = selector.select_model(TaskType.CODING, "frontend")
print(f"前端开发使用模型: {model}")  # glm-4.7

环境变量配置

为了安全地管理 API 密钥，建议使用环境变量：

# ~/.bashrc 或 ~/.zshrc

# 智谱 AI (GLM4.7)
export ZHIPU_API_KEY="your-zhipu-api-key"

# 月之暗面 (Kimi 2.5)
export MOONSHOT_API_KEY="your-moonshot-api-key"

# MiniMax
export MINIMAX_API_KEY="your-minimax-api-key"

性能监控配置

添加成本追踪和性能监控：

# cost_tracker.py
import time
from dataclasses import dataclass
from typing import Dict, List

@dataclass
class ModelUsage:
    model_name: str
    input_tokens: int
    output_tokens: int
    latency_ms: float
    cost_usd: float
    timestamp: float

class CostTracker:
    def __init__(self):
        # 每百万 token 成本（输出）
        self.pricing = {
            "glm-4.7": 2.00,
            "kimi-2.5": 3.00,
            "minimax-2.5": 1.20,
        }
        self.usage_history: List[ModelUsage] = []
    
    def track_usage(self, model_name: str, 
                    input_tokens: int, 
                    output_tokens: int,
                    latency_ms: float):
        """追踪模型使用情况"""
        price_per_million = self.pricing.get(model_name, 2.00)
        cost = (output_tokens / 1_000_000) * price_per_million
        
        usage = ModelUsage(
            model_name=model_name,
            input_tokens=input_tokens,
            output_tokens=output_tokens,
            latency_ms=latency_ms,
            cost_usd=cost,
            timestamp=time.time()
        )
        self.usage_history.append(usage)
        
        return cost
    
    def get_summary(self) -> Dict:
        """获取使用统计摘要"""
        summary = {}
        
        for model in self.pricing.keys():
            model_usage = [u for u in self.usage_history 
                          if u.model_name == model]
            
            if model_usage:
                summary[model] = {
                    "total_calls": len(model_usage),
                    "total_input_tokens": sum(u.input_tokens for u in model_usage),
                    "total_output_tokens": sum(u.output_tokens for u in model_usage),
                    "total_cost_usd": sum(u.cost_usd for u in model_usage),
                    "avg_latency_ms": sum(u.latency_ms for u in model_usage) / len(model_usage),
                }
        
        return summary
    
    def print_report(self):
        """打印成本报告"""
        summary = self.get_summary()
        
        print("\n" + "="*60)
        print("模型使用成本报告")
        print("="*60)
        
        total_cost = 0
        for model, stats in summary.items():
            print(f"\n{model}:")
            print(f"  调用次数: {stats['total_calls']}")
            print(f"  输出 Token: {stats['total_output_tokens']:,}")
            print(f"  总成本: ${stats['total_cost_usd']:.4f}")
            print(f"  平均延迟: {stats['avg_latency_ms']:.0f}ms")
            total_cost += stats['total_cost_usd']
        
        print(f"\n总成本: ${total_cost:.4f}")
        print("="*60)

# 使用示例
tracker = CostTracker()

# 模拟使用
tracker.track_usage("minimax-2.5", 500, 1000, 1200)
tracker.track_usage("kimi-2.5", 1000, 2000, 2500)
tracker.track_usage("glm-4.7", 800, 1500, 1800)

tracker.print_report()

测试验证

单元测试示例

# test_model_selection.py
import pytest
from agent_router import ModelSelector, TaskType

def test_simple_task_uses_minimax():
    selector = ModelSelector()
    model = selector.select_model(TaskType.SIMPLE)
    assert model == "minimax-2.5"

def test_complex_coding_uses_kimi():
    selector = ModelSelector()
    model = selector.select_model(TaskType.CODING, "complex")
    assert model == "kimi-2.5"

def test_frontend_uses_glm():
    selector = ModelSelector()
    model = selector.select_model(TaskType.CODING, "frontend")
    assert model == "glm-4.7"

def test_architecture_uses_kimi():
    selector = ModelSelector()
    model = selector.select_model(TaskType.ARCHITECTURE)
    assert model == "kimi-2.5"

集成测试

验证实际 API 调用：

# test_integration.py
import os
from openai import OpenAI

def test_model_connectivity():
    """测试各模型 API 连通性"""
    models = {
        "glm-4.7": {
            "client": OpenAI(
                api_key=os.getenv("ZHIPU_API_KEY"),
                base_url="https://open.bigmodel.cn/api/paas/v4"
            ),
            "model": "glm-4.7"
        },
        "kimi-2.5": {
            "client": OpenAI(
                api_key=os.getenv("MOONSHOT_API_KEY"),
                base_url="https://api.moonshot.cn/v1"
            ),
            "model": "kimi-k2.5"
        },
        "minimax-2.5": {
            "client": OpenAI(
                api_key=os.getenv("MINIMAX_API_KEY"),
                base_url="https://api.minimaxi.com/v1"
            ),
            "model": "MiniMax-M2.5"
        }
    }
    
    for name, config in models.items():
        try:
            response = config["client"].chat.completions.create(
                model=config["model"],
                messages=[{"role": "user", "content": "Hello"}],
                max_tokens=10
            )
            print(f"✓ {name}: 连接成功")
        except Exception as e:
            print(f"✗ {name}: 连接失败 - {e}")

if __name__ == "__main__":
    test_model_connectivity()

关键配置参数说明

Temperature 参数建议

Agent 类型	推荐 Temperature	说明
Oracle	0.3-0.4	需要确定性的架构决策
Developer	0.2-0.3	代码生成需要高确定性
Librarian	0.2-0.3	信息检索应准确一致
Designer	0.5-0.7	设计可以适当创造性
Sisyphus	0.6-0.8	协调需要一定灵活性

Max Tokens 配置

任务类型	推荐 Max Tokens	说明
简单问答	1024-2048	简短回答
代码生成	4096-8192	完整函数/类
架构设计	8192-16384	详细设计文档
长文档分析	16384-32768	完整分析报告

参考资料

OpenCode 配置基础 - 官方配置指南
GLM-4.7 API 接入指南 - GLM4.7 接入示例
MiniMax API 文档 - MiniMax API 参考