Eino ADK 实战：从零构建你的第一个 Go 智能体

package main

import (
    "context"
    "fmt"

    "github.com/cloudwego/eino/adk"
    "github.com/cloudwego/eino/components/tool"
    "github.com/cloudwego/eino/schema"
)

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

    // 初始化 ChatModel（以 OpenAI 为例）
    chatModel := initOpenAIChatModel()

    // 定义工具
    searchTool := createSearchTool()
    calculatorTool := createCalculatorTool()

    // 创建 ChatModelAgent
    agent, err := adk.NewChatModelAgent(ctx, &adk.ChatModelAgentConfig{
        Model:        chatModel,
        Tools:        []tool.BaseTool{searchTool, calculatorTool},
        SystemPrompt: "你是一个有帮助的助手，可以搜索信息和进行计算。",
        MaxSteps:     10,
    })
    if err != nil {
        panic(err)
    }

    // 运行 Agent
    result, err := agent.Run(ctx, "北京今天的气温是多少？换算成华氏度。")
    if err != nil {
        panic(err)
    }
    fmt.Println(result.Content)
}

// 自定义工具的实现示例
func createSearchTool() tool.BaseTool {
    return tool.NewSimpleTool(
        "web_search",
        "搜索互联网上的实时信息",
        func(ctx context.Context, params map[string]interface{}) (string, error) {
            query := params["query"].(string)
            // 调用搜索 API
            results, err := searchAPI.Search(ctx, query)
            if err != nil {
                return "", err
            }
            return formatResults(results), nil
        },
        tool.WithStringParam("query", "搜索关键词", true),
    )
}

deepAgent, err := adk.NewDeepAgent(ctx, &adk.DeepAgentConfig{
    Model:        chatModel,
    Tools:        tools,
    SystemPrompt: "你是一个数据分析专家，擅长分解复杂问题并逐步解决。",
    MaxSteps:     25,
    Planning:     true,  // 启用任务规划
    Reflection:   true,  // 启用执行反思
})

// 注册工具调用拦截器
agent.OnToolCall(func(ctx context.Context, call *schema.ToolCall) (*schema.ToolResult, error) {
    // 对敏感操作（如发送邮件）进行拦截
    if call.Name == "send_email" {
        recipient := call.Args["to"].(string)
        subject := call.Args["subject"].(string)
        // 返回 Interrupt 暂停 Agent 执行
        return nil, adk.Interrupt(fmt.Sprintf(
            "请确认发送邮件:\n收件人: %s\n主题: %s",
            recipient, subject,
        ))
    }
    return nil, nil // 其他工具正常执行
})

// 执行 Agent（可能在某步中断）
result, err := agent.Run(ctx, "给张三发一封会议通知邮件")
if errors.Is(err, adk.ErrInterrupted) {
    // Agent 已中断，获取 Checkpoint
    checkpoint := agent.GetCheckpoint()
    // 持久化 checkpoint（如存入 Redis）
    saveCheckpoint(checkpoint)
    // 展示中断信息给用户
    fmt.Println("等待审核:", checkpoint.InterruptMessage)
}

// --- 人工审核后 ---

// 读取 checkpoint
checkpoint := loadCheckpoint()

// 构造人工审批结果
approvedResult := &schema.ToolResult{
    Name:    "send_email",
    Content: "邮件已确认发送",
}

// 恢复 Agent 执行
result, err := agent.Resume(ctx, checkpoint, approvedResult)
fmt.Println(result.Content) // "邮件已成功发送给张三"

// Checkpoint 结构示意
type AgentCheckpoint struct {
    ConversationHistory []schema.Message   // 完整对话历史
    CurrentStep         int                // 当前执行步骤
    PendingToolCalls    []schema.ToolCall  // 待执行的工具调用
    InterruptMessage    string             // 中断原因
    Metadata            map[string]any     // 自定义元数据
}

// 状态持久化示例
func saveCheckpoint(cp *adk.AgentCheckpoint) error {
    data, err := json.Marshal(cp)
    if err != nil {
        return err
    }
    return redis.Set(ctx, "agent:checkpoint:"+sessionID, data, 24*time.Hour).Err()
}

