Go如何开发AI应用

llm, err := openai.New(
	openai.WithModel("deepseek-chat"),
	openai.WithBaseURL("https://api.deepseek.com"),
	openai.WithToken("xxxxxxxxxooooooooo"),
)

const (
	// ChatMessageTypeAI is a message sent by an AI.
	ChatMessageTypeAI ChatMessageType = "ai"
	// ChatMessageTypeHuman is a message sent by a human.
	ChatMessageTypeHuman ChatMessageType = "human"
	// ChatMessageTypeSystem is a message sent by the system.
	ChatMessageTypeSystem ChatMessageType = "system"
	// ChatMessageTypeGeneric is a message sent by a generic user.
	ChatMessageTypeGeneric ChatMessageType = "generic"
	// ChatMessageTypeFunction is a message sent by a function.
	ChatMessageTypeFunction ChatMessageType = "function"
	// ChatMessageTypeTool is a message sent by a tool.
	ChatMessageTypeTool ChatMessageType = "tool"
)

content := []llms.MessageContent{
	llms.TextParts(llms.ChatMessageTypeSystem,
		`你是一个资深的安全行业从业者，擅长编写基于nuclei的yaml规则。
			要求如下：
			1. 输入：python代码
			2. 输出：nuclei的yaml规则
			4. 只能使用request协议或network协议
			5. 不要做其他任何说明，请直接输出纯文本，不要包含任何格式标记
			6. 请进行自检查，确认多个matcher之间的条件关系或者matcher内多个匹配中间的条件关系是否正确，可以使用condition: and 或者 matchers-condition: and 进行修正
			7. 如果存在多个请求之间的逻辑关系，可以使用flow语法，但仅限于使用&&或者||等运算符，例如：flow: requests(1) && requests(2) && requests(3) || requests(4) && requests(5) && requests(6)
	`),
	llms.TextParts(llms.ChatMessageTypeHuman, pycode),
}

