字节跳动Golang大模型应用开发框架Eino AI Agent开发实例-Infortress自然语言搜索

type PageRequest struct {
	Size    int    `json:"size"`
	Index   int    `json:"index"`
	OrderBy string `json:"orderBy"`
	Sort    string `json:"sort"`
}

type SearchRequest struct {
	Pager                  PageRequest `json:"pager"`
	FileTypes              string      `json:"fileTypes"`
	FileExtensions         string      `json:"fileExtensions"`
	FileNameFuzzyMatch     string      `json:"fileNameFuzzyMatch"`
	ModifyTimeStart        int64       `json:"modifyTimeStart"` //millseconds since EPOCH
	ModifyTimeEnd          int64       `json:"modifyTimeEnd"`   //millseconds since EPOCH
	SizeLow                int64       `json:"sizeLow"`
	SizeHigh               int64       `json:"sizeHigh"`
	Deleted                int         `json:"deleted"`         //0: ignore, 1: true, -1: false
}

{
  "pager": {
    "size": 10,
    "index": 1,
    "orderBy": "size",
    "sort": "desc"
  },
  "fileTypes": "image",
  "fileExtensions": "",
  "fileNameFuzzyMatch": "",
  "modifyTimeStart": 1735660800000,
  "modifyTimeEnd": 1767196800000,
  "sizeLow": 0,
  "sizeHigh": 0,
  "deleted": -1
}

package aiAgents

import (
	"context"
	"encoding/json"
	"infortresserver/logger"
	"infortresserver/models"

	"github.com/cloudwego/eino-ext/components/model/ark"
	"github.com/cloudwego/eino/components/tool"
	"github.com/cloudwego/eino/components/tool/utils"
	"github.com/cloudwego/eino/compose"
	"github.com/cloudwego/eino/schema"
)

var (
	// 声明一个全局的Agent变量
	agent *compose.Runnable[[]*schema.Message, []*schema.Message] = nil
	// 大模型的配置，这个如果是提供互联网服务的话可以直接写死
	activeLLM models.LLMConfig
)

// 定义大模型输出的结构 description 字段是给大模型的提示prompt，告诉大模型该怎么生成对应的值
type FileSearchRequest struct {
	OrderBy            string `json:"orderBy" jsonschema:"description=排序方式，按文件名排序返回name，按文件类型或者扩展名排序返回extension，按时间排序返回modifyTime，按文件大小排序返回size，默认返回name"`
	Sort               string `json:"sort" jsonschema:"description=文件排序的顺序，返回asc或者desc，默认asc，"`
	FileNameFuzzyMatch string `json:"fileNameFuzzyMatch,omitempty" jsonschema:"description=文件名或者文件名的一部分"`
	FileTypes          string `json:"fileTypes" jsonschema:"description=文件类型，有image，video，audio，document，这几种，如果没找到则返回空字符串，如果包含多个类型则以|连接"`
	FileExtensions     string `json:"fileExtensions,omitempty" jsonschema:"description=文件扩展名，比如doc,pdf,xls,mp4,mp3等，如果没找到则返回空字符串，如果包含多个类型则以|连接"`
	ModifyTimeStart    int64  `json:"modifyTimeStart,omitempty" jsonschema:"description=时间范围的启始时间，为millisecond since epoc"`
	ModifyTimeEnd      int64  `json:"modifyTimeEnd,omitempty" jsonschema:"description=时间范围的结束时间，为millisecond since epoc"`
	// SizeLow            int64  `json:"sizeLow,omitempty" jsonschema:"description=文件需要大于这个值，单位为字节"`
	// SizeHigh           int64  `json:"sizeHigh,omitempty" jsonschema:"description=文件需要小于这个值，单位为字节"`
}

func BuildFileSearchRequest(_ context.Context, params *FileSearchRequest) (*FileSearchRequest, error) {
	//Eino 在大模型生成params后会执行这个函数
	//我们这里不做任何操作，直接返回params给程序去做进一步处理
	return params, nil
}