// 状态恢复
func loadCheckpoint(sessionID string) (*adk.AgentCheckpoint, error) {
    data, err := redis.Get(ctx, "agent:checkpoint:"+sessionID).Bytes()
    if err != nil {
        return nil, err
    }
    var cp adk.AgentCheckpoint
    return &cp, json.Unmarshal(data, &cp)
}

package main

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

    "github.com/cloudwego/eino/adk"
    "github.com/cloudwego/eino/components/model/openai"
    "github.com/cloudwego/eino/components/tool"
    "github.com/cloudwego/eino/schema"
)

// 数据查询工具
func createQueryTool() tool.BaseTool {
    return tool.NewSimpleTool(
        "query_database",
        "执行 SQL 查询获取数据",
        func(ctx context.Context, params map[string]interface{}) (string, error) {
            sql := params["sql"].(string)
            rows, err := db.QueryContext(ctx, sql)
            if err != nil {
                return "", fmt.Errorf("查询失败: %w", err)
            }
            defer rows.Close()
            results := scanRows(rows)
            data, _ := json.Marshal(results)
            return string(data), nil
        },
        tool.WithStringParam("sql", "SQL 查询语句", true),
    )
}

// 数据分析工具
func createAnalysisTool() tool.BaseTool {
    return tool.NewSimpleTool(
        "analyze_data",
        "对数据进行统计分析（均值、中位数、趋势等）",
        func(ctx context.Context, params map[string]interface{}) (string, error) {
            data := params["data"].(string)
            method := params["method"].(string)
            result := performAnalysis(data, method)
            return result, nil
        },
        tool.WithStringParam("data", "JSON 格式的数据", true),
        tool.WithStringParam("method", "分析方法: mean/median/trend/distribution", true),
    )
}

// 报告生成工具
func createReportTool() tool.BaseTool {
    return tool.NewSimpleTool(
        "generate_report",
        "根据分析结果生成 Markdown 格式报告",
        func(ctx context.Context, params map[string]interface{}) (string, error) {
            findings := params["findings"].(string)
            title := params["title"].(string)
            report := fmt.Sprintf("# %s\n\n%s\n", title, findings)
            return report, nil
        },
        tool.WithStringParam("title", "报告标题", true),
        tool.WithStringParam("findings", "分析发现的内容", true),
    )
}

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

    // 初始化模型
    chatModel, err := openai.NewChatModel(ctx, &openai.ChatModelConfig{
        Model:  "gpt-4o",
        APIKey: os.Getenv("OPENAI_API_KEY"),
    })
    if err != nil {
        log.Fatal(err)
    }

    // 创建数据分析 Agent
    agent, err := adk.NewDeepAgent(ctx, &adk.DeepAgentConfig{
        Model: chatModel,
        Tools: []tool.BaseTool{
            createQueryTool(),
            createAnalysisTool(),
            createReportTool(),
        },
        SystemPrompt: `你是一个专业的数据分析师。你的工作流程是：
1. 理解用户的分析需求
2. 编写 SQL 查询获取数据
3. 对数据进行统计分析
4. 生成结构化分析报告

注意：SQL 查询必须包含 LIMIT 子句防止数据量过大。`,
        MaxSteps:   20,
        Planning:   true,
        Reflection: true,
    })
    if err != nil {
        log.Fatal(err)
    }

    // 添加敏感操作拦截
    agent.OnToolCall(func(ctx context.Context, call *schema.ToolCall) (*schema.ToolResult, error) {
        if call.Name == "query_database" {
            sql := call.Args["sql"].(string)
            if containsDangerousSQL(sql) {
                return nil, adk.Interrupt("检测到危险 SQL 操作，请人工审核: " + sql)
            }
        }
        return nil, nil
    })

    // 执行分析任务
    result, err := agent.Run(ctx, "分析过去 30 天的用户注册趋势，按日统计并识别异常波动")
    if err != nil {
        log.Fatal(err)
    }
    fmt.Println(result.Content)
}

func containsDangerousSQL(sql string) bool {
    // 检测 DROP、DELETE、UPDATE 等危险操作
    dangerousKeywords := []string{"DROP", "DELETE", "UPDATE", "TRUNCATE", "ALTER"}
    upperSQL := strings.ToUpper(sql)
    for _, keyword := range dangerousKeywords {
        if strings.Contains(upperSQL, keyword) {
            return true
        }
    }
    return false
}