在Go中构建自主AI代理：实战生产级指南

AI 软件开始看起来不再像聊天框，而更像是一个工作者。现代系统不再等待人类指导每一步，而是可以自主选择行动、使用工具并持续工作直到目标完成。这就是 AI 智能体的核心思想。

智能体不是一个简单的提示后接一个简单的响应。它以循环方式运作。

设定一个目标

决定下一步做什么

调用工具或收集更多信息

记录结果

重复直到任务完成或系统安全停止

对于产品团队来说，这一转变解锁了以前需要在流程中间进行手动操作的工作流程。示例包括：

跨多个来源收集和汇总信息的研究助手

监控链上活动并发出警报或采取行动的监控系统

将数据库、CRM 和内部 API 等传统系统与现代推理系统连接起来的运维工具

Python 仍然是实验的默认语言。然而，当目标是在生产环境中运行可靠的服务，并具有强大的并发性和可预测的性能时，Go 成为了一个引人注目的选择。

AI 智能体由什么组成

智能体可以理解为四个相互协作的部分。不同的框架使用不同的术语，但核心功能保持一致。

决策（大脑）

该组件通常由大型语言模型提供支持，尽管也可以使用其他推理系统。它的工作是评估任务的当前状态并确定下一步行动。

决策系统会考虑：

目标

约束条件

先前步骤的历史记录

典型的决策包括：

因为已收集到足够的信息而生成最终结果

通过工具请求新信息

在继续之前验证先前的输出

工具（双手）

工具允许智能体与外部世界互动。在实际系统中，大多数有用的工作都发生在工具层面。

示例包括：

搜索 API 或内部知识库

区块链索引器和 RPC 查询

数据库读取和经过严格控制的写入

沙箱内的代码执行

电子邮件、工单或 Slack 集成

记忆（上下文）

智能体需要记录其行动和观察结果。

工作记忆存储当前执行的短期历史。这可以包括最近的步骤、中间结果和部分草稿。

长期记忆存储跨会话的知识。这通常通过嵌入（embeddings）结合向量数据库来实现。

目标不是每次都将所有内容发送给模型。相反，系统只检索与当前步骤最相关的信息。

编排（引擎）

编排是负责协调整个过程的控制循环。

该组件：

构建下一个提示或系统状态

调用推理模型

解析模型返回的决策

执行请求的工具

存储结果以供后续步骤使用

强制执行步骤计数、运行时长和成本等限制

在生产系统中，编排与模型本身同样重要。

为什么 Go 非常适合智能体

智能体系统通常同时执行许多小型操作。这可能包括 API 调用、事件监听器、数据处理作业、重试和工具执行。

Go 的优势天然契合这些需求。

通过 goroutines 和 channels 实现并发，允许多个工具调用并行运行。

类型安全确保工具的输入和输出通过严格的结构定义，而不是松散格式的字符串。

部署简单直接。Go 生成一个独立的二进制文件，可以轻松容器化和部署。

即使对于处理大量 I/O 操作的长时间运行服务，性能也保持稳定。

一个实用的 Go 骨架（极简但真实）

以下是一个简化结构，类似于真实的生产代码。它展示了清晰的接口、明确的工具契约以及带有停止条件的安全执行循环。

package main

import (
    "context"
    "fmt"
    "strings"
    "time"
)

type Agent struct {
    Goal     string
    Memory   []string
    MaxSteps int
}

type Tool interface {
    Name() string
    Run(ctx context.Context, input string) (string, error)
}

func decideNextStep(goal string, history []string) string {
    // This is a placeholder for an LLM call or other decision logic.
    // For demonstration, we'll hardcode a tool call.
    return "TOOL:SearchWeb:latest-defi-rates"
}