// 初始化Agent
func initAgent(llm models.LLMConfig) {

	ctx := context.Background()

	// 通过Eino的 工具类utils生成一个tool，Eino还提供了tool定义的其他方式，请参考Eino文档
	// 第一个参数是tool的名字，第二个参数是给大模型关于这个tool的角色设定
	// 第三个参数是一个函数，这个函数有2个意义，函数的参数是大模型要根据用户输入转换成的golang结构，tool在调用大模型生成golang结构后，会执行这个函数
	searchRequestBuilder, err := utils.InferTool("file_searcher_request_builder", "你的任务是根据用户的描述，提取搜索文件的过滤条件信息", BuildFileSearchRequest)
	if err != nil {
		logger.Log.Errorf("InferTool failed, err=%v", err)
		return
	}

	// 初始化tools，支持多个tool的，我们这里只用到了一个tool
	fileSearchTools := []tool.BaseTool{
		searchRequestBuilder,
	}

	activeLLM = llm
	agent = nil

	// 创建并配置 ChatModel 如果是提供互联网服务的话可以大模型参数可以直接写死
	chatModel, err := ark.NewChatModel(context.Background(), &ark.ChatModelConfig{
        // 这里必须选择支持function call的大模型，deepseek目前不支持
		// BaseURL: "https://ark.cn-beijing.volces.com/api/v3", // 服务地址
		// Region:  "cn-beijing",                               // 区域
		// Model:   "doubao-pro-32k-functioncall-240815",       // 模型端点 ID
		// APIKey:  "dddddd-hhh-gggg-ffff-eeeeeeee",
		BaseURL: llm.BaseURL, // 服务地址
		Region:  llm.Region,  // 区域
		Model:   llm.Model,   // 模型端点 ID
		APIKey:  llm.APIKey,
		// Temperature: gptr.Of(float32(0.7)),
	})
	if err != nil {
		logger.Log.Errorf("NewChatModel failed, err=%v", err)

		return
	}

	// 获取工具信息, 用于绑定到 ChatModel
	toolInfos := make([]*schema.ToolInfo, 0, len(fileSearchTools))
	var info *schema.ToolInfo
	for _, fileSearchTool := range fileSearchTools {
		info, err = fileSearchTool.Info(ctx)
		if err != nil {
			logger.Log.Infof("get ToolInfo failed, err=%v", err)
			return
		}
		toolInfos = append(toolInfos, info)
	}

	// 将 tools 绑定到 ChatModel
	err = chatModel.BindTools(toolInfos)
	if err != nil {
		logger.Log.Errorf("BindTools failed, err=%v", err)
		return
	}

	// 创建 tools 节点
	fileSearchToolsNode, err := compose.NewToolNode(context.Background(), &compose.ToolsNodeConfig{
		Tools: fileSearchTools,
	})
	if err != nil {
		logger.Log.Errorf("create fileSearchToolsNode failed, err=%v", err)
		return
	}

	// 构建完整的处理链
	chain := compose.NewChain[[]*schema.Message, []*schema.Message]()
	chain.
		AppendChatModel(chatModel, compose.WithNodeName("chat_model")).
		AppendToolsNode(fileSearchToolsNode, compose.WithNodeName("file_search_tools_node"))

	// 编译并运行 chain
	newAgent, err := chain.Compile(ctx)
	if err != nil {
		logger.Log.Errorf("chain.Compile failed, err=%v", err)
		return
	}

	agent = &newAgent

}

