用 Go 搭一个会记忆、能进化的 Agent 平台：TPClaw v1.0 实战拆解

预计阅读时间：11 分钟

自托管 AI 智能体平台的选择正在变多。OpenClaw 打开了"Agent 即服务"的思路，但对 Go 技术栈的团队来说，Python 生态的依赖链始终是个部署负担。今天正式发布 v1.0 的 TPClaw，由 TeamBuf 和 RuleGo 团队联合打造，用 Go 从零写起，把规则引擎和智能体框架揉在一起——核心一句话：规则链即智能体，智能体即服务。

这篇文章拆解 TPClaw 的设计逻辑，并给出可以直接跑起来的配置示例。

规则链即智能体：从"聊天机器人"到"自主干活"

大多数 Agent 框架还停留在"你问它答"的模式。TPClaw 的切入点不同——它把 RuleGo 的规则链当作智能体的执行骨架。一条规则链就是一组有序的处理节点，每个节点可以是一次 LLM 调用、一次工具执行、一次条件判断或一次子链分发。

这意味着智能体不再是单轮对话的封装，而是一条可编排、可暂停、可恢复的执行流水线：

目标拆解：给智能体一个高层目标，它通过规则链中的规划节点自动拆解为子任务。
并行分发：子任务通过规则链的分支节点并行下发给不同工具或子智能体。
结果汇聚：各分支结果回到汇聚节点，由 LLM 节点综合判断是否达成目标，未达成则循环迭代。

这种设计的好处是：每一步的输入输出都落在规则链的上下文里，天然可追溯、可调试。你不需要在日志里拼凑 Agent 的决策路径——链路本身就是完整的执行记录。

有记忆、懂协作：不是单兵作战

TPClaw 在规则链之外加了两个关键层：

记忆层。智能体的每次执行结果会写入持久化存储（目前支持 SQLite、PostgreSQL 等）。下次收到同类任务时，规划节点会先检索历史记忆，避免重复试错。这不是简单的对话历史回放，而是结构化的"经验库"——哪些工具组合解决了哪类问题，哪些路径走了弯路，都有记录。

协作层。多个智能体可以组成团队，通过消息总线互相派发任务。一个"编排智能体"负责拆解目标，多个"执行智能体"各司其职（比如一个专做代码搜索，一个专做数据分析）。协作的调度逻辑同样用规则链定义，而不是硬编码的流程图。

用 Go 自托管：部署成本降到最低

TPClaw 的整个运行时就是单个 Go 二进制，没有 Python 迥腐的依赖地狱。这对以下场景尤其友好：

内网部署、数据不出域的企业环境
边缘设备上跑轻量 Agent（Go 二进制体积小、启动快）
已有 Go 微服务体系，想直接嵌入 Agent 能力而不引入新语言栈

RuleGo 本身已经是成熟的规则引擎（GitHub 上有数千 star），TPClaw 在其之上封装了 LLM 调用、工具注册、记忆管理等 Agent 专用组件，而不是另起炉灶重写调度逻辑。这意味着 RuleGo 用户已有的规则链资产可以平滑迁移。

实战：定义一条"代码审查智能体"规则链

下面用一个最小示例演示如何在 TPClaw 中定义一条规则链，让智能体自主完成代码审查任务。这个示例基于 RuleGo 的规则链 DSL，TPClaw 在此之上扩展了 AI 节点类型。

1. 安装 TPClaw

# 克隆项目
git clone https://github.com/TPClaw/tpclaw.git
cd tpclaw

# 编译（需要 Go 1.21+）
go build -o tpclaw-server ./cmd/server

# 启动服务，默认监听 :8080
./tpclaw-server --config config.yaml

config.yaml 最小配置：

server:
  port: 8080

llm:
  provider: openai          # 也支持 azure、ollama 等
  base_url: https://api.openai.com/v1
  api_key: ${OPENAI_API_KEY}  # 从环境变量读取
  model: gpt-4o

memory:
  store: sqlite
  path: ./data/memory.db

rulego:
  pool_size: 100

启动前设置环境变量：

export OPENAI_API_KEY="sk-your-key-here"

2. 定义规则链：代码审查智能体

以下 JSON 定义了一条三节点规则链——先拉取代码差异，再让 LLM 分析，最后输出审查意见并写入记忆：

