复杂业务逻辑的利器-编排

// 1. 使用检索器查找相关文档
docs, err := retriever.Retrieve(ctx, userQuery)

// 2. 处理检索结果，整理成字符串
var docsContext string
for _, doc := range docs {
    docsContext += doc.Content + "\n"
}

// 3. 使用模板生成 prompt
messages, err := template.Format(ctx, map[string]interface{}{
    "docsContext": docsContext,
    "question":    userQuery,
})

// 4. 使用 ChatModel 生成回答
resp, err := chatModel.Generate(ctx, messages)

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/cloudwego/eino-ext/components/model/openai"
    "github.com/cloudwego/eino-ext/components/retriever/fornaxknowledge"
    "github.com/cloudwego/eino/components/prompt"
    "github.com/cloudwego/eino/compose"
    "github.com/cloudwego/eino/schema"
)

const (
    DefaultSystemPrompt = `你是一个法律助手，请基于以下内容回答用户的问题：

=====参考内容=====
{context}
====FINISH====
`
    DefaultUserPrompt = `问题：{query}`
)

func main() {
    ctx := context.Background()
    // 1. 创建 retriever
    retriever, err := fornaxknowledge.NewKnowledgeRetriever(ctx, &fornaxknowledge.Config{
        AK:            os.Getenv("FORNAX_AK"),
        SK:            os.Getenv("FORNAX_SK"),
        KnowledgeKeys: []string{os.Getenv("FORNAX_KNOWLEDGE_KEY")},
    })
    if err != nil {
        panic(err)
    }

    // 2. 创建 ChatModel
    temp := float32(0.7)
    chatModel, err := openai.NewChatModel(ctx, &openai.ChatModelConfig{
        Model:       "gpt-4",
        APIKey:      os.Getenv("OPENAI_API_KEY"),
        Temperature: &temp,
    })
    if err != nil {
        panic(err)
    }

    // 3. 创建一个 Chain，用于处理知识库检索和问答
    chain := compose.NewChain[string, *schema.Message]()
    chain.
        // 并行节点，用于同时准备多个参数
        AppendParallel(compose.NewParallel().
            // 透传 query 参数
            AddLambda("query", compose.InvokableLambda(func(ctx context.Context, input string) (string, error) {
                return input, nil
            }), compose.WithNodeName("PassthroughQuery")).
            // 处理上下文信息
            AddGraph("context",
                // 创建一个子 Chain 用于获取上下文
                compose.NewChain[string, string]().
                    // 使用检索器获取相关文档
                    AppendRetriever(retriever, compose.WithNodeName("KnowledgeRetriever")).
                    // 将文档转换为字符串
                    AppendLambda(compose.InvokableLambda(func(ctx context.Context, docs []*schema.Document) (string, error) {
                        var context string
                        for _, doc := range docs {
                            context += doc.Content + "\n"
                        }
                        return context, nil
                    }), compose.WithNodeName("DocumentConverter")),
                compose.WithNodeName("ContextPreparer"),
            ),
        ).
        // 此处的 input 为 {"query": "什么是合同？", "context": "xxx"}
        // 使用模板生成 prompt
        AppendChatTemplate(
            prompt.FromMessages(
                schema.FString,
                schema.SystemMessage(DefaultSystemPrompt),
                schema.UserMessage(DefaultUserPrompt),
            ),
            compose.WithNodeName("QAPromptTemplate"),
        ).
        // 此处的 input 为两条消息的 []*schema.Message, 第一条为系统消息，第二条为用户消息。
        // 使用 ChatModel 生成回答
        AppendChatModel(chatModel, compose.WithNodeName("QAChatModel"))

    // 3. 编译
    r, err := chain.Compile(ctx, compose.WithGraphName("RAGChain"))
    if err != nil {
        panic(err)
    }

    // 4. 调用 chain
    resp, err := r.Invoke(ctx, "什么是合同？")
    if err != nil {
        panic(err)
    }

    fmt.Println(resp.Content)
}