// 这个函数给外部程序调用，输入为用户的自然语言，输出为大模型转换后的golang struct搜索过滤条件
func BuildSearchRequestFromNatureLanguage(llm models.LLMConfig, input string) *FileSearchRequest {

	ctx := context.Background()

	//初始化agent
	if agent == nil || llm != activeLLM {
		initAgent(llm)
	}
	// 运行Agent
	resp, err := (*agent).Invoke(ctx, []*schema.Message{
		{
			Role:    schema.User,
			Content: input,
		},
	})
	if err != nil {
		logger.Log.Errorf("agent.Invoke failed, err=%v", err)
	}

	// // 输出结果
	for idx, msg := range resp {
		logger.Log.Infof("\n")
		logger.Log.Infof("message %d: %s: %s", idx, msg.Role, msg.Content)

		fileSearchRequest := FileSearchRequest{}
		//大语言的输出是Json格式的FileSearchRequest，我们这里序列化一下
		//不知道有没有办法直接返回golang struct，知道的同学指教一下
		json.Unmarshal([]byte(msg.Content), &fileSearchRequest)
		return &fileSearchRequest
	}

	return nil

}

type SearchResult struct {
	Request models.SearchRequest `json:"request"`
	Files   []db.FileEntry       `json:"files"`
}

func searchFilesV2(ctx iris.Context) {

	logger.Log.Debug("searchFiles reqeust got")

	var searchRequest models.SearchRequest

	if err := ctx.ReadJSON(&searchRequest); err != nil {
		logger.Log.Error(errors.Wrap(err, "decode search request failed."))
		ctx.StatusCode(iris.StatusBadRequest)
		return
	}


	applyFiltersGeneratedFromNatureLanguage(&searchRequest)

	lrs, err := db.SearchFiles(searchRequest)
	if err != nil {
		logger.Log.Error(errors.Wrap(err, "search files faied"))
	}

	result := SearchResult{}
	//返回SearchRequest方便客户端加载更多条目时直接使用
	result.Request = searchRequest
	result.Files = lrs

	ctx.JSON(result)

}



func applyFiltersGeneratedFromNatureLanguage(searchRequest *models.SearchRequest) *models.SearchRequest {

	//如果搜索请求不是自然语言，则直接使用客户端的搜索条件，走常规搜索方式
	if searchRequest.NaturalLanguageContent == "" {
		return searchRequest
	}
	
	//调用AiAgent 根据用户自然语言输入生成搜索条件
	searchFileFilter := aiAgents.BuildSearchRequestFromNatureLanguage(searchRequest.LLM, searchRequest.NaturalLanguageContent)
	if searchFileFilter == nil {
		return searchRequest
	}

	//将搜索条件附加到客户端传入的搜索条件
	if searchFileFilter.Sort != "" {
		searchRequest.Pager.Sort = searchFileFilter.Sort
	}

	if searchFileFilter.OrderBy != "" {
		searchRequest.Pager.OrderBy = searchFileFilter.OrderBy
	}

	if searchFileFilter.FileNameFuzzyMatch != "" {
		searchRequest.FileNameFuzzyMatch = searchFileFilter.FileNameFuzzyMatch
	}

	if searchFileFilter.FileNameFuzzyMatch != "" {
		searchRequest.FileNameFuzzyMatch = searchFileFilter.FileNameFuzzyMatch
	}

	if searchFileFilter.FileTypes != "" {
		searchRequest.FileTypes = searchFileFilter.FileTypes
	}

	if searchFileFilter.FileExtensions != "" {
		searchRequest.FileExtensions = searchFileFilter.FileExtensions
	}

	if searchFileFilter.ModifyTimeStart != 0 {
		searchRequest.ModifyTimeStart = searchFileFilter.ModifyTimeStart
	}

	if searchFileFilter.ModifyTimeEnd != 0 {
		searchRequest.ModifyTimeEnd = searchFileFilter.ModifyTimeEnd
	}
	// if searchFileFilter.SizeLow != 0 {
	// 	searchRequest.SizeLow = searchFileFilter.SizeLow
	// }

	// if searchFileFilter.SizeHigh != 0 {
	// 	searchRequest.SizeHigh = searchFileFilter.SizeHigh
	// }

	return searchRequest

}