推荐订阅源

Agent 路由模式实战：基于 Google ADK 的实现

路由模式（Routing Pattern）是 Agent 架构中的核心控制机制——让协调者根据用户意图，动态将请求分发给 specialized 子智能体处理。

---

路由设计

┌─────────────────────────────────────┐
│         Coordinator                 │
│    (协调者 - 路由决策)                │
└──────────────┬──────────────────────┘
               │
      ┌────────┴────────┐
      ▼                 ▼
┌──────────┐      ┌──────────┐
│  Booker  │      │   Info   │
│ 预订专家  │      │ 信息专家  │
└──────────┘      └──────────┘

---

代码实现

import uuid
import os
from dotenv import load_dotenv
from google.adk.agents import Agent
from google.adk.runners import InMemoryRunner
from google.adk.tools import FunctionTool
from google.genai import types
from google.adk.models.lite_llm import LiteLlm

load_dotenv('../.env')

# ========== 1. 定义工具 ==========

def booking_handler(request: str) -> str:
    """处理机票和酒店预订请求。"""
    print("-------------------------- 预订处理器已调用 ----------------------------")
    return f"已模拟处理预订请求：'{request}'。"

def info_handler(request: str) -> str:
    """处理一般信息请求。"""
    print("-------------------------- 信息处理器已调用 ----------------------------")
    return f"信息请求：'{request}'。结果：模拟信息检索。"

booking_tool = FunctionTool(booking_handler)
info_tool = FunctionTool(info_handler)

# ========== 2. 配置模型 ==========

model = LiteLlm(
    model=f"openai/{os.getenv('MODEL', 'kimi-k2.5')}",
    api_base=os.getenv("API_BASE", "https://api.moonshot.cn/v1"),
    api_key=os.getenv("API_KEY")
)

# ========== 3. 定义子智能体 ==========

booking_agent = Agent(
    name="Booker",
    model=model,
    description="专门处理机票和酒店预订请求，通过 booking tool 实现。",
    tools=[booking_tool]
)

info_agent = Agent(
    name="Info",
    model=model,
    description="专门提供一般信息和答疑，通过 info tool 实现。",
    tools=[info_tool]
)

# ========== 4. 定义协调者（路由核心） ==========

root_agent = Agent(
    name="Coordinator",
    model=model,
    instruction=(
        "你是主协调者，只负责分析用户请求并委托给合适的专用智能体。"
        "不要直接回答用户。\n"
        "- 任何涉及机票或酒店预订的请求，委托给 'Booker' 智能体。\n"
        "- 其他一般信息问题，委托给 'Info' 智能体。"
    ),
    description="负责将用户请求路由到正确专用智能体的协调者。",
    sub_agents=[booking_agent, info_agent]
)

---

运行效果

使用 adk web 启动调试界面：

测试用例

输入	路由目标	输出
"帮我预订去巴黎的机票"	Booker	预订处理器已调用
"巴黎有什么景点"	Info	信息处理器已调用

---

路由扩展

当前的路由模式已能应对基础场景，但在复杂业务环境中，可进行如下优化：

1. 多级路由（Hierarchical Routing）

当业务复杂度提升时，单层路由可能面临决策负担过重的问题。多级路由通过引入中间层路由节点，形成树状决策结构：

                    ┌─────────────────┐
                    │   Root Router   │
                    │  (根路由决策层)  │
                    └────────┬────────┘
                             │
           ┌─────────────────┼─────────────────┐
           ▼                 ▼                 ▼
    ┌────────────┐   ┌────────────┐   ┌────────────┐
    │  Travel    │   │   E-com    │   │   Admin    │
    │ 二级路由器  │   │ 二级路由器  │   │ 二级路由器  │
    └──────┬─────┘   └──────┬─────┘   └──────┬─────┘
           │                │                │
     ┌─────┴─────┐    ┌─────┴─────┐    ┌─────┴─────┐
     ▼           ▼    ▼           ▼    ▼           ▼
  ┌──────┐  ┌──────┐┌──────┐  ┌──────┐┌──────┐  ┌──────┐
  │Flight│  │Hotel ││Order │  │Refund││User  │  │Config│
  └──────┘  └──────┘└──────┘  └──────┘└──────┘  └──────┘

实现思路：

• 根路由负责粗粒度领域判断（如 travel/e-commerce/admin）
• 二级路由器专注领域内的细粒度分发
• 每级路由的 prompt 更精简，决策准确率更高

2. 向量检索路由（Vector-Based Routing）

当子 Agent 数量增多时，依赖 LLM 做逐一判断会产生较高的延迟和成本。向量检索路由通过语义相似度匹配实现高效分发：

# 伪代码示例
class VectorRouter:
    def __init__(self, agents: List[Agent]):
        self.agent_descriptions = [
            (agent, f"{agent.name}: {agent.description}") 
            for agent in agents
        ]
        # 预计算所有 agent 描述的 embedding
        self.embeddings = embed([desc for _, desc in self.agent_descriptions])
    
    def route(self, query: str) -> Agent:
        query_emb = embed(query)
        # 快速相似度匹配，找到最相关的 agent
        best_match = cosine_similarity(query_emb, self.embeddings).argmax()
        return self.agent_descriptions[best_match][0]

优势：

• 响应更快：O(1) 级别的向量检索替代 LLM 推理
• 成本更低：无需为每次路由调用 LLM
• 可解释性强：相似度分数可直接展示路由依据

3. 混合路由策略（Hybrid Routing）

结合规则、向量、LLM 三种路由方式的优势：

路由方式	适用场景	实现成本	准确性
规则路由	意图明确的指令（如 /book、/help）	低	极高
向量路由	常见查询的语义匹配	中	高
LLM 路由	复杂、模糊的请求	高	高

执行顺序：规则 → 向量 → LLM（逐级兜底）

4. 路由缓存与反馈学习

• 结果缓存：相同/相似查询的路由结果缓存，减少重复计算
• 反馈闭环：记录路由决策结果，对错误路由进行自动修正
• 热更新：支持运行时动态添加/移除子 Agent，无需重启

---

总结

1. 职责分离：Coordinator 只做路由决策，子 Agent 专注执行
2. 声明式配置：通过 description 和 instruction 让 LLM 自动决策路由
3. 易于扩展：新增功能只需添加子 Agent，无需修改路由逻辑
4. 渐进演进：从单层路由到多级、向量、混合策略，按需升级