func (a *Agent) Run(ctx context.Context, tools map[string]Tool) (string, error) {
    if a.MaxSteps <= 0 {
        a.MaxSteps = 5
    }

    for step := 1; step <= a.MaxSteps; step++ {
        // Prepare state for the decision-making component (e.g., an LLM prompt)
        state := fmt.Sprintf("Goal: %s\nHistory: %s\n", a.Goal, strings.Join(a.Memory, " | "))
        _ = state // Suppress unused variable warning for this simplified example

        // Get the decision for the next step
        decision := decideNextStep(a.Goal, a.Memory)

        // Check if the agent has decided to output a final result
        if strings.HasPrefix(decision, "FINAL:") {
            return strings.TrimPrefix(decision, "FINAL:"), nil
        }

        // Check if the agent has decided to use a tool
        if strings.HasPrefix(decision, "TOOL:") {
            parts := strings.SplitN(decision, ":", 3)
            if len(parts) < 3 {
                a.Memory = append(a.Memory, "Planner produced malformed tool call.")
                continue
            }
            toolName := parts[1]
            input := parts[2]

            tool, ok := tools[toolName]
            if !ok {
                a.Memory = append(a.Memory, fmt.Sprintf("Unknown tool requested: %s", toolName))
                continue
            }

            // Execute the tool with a timeout
            toolCtx, cancel := context.WithTimeout(ctx, 10*time.Second)
            result, err := tool.Run(toolCtx, input)
            cancel() // Ensure context is cancelled to release resources

            if err != nil {
                a.Memory = append(a.Memory, fmt.Sprintf("Tool %s error: %v", toolName, err))
                continue
            }
            a.Memory = append(a.Memory, fmt.Sprintf("Tool %s(%q) -> %s", toolName, input, result))
            continue
        }

        // If the decision format is unrecognized
        a.Memory = append(a.Memory, "Planner produced unrecognized decision format.")
    }

    // If MaxSteps is reached without a final answer
    return "", fmt.Errorf("stopped after %d steps without reaching a final answer", a.MaxSteps)
}

这种设计使职责清晰分离。

智能体控制执行循环。

工具是可插拔且强类型的。

决策可以安全解析并在超时和步骤限制等严格约束下执行。

从原型到生产

创建一个演示智能体相对简单。构建一个能在生产中可靠运行的智能体需要精心设计。

使用检索的持久内存

随着工具结果和对话历史的增长，每次都将整个上下文发送回模型会变得低效。

记住我以更快登录

更好的模式是存储笔记、工具输出和决策等工件，然后为每个步骤只检索最相关的项目。

典型的实现包括：

存储摘要和嵌入

为每个步骤检索最相关的项目

在模型提示中只包含这些项目

敏感操作的受控工作流

如果智能体可以修改生产数据或转移金融资产，不受限制的自主性会变得危险。

更安全的方法是引入工作流层或策略引擎。

明确定义允许的操作。

验证操作之间的转换。

某些步骤需要人工批准。

这在不完全移除自动化的前提下，创建了防护措施。

用于扩展的队列和 Worker 系统

大多数智能体工作负载是 I/O 密集型的，因为它们依赖于模型调用和外部 API。

在 Redis、RabbitMQ 或 Amazon SQS 等作业队列后面运行系统具有以下优势。

流量高峰不会使主应用程序过载。

重试变得一致且可追踪。

Worker 可以水平扩展以应对增长的需求。

安全考虑

授予软件自主行动的能力会改变系统安全模型。一些防护措施至关重要。

工具沙箱和最小权限

工具必须严格授权。智能体不应不受限制地访问：

生产数据库

私钥

关键服务器上的 Shell 访问

如果需要执行代码，它应该在具有严格网络控制的隔离沙箱中运行。

提示注入风险

智能体通常会读取外部来源，例如网页、工单和文档。这些来源中的任何一个都可能包含恶意指令。

智能体必须将检索到的文本视为数据而非指令。

有效的防护措施包括：

使用 JSON 或 schema 的结构化决策输出

阻止受限操作的策略过滤器

所有工具执行的日志记录和审计

敏感操作的人工批准要求

成本和安全的断路器

自主系统可能会陷入循环或反复调用工具。

生产系统应强制执行以下严格限制：

最大步骤数

最大运行时长

最大成本

最大工具调用次数

当达到限制时，系统应停止并返回其可用的最佳结果以及解释。

总结

AI 的真正转型不仅在于更好的模型。它在于构建能够从头到尾完成工作流的系统能力。

成功的团队将不仅仅是集成一个语言模型。他们将设计可靠的编排层、安全的工具集成和可观察的基础设施。

Go 非常适合这一层。它提供快速的并发性、可预测的部署和强大的类型保证，以构建稳定的服务。

Ancilar 如何帮助团队安全地交付智能体系统

Ancilar 与创始人及工程团队合作，将智能体原型转化为可靠的生产系统。

这通常涉及构建支持长期稳定性的基础设施，而不仅仅关注模型本身。

常见的合作包括：

用于智能体编排和多智能体工作流的 Go 后端

具有受控权限和完整审计跟踪的安全链上集成

侧重于工具访问和提示注入风险的安全审查

包括队列、Worker 系统、向量检索和监控在内的扩展架构

对于从实验原型转向生产级系统的团队来说，这些工程层往往是演示与可靠产品之间的区别。

• 原文链接： medium.com/@ancilartech/...
• 登链社区 AI 助手，为大家转译优秀英文文章，如有翻译不通的地方，还请包涵～