LemonData logoLemonData

設定

語言
部落格

構建多模型 AI Agent：實用架構指南

L
LemonData
·2026年2月26日·27 次瀏覽
#AI 智能體#多模型#架構#教學#LangChain
構建多模型 AI Agent：實用架構指南

構建多模型 AI Agent：實用架構指南

大多數 AI Agent 都使用單一模型處理所有事務。規劃步驟、工具調用、摘要、錯誤恢復。這在 demo 時可行，但在生產環境中，這是一種浪費。

需要深度推理的規劃步驟與 JSON 提取步驟並不需要相同的模型。程式碼生成任務與分類任務有不同的需求。使用 Claude Opus 4.6（每 1M Output Tokens $25）來格式化日期字串，就像聘請資深建築師來刷牆一樣。

以下是如何構建將每個步驟路由到最佳模型的 Agent。

多模型 Agent 架構

User Request
    │
    ▼
┌─────────────┐
│   Router     │  ← 分類任務複雜度
│  (fast model)│
└──────┬──────┘
       │
   ┌───┴───┐
   ▼       ▼
┌──────┐ ┌──────┐
│Simple│ │Complex│
│Model │ │Model  │
└──┬───┘ └──┬───┘
   │        │
   ▼        ▼
┌─────────────┐
│  Aggregator  │  ← 合併結果
│  (fast model)│
└─────────────┘

三個組件：

  1. 一個根據複雜度對傳入任務進行分類的路由 (Router)
  2. 一個匹配不同任務類型的模型池
  3. 一個在需要時合併結果的聚合器 (Aggregator)

使用 OpenAI SDK 實作

透過聚合器使用單一 API key，您無需管理多個 SDK 即可存取所有模型：

from openai import OpenAI

client = OpenAI(
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

# Model pool with cost/capability tiers
MODELS = {
    "router": "gpt-4.1-mini",        # $0.40/1M in - fast classification
    "simple": "gpt-4.1-mini",         # $0.40/1M in - extraction, formatting
    "reasoning": "claude-sonnet-4-6",  # $3.00/1M in - planning, analysis
    "complex": "gpt-4.1",             # $2.00/1M in - code gen, multi-step
    "budget": "deepseek-chat",         # $0.28/1M in - bulk processing
}

def route_task(task: str) -> str:
    """Use a cheap model to classify task complexity."""
    response = client.chat.completions.create(
        model=MODELS["router"],
        messages=[
            {"role": "system", "content": """Classify this task into one category:
- simple: data extraction, formatting, translation
- reasoning: analysis, planning, comparison
- complex: code generation, multi-step problem solving
- budget: bulk processing, non-critical tasks
Reply with just the category name."""},
            {"role": "user", "content": task}
        ],
        max_tokens=10
    )
    category = response.choices[0].message.content.strip().lower()
    return MODELS.get(category, MODELS["simple"])

def execute_task(task: str, context: str = "") -> str:
    """Route task to appropriate model and execute."""
    model = route_task(task)
    messages = []
    if context:
        messages.append({"role": "system", "content": context})
    messages.append({"role": "user", "content": task})

    response = client.chat.completions.create(
        model=model,
        messages=messages
    )
    return response.choices[0].message.content

實戰 Agent：程式碼審查流水線

這是一個審查 Pull Request 的實用多模型 Agent：

def review_pr(diff: str) -> dict:
    """Multi-model PR review pipeline."""

    # Step 1: Classify changes (cheap model)
    classification = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{
            "role": "user",
            "content": f"Classify these code changes: {diff[:2000]}\n"
                       "Categories: bugfix, feature, refactor, docs, test"
        }],
        max_tokens=20
    ).choices[0].message.content

    # Step 2: Security scan (reasoning model)
    security = client.chat.completions.create(
        model="claude-sonnet-4-6",
        messages=[{
            "role": "system",
            "content": "You are a security reviewer. Check for: "
                       "SQL injection, XSS, auth bypass, secrets in code, "
                       "unsafe deserialization. Be specific about line numbers."
        }, {
            "role": "user",
            "content": f"Review this diff for security issues:\n{diff}"
        }]
    ).choices[0].message.content

    # Step 3: Code quality (general model)
    quality = client.chat.completions.create(
        model="gpt-4.1",
        messages=[{
            "role": "user",
            "content": f"Review code quality: naming, structure, "
                       f"error handling, test coverage.\n{diff}"
        }]
    ).choices[0].message.content

    # Step 4: Summary (cheap model)
    summary = client.chat.completions.create(
        model="gpt-4.1-mini",
        messages=[{
            "role": "user",
            "content": f"Summarize this PR review in 3 bullet points:\n"
                       f"Type: {classification}\n"
                       f"Security: {security[:500]}\n"
                       f"Quality: {quality[:500]}"
        }]
    ).choices[0].message.content

    return {
        "classification": classification,
        "security": security,
        "quality": quality,
        "summary": summary
    }

典型 PR 審查（2K Token Diff）的成本明細：

步驟 模型 Input Tokens 成本
分類 GPT-4.1-mini ~2,100 $0.0008
安全性 Claude Sonnet 4.6 ~2,500 $0.0075
品質 GPT-4.1 ~2,500 $0.0050
摘要 GPT-4.1-mini ~1,200 $0.0005
總計 ~$0.014

若四個步驟全部使用 Claude Sonnet 4.6，成本約為 $0.028。多模型方法將成本降低了 50%，同時在最關鍵的地方（安全性審查）使用了最強大的模型。

LangChain 整合

from langchain_openai import ChatOpenAI

# Create model instances with different configs
fast = ChatOpenAI(
    model="gpt-4.1-mini",
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

reasoning = ChatOpenAI(
    model="claude-sonnet-4-6",
    api_key="sk-lemon-xxx",
    base_url="https://api.lemondata.cc/v1"
)

# Use in LangChain chains
from langchain_core.prompts import ChatPromptTemplate

classify_chain = ChatPromptTemplate.from_template(
    "Classify: {input}"
) | fast

analyze_chain = ChatPromptTemplate.from_template(
    "Analyze in depth: {input}"
) | reasoning

何時使用多模型 Agent

多模型路由會增加複雜性。在以下情況下是值得的：

  • 您的 Agent 處理多樣化的任務類型（而不僅僅是聊天）
  • 每月 API 成本超過 $100（節省變得有意義）
  • 您需要特定模型的優勢（Claude 用於程式碼、Gemini 用於長上下文、GPT 用於速度）
  • 某些步驟對延遲敏感，而其他步驟則不然

對於簡單的聊天機器人或單一用途的 Agent，單一模型就足夠了。當每個請求都需要相同的能力時，路由的開銷並不合理。

核心要點

  1. 使用能處理好每個步驟的最便宜模型
  2. 將昂貴的模型留給真正需要的任務
  3. 分類/路由步驟應始終使用最便宜的可用模型
  4. 衡量每次 Agent 運行的實際成本，而不僅僅是 per-token 定價
  5. 使用單一 key 的 API 聚合器可顯著簡化多模型存取

透過一個 API 存取所有模型：lemondata.cc 提供 300+ 個模型，只需一個 API key。無需管理多個供應商帳戶即可構建多模型 Agent。

Share: