用 Go 构建生产级 AI Agent：Agent SDK Go 的多模型、记忆与 MCP 集成

项目地址：

• GitHub：Ingenimax/agent-sdk-go
• MCP 协议：modelcontextprotocol.io

Agent SDK Go 是一个 Go 语言的 AI Agent 框架，覆盖多模型接入、记忆管理、模块化工具、MCP 集成、Token 追踪，并内置安全护栏与可观测性。

Go AI Agent 开发的痛点

在实际项目里，常见的几类问题：

场景一：想在 Go 里做一个 AI Agent，自动完成复杂任务。自己实现很复杂——状态管理、记忆、工具调用、错误处理，一大堆事情。

场景二：Agent 需要记住之前的对话，但自己实现记忆管理很麻烦。用 Buffer 还是向量检索？怎么持久化？

场景三：想让 Agent 调用外部工具（Web 搜索、数据库、API），但集成很困难。每个工具都要自己写适配器。

场景四：要把 Agent 部署到生产环境，但缺乏安全护栏、可观测性、多租户支持。

这些问题的共同点是：Go 的 AI Agent 框架缺乏生产级特性。

Agent SDK Go 是什么

Agent SDK Go 不是一个模型，而是一个框架，提供：

• 多模型智能：OpenAI、Anthropic、Google Vertex AI、DeepSeek、Ollama、vLLM
• 模块化工具：Web 搜索、数据检索、MCP 集成
• 高级记忆：Buffer 记忆、向量检索、持久化
• MCP 集成：Model Context Protocol 支持
• Token 追踪：内置 Token 计数和成本监控
• 企业特性：安全护栏、可观测性、多租户

技术栈上，Agent SDK Go 需要 Go 1.23+，可选 Redis 用于分布式记忆。

核心架构

Agent SDK Go 的架构分七个核心组件。

1. Agent（Agent 协调器）

协调 LLM、记忆、工具的中央控制器：

agent := agentsdk.NewAgent(agentsdk.Config{
    LLM:    llm,
    Memory: memory,
    Tools:  tools,
})

2. LLM（语言模型接口）

统一的模型访问接口：

llm := openai.NewLLM(openai.Config{
    APIKey: os.Getenv("OPENAI_API_KEY"),
    Model:  "gpt-4",
})

3. Memory（记忆存储）

持久化记忆管理：

// Buffer 记忆
memory := agentsdk.NewBufferMemory(100)

// 向量记忆
memory := agentsdk.NewVectorMemory(vectorStore)

4. Tools（工具）

模块化工具生态：

tools := []agentsdk.Tool{
    websearch.NewTool(),
    database.NewTool(),
}

5. Vector Store（向量存储）

向量检索支持：

vectorStore := chroma.NewStore(chroma.Config{
    Endpoint: "http://localhost:8000",
})

6. Guardrails（安全护栏）

安全检查机制：

guardrails := agentsdk.NewGuardrails(agentsdk.GuardrailsConfig{
    MaxTokens:     4000,
    AllowedTools:  []string{"web_search", "database_query"},
    BlockedTopics: []string{"politics", "religion"},
})

7. Execution Plan（执行计划）

结构化任务框架：

plan := agentsdk.NewPlan(agentsdk.PlanConfig{
    MaxIterations:   10,
    RequireApproval: true,
})

支持的 LLM 提供商

Agent SDK Go 支持多个 AI 模型提供商：

统一 API，切换模型只需改配置。

核心功能

基本 Agent

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/Ingenimax/agent-sdk-go/agentsdk"
    "github.com/Ingenimax/agent-sdk-go/llm/openai"
    "github.com/Ingenimax/agent-sdk-go/memory"
    "github.com/Ingenimax/agent-sdk-go/tools/websearch"
)

func main() {
    ctx := context.Background()

    // 创建 LLM
    llm := openai.NewLLM(openai.Config{
        APIKey: os.Getenv("OPENAI_API_KEY"),
        Model:  "gpt-4",
    })

    // 创建记忆
    mem := memory.NewBufferMemory(100)

    // 创建工具
    tools := []agentsdk.Tool{
        websearch.NewTool(),
    }

    // 创建 Agent
    agent := agentsdk.NewAgent(agentsdk.Config{
        LLM:    llm,
        Memory: mem,
        Tools:  tools,
    })

    // 运行 Agent
    response, err := agent.Run(ctx, "搜索 Go 语言的最新版本")
    if err != nil {
        panic(err)
    }

    fmt.Println(response)
}

Token 追踪

// 详细生成（包含 Token 统计）
response, err := agent.GenerateDetailed(ctx, "你好")
if err != nil {
    panic(err)
}

fmt.Printf("Token used: %d\n", response.TokenUsage.Total)
fmt.Printf("Cost: $%.4f\n", response.TokenUsage.Cost)

YAML 配置

创建 agent.yaml：

agent:
  name: "research-assistant"
  maxIterations: 10
  requireApproval: false

llm:
  provider: openai
  model: gpt-4
  apiKey: $OPENAI_API_KEY

memory:
  type: buffer
  size: 100

tools:
  - name: web_search
    type: websearch
  - name: database_query
    type: database
    config:
      connectionString: $DATABASE_URL

guardrails:
  maxTokens: 4000
  allowedTools:
    - web_search
    - database_query

使用配置：

agent, err := agentsdk.LoadFromYAML("agent.yaml")
if err != nil {
    panic(err)
}

response, err := agent.Run(ctx, "查询最新的销售数据")

MCP 集成

// 创建 MCP Server
mcpServer := mcp.NewServer(mcp.Config{
    Transport: "stdio",
    Tools: []mcp.Tool{
        aws.NewTool(),
        kubernetes.NewTool(),
    },
})

// 懒加载初始化
mcpServer.SetLazyInit(true)

// 添加到 Agent
agent.AddTool(mcpServer)

自动配置生成

// 从简单的系统提示自动生成完整配置
config, err := agentsdk.AutoGenerateConfig(ctx, llm, agentsdk.AutoConfigInput{
    SystemPrompt: "你是一个专业的数据分析助手",
    Role:         "data-analyst",
})
if err != nil {
    panic(err)
}

agent := agentsdk.NewAgent(config)

结构化输出

type Report struct {
    Title    string   `json:"title"`
    Summary  string   `json:"summary"`
    Findings []string `json:"findings"`
}

var report Report
err := agent.GenerateStructured(ctx, "分析销售数据", &report)
if err != nil {
    panic(err)
}

fmt.Printf("Title: %s\n", report.Title)
fmt.Printf("Findings: %v\n", report.Findings)

向量记忆

// 创建向量存储
vectorStore := chroma.NewStore(chroma.Config{
    Endpoint: "http://localhost:8000",
})

// 创建向量记忆
memory := agentsdk.NewVectorMemory(vectorStore)

// 添加记忆
memory.Add(ctx, "用户喜欢 Go 语言")
memory.Add(ctx, "用户在做 AI 开发")

// 检索相关记忆
relevant, err := memory.Search(ctx, "用户的编程语言偏好", 5)

CLI 工具

# 安装 CLI
go install github.com/Ingenimax/agent-sdk-go/cmd/agent-cli@latest

# 初始化 Agent
agent-cli init

# 运行 Agent
agent-cli run --config agent.yaml

# 交互式聊天
agent-cli chat

CLI 功能：

• agent-cli init：初始化配置
• agent-cli run：运行 Agent
• agent-cli chat：交互式聊天
• --allowedTools：限制工具访问

快速开始

安装

go get github.com/Ingenimax/agent-sdk-go

基本使用

package main

import (
    "context"
    "fmt"
    "os"

    "github.com/Ingenimax/agent-sdk-go/agentsdk"
    "github.com/Ingenimax/agent-sdk-go/llm/openai"
)

func main() {
    ctx := context.Background()

    // 创建 LLM
    llm := openai.NewLLM(openai.Config{
        APIKey: os.Getenv("OPENAI_API_KEY"),
    })

    // 创建 Agent
    agent := agentsdk.NewAgent(agentsdk.Config{
        LLM: llm,
    })

    // 运行
    response, err := agent.Run(ctx, "你好，世界")
    if err != nil {
        panic(err)
    }

    fmt.Println(response)
}

使用 Anthropic

import "github.com/Ingenimax/agent-sdk-go/llm/anthropic"

llm := anthropic.NewLLM(anthropic.Config{
    APIKey: os.Getenv("ANTHROPIC_API_KEY"),
    Model:  "claude-3-opus",
})

使用 Ollama（本地模型）

import "github.com/Ingenimax/agent-sdk-go/llm/ollama"

llm := ollama.NewLLM(ollama.Config{
    Endpoint: "http://localhost:11434",
    Model:    "llama3",
})

高级功能

多租户

// 创建多租户管理器
tenantManager := agentsdk.NewTenantManager()

// 为租户创建独立的 Agent
tenantAgent, err := tenantManager.CreateAgent("tenant-123", agentsdk.Config{
    LLM:    llm,
    Memory: memory,
})

// 租户数据隔离
tenantAgent.Run(ctx, "查询数据")

安全护栏

guardrails := agentsdk.NewGuardrails(agentsdk.GuardrailsConfig{
    // Token 限制
    MaxTokens: 4000,

    // 工具白名单
    AllowedTools: []string{"web_search"},

    // 禁止话题
    BlockedTopics: []string{"politics", "violence"},

    // 输入验证
    InputValidator: func(input string) error {
        if len(input) > 1000 {
            return fmt.Errorf("input too long")
        }
        return nil
    },
})

agent.SetGuardrails(guardrails)

可观测性

// 启用追踪
agent.SetTracing(true)

// 启用日志
agent.SetLogging(true)

// 自定义追踪器
tracer := jaeger.NewTracer(jaeger.Config{
    Endpoint: "http://localhost:14268/api/traces",
})
agent.SetTracer(tracer)

Nina：AI 助手

Agent SDK Go 包含 Nina，一个通过 MCP 提供的 AI 助手，帮助开发者导航代码库：

# 在 Cursor 或 Claude Desktop 中配置 MCP
# Nina 会帮助你理解代码、调试问题

与类似方案对比

Agent SDK Go 的优势：

1. 生产级：内置安全护栏、可观测性、多租户
2. Token 追踪：内置成本监控
3. MCP 集成：原生支持 Model Context Protocol
4. Nina 助手：AI 帮助导航代码库

Anyi 的优势：

• 配置驱动（YAML/JSON）
• 国内模型支持更好

LangChainGo 的优势：

• 社区更大，生态更丰富

适用场景

生产级应用。需要安全护栏、可观测性、多租户。

复杂 Agent。需要记忆管理、工具调用、多步骤任务。

企业部署。需要数据隔离、成本控制、审计日志。

多模型应用。需要同时使用多个 AI 模型。

成本敏感。需要精确的 Token 追踪和成本控制。

MCP 生态。需要集成 MCP 工具。

局限性和风险

Go 版本要求高。需要 Go 1.23+。

Redis 依赖。分布式记忆需要 Redis。

社区相对小。和 LangChain 比，社区还比较小。

文档不够完善。有些高级功能的文档不够详细。

学习曲线。概念比较多（Agent、LLM、Memory、Tools、Guardrails），需要时间理解。

最佳实践

使用 YAML 配置。便于维护和部署。

启用安全护栏。生产环境必须配置。

监控 Token 成本。避免意外的高成本。

使用向量记忆。复杂场景下比 Buffer 更好。

启用可观测性。便于调试和监控。

限制工具访问。使用 allowedTools 限制工具范围。

结语

Agent SDK Go 的目标是给 Go 提供一个生产级的 AI Agent 框架。当前 Go 的 AI Agent 框架要么功能太简单，要么缺乏生产级特性，它用一种比较全面的方式覆盖了这些点：多模型、记忆管理、工具集成、安全护栏、可观测性、多租户。

技术上，它支持 6+ 个 AI 模型提供商，内置 Token 追踪和成本监控，原生支持 MCP，还有 Nina AI 助手帮助开发。它还比较年轻，有很多需要完善的地方。

如果你在用 Go 做生产级 AI Agent，需要安全护栏和可观测性，或者需要精确的成本控制，可以试试 Agent SDK Go。

参考链接：

• Agent SDK Go GitHub: https://github.com/Ingenimax/agent-sdk-go
• MCP 协议: https://modelcontextprotocol.io