Golang 编写简单的 AI Agent Demo

创建 Go 项目

mkdir example-agent
cd example-agent
go mod init example-agent
touch main.go

循环输入输出

// main.go
package main

import (
	"bufio"
	"fmt"
	"os"
	"strings"
)

func main() {
	// 创建一个读取器，用来读取用户的输入
	reader := bufio.NewReader(os.Stdin)

	for {
		fmt.Print("You: ")

		// 读取用户输入，直到遇到换行符
		input, _ := reader.ReadString('\n')

		// 如果用户输入 "exit" 或 "quit"，就退出循环
		if strings.TrimSpace(input) == "exit" || strings.TrimSpace(input) == "quit" {
			fmt.Println("再见！")
			break
		}

		fmt.Println("Agent: 你说的是：", input)
	}
}

连接 AI (LLM)

# 这个 star 多，就不用 OpenAI 官方 SDK 了
go get github.com/sashabaranov/go-openai

// main.go
package main

import (
	"bufio"
	"context"
	"fmt"
	"log"
	"os"
	"strings"

	"github.com/sashabaranov/go-openai"
)

func main() {
	// --- 初始化 AI 客户端 ---
	// 实际使用时，请务必使用安全的方式管理你的 API Key
	config := openai.DefaultConfig(os.Getenv("API_KEY"))
	// 使用第三方 API 代理，需设置 BaseURL
	config.BaseURL = "http://localhost:8080/v1"
	client := openai.NewClientWithConfig(config)

	// 创建一个列表来存储整个对话的上下文（历史消息）
	messages := []openai.ChatCompletionMessage{}

	reader := bufio.NewReader(os.Stdin)

	for {
		fmt.Print("You: ")
		input, _ := reader.ReadString('\n')
		if strings.TrimSpace(input) == "exit" || strings.TrimSpace(input) == "quit" {
			fmt.Println("再见！")
			break
		}

		// 将用户的消息添加到对话历史中
		messages = append(messages, openai.ChatCompletionMessage{
			Role:    openai.ChatMessageRoleUser,
			Content: input,
		})

		// --- 调用 LLM API ---
		resp, err := client.CreateChatCompletion(
			context.Background(),
			openai.ChatCompletionRequest{
				Model:    openai.GPT4Turbo,
				Messages: messages,
			},
		)

		if err != nil {
			log.Printf("ChatCompletion error: %v\n", err)
			continue
		}

		aiResponse := resp.Choices[0].Message

		// 将 AI 的回复也添加到对话历史中
		messages = append(messages, aiResponse)
	}
}

Agent 工具（Tools）

// ... 其他代码 ...

/*
readFile 读取指定文件的内容
*/
func readFile(filename string) (string, error) {
	data, err := os.ReadFile(filename)
	if err != nil {
		return "", err
	}
	return string(data), nil
}

/*
listFiles 列出指定目录中的所有文件和子目录
*/
func listFiles(path string) (string, error) {
	files, err := os.ReadDir(path)
	if err != nil {
		return "", err
	}

	var fileNames []string
	for _, file := range files {
		fileNames = append(fileNames, file.Name())
	}

	return fmt.Sprintf("%v", fileNames), nil
}

/*
editFile 编辑文件内容，通过字符串替换的方式
*/
func editFile(filename, old, new string) error {
	data, err := os.ReadFile(filename)
	if err != nil {
		return err
	}

	newData := strings.Replace(string(data), old, new, -1)

	return os.WriteFile(filename, []byte(newData), 0644)
}

// ... main 函数 ...

整合调用

