agentscope.go

AgentScope.Go —— 一个生产级的 AI Agent 开发框架，助你使用 Go 构建基于大语言模型的智能应用。

English: README_EN.md

概述

AgentScope.Go 提供了构建智能 Agent 所需的一切，采用 ReAct（推理 + 行动）范式：工具调用、记忆管理、多 Agent 协作、多平台聊天机器人（Webhook/Discord/飞书）、生态市场（MCP/Skill） 等功能一应俱全，并且全部使用地道的 Go 语言惯用法实现。

新增能力（v2.5.0）

Channel 多平台集成：3 个平台适配器开箱即用——Webhook（零依赖 HTTP）、Discord（discordgo）、飞书（纯 HTTP，含 send_message/list_chats agent 工具）；chat→agent 路由 + 异步运行 + 回复回发。
Hub 市场：浏览 + 安装 MCP/Skill 卡片（FSHub 目录即市场，zip-slip 防护）。
Plugin 生态示例：三阶段生命周期 + YAML 配置 + 工具注册（examples/plugin_demo）。
RAG 托管知识库：document→parser(Text/PDF/PPTX/Image)→chunker→blob→kb→index 全管道 + RAGMiddleware + KB HTTP API。对齐 Python rag/ 托管服务。
消息总线 CoordBus：Lock/Registry/Queue/Log 四原语（Local+Redis 双后端）+ 跨会话投影。
Web UI 控制台：零构建 SPA（Chat/KB/System，go:embed 单二进制）。
Agentic Memory：agent 自主管理 Markdown 记忆文件（文件式，区别于被动检索的 ReMe）。
Tracing 语义属性：Span 五钩点提取（model/tool/iteration/usage）+ otelSpan 桥接。
MCP 声明式配置：ServerSpec YAML + 6-server 目录 + 弹性连接。
Langfuse 接入 + RBAC 测试 + 审计接线 + slog 结构化日志规范。

快速开始

环境要求： Go 1.25 或更高版本

go get github.com/linkerlin/agentscope.go

import (
    "context"
    "fmt"
    "os"

    "github.com/linkerlin/agentscope.go/agent/react"
    "github.com/linkerlin/agentscope.go/message"
    "github.com/linkerlin/agentscope.go/model/openai"
)

func main() {
    chatModel, _ := openai.Builder().
        APIKey(os.Getenv("OPENAI_API_KEY")).
        ModelName("gpt-4o-mini").
        Build()

    agent, _ := react.Builder().
        Name("Assistant").
        SysPrompt("You are a helpful AI assistant.").
        Model(chatModel).
        Build()

    response, _ := agent.Call(context.Background(), message.NewMsg().
        Role(message.RoleUser).
        TextContent("Hello! What can you help me with?").
        Build())

    fmt.Println(response.GetTextContent())
}

支持的模型

提供商	包路径	说明
OpenAI Chat	`github.com/linkerlin/agentscope.go/model/openai`	GPT-4o / GPT-4o-mini / o1 / o3 等（Chat Completions API）
OpenAI Response	`github.com/linkerlin/agentscope.go/model/openai_response`	o3 / o4-mini 等（Responses API，支持 reasoning 流）
Anthropic	`github.com/linkerlin/agentscope.go/model/anthropic`	Claude 3.5 Sonnet / Opus / Haiku 原生 HTTP + SSE
Gemini	`github.com/linkerlin/agentscope.go/model/gemini`	Gemini 1.5 Flash / Pro 原生 HTTP + SSE
DashScope (阿里云)	`github.com/linkerlin/agentscope.go/model/dashscope`	通义千问系列（OpenAI 兼容）
DeepSeek	`github.com/linkerlin/agentscope.go/model/deepseek`	DeepSeek-V3 / Coder / Reasoner（OpenAI 兼容）
Moonshot	`github.com/linkerlin/agentscope.go/model/moonshot`	Kimi 系列（OpenAI 兼容）
xAI	`github.com/linkerlin/agentscope.go/model/xai`	Grok 系列（OpenAI 兼容）
vLLM	`github.com/linkerlin/agentscope.go/model/vllm`	私有化部署（OpenAI 兼容）
Ollama	`github.com/linkerlin/agentscope.go/model/ollama`	本地开源模型（OpenAI 兼容）

任何兼容 OpenAI API 格式的服务都可以通过 BaseURL 配置使用。

按模型提供商快速上手

scripts/model_examples/ 提供每家模型提供商的最小可运行脚本，以及多 Agent、事件流、多模态等场景示例：

cd scripts/model_examples/openai_chat_call
export OPENAI_API_KEY=sk-...
go run .

