Eino 核心组件详解：ChatModel、Tool 与 Retriever 实战

type ChatModel interface {
    Generate(ctx context.Context, input []*schema.Message, opts ...Option) (*schema.Message, error)
    Stream(ctx context.Context, input []*schema.Message, opts ...Option) (*schema.StreamReader[*schema.Message], error)
    BindTools(tools []*schema.ToolInfo) error
}

// OpenAI
model, _ := openai.NewChatModel(ctx, &openai.ChatModelConfig{
    Model:  "PROVIDER_MODEL@REVIEWED_REVISION",
    APIKey: os.Getenv("OPENAI_API_KEY"),
})

// Ollama 本地模型
model, _ := ollama.NewChatModel(ctx, &ollama.ChatModelConfig{
    Model:   "LOCAL_MODEL@REVIEWED_REVISION",
    BaseURL: "http://localhost:11434",
})

// Ark (字节火山引擎)
model, _ := ark.NewChatModel(ctx, &ark.ChatModelConfig{
    Model:  "ARK_ENDPOINT@REVIEWED_REVISION",
    APIKey: os.Getenv("ARK_API_KEY"),
})

// 同步调用 - 适用于后台处理
message, err := model.Generate(ctx, []*schema.Message{
    schema.SystemMessage("you are a helpful assistant."),
    schema.UserMessage("what does the future AI App look like?"),
})
if err != nil {
    log.Fatal(err)
}
fmt.Println(message.Content)

// 流式调用 - 适用于实时 UI
reader, err := model.Stream(ctx, messages)
if err != nil {
    log.Fatal(err)
}
defer reader.Close()

for {
    chunk, err := reader.Recv()
    if err == io.EOF {
        break
    }
    fmt.Print(chunk.Content) // 逐 token 输出
}

type ToolInfo struct {
    Name        string          // 工具名称
    Description string          // 功能描述（模型据此判断何时调用）
    Parameters  *schema.Schema  // JSON Schema 格式的参数定义
}

// 定义搜索工具
searchTool := &schema.ToolInfo{
    Name:        "web_search",
    Description: "Search the web for current information about a topic",
    Parameters: &schema.Schema{
        Type: "object",
        Properties: map[string]*schema.Schema{
            "query": {
                Type:        "string",
                Description: "The search query",
            },
            "max_results": {
                Type:        "integer",
                Description: "Maximum number of results to return",
            },
        },
        Required: []string{"query"},
    },
}

// 注册到模型
err := model.BindTools([]*schema.ToolInfo{searchTool})

type Retriever interface {
    Retrieve(ctx context.Context, query string, opts ...Option) ([]*schema.Document, error)
}

retriever, _ := elasticsearch.NewRetriever(ctx, &elasticsearch.RetrieverConfig{
    Addresses: []string{"http://localhost:9200"},
    Index:     "knowledge_base",
    TopK:      5,
    // 支持混合检索：向量 + 关键词
    SearchMode: elasticsearch.HybridSearch,
})

docs, err := retriever.Retrieve(ctx, "Eino 框架的核心组件有哪些？")
for _, doc := range docs {
        fmt.Printf("Score: %.3f | Content: %s\n", doc.Score, doc.Content)
}

retriever, _ := vikingdb.NewRetriever(ctx, &vikingdb.RetrieverConfig{
    Collection: "my_knowledge_base",
    TopK:       5,
    Region:     "cn-beijing",
})

// 接口完全一致，上层代码无需修改
docs, err := retriever.Retrieve(ctx, "向量数据库的选型建议")

// 从 Web URL 加载
loader, _ := weburl.NewLoader(&weburl.Config{
    URL:     "https://example.com/docs",
    Timeout: 30 * time.Second,
})
docs, _ := loader.Load(ctx)

// 从本地文件加载
loader, _ := file.NewLoader(&file.Config{
    Path: "/data/knowledge/*.md",
})
docs, _ := loader.Load(ctx)

// HTML 分割器：按语义切片
splitter, _ := htmlsplitter.NewTransformer(&htmlsplitter.Config{
    ChunkSize:    512,
    ChunkOverlap: 64,
})
chunks, _ := splitter.Transform(ctx, docs)

// Score Reranker：按相关性重排
reranker, _ := scorereranker.NewTransformer(&scorereranker.Config{
    Model: "bge-reranker-v2",
    TopN:  3,
})
ranked, _ := reranker.Transform(ctx, chunks)

indexer, _ := elasticsearch.NewIndexer(ctx, &elasticsearch.IndexerConfig{
    Addresses: []string{"http://localhost:9200"},
    Index:     "knowledge_base",
})

// 批量索引文档
err := indexer.Store(ctx, chunks)

embedder, _ := openai.NewEmbedding(ctx, &openai.EmbeddingConfig{
    Model: "text-embedding-3-small",
})

vectors, err := embedder.EmbedStrings(ctx, []string{
    "Eino 是一个 Go 语言 AI 框架",
    "ChatModel 接口支持多种模型",
})
// 向量维度由所选模型决定，不应硬编码。