// 在 for 循环中
resp, err := client.CreateChatCompletion(
	context.Background(),
	openai.ChatCompletionRequest{
		Model:    openai.GPT4Turbo,
		Messages: messages,

		// 定义可用工具（Function Calling）告诉 AI 它可以调用哪些函数
		Tools: []openai.Tool{
			{
				Type: openai.ToolTypeFunction,
				Function: &openai.FunctionDefinition{
					Name:        "read_file",
					Description: "Reads the content of a file.",
					// JSON Schema 定义参数格式
					Parameters: json.RawMessage(`{
						"type": "object",
						"properties": {
							"filename": {
								"type": "string",
								"description": "The path to the file to read"
							}
						},
						"required": ["filename"]
					}`),
				},
			},
			{
				Type: openai.ToolTypeFunction,
				Function: &openai.FunctionDefinition{
					Name:        "list_files",
					Description: "Lists files in a directory.",
					Parameters: json.RawMessage(`{
						"type": "object",
						"properties": {
							"path": {
								"type": "string",
								"description": "The directory path to list files from"
							}
						},
						"required": ["path"]
					}`),
				},
			},
			{
				Type: openai.ToolTypeFunction,
				Function: &openai.FunctionDefinition{
					Name:        "edit_file",
					Description: "Edits a file by replacing a string.",
					Parameters: json.RawMessage(`{
						"type": "object",
						"properties": {
							"filename": {
								"type": "string",
								"description": "The path to the file to edit"
							},
							"old": {
								"type": "string",
								"description": "The string to be replaced"
							},
							"new": {
								"type": "string",
								"description": "The new string to replace with"
							}
						},
						"required": ["filename", "old", "new"]
					}`),
				},
			},
		},
	},
)

// ... 其他代码 ...

func main() {
  // ...

  for {
      // ...

    messages = append(messages, openai.ChatCompletionMessage{
        Role:    openai.ChatMessageRoleUser,
        Content: input,
    })

    resp, err := client.CreateChatCompletion(
        // ... (请求信息，包含 list_files 等工具) ...
    )

    // ... (错误处理) ...

    message := resp.Choices[0].Message
    messages = append(messages, message)

    // --- 检查 AI 是否要调用工具 ---
    if message.ToolCalls != nil {
      fmt.Println("Agent: 正在调用工具...")
      for _, toolCall := range message.ToolCalls {
        var result string // 存储工具执行结果
        var err error

        // 根据工具名称执行相应的函数
        switch toolCall.Function.Name {
          case "read_file":
            var args struct {
              Filename string `json:"filename"`
            }
            json.Unmarshal([]byte(toolCall.Function.Arguments), &args)

            result, err = readFile(args.Filename)

          case "list_files":
            var args struct {
              Path string `json:"path"`
            }
            json.Unmarshal([]byte(toolCall.Function.Arguments), &args)

            result, err = listFiles(args.Path)

          case "edit_file":
            var args struct {
              Filename string `json:"filename"`
              Old      string `json:"old"`
              New      string `json:"new"`
            }
            json.Unmarshal([]byte(toolCall.Function.Arguments), &args)

            err = editFile(args.Filename, args.Old, args.New)
            if err == nil {
              result = "File edited successfully."
            }
        }

        if err != nil {
          result = err.Error()
        }

        // 将工具执行结果添加到历史消息
        messages = append(messages, openai.ChatCompletionMessage{
          Role:       openai.ChatMessageRoleTool,
          Content:    result,                     
          Name:       toolCall.Function.Name,     
          ToolCallID: toolCall.ID,               
        })
      }
      // 发送给 AI ，根据工具执行结果生成最终回复
      resp, err = client.CreateChatCompletion(
        context.Background(),
        openai.ChatCompletionRequest{
          Model:    openai.GPT4Turbo,
          Messages: messages, 
        },
      )

      if err != nil {
        log.Printf("Tool Result ChatCompletion error: %v\n", err)
        continue
      }

      // 显示 AI 的最终回复
      fmt.Println("Agent:", resp.Choices[0].Message.Content)

      // 将最终回复也添加到历史消息
      messages = append(messages, resp.Choices[0].Message)

    } else {
      // 如果 AI 没有调用工具，直接显示回复 
      fmt.Println("Agent:", message.Content)
    }
  }
}