目前已覆盖：OpenAI Chat / OpenAI Response / Anthropic / Gemini / DashScope / DeepSeek / Moonshot / xAI / Ollama / vLLM，以及 multiagent / stream / multimodal。

Cookbook

cookbook/ 提供可复用的解决方案 recipes：

长文档摘要（MapReduce）
多 Agent 审稿（Reflection + Pipeline）
RAG 问答（Loader + Embedding + ReMe）
定时报告 Agent（Schedule）
自愈 Agent（GEP / Evolver）

核心包

包名	说明
`message`	`Msg` 类型，支持多模态内容块（文本、图片、音频、视频、工具调用/结果、思考过程）
`model`	`ChatModel` 接口，支持流式响应
`agent`	`Agent` 基础接口与 `Base` 统一生命周期（Hook、流式事件、Usage 统计）
`agent/react`	ReAct Agent 实现，内嵌 `agent.Base`
`memory`	`Memory` 接口 + 5 实现（InMemory/Window/ReMeInMemory/ReMeFile/ReMeVector） + 7 向量后端 + Hybrid Search(BM25+Reranker) + Dream 演化 + 知识图谱
`tool`	`Tool` 接口 + 内置工具（file: Read/Write/Edit/Glob/Grep, shell, web, json, multimodal + Task/Schedule/Subagent）
`formatter`	独立的模型请求/响应格式化抽象层（OpenAI / Anthropic / Gemini / DashScope / Ollama）
`pipeline`	多 Agent 编排：Pipeline（顺序）+ Parallel（并发）
`msghub`	广播式多 Agent 消息调度（Hub）
`workflow`	高级多 Agent 编排：条件（Condition）、循环（Loop）、MapReduce
`reflection`	Agent 自省/反思模式：Writer + Critic 循环迭代优化
`a2a`	A2A 协议实现：AgentCard、Task、SSE、Registry、ShardRouter、安全（认证/限流/WebSocket）
`gateway`	HTTP + SSE + WebSocket + AG-UI Gateway，多租户认证 + Session 持久化 + Tool Offload + KB API + 审计 + RBAC
`service`	多租户 Service 层：Storage + Auth + Credential 加密 + RBAC 角色/权限 + 审计日志
`rag`	托管知识库：document/parser(Text/PDF/PPTX/Image)/chunker/blob/kb/index 全管道 + RAGMiddleware + KB HTTP API
`messagebus`	分布式消息总线：LocalBus + RedisBus + CoordBus 四原语(Lock/Registry/Queue/Log) + TeamBus + 跨会话投影
`middleware`	Agent 生命周期中间件（洋葱模型）+ Budget/TTS/LongTermMemory/RAG/AgenticMemory
`logging`	结构化日志规范：stdlib slog 封装 + LOG_LEVEL/LOG_FORMAT 环境配置 + 请求级 FromContext
`schedule`	Cron 定时任务调度器
`async`	异步任务执行池
`loader`	文档加载器（TextLoader / DirLoader）
`observability`	OpenTelemetry + LangSmith + Langfuse + Tracing 语义属性提取 + otelbridge
`channel`	多平台集成：ChannelEvent/Channel 接口/Gateway/Dispatcher/Routing + Webhook/Discord/飞书 3 适配器 + 飞书 agent 工具
`hub`	Hub 市场：MCP/Skill 卡片浏览+安装（FSHub + zip-slip 防护）
`session`	会话管理
`hook`	钩子系统，支持人机协作
`plan`	PlanNotebook，用于结构化多步骤任务管理
`embedding`	独立 Embedding 包：OpenAI / Ollama / Gemini / DashScope / DashScope多模态 + FileCache，可直接用于 gateway / memory / RAG
`evolver`	GEP Gene/Capsule 类型 + Evolver 客户端 + Run/Reflect/Solidify 流程 + Skill→Gene 蒸馏（Phase 6 对齐 evolver 优势）
`embedding/onnx`	ONNX 本地推理：CLIP 图像嵌入 + Whisper 音频嵌入 + 模型管理器（HTTP 代理方案，零 CGO 依赖）

Channel 多平台集成

Agent 接入 Webhook / Discord / 飞书，一条管道收发消息：

// 1. 构建 channel 子系统
wh := channel.NewWebhookChannel("webhook-1")
router := channel.NewChatRouter(channel.RouteTable{
    ChannelID: "webhook-1",
    Bindings:  []channel.Binding{{ChatIDPrefix: "dev-", AgentID: "dev-agent", SessionPrefix: "dev-"}},
})
gateway := channel.NewGateway(router, runner)   // runner 适配 SessionManager
dispatcher := channel.NewDispatcher(gateway, channel.NewRegistry())

