ai软件实例 使用 Telegram 和 Cohere 在 Go 中构建 AI 文本生成机器人

本文将探讨如何使用构建聊天机器人，并将其与 API集成以进行自然语言生成。

获取 API密钥

设置你的机器人

一旦你的机器人被创建，将为你提供一个机器人令牌。我们将保留这一点，以便以后使用。

在我们开始之前，请确保你的机器上已经安装了Go。你可以从Go的官方网站（）下载并安装它。

或者你可以像我一样使用 。

设置你的项目 让我们看看代码

导入依赖项:

 package main
 
 import (
     _ "embed"
     "log"
     "strings"
     "time"
 
     "github.com/NicoNex/echotron/v3"
     "github.com/cohere-ai/cohere-go"
 )

类型定义：

 type stateFn func(*echotron.Update) stateFn

在这里，我们定义了一个自定义类型 ，它表示一个以 .为参数并返回另一个 函数的函数。

Bot 结构体:

 type bot struct {
 chatID int64
 echotron.API
 cohereClient *cohere.Client
 state        stateFn

我们定义一个bot结构体，封装了我们的聊天机器人所需的必要字段，例如：

API密钥和命令：

 var (
     token         string
     cohereAPIKey  string
     commands      = []echotron.BotCommand{
         {Command: "/start", Description: "Activate the bot."},
         {Command: "/generate", Description: "Generate an answer."},
     }
 )

这里，我们声明了用于 Bot API的API密钥（token）和用于 API的API密钥（）的变量。

此外，我们定义了一个包含.结构体的数组，以表示机器人命令及其描述。

 func newBot(chatID int64) echotron.Bot {
     cohereClient, err := cohere.CreateClient(cohereAPIKey)
     if err != nil {
         log.Fatalln(err)
     }
 
     b := &bot{
         chatID:       chatID,
         API:          echotron.NewAPI(token),
         cohereClient: cohereClient,
     }
     b.state = b.handleMessage
     return b
 }

这个函数由调度程序调用，为每个与其交互的聊天创建一个新的机器人实例。

它初始化一个新的客户端，使用提供的创建一个机器人实例，设置 API与 Bot API token，并将初始状态设置为。

处理提示：

 func (b *bot) handlePrompt(update *echotron.Update) stateFn {
     b.SendChatAction(echotron.Typing, b.chatID, nil)
     response, err := b.generateText(message(update))
     if err != nil {
         log.Println("handlePrompt", err)
         b.SendMessage("An error occurred!", b.chatID, nil)
         return b.handleMessage
     }
     b.SendMessage(response, b.chatID, nil)
     return b.handleMessage
 }

这个方法处理用户提示并使用 API生成响应。

它发送一个“”聊天动作来指示机器人正在处理请求，根据用户提示使用方法生成响应，并将响应发送回聊天。

如果在文本生成过程中发生错误，它会记录错误，发送错误消息，并转换回状态。

处理消息：

 func (b *bot) handleMessage(update *echotron.Update) stateFn {
     switch m := message(update); {
     case strings.HasPrefix(m, "/start"):
         b.SendMessage("Hello world", b.chatID, nil)
     case strings.HasPrefix(m, "/generate"):
         b.SendMessage("Please enter a prompt:", b.chatID, nil)
         return b.handlePrompt
     }
     return b.handleMessage
 }

这个方法处理机器人接收到的不同消息命令。

更新机器人状态：

 func (b *bot) Update(update *echotron.Update) {
     b.state = b.state(update)
 }

这种方法需要实现.Bot接口。它会根据接收到的更新更新机器人的当前状态。

使用 API生成文本：

 func (b *bot) generateText(prompt string) (string, error) {
     options := cohere.GenerateOptions{
         Model:             "command",
         Prompt:            prompt,
         MaxTokens:         300,
         Temperature:       0.9,
         K:                 0,
         StopSequences:     []string{},
         ReturnLikelihoods: "NONE",
     }
 
     response, err := b.cohereClient.Generate(options)
     if err != nil {
         return "", err
     }
 
     return response.Generations[0].Text, nil
 }

这个方法使用 的 API 生成文本。

提取消息：

 func message(u *echotron.Update) string {
     if u.Message != nil {
         return u.Message.Text
     } else if u.EditedMessage != nil {
         return u.EditedMessage.Text
     } else if u.CallbackQuery != nil {
         return u.CallbackQuery.Data
     }
     return ""
 }

此函数从给定的更新中提取消息。

主要函数：

 func main() {
     echotron.NewAPI(token).SetMyCommands(nil, commands...)
 
     dsp := echotron.NewDispatcher(token, newBot)
     for {
         err := dsp.Poll()
         if err != nil {
             log.Println("Error polling updates:", err)
         }
 
         time.Sleep(5 * time.Second)
     }
 }

main 函数作为我们聊天机器人的入口点。

使用.保护API密钥：

为了保护您的API密钥并防止它们被提交和推送到远程存储库，您可以使用.文件。下面是您可以执行的步骤：

通过将和添加到.文件中，Git将忽略这些文件并不会包含在您的代码库中。

请确保将您的API密钥存储在单独的文件中（例如和），并将它们添加到.文件中以保持私密。

运行您的代码：

 go run main.go

我觉得我在这里漏掉了什么，但是 go run main.go 运行正常，所以……

测试您的机器人：

以下是 main.go 的代码：

 package main
 
 import (
     _ "embed"
     "log"
     "strings"
     "time"
 
     "github.com/NicoNex/echotron/v3"
     "github.com/cohere-ai/cohere-go"
 )
 
 
 type stateFn func(*echotron.Update) stateFn
 
 
 type bot struct {
     chatID int64
     echotron.API
     cohereClient *cohere.Client
     state        stateFn
 }
 
 var (
     //go:embed tgtoken
     token string
     //go:embed chtoken
     cohereAPIKey string
 
     commands = []echotron.BotCommand{
         {Command: "/start", Description: "Activate the bot."},
         {Command: "/generate", Description: "Generate an answer."},
     }
 )
 
 func newBot(chatID int64) echotron.Bot {
     cohereClient, err := cohere.CreateClient(cohereAPIKey)
     if err != nil {
         log.Fatalln(err)
     }
 
     b := &bot{
         chatID:       chatID,
         API:          echotron.NewAPI(token),
         cohereClient: cohereClient,
     }
     b.state = b.handleMessage
     return b
 }
 
 func (b *bot) handlePrompt(update *echotron.Update) stateFn {
     b.SendChatAction(echotron.Typing, b.chatID, nil)
     response, err := b.generateText(message(update))
     if err != nil {
         log.Println("handlePrompt", err)
         b.SendMessage("An error occurred!", b.chatID, nil)
         return b.handleMessage
     }
     b.SendMessage(response, b.chatID, nil)
     return b.handleMessage
 }
 
 func (b *bot) handleMessage(update *echotron.Update) stateFn {
     switch m := message(update); {
 
     case strings.HasPrefix(m, "/start"):
         b.SendMessage("Hello world", b.chatID, nil)
 
     case strings.HasPrefix(m, "/generate"):
         b.SendMessage("Please enter a prompt:", b.chatID, nil)
         return b.handlePrompt
     }
     return b.handleMessage
 }
 
 // This method is needed to implement the echotron.Bot interface.
 func (b *bot) Update(update *echotron.Update) {
     b.state = b.state(update)
 }
 
 // Generate text using the Cohere API
 func (b *bot) generateText(prompt string) (string, error) {
     options := cohere.GenerateOptions{
         Model:             "command",
         Prompt:            prompt,
         MaxTokens:         300,
         Temperature:       0.9,
         K:                 0,
         StopSequences:     []string{},
         ReturnLikelihoods: "NONE",
     }
 
     response, err := b.cohereClient.Generate(options)
     if err != nil {
         return "", err
     }
 
     return response.Generations[0].Text, nil
 }
 
 // Returns the message from the given update.
 func message(u *echotron.Update) string {
     if u.Message != nil {
         return u.Message.Text
     } else if u.EditedMessage != nil {
         return u.EditedMessage.Text
     } else if u.CallbackQuery != nil {
         return u.CallbackQuery.Data
     }
     return ""
 }
 
 func main() {
     echotron.NewAPI(token).SetMyCommands(nil, commands...)
 
     // This is the entry point of echotron library.
     dsp := echotron.NewDispatcher(token, newBot)
     for {
         err := dsp.Poll()
         if err != nil {
             log.Println("Error polling updates:", err)
         }
 
         // In case of connection issues, wait 5 seconds before trying to reconnect.
         time.Sleep(5 * time.Second)
     }
 }

结论

太棒了！我们使用的API创建了一个文本生成机器人，并在上部署了它。

你现在可以拿着这个并扩展你的聊天机器人的功能。

你可以在这里了解更多关于的内容。（非常感谢库背后的开发者，他查看了代码，帮助我改进了它并向我展示了一些很酷的东西！）