template := chattemplate.New(&chattemplate.Config{
    Templates: []*schema.Message{
        schema.SystemMessage("你是一个专业的技术助手。\n\n参考资料：\n{{.context}}"),
        schema.UserMessage("{{.question}}"),
    },
})

messages, _ := template.Format(ctx, map[string]interface{}{
    "context":  retrievedDocs,
    "question": "Eino 的组件设计原则是什么？",
})
// 输出标准 []*schema.Message，直接传给 ChatModel

// 数据格式化 Lambda
formatNode := lambda.New(func(ctx context.Context, docs []*schema.Document) (string, error) {
    var sb strings.Builder
    for i, doc := range docs {
        sb.WriteString(fmt.Sprintf("[%d] %s\n", i+1, doc.Content))
    }
    return sb.String(), nil
})

// 过滤 Lambda
filterNode := lambda.New(func(ctx context.Context, msg *schema.Message) (*schema.Message, error) {
    if len(msg.Content) > 10000 {
        msg.Content = msg.Content[:10000] + "...(truncated)"
    }
    return msg, nil
})

package main

import (
    "context"
    "fmt"
    "log"
    "os"

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

// 定义搜索工具的执行逻辑
func executeSearch(argumentsJSON string) (string, error) {
    // 解析并校验参数、执行授权，再调用真实搜索 API。
    // 模型生成的参数不能直接作为授权或 URL。
    return fmt.Sprintf("示意结果：%s", argumentsJSON), nil
}

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

    // 1. 初始化 ChatModel
    model, err := openai.NewChatModel(ctx, &openai.ChatModelConfig{
        Model:  "PROVIDER_MODEL@REVIEWED_REVISION",
        APIKey: os.Getenv("OPENAI_API_KEY"),
    })
    if err != nil {
        log.Fatal(err)
    }

    // 2. 定义并注册 Tool
    searchTool := &schema.ToolInfo{
        Name:        "web_search",
        Description: "Search the internet for current information",
        Parameters: &schema.Schema{
            Type: "object",
            Properties: map[string]*schema.Schema{
                "query": {
                    Type:        "string",
                    Description: "Search query keywords",
                },
            },
            Required: []string{"query"},
        },
    }

    if err := model.BindTools([]*schema.ToolInfo{searchTool}); err != nil {
        log.Fatal(err)
    }

    // 3. 第一轮对话：模型决定是否调用工具
    messages := []*schema.Message{
        schema.SystemMessage("你是一个有用的助手，可以通过搜索获取最新信息。"),
        schema.UserMessage("Eino 框架最新版本是什么？"),
    }

    response, err := model.Generate(ctx, messages)
    if err != nil {
        log.Fatal(err)
    }

    // 4. 检查模型是否请求调用工具
    if len(response.ToolCalls) > 0 {
        for _, call := range response.ToolCalls {
            fmt.Printf("模型请求调用工具: %s, 参数: %s\n", call.Function.Name, call.Function.Arguments)

            // 5. 执行工具
            if call.Function.Name != searchTool.Name {
                log.Printf("拒绝未允许的工具：%s", call.Function.Name)
                continue
            }
            result, err := executeSearch(call.Function.Arguments)
            if err != nil {
                log.Printf("搜索失败：%v", err)
                continue
            }

            // 6. 将工具结果回传
            messages = append(messages, response) // 助手消息（含 tool_call）
            messages = append(messages, schema.ToolMessage(result, call.ID))
        }

        // 7. 模型基于工具结果生成最终回答
        finalResponse, err := model.Generate(ctx, messages)
        if err != nil {
            log.Fatal(err)
        }
        fmt.Println("最终回答:", finalResponse.Content)
    } else {
        fmt.Println("直接回答:", response.Content)
    }
}

// 为 ChatModel 调用添加超时和重试
ctx, cancel := context.WithTimeout(ctx, 30*time.Second)
defer cancel()

var response *schema.Message
for retries := 0; retries < 3; retries++ {
    response, err = model.Generate(ctx, messages)
    if err == nil {
        break
    }
    time.Sleep(time.Duration(retries+1) * time.Second)
}

var currentModel ChatModel // 接口变量

func switchModel(provider string) {
    switch provider {
    case "openai":
        currentModel, _ = openai.NewChatModel(ctx, openaiConfig)
    case "ollama":
        currentModel, _ = ollama.NewChatModel(ctx, ollamaConfig)
    }
}

toolCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
defer cancel()

result, err := executeTool(toolCtx, toolCall)
if err != nil {
    result = "工具执行超时，请尝试其他方式回答"
}

mergeNode := lambda.New(func(ctx context.Context, results [][]*schema.Document) ([]*schema.Document, error) {
    seen := make(map[string]bool)
    var merged []*schema.Document
    for _, docs := range results {
        for _, doc := range docs {
            if !seen[doc.ID] {
                seen[doc.ID] = true
                merged = append(merged, doc)
            }
        }
    }
    return merged, nil
})