// 2. 平台适配器（3 选 1）
// dc := discord.New("discord-1", os.Getenv("DISCORD_TOKEN"))          // Discord
// fc := feishu.New("feishu-1", appID, appSecret)                      // 飞书（纯 HTTP）

// 3. 启动 + 服务 webhook 端点
dispatcher.StartAll(ctx)
mux.Handle("/webhook", wh)   // 或 fc（飞书事件订阅 URL）

飞书 agent 工具：feishu_send_message / feishu_list_chats（agent 主动操作飞书）。详见 docs/CHANNEL.md。

Hub 市场

从注册中心浏览 + 安装 MCP/Skill：

h, _ := builtin.NewFSHub("./catalog", "demo", "Demo Hub", "")
mcps, next, _ := h.ListMCPCards(ctx, "", 0, 20)   // 浏览（游标分页）
hub.InstallSkill(ctx, skillCard, "./skills")      // 下载+解压（zip-slip 防护）
mgr, _ := hub.InstallMCPs(ctx, mcps)              // 弹性连接（缺失二进制跳过）

Gateway 接入：srv.WithHubs(h) + srv.RegisterHubRoutes()（浏览/安装 5 路由）。详见 docs/HUB.md。

ONNX 生产化（多模态本地推理）

无需 Python 环境，纯 Go 实现图像/音频预处理管道，通过 HTTP 代理连接 ONNX Runtime 服务：

import "github.com/linkerlin/agentscope.go/embedding/onnx"

// 图像预处理（CLIP）→ 输出 NCHW [1,3,224,224]
preprocessor := onnx.NewImagePreprocessor(onnx.DefaultCLIPPreprocessConfig())
vec, _ := preprocessor.Preprocess(imageReader)

// 音频预处理（Whisper）→ 输出 Mel 频谱图 [1,80,3000]
audioProc := onnx.NewAudioPreprocessor(onnx.DefaultWhisperPreprocessConfig())
mel, _ := audioProc.Preprocess(pcmSamples, 16000)

// CLIP 图像嵌入器（HTTP 代理）
clip := onnx.NewCLIPImageEmbedder(onnx.DefaultCLIPImageEmbedderConfig())
embedding, _ := clip.EmbedImage(vec)

// 跨模态相似度（图像-文本对齐）
sim, _ := onnx.CrossModalSimilarity(imageEmbedding, textEmbedding)

// 模型管理器：自动下载/缓存/版本管理
manager, _ := onnx.NewModelManager(onnx.DefaultModelManagerConfig())
manager.RegisterModel(onnx.PredefinedModels()[0]) // CLIP ViT-B/32

A2A 增强（认证 + 限流 + WebSocket）

A2A 协议完整实现，新增生产级安全与实时通信能力：

import "github.com/linkerlin/agentscope.go/a2a"

// 安全服务器：认证 + 限流 + CORS + 日志
server := a2a.NewSecureServer(card, runner, store)
server.auth.AddAPIKey("sk-xxx", "production-client")
server.WithRateLimit(a2a.NewRateLimiter(100, 200)) // 100 req/s, burst 200

// WebSocket 实时任务推送
wsServer := a2a.NewWebSocketEnabledServer(card, runner, store)
// 客户端通过 WebSocket 订阅任务状态，实时接收 task_update 事件

性能基准

测试项	性能	说明
嵌入缓存命中	550 ns/op	内存 LRU，无锁读
跨模态相似度	741 ns/op	512 维余弦相似度
向量存储搜索（1000 节点）	229 μs/op	暴力搜索 + HNSW 自动切换
FTS 全文搜索（1000 文档）	97 μs/op	FTS5 trigram + CJK 回退
ReMe 文件记忆添加	463 μs/op	含持久化写入
ReAct 记忆注入	132 μs/op	向量检索 + 格式化 + 注入
ONNX 图像预处理	3.5 ms/op	1024×768 → 224×224 + 归一化
ONNX 音频预处理	~9.7 s/op	30s 音频 → Mel 频谱图（可优化）

运行基准：go test ./memory/... -run=^$ -bench=. -benchtime=1s

高层生产服务 Bootstrap（强烈推荐）

gateway.AppConfig + NewApp 提供接近 Python create_app + lifespan 的“一键”体验，支持大量自动装配：

