跟 Blades 学 Agent 设计 - 02 让 Agent 学会"随机应变"

if strings.Contains(userQuery, "订单") {
    routeToOrderModule()
} else if strings.Contains(userQuery, "技术支持") {
    routeToSupportModule()
}

用户输入："我想知道这个产品的规格。"
AI 分析后识别出意图为"查询产品信息"，于是将请求路由到产品信息模块。

  总经理
  ├─────────────────┬─────────────────┬─────────────────┬─────────────────┐
  技术部           市场部           人事部           财务部           运营部
  │                │                │                │                │
  ├─────┬─────┐    ├─────┬─────┐    │                ├─────┬─────┐    │
  前端组 后端组   推广组  销售组   招聘培训组        会计组 审计组   客服组

   You are a routing agent.
    Choose the single best route key for handling the user's request.
    User message: <user_message>
    Available route keys (choose exactly one):
    - math_agent: You provide help with math problems. Explain your reasoning at each step and include examples.
    - history_agent: You provide assistance with historical queries. Explain important events and context clearly.

package main

import (
    "context"
    "encoding/json"
    "fmt"
    "log"
    "strings"

    "github.com/go-kratos/blades"
    "github.com/go-kratos/blades/contrib/openai"
)

// RoutingWorkflow is a workflow that routes requests to different agents based on the content of the prompt.
type RoutingWorkflow struct {
    blades.Agent
    routes map[string]string
    agents map[string]blades.Agent
}

// NewRoutingWorkflow creates a new RoutingWorkflow with the given model provider and routes.
func NewRoutingWorkflow(routes map[string]string) (*RoutingWorkflow, error) {
    provider := openai.NewChatProvider()
    router, err := blades.NewAgent(
        "triage_agent",
        blades.WithModel("gpt-5"),
        blades.WithProvider(provider),
        blades.WithInstructions("You determine which agent to use based on the user's homework question"),
    )
    if err != nil {
        returnnil, err
    }
    agents := make(map[string]blades.Agent, len(routes))
    for name, instructions := range routes {
        agent, err := blades.NewAgent(
            name,
            blades.WithModel("gpt-5"),
            blades.WithProvider(provider),
            blades.WithInstructions(instructions),
        )
        if err != nil {
            returnnil, err
        }
        agents[name] = agent
    }
    return &RoutingWorkflow{
        Agent:  router,
        routes: routes,
        agents: agents,
    }, nil
}

// Run selects a route using the prompt content and streams from the chosen runner.
func (r *RoutingWorkflow) Run(ctx context.Context, invocation *blades.Invocation) blades.Generator[*blades.Message, error] {
    returnfunc(yield func(*blades.Message, error) bool) {
        agent, err := r.selectRoute(ctx, invocation)
        if err != nil {
            yield(nil, err)
            return
        }
        stream := agent.Run(ctx, invocation)
        for msg, err := range stream {
            if !yield(msg, err) {
                break
            }
        }
    }
}

// selectRoute determines the best route key and runner for the given prompt.
func (r *RoutingWorkflow) selectRoute(ctx context.Context, invocation *blades.Invocation) (blades.Agent, error) {
    var buf strings.Builder
    buf.WriteString("You are a routing agent.\n")
    buf.WriteString("Choose the single best route key for handling the user's request.\n")
    buf.WriteString("User message: " + invocation.Message.Text() + "\n")
    buf.WriteString("Available route keys (choose exactly one):\n")
    routes, err := json.Marshal(r.routes)
    if err != nil {
        returnnil, err
    }
    buf.WriteString(string(routes))
    for res, err := range r.Agent.Run(ctx, blades.NewInvocation(blades.UserMessage(buf.String()))) {
        if err != nil {
            returnnil, err
        }
        choice := strings.TrimSpace(res.Text())
        return r.agents[choice], nil
    }
    returnnil, fmt.Errorf("no route selected")
}

func main() {
    var (
        routes = map[string]string{
            "math_agent":    "You provide help with math problems. Explain your reasoning at each step and include examples.",
            "history_agent": "You provide assistance with historical queries. Explain important events and context clearly.",
        }
    )
    routing, err := NewRoutingWorkflow(routes)
    if err != nil {
        log.Fatal(err)
    }
    // Example prompt that will be routed to the history_agent
    input := blades.UserMessage("What is the capital of France?")
    runner := blades.NewRunner(routing)
    res, err := runner.Run(context.Background(), input)
    if err != nil {
        log.Fatal(err)
    }
    log.Println(res.Text())
}