completion, err := llm.GenerateContent(
	ctx,
	content,
	llms.WithMaxTokens(2000),
	llms.WithTemperature(0.7),
	llms.WithStreamingReasoningFunc(func(ctx context.Context, reasoningChunk []byte, chunk []byte) error {
		file, err := os.OpenFile("test1.yaml", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
		if err != nil {
			return err
		}
		defer file.Close()

		writer := bufio.NewWriter(file)
		defer writer.Flush()
		if _, err := writer.Write(chunk); err != nil {
			return err
		}
		if writer.Buffered() > 4096 {
			return writer.Flush()
		}
		if len(chunk) > 0 {
			fmt.Printf("Streaming Content: %s\n", string(chunk))
		}
		return nil
	}),
)

ctx := context.Background()
userprompt := "你能帮我实现愿望吗？"
content := []llms.MessageContent{
	llms.TextParts(llms.ChatMessageTypeSystem,`你是一个小仙女，能帮别人实现所有愿望`),
	llms.TextParts(llms.ChatMessageTypeHuman,userprompt),
}
completion, err := llms.GenerateFromSinglePrompt(
	ctx,
	llm,
	content,
	llms.WithTemperature(0.8),
	llms.WithStreamingFunc(func(ctx context.Context, chunk []byte) error {
		fmt.Print(string(chunk))
		return nil
	}),
)

template := "请用{style}风格，为{topic}写一段简短的介绍（不超过50字）："
prompt := prompts.NewPromptTemplate(
	[]string{"style", "topic"}, // 输入变量
	template,                   // 模板字符串
)
llmChain := chains.NewLLMChain(llm, prompt)
input := map[string]any{
	"style": "幽默风趣",
	"topic": "程序员",
}

template2 := "请将下面的内容翻译成英文：\n{content}"
prompt2 := prompts.NewPromptTemplate(
	[]string{"content"},
	template2,
)
llmChain2 := chains.NewLLMChain(llm, prompt2)
sequentialChain := chains.NewSequentialChain(
	[]chains.Chain{llmChain, llmChain2},
	[]string{"style", "topic"},  // 输入变量
	[]string{"content"},         // 中间变量（第一个Chain的输出作为第二个Chain的输入）
)
seqResult, err := chains.Run(ctx, sequentialChain, input)
if err != nil {
	log.Fatalf("运行Sequential Chain失败: %v", err)
}
fmt.Println("翻译结果：")
fmt.Println(seqResult)

// init chat model
cfg := &openai.ChatModelConfig{
	APIKey:      "",
	BaseURL:     "",
	Model:       "",
	Temperature: 0.7,
	MaxTokens:   2048,
}
chatModel, err := openai.NewChatModel(ctx, cfg)
if err != nil {
	return nil, fmt.Errorf("failed to create chat model: %w", err)
}

type Handler interface {
    OnStart(ctx context.Context, info *RunInfo, input CallbackInput) context.Context
    OnEnd(ctx context.Context, info *RunInfo, output CallbackOutput) context.Context
    OnError(ctx context.Context, info *RunInfo, err error) context.Context
    OnStartWithStreamInput(ctx context.Context, info *RunInfo,
       input *schema.StreamReader[CallbackInput]) context.Context
    OnEndWithStreamOutput(ctx context.Context, info *RunInfo,
       output *schema.StreamReader[CallbackOutput]) context.Context
}

// init agent
agent, err := react.NewAgent(ctx, &react.AgentConfig{
	ToolsConfig:      compose.ToolsNodeConfig{Tools: tools},	// 可以提供mcp工具
	ToolCallingModel: chatModel,								// 之前创建的chatModel
	MaxStep:          20,
	MessageModifier: func(ctx context.Context, input []*schema.Message) []*schema.Message {			// 模型被调用前的回调
		return input
	},
})
if err != nil {
	return nil, fmt.Errorf("failed to create agent: %w", err)
}

// 非流式
response, err := agent.Generate(ctx, messages)
if err != nil {
	return nil, fmt.Errorf("failed to generate initial response: %w", err)
}

// 流式
response, err := s.agent.Stream(ctx, messages)
if err != nil {
	return fmt.Errorf("failed to generate initial response: %w", err)
}
for {
	defer response.Close()
	content, rerr := response.Recv()
	if rerr == io.EOF {
		break
	}
	if rerr != nil {
		return fmt.Errorf("failed to receive response: %w", rerr)
	}
	if len(content.Content) > 0 {
		fmt.print(content.Content)
	}
}

type InvokableRun func(ctx context.Context, arguments string, opts ...Option) (content string, err error)
type StreamableRun func(ctx context.Context, arguments string, opts ...Option) (content *schema.StreamReader[string], err error)

type BaseTool interface {
    Info() *schema.ToolInfo
}

// InvokableTool the tool for ChatModel intent recognition and ToolsNode execution.
type InvokableTool interface {
    BaseTool
    Run() InvokableRun
}

// StreamableTool the stream tool for ChatModel intent recognition and ToolsNode execution.
type StreamableTool interface {
    BaseTool
    Run() StreamableRun
}

// 初始化mcp Client连接到mcp server
mcpClient, err := client.NewStdioMCPClient(
	config.MCP.ServerPath,
	config.MCP.ServerArgs,
)
if err != nil {
	return nil, fmt.Errorf("failed to create MCP client: %w", err)
}

initRequest := mcp.InitializeRequest{}
initRequest.Params.ProtocolVersion = mcp.LATEST_PROTOCOL_VERSION
initRequest.Params.ClientInfo = mcp.Implementation{
	Name:    "demo-mcp-client",
	Version: "1.0.0",
}
_, err = mcpClient.Initialize(ctx, initRequest)
if err != nil {
	return nil, fmt.Errorf("failed to initialize MCP client: %w", err)
}

// 获取mcp server的tools返回符合eino框架的tools结构
tools, err := mcp.GetTools(ctx, &mcp.Config{Cli: mcpClient})
if err != nil {
	return nil, fmt.Errorf("failed to get tools: %w", err)
}

indexer     indexer.Indexer     // rag文本向量索引器
retriever   retriever.Retriever // rag文本向量检索器
embedder    embedding.Embedder  // rag文本向量嵌入器

client := redis.NewClient(&redis.Options{
	Addr:     redisAddr,
	Protocol: 2, // 强制使用Redis协议2
	Password: password,
})

// 测试Redis连接
if err := client.Ping(ctx).Err(); err != nil {
	return nil, fmt.Errorf("redis连接失败: %v", err.Error())
}

// 初始化Embedder组件, 这个是我自己实现的，只需要实现其接口即可，也可以使用模型厂商提供的服务
// type Embedder interface {
//	 EmbedStrings(ctx context.Context, texts []string, opts ...Option) ([][]float64, error) // invoke
// }
embedder := NewSimpleEmbedder(1536)

idx, err := rindexer.NewIndexer(ctx, &rindexer.IndexerConfig{
	Client:    client,
	KeyPrefix: prefix + ":messages",
	Embedding: embedder,
})
if err != nil {
	return nil, fmt.Errorf("初始化索引器失败: %w", err)
}
// 创建检索器
ret, err := redisret.NewRetriever(ctx, &redisret.RetrieverConfig{
	Client:       client,
	Index:        prefix + ":messages",
	VectorField:  "vector",
	TopK:         10,
	ReturnFields: []string{"content", "conversation_id", "role", "user_id", "timestamp"},
	Embedding:    embedder,
	DocumentConverter: func(ctx context.Context, doc redis.Document) (*schema.Document, error) {
		return &schema.Document{
			ID:      doc.ID,
			Content: doc.Fields["content"],
			MetaData: map[string]any{
				"conversation_id": doc.Fields["conversation_id"],
				"role":            string(doc.Fields["role"]),
				"user_id":         doc.Fields["user_id"],
				"timestamp":       doc.Fields["timestamp"],
			},
		}, nil
	},
})
if err != nil {
	return nil, fmt.Errorf("初始化检索器失败: %w", err)
}