appCfg := gateway.AppConfig{
    Agent:                 myAgent,
    Storage:               service.NewMemoryStorage(),
    JWTAuth:               jwtAuth,
    WorkspaceBaseDir:      "./workspaces",
    AutoStandardTools:     true,           // 自动为 sessions 注入 file+task+web+json+schedule 等
    AutoToolOffload:       true,
    DefaultPermissionMode: permission.ModeExplore,
    EmbeddingModel:        embedding.NewOpenAI(apiKey, "text-embedding-3-small"),
    EmbeddingCacheDir:     "./.embed_cache", // 自动 WithFileCache
}
srv := gateway.NewApp(appCfg)
srv.RegisterAppRoutes(jwtAuth)
srv.Start()   // 自动恢复 persisted schedules
defer srv.Close()

详见 examples/full_service 和 examples/production。

Embedding 包

独立使用：

import "github.com/linkerlin/agentscope.go/embedding"

emb := embedding.NewOpenAI(os.Getenv("OPENAI_API_KEY"), "text-embedding-3-small")
emb = embedding.WithFileCache(emb, ".cache/embeddings") // 可选

vecs, _ := emb.Embed(ctx, []string{"hello world"})

支持 Gemini / DashScope (含多模态提示)。

使用工具

import "github.com/linkerlin/agentscope.go/tool"

myTool := tool.NewFunctionTool(
    "weather",
    "获取指定城市的当前天气",
    map[string]any{
        "type": "object",
        "properties": map[string]any{
            "city": map[string]any{"type": "string"},
        },
        "required": []string{"city"},
    },
    func(ctx context.Context, input map[string]any) (any, error) {
        city := input["city"].(string)
        return fmt.Sprintf("%s 天气晴朗，22°C", city), nil
    },
)

agent, _ := react.Builder().
    Name("WeatherBot").
    Model(chatModel).
    Tools(myTool).
    Build()

记忆管理

基础 Memory

import "github.com/linkerlin/agentscope.go/memory"

mem := memory.NewInMemoryMemory()
agent, _ := react.Builder().
    Name("Assistant").
    Model(chatModel).
    Memory(mem).
    Build()

ReMe 长期记忆（文件 + 向量）

import "github.com/linkerlin/agentscope.go/memory"
import "github.com/linkerlin/agentscope.go/memory/handler"

// 创建向量记忆
v, _ := memory.NewReMeVectorMemory(cfg, counter, nil, embedModel)

// 注入编排器，实现自动提取与检索
orch := handler.NewMemoryOrchestrator(personalSum, proceduralSum, toolSum, memTool, profileTool, historyTool, dedup)
v.SetOrchestrator(orch)

// 端到端自动提取个人/任务记忆并写入向量库
res, _ := v.SummarizeMemory(ctx, msgs, "alice", "coding_task", "")

// 统一检索
nodes, _ := v.RetrieveMemoryUnified(ctx, "Go 最佳实践", "alice", "coding_task", "", memory.RetrieveOptions{TopK: 5})

ReAct 记忆注入编排

import "github.com/linkerlin/agentscope.go/memory"

// 创建 ReAct 步级记录器
recorder := memory.NewReactStepRecorder(memory.NewInMemoryStepStore())

// 创建记忆注入编排器（4 种策略：recent/targeted/personal/hybrid）
orchestrator := memory.NewReactOrchestrator(recorder, store, memory.DefaultReactOrchestratorConfig())

// 在 ReAct 循环中注入相关记忆
memNodes, sysMsg, _ := orchestrator.InjectMemory(ctx, query, history, "alice", "coding_task")

// 复盘提取：成功路径 / 失败教训 / 新知识
replay := memory.NewReactReplayExtractor(memory.DefaultReactReplayConfig())
result, _ := replay.Replay(ctx, steps)

钩子系统（人机协作）

import "github.com/linkerlin/agentscope.go/hook"

loggingHook := hook.HookFunc(func(ctx context.Context, hCtx *hook.HookContext) (*hook.HookResult, error) {
    fmt.Printf("[%s] Agent: %s\n", hCtx.Point, hCtx.AgentName)
    return nil, nil
})

agent, _ := react.Builder().
    Name("Assistant").
    Model(chatModel).
    Hooks(loggingHook).
    Build()

计划笔记本

import "github.com/linkerlin/agentscope.go/plan"

notebook := plan.NewPlanNotebook()
p := notebook.CreatePlan("研究任务")
notebook.AddStep(p.ID, "搜索信息")
notebook.AddStep(p.ID, "总结发现")

// 作为工具在 Agent 中使用
agent, _ := react.Builder().
    Name("Planner").
    Model(chatModel).
    Tools(notebook.AsTool()).
    Build()

多模型后端示例

Anthropic

import "github.com/linkerlin/agentscope.go/model/anthropic"

