tRPC-Agent-Go 快速上手：Go 生态终于有了自己的 Agent 框架

1
2
3
4

type Agent interface {
    Info() Info
    Run(ctx context.Context, req *Request, opts ...Option) (<-chan *Event, error)
}

1
2
3
4
5

type Tool interface {
    Name() string
    Description() *FuncSchema
    Call(ctx context.Context, input map[string]any) (any, error)
}

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106

package main

import (
	"context"
	"fmt"
	"log"
	"math"

	"trpc.group/trpc-go/trpc-agent-go/agent/llmagent"
	"trpc.group/trpc-go/trpc-agent-go/event"
	"trpc.group/trpc-go/trpc-agent-go/model"
	"trpc.group/trpc-go/trpc-agent-go/model/openai"
	"trpc.group/trpc-go/trpc-agent-go/runner"
	"trpc.group/trpc-go/trpc-agent-go/tool"
	"trpc.group/trpc-go/trpc-agent-go/tool/function"
)

// 计算器函数，后面注册为 Tool
func calculate(_ context.Context, params map[string]any) (any, error) {
	a := params["a"].(float64)
	b := params["b"].(float64)
	op := params["op"].(string)
	switch op {
	case "add":
		return a + b, nil
	case "sub":
		return a - b, nil
	case "mul":
		return a * b, nil
	case "div":
		if b == 0 {
			return nil, fmt.Errorf("division by zero")
		}
		return a / b, nil
	case "pow":
		return math.Pow(a, b), nil
	default:
		return nil, fmt.Errorf("unknown operator: %s", op)
	}
}

func main() {
	ctx := context.Background()

	// 1. 创建模型（OpenAI 兼容接口）
	// API Key 通过环境变量 OPENAI_API_KEY 传入
	// 用 DeepSeek 则设 DEEPSEEK_API_KEY，传 openai.WithVariant("deepseek")
	model := openai.New("gpt-4o-mini")

	// 2. 用标准 Go 函数创建一个计算器 Tool
	calcTool := function.NewFunctionTool(
		calculate,
		function.WithName("calculator"),
		function.WithDescription("四则运算。参数：a,b 为数值，op 取值 add/sub/mul/div/pow"),
	)

	// 3. 创建 LLMAgent
	agent := llmagent.New("math-assistant",
		llmagent.WithModel(model),
		llmagent.WithTools([]tool.Tool{calcTool}),
		llmagent.WithInstruction("你是一个数学助手，使用 calculator 工具处理所有计算问题。"),
		llmagent.WithMaxToolRound(5), // 防止无限工具调用循环
	)

	// 4. 创建 Runner
	r := runner.NewRunner("demo-app", agent)

	// 5. 运行，传入结构化消息
	events, err := r.Run(ctx, "user-1", "session-1",
		model.NewUserMessage("计算 1234 × 5678 等于多少？"),
	)
	if err != nil {
		log.Fatal(err)
	}

	// 6. 消费事件流
	for evt := range events {
		if evt.Error != nil {
			fmt.Printf("❌ 错误: %s\n", evt.Error.Message)
			continue
		}
		if evt.Response == nil || len(evt.Response.Choices) == 0 {
			continue
		}
		choice := evt.Response.Choices[0]

		switch evt.Response.Object {
		case "chat.completion.chunk":
			// 流式文本块
			fmt.Print(choice.Delta.Content)
		case "chat.completion":
			fmt.Println("\n--- 最终响应 ---")
			fmt.Println(choice.Message.Content)
		default:
			// tool.response 等事件静默处理
		}

		// 检测工具调用
		if len(choice.Message.ToolCalls) > 0 {
			for _, tc := range choice.Message.ToolCalls {
				fmt.Printf("🔧 调用工具: %s\n  参数: %s\n",
					tc.Function.Name, string(tc.Function.Arguments))
			}
		}
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89

package main

import (
	"context"
	"fmt"
	"log"

	"trpc.group/trpc-go/trpc-agent-go/agent/graphagent"
	"trpc.group/trpc-go/trpc-agent-go/event"
	"trpc.group/trpc-go/trpc-agent-go/graph"
	"trpc.group/trpc-go/trpc-agent-go/model"
	"trpc.group/trpc-go/trpc-agent-go/runner"
)

func main() {
	ctx := context.Background()

	// 1. 创建状态图（用默认消息结构）
	sg := graph.NewStateGraph(graph.MessagesStateSchema())

	// 2. 添加节点（每个节点是一个处理函数）
	sg.AddNode("analyze", func(ctx context.Context, s graph.State) (any, error) {
		// 简化的情感判定
		msg := fmt.Sprintf("%v", s["messages"])
		if len(msg) > 10 {
			return graph.State{"sentiment": "positive"}, nil
		}
		return graph.State{"sentiment": "negative"}, nil
	})

	sg.AddNode("handle-positive", func(ctx context.Context, s graph.State) (any, error) {
		fmt.Println("✅ 积极反馈，正常回复")
		return graph.State{"response": "收到您的正面反馈，感谢支持！"}, nil
	})

	sg.AddNode("handle-negative", func(ctx context.Context, s graph.State) (any, error) {
		fmt.Println("⚠️ 负面反馈，升级处理")
		return graph.State{
			"response": "已升级到人工客服，将在24小时内联系您。",
			"priority": "high",
		}, nil
	})

	// 3. 设置条件路由 — 根据 sentiment 走不同分支
	sg.AddConditionalEdges("analyze",
		func(ctx context.Context, s graph.State) (string, error) {
			sentiment := s["sentiment"].(string)
			if sentiment == "positive" {
				return "handle-positive", nil
			}
			return "handle-negative", nil
		},
		map[string]string{
			"handle-positive": "positive-processor",
			"handle-negative": "negative-processor",
		},
	)

	// 4. 设置入口和出口
	sg.SetEntryPoint("analyze")
	sg.SetFinishPoint("handle-positive")
	sg.SetFinishPoint("handle-negative")

	// 5. 创建 GraphAgent
	agent := graphagent.New("sentiment-router",
		graphagent.WithStateGraph(sg),
	)

	r := runner.NewRunner("demo", agent)
	events, err := r.Run(ctx, "user-1", "session-1",
		model.NewUserMessage("你们的产品太棒了！"),
	)
	if err != nil {
		log.Fatal(err)
	}

	for evt := range events {
		if evt.Error != nil {
			fmt.Printf("❌ 错误: %s\n", evt.Error.Message)
			continue
		}
		if evt.Response == nil || len(evt.Response.Choices) == 0 {
			continue
		}
		if evt.Response.Object == "chat.completion" {
			fmt.Println("最终响应:", evt.Response.Choices[0].Message.Content)
		}
	}
}