{
  "id": "code_review_agent",
  "name": "代码审查智能体",
  "chain": [
    {
      "id": "fetch_diff",
      "type": "tool",
      "config": {
        "tool_name": "git_diff",
        "repo_path": "/path/to/your/repo",
        "branch": "main"
      },
      "next": ["llm_review"]
    },
    {
      "id": "llm_review",
      "type": "ai_llm",
      "config": {
        "prompt_template": "你是一位资深代码审查工程师。以下是本次提交的代码差异：\n{{.fetch_diff_output}}\n\n请从以下维度审查：\n1. 逻辑正确性\n2. 安全隐患\n3. 性能影响\n4. 可读性与命名\n\n输出格式：每个维度给出评分(1-5)和具体建议。",
        "model": "gpt-4o",
        "temperature": 0.3
      },
      "next": ["save_memory"]
    },
    {
      "id": "save_memory",
      "type": "memory_write",
      "config": {
        "category": "code_review",
        "tags": ["git_diff", "review_result"],
        "ttl": "30d"
      }
    }
  ]
}

关键节点类型说明：

节点 type	作用	TPClaw 扩展
`tool`	调用注册的工具（git_diff、http_request 等）	✅
`ai_llm`	调用 LLM，支持模板变量注入上下文	✅
`memory_write`	将结果写入记忆库，下次同类任务可检索	✅ TPClaw 新增
`memory_read`	从记忆库检索历史经验	✅ TPClaw 新增
`branch`	条件分支，根据 LLM 输出决定走哪条路	RuleGo 原生

3. 注册工具并触发智能体

package main

import (
    "fmt"
    "github.com/rulego/rulego"
    "github.com/tpclaw/tpclaw-sdk"
)

func main() {
    // 初始化 TPClaw 客户端
    client := tpclaw.NewClient("http://localhost:8080")

    // 注册 git_diff 工具
    client.RegisterTool(tpclaw.Tool{
        Name:        "git_diff",
        Description: "获取 Git 仓库的代码差异",
        Handler: func(params map[string]interface{}) (string, error) {
            repoPath := params["repo_path"].(string)
            branch := params["branch"].(string)
            // 实际实现：调用 git diff 命令
            return runGitDiff(repoPath, branch)
        },
    })

    // 触发智能体执行
    result, err := client.ExecuteChain("code_review_agent", map[string]interface{}{
        "repo_path": "/home/dev/my-project",
        "branch":    "feature/login-refactor",
    })
    if err != nil {
        panic(err)
    }

    fmt.Println("审查结果：", result.Output)
    fmt.Println("记忆已保存，ID：", result.MemoryID)
}

runGitDiff 的简单实现：

func runGitDiff(repoPath, branch string) (string, error) {
    cmd := exec.Command("git", "-C", repoPath, "diff", branch+"...HEAD")
    output, err := cmd.Output()
    if err != nil {
        return "", fmt.Errorf("git diff 执行失败: %v", err)
    }
    return string(output), nil
}

4. 让智能体利用记忆进化

下次对同一仓库做审查时，在规则链开头加一个 memory_read 节点：

{
  "id": "recall_history",
  "type": "memory_read",
  "config": {
    "category": "code_review",
    "query": "{{.repo_path}}",
    "top_k": 3
  },
  "next": ["fetch_diff"]
}

LLM 节点的 prompt_template 相应调整，注入历史经验：

以下是该仓库最近3次代码审查的经验总结：
{{.recall_history_output}}

结合历史经验，审查本次差异：
{{.fetch_diff_output}}

这样智能体就不会对同一个仓库反复犯相同的审查盲点——它在"进化"。

什么时候该考虑 TPClaw

几个适用场景和边界：

适合的： - 团队主力语言是 Go，不想为了 Agent 引入 Python 运行时 - 需要内网自托管，数据完全不出域 - Agent 任务是结构化的多步骤流程（代码审查、数据处理、运维巡检），而非开放式闲聊 - 已有 RuleGo 规则链资产，想在此基础上加 AI 能力

需要观望的： - 如果你依赖大量 Python 生态的工具库（如 LangChain 的丰富 tool 集成），TPClaw 的工具生态还在早期 - 多模态（图像、语音）场景目前支持有限，核心聚焦在文本和结构化数据 - 团队没有 Go 开发经验时，维护成本可能反而高于用 Python 框架

快速评估清单：

评估项	选 TPClaw 的信号	选其他方案的信号
主力技术栈	Go	Python / Node
部署环境	内网 / 边缘 / 单机	云原生 K8s + Python 镜像
Agent 任务类型	结构化多步骤流程	开放式对话 + 丰富插件
规则引擎经验	已用 RuleGo	无，或用其他引擎
记忆需求	需要跨任务持久记忆	只需单会话上下文

TPClaw v1.0 是一个起步信号——Go 生态终于有了自己的 Agent 平台，而且不是简单套壳，是从规则引擎的执行模型出发重新定义"智能体该怎么跑"。如果你正在用 RuleGo 或者对 Go 自托管 Agent 有需求，现在是从源码读起、用最小规则链试跑的好时机。