chatModel, _ := anthropic.NewBuilder().
    APIKey(os.Getenv("ANTHROPIC_API_KEY")).
    ModelName("claude-3-5-sonnet-20241022").
    Build()

Gemini

import "github.com/linkerlin/agentscope.go/model/gemini"

chatModel, _ := gemini.NewBuilder().
    APIKey(os.Getenv("GEMINI_API_KEY")).
    ModelName("gemini-1.5-flash").
    Build()

DashScope（阿里云）

import "github.com/linkerlin/agentscope.go/model/dashscope"

chatModel, _ := dashscope.Builder().
    APIKey(os.Getenv("DASHSCOPE_API_KEY")).
    ModelName("qwen-max").
    Build()

Ollama

import "github.com/linkerlin/agentscope.go/model/ollama"

chatModel, _ := ollama.NewBuilder().
    BaseURL("http://127.0.0.1:11434/v1").
    ModelName("llama3.2").
    Build()

DeepSeek

import "github.com/linkerlin/agentscope.go/model/deepseek"

chatModel, _ := deepseek.Builder("sk-...").
    ModelName(deepseek.ModelChat).
    Build()

Moonshot (Kimi)

import "github.com/linkerlin/agentscope.go/model/moonshot"

chatModel, _ := moonshot.Builder("sk-...").
    ModelName(moonshot.Model8K).
    Build()

xAI (Grok)

import "github.com/linkerlin/agentscope.go/model/xai"

chatModel, _ := xai.Builder("xai-...").
    ModelName(xai.ModelGrok2).
    Build()

vLLM

import "github.com/linkerlin/agentscope.go/model/vllm"

chatModel, _ := vllm.Builder("http://localhost:8000/v1", "sk-...").
    ModelName("meta-llama/Meta-Llama-3-8B-Instruct").
    Build()

OpenAI Response API

import "github.com/linkerlin/agentscope.go/model/openai_response"

chatModel, _ := openai_response.Builder().
    APIKey(os.Getenv("OPENAI_API_KEY")).
    ModelName("o3").
    ThinkingEnable(true).
    ReasoningEffort("medium").
    Build()

多 Agent 编排

顺序执行（Pipeline）

import "github.com/linkerlin/agentscope.go/pipeline"

pipe := pipeline.New("ResearchPipe", plannerAgent, writerAgent)
resp, _ := pipe.Call(ctx, message.NewMsg().Role(message.RoleUser).TextContent("Go 并发模式").Build())

广播调度（MsgHub）

import "github.com/linkerlin/agentscope.go/msghub"

hub := msghub.New()
hub.Register("coder", coderAgent)
hub.Register("reviewer", reviewerAgent)
results := hub.Broadcast(ctx, msg) // map[string]*message.Msg

并行 / 条件 / 循环（Workflow）

import "github.com/linkerlin/agentscope.go/workflow"

// 并行：让两个 Agent 同时处理，合并结果
par := workflow.NewParallel("DualCheck", nil, agentA, agentB)

// 条件：根据输入内容决定走哪个分支
cond := workflow.NewCondition("Router",
    func(m *message.Msg) bool { return strings.Contains(m.GetTextContent(), "urgent") },
    urgentAgent, normalAgent)

// 循环：反复优化直到满足质量条件
loop := workflow.NewLoop("Refiner", editorAgent,
    func(m *message.Msg) bool { return !strings.Contains(m.GetTextContent(), "FINAL") },
    5)

实时对话 Gateway

import "github.com/linkerlin/agentscope.go/gateway"

srv := gateway.NewServer(agent)
http.ListenAndServe(":8080", srv)

POST /chat —— 非流式对话，请求体 {"text":"..."}，返回 JSON。
POST /chat/stream —— SSE 流式对话，浏览器可用 EventSource 接收增量回复。
GET /chat/ws —— WebSocket 流式对话，支持双向实时交互。

MapReduce 工作流

import "github.com/linkerlin/agentscope.go/workflow"

mr := workflow.NewMapReduce(
    "DocSummary",
    func(m *message.Msg) []string { return splitIntoParagraphs(m.GetTextContent()) },
    summarizerAgent, // mapper
    synthesizerAgent, // reducer
    4, // parallelism
)

输入被 split 成多个 chunk，每个 chunk 由 mapper 并行处理，最后由 reducer 汇总为单一结果。

Agent 自省/反思模式

import "github.com/linkerlin/agentscope.go/reflection"

agent := reflection.NewSelfReflectingAgent(
    "RefiningWriter",
    writerAgent,
    criticAgent,
    func(_, critique *message.Msg) bool {
        return strings.Contains(critique.GetTextContent(), "PASS")
    },
    3, // max iterations
)

resp, _ := agent.Call(ctx, message.NewMsg().Role(message.RoleUser).TextContent("topic").Build())

示例

examples/a2a —— A2A 协议基础：AgentCard、Task、SSE
examples/a2a_redis_registry —— A2A Redis 分布式注册中心
examples/embedding —— 独立 Embedding 包（OpenAI/Ollama + FileCache）
examples/schedule —— Cron 定时任务调度器
examples/rag —— RAG 问答完整流程（Loader + Embedding + ReMe）
examples/rag_kb —— 托管知识库管道（上传→解析→分块→索引→检索，离线可运行）
examples/agentic_memory —— Agentic Memory（agent 自主管理 Markdown 记忆）
examples/mcp_servers —— MCP 声明式配置（YAML 加载 + 弹性连接多 server）
examples/web_ui —— Web UI 控制台（Chat/KB/System，零构建 SPA）
examples/channel_webhook —— Channel 多平台（Webhook 收发 + chat→agent 路由 + 回复回发）
examples/channel_discord —— Discord bot（WebSocket Gateway 收消息 + REST 回发）
examples/channel_feishu —— 飞书 bot（事件订阅 webhook + 发送，纯 HTTP）
examples/hub_demo —— Hub 市场（浏览 MCP/Skill 卡片 + 下载安装）
examples/plugin_demo —— Plugin 系统（三阶段生命周期 + YAML 配置 + 工具注册）
examples/observability —— OpenTelemetry + LangSmith 追踪
examples/state —— AgentState 持久化（JSONFile/Redis）
examples/a2a_secure —— A2A 认证 + 限流 + WebSocket
examples/memory_benchmark —— 记忆系统基准测试运行
examples/onnx —— ONNX 图像/音频预处理与嵌入
examples/react_orchestrator —— ReAct 记忆注入编排
examples/cross_modal —— 跨模态检索（文本→图像/音频）
examples/multimodal —— 多模态 Agent（图像/音频输入）
examples/multimodal_router —— 多模态路由自动切换
examples/middleware —— Agent 生命周期中间件链
examples/interrupt —— 中断处理与暂停恢复
examples/trace —— 事件追踪与 Hook 系统
examples/web_ui —— Web UI 实时对话
examples/hello —— Agent 基础用法
examples/tools —— 带计算工具的 Agent
examples/v2_event_stream —— V2 事件流完整生命周期演示
examples/anthropic —— 使用 Claude 后端的 Agent
examples/gemini —— 使用 Gemini 后端的 Agent
examples/pipeline —— 多 Agent 顺序编排（Pipeline）
examples/msghub —— 广播式多 Agent 消息调度
examples/workflow —— 并行 + 条件 + 循环工作流
examples/gateway —— HTTP + SSE 实时对话 Gateway
examples/reflection —— Writer + Critic 自我反思迭代
examples/mapreduce —— MapReduce 长文档摘要
examples/reme/file —— ReMe 文件型记忆（ReMeLight）
examples/reme/vector —— ReMe 向量记忆检索
examples/reme/orchestrator —— ReMe Orchestrator 端到端（提取 + 检索 + Profile）
examples/voice —— STT → Chat → TTS 语音对话 Pipeline
examples/multi_tenant_workspace —— 多租户认证 + Workspace + 权限引擎端到端
examples/production —— 全功能生产级服务（Auth + 工具 + 权限 + Gateway）
examples/full_service —— 极简重度自动装配生产服务（推荐）
examples/studio —— 纯 Go 轻量 Studio (HTMX) —— 完整 Auth/Agents/Credentials/Schedules/Chat + 实时 SSE + auto tools 结果展示
examples/evolver —— GEP 自演化 demo（Gene/Capsule、Run/Reflect/Solidify 闭环、Skill 蒸馏、Recording 调用、演化记忆 recall）
examples/langsmith —— Agent 事件流转发到 LangSmith
examples/controlplane_demo —— 控制平面端到端演示（Goal/ShouldRun/门/租约/看板/谱系，内存 Kernel）
examples/controlplane_sql —— 控制平面进阶演示（SQL 持久化跨重启 + 跨进程 Writeback→Spend + 票据强制 + issue-fix lane 门控 + reward hard_policy 否决 + ReapAll 维护）
examples/controlplane_http —— 控制平面 HTTP API 全流程（authorize 拿 token → writeback → spend → 门开/解 → review/kanban → capabilities → maintenance）

可观测性

追踪中间件（Phase 5 新增，对齐 Python）

使用 TracingMiddlewareAdapter 可在 Agent 生命周期（on_reply、on_reasoning、on_acting、on_model_call、on_system_prompt）注入 tracing spans。

import (
    "github.com/linkerlin/agentscope.go/observability"
    "github.com/linkerlin/agentscope.go/agent/react"
)

tracer := observability.NewOTelTracer(...) // 或 LangSmith tracer 等
tracingMW := &observability.TracingMiddlewareAdapter{
    Tracer: tracer,
    Name:   "my-agent",
}

agent, _ := react.Builder().
    Name("TracedAgent").
    Model(chatModel).
    Middlewares(tracingMW).  // 直接用于 middleware 链
    Build()

也可用 TracedAgent 包装：

traced := observability.NewTracedAgent("my-agent", baseAgent).WithTracer(tracer)

支持 RecordingTracer 用于调试（见 examples/full_service）。

LangSmith 追踪

import (
    "github.com/linkerlin/agentscope.go/event"
    "github.com/linkerlin/agentscope.go/observability"
)

client := observability.NewLangSmithClient(os.Getenv("LANGSMITH_API_KEY"))
observer := observability.NewLangSmithObserver(client, "my-project", "session-1")

bus := event.NewBus(100)
go observer.Observe(ctx, bus)

agent, _ := react.Builder().
    Name("TracedAgent").
    Model(chatModel).
    WithEventBus(bus).
    Build()

Agent 运行期间的所有事件（ReplyStart、TextBlockDelta、ToolCallStart、ToolCallEnd、ReplyEnd 等）将自动上报到 LangSmith，生成完整的调用链追踪。

OpenTelemetry

import "github.com/linkerlin/agentscope.go/observability"

tp, _ := observability.InitTracerProvider("agent-service")
defer tp.Shutdown(context.Background())

Gateway 自动集成 OTel HTTP 中间件，所有请求都会被追踪。Toolkit 层也有 TracingMiddleware。

GEP 自演化与 Evolver 对齐（Phase 6 新阶段）

agentscope.go 现在对齐了 Evolver（及 evolver.py）的核心优势——基于 GEP（Gene Evolution Protocol）的自演化能力。

为什么对齐 Evolver？

Evolver 的论文与实践表明：紧凑的 Gene（策略基因，带 signals_match + strategy + constraints + validation） 作为演化资产，远优于松散的 ad-hoc prompt / skill 文档。它提供：

可审计、可复用、可固化的演化闭环（run → reflect → solidify）
Capsule（成功快照，含 blast_radius、execution_trace、outcome）
带类型的记忆（remember/recall gene/capsule/event，支持 narrativeMemory / memoryGraph）
结构化会议（meeting_start / proceed / human_input / finalize）
ATP 任务市场（claim / complete + hub 复用）
Skill ↔ Gene 蒸馏（skill2gep / distiller / publisher）
安全与回滚（safety_status、policy、gitOps rollback）

agentscope.go 已有 ReMe（世界级记忆）、a2a（领先协议）、gateway（MCP 完美桥接）、事件+tracing 基础设施，因此我们轻量桥接而非重造：

提供原生 Go 类型 + 高层流程 API
通过现有 MCP 网关即可让你的 Agent 直接调用 evolver 全部工具
ReMe + 新 MemoryTypeGene/Capsule 天然承载演化资产
Skill 蒸馏 + Recording 风格可见性（类似 Phase 5 tracing）

快速使用（Mock 先行，生产接 MCP）

import "github.com/linkerlin/agentscope.go/evolver"

flow := evolver.NewGEPFlow(evolver.NewMockEvolver()) // 生产：换成真实 backed client
runCfg := evolver.RunConfig{Context: "recurring gateway timeout on large payload", Strategy: "repair-only"}
runRes, solRes, _ := flow.RunAndSolidify(ctx, runCfg, false /* 设 true 干运行 */)

fmt.Println("Selected gene:", runRes.SelectedGene.ID)
fmt.Println("Solidified capsule:", solRes.CapsuleID)

// Skill 蒸馏为 Gene（对齐 skillDistiller）
sk := &skill.AgentSkill{Name: "timeout_recovery", Description: "...", SkillContent: "..."}
gene := sk.DistillToGene(evolver.CategoryRepair)
flow.Client.UpsertGene(ctx, gene)

// 演化记忆 recall（narrative 风格）
_ = flow.Client.Remember(ctx, evolver.RememberRequest{Text: "...", Type: "capsule", Category: evolver.CategoryRepair})
hits, _ := flow.Client.Recall(ctx, evolver.RecallRequest{Query: "timeout", Category: "capsule"})

生产集成：在 gateway.AppConfig{EvolverEnabled: true} 启动后，session agent 即可通过 MCP 工具调用 evolver__evolver_run / evolver_solidify 等（见 gateway/session_mcp_gateway）。配合 ReMe 持久化 gene/capsule 资产，即可实现“遇到错误自动触发 GEP 修复 + 固化 + 审计”。

详见：

evolver/ 包（types, client, gep flow, tests）
examples/evolver/main.go（完整可运行 demo，含 recording calls、distill、recall）
DEV_PLAN_CATCHUP.md Phase 6 章节（含优势对比、实施策略）
evolver 官方：基因优于 skill 的论文 arXiv:2604.15097

未来将持续增强：真实 MCP 客户端包装、Studio 演化资产 UI、a2a ATP 任务扩展、ReMe 深度 memoryGraph 实现。

部署与迁移

生产部署指南：docs/DEPLOYMENT.md
从 Python AgentScope 或旧版本迁移：MIGRATION.md
版本发布流程：RELEASE_CHECKLIST.md

贡献与社区

我们欢迎所有形式的贡献！

贡献指南：CONTRIBUTING.md
行为准则：CODE_OF_CONDUCT.md
安全漏洞报告：SECURITY.md
当前任务与路线图：TODO.md
详细演进方案：演进方案.md

如果你在使用过程中遇到问题，请先查看 docs/ 和 examples/，然后提交 Issue。

许可证

Apache License 2.0 —— 详见 LICENSE 文件。

Name		Name	Last commit message	Last commit date
.codebuddy		.codebuddy
.cursor/skills/frontend-design		.cursor/skills/frontend-design
.github		.github
.workbuddy/memory		.workbuddy/memory
a2a		a2a
agent		agent
async		async
benchmark		benchmark
channel		channel
config		config
console		console
controlplane		controlplane
cookbook		cookbook
credential		credential
dist		dist
docs-site		docs-site
docs		docs
embedding		embedding
event		event
evolver		evolver
examples		examples
finetune		finetune
formatter		formatter
gateway		gateway
hook		hook
hub		hub
integrations		integrations
internal/llmenv		internal/llmenv
interruption		interruption
loader		loader
logging		logging
memory		memory
message		message
messagebus		messagebus
middleware		middleware
model		model
msghub		msghub
node_modules		node_modules
observability		observability
output		output
permission		permission
pipeline		pipeline
plan		plan
plugin		plugin
rag		rag
reflection		reflection
rerank		rerank
retry		retry
runcontext		runcontext
schedule		schedule
scripts/model_examples		scripts/model_examples
service		service
session		session
shutdown		shutdown
site		site
skill		skill
state		state
tests/cross_lang		tests/cross_lang
tool		tool
toolkit		toolkit
tts		tts
workflow		workflow
workspace		workspace
.env.example		.env.example
.gitattributes		.gitattributes
.gitignore		.gitignore
.golangci.yml		.golangci.yml
AGENTS.md		AGENTS.md
CHANGELOG.md		CHANGELOG.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
DEV_PLAN_CATCHUP.md		DEV_PLAN_CATCHUP.md
GoGPU_vs_Born_深度对比报告.md		GoGPU_vs_Born_深度对比报告.md
LICENSE		LICENSE
LoopX演进方案.md		LoopX演进方案.md
MIGRATION.md		MIGRATION.md
Makefile		Makefile
OpenSquilla演进方案.md		OpenSquilla演进方案.md
README.md		README.md
README_EN.md		README_EN.md
RELEASE_CHECKLIST.md		RELEASE_CHECKLIST.md
RELEASE_NOTES_v2.0.0.md		RELEASE_NOTES_v2.0.0.md
RELEASE_NOTES_v2.4.2.md		RELEASE_NOTES_v2.4.2.md
RELEASE_NOTES_v2.4.3.md		RELEASE_NOTES_v2.4.3.md
RELEASE_NOTES_v2.5.0.md		RELEASE_NOTES_v2.5.0.md
RELEASE_NOTES_v2.6.0.md		RELEASE_NOTES_v2.6.0.md
ReMe记忆演进方案.md		ReMe记忆演进方案.md
SECURITY.md		SECURITY.md
TODO.md		TODO.md
V2演进方案.md		V2演进方案.md
go.mod		go.mod
go.sum		go.sum
mkdocs.yml		mkdocs.yml
package-lock.json		package-lock.json
package.json		package.json
version.go		version.go
演进方案.md		演进方案.md
演进方案v2.md		演进方案v2.md
演进方案v3.md		演进方案v3.md
演进方案v4.md		演进方案v4.md

Latest commit

History

Folders and files

Repository files navigation