第一章：Go语言AI Agent开发全栈实践概览
Go语言凭借其高并发支持、静态编译、简洁语法与成熟工具链，正成为构建高性能、可部署AI Agent系统的理想选择。本章不聚焦单一模块，而是呈现一个端到端的实践视角：从Agent核心行为建模、LLM交互封装，到服务暴露、状态持久化与可观测性集成，全部基于纯Go生态实现。
为什么选择Go构建AI Agent
- 原生goroutine与channel天然适配Agent多任务协同（如并行调用多个工具、流式响应处理）
- 静态二进制可一键部署至边缘设备或K8s集群，规避Python环境依赖痛点
net/http+gin/echo构建低延迟API网关；go-sqlite3或ent轻量管理会话记忆；opentelemetry-go无缝接入分布式追踪
快速启动一个Agent服务骨架
执行以下命令初始化项目并引入关键依赖：
mkdir go-agent-demo && cd go-agent-demo
go mod init example.com/agent
go get github.com/gin-gonic/gin github.com/google/uuid github.com/tmc/langchaingo@v0.5.9创建 main.go，定义基础Agent结构与HTTP端点：
package main
import (
"github.com/gin-gonic/gin"
"github.com/google/uuid"
)
// Agent代表一个具备记忆与决策能力的实体
type Agent struct {
ID string `json:"id"`
Memory []string `json:"memory"` // 简化版短期记忆（实际建议用向量库）
}
func main() {
r := gin.Default()
r.POST("/chat", func(c *gin.Context) {
var req struct {
Message string `json:"message"`
}
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(400, gin.H{"error": "invalid JSON"})
return
}
// 此处将接入LLM调用逻辑（如LangChainGo的OpenAI模型链）
resp := Agent{
ID: uuid.New().String(),
Memory: []string{req.Message, "Agent received your message."},
}
c.JSON(200, resp)
})
r.Run(":8080") // 启动服务，访问 http://localhost:8080/chat 测试
}核心能力组件对照表
| 能力维度 | 推荐Go方案 | 说明 |
|---|---|---|
| LLM交互 | langchaingo/llms/openai |
支持流式响应、函数调用（tool calling） |
| 工具调用管理 | 自定义Tool接口 + map[string]Tool |
统一注册与路由外部API或本地函数 |
| 会话状态存储 | github.com/mattn/go-sqlite3 + ent |
支持结构化记忆检索与TTL过期 |
| 日志与追踪 | go.opentelemetry.io/otel + zap |
关联请求ID，追踪Agent决策链路 |
第二章：Prompt编排与智能体意图理解
2.1 Prompt工程原理与Go语言模板化实现
Prompt工程本质是将任务意图、上下文约束与输出格式通过结构化文本精准编码。在Go中，text/template 提供了安全、可复用的模板化能力，天然适配LLM输入构造需求。
模板核心要素
- 变量注入：
{{.UserQuery}}绑定运行时数据 - 逻辑控制：
{{if .WithExamples}}...{{end}}动态拼接示例 - 转义防护：自动HTML/JS转义，避免注入风险
示例：多角色对话模板
const systemPromptTmpl = `你是一名{{.Role}}，请严格遵循以下规则：
- 响应语言：{{.Lang}}
- 输出格式：{{.Format}}
{{if .Examples}}- 参考示例：{{range .Examples}} "{{.}}"{{end}}{{end}}`逻辑分析：模板接收
Role,Lang,Format,Examples四个字段；{{range}}支持动态展开示例列表，{{if}}实现条件分支。参数需为导出字段（首字母大写），否则模板引擎无法访问。
| 字段 | 类型 | 必填 | 说明 |
|---|---|---|---|
| Role | string | 是 | 角色定义（如”SQL专家”） |
| Lang | string | 否 | 默认为”zh” |
| Format | string | 是 | “JSON” / “Markdown”等 |
| Examples | []string | 否 | 示例数组，空则跳过渲染 |
graph TD
A[原始Prompt] --> B[模板解析]
B --> C[参数绑定]
C --> D[安全转义]
D --> E[生成最终Prompt]2.2 多轮对话状态感知与上下文动态注入
多轮对话的核心挑战在于维持一致的语义状态，并在每次响应中精准注入相关上下文。
状态建模与更新机制
采用轻量级 ConversationState 类封装用户意图、槽位值、对话轮次及历史动作：
class ConversationState:
def __init__(self):
self.slots = {} # 当前已填充的槽位（如 {"city": "上海", "date": "明天"}）
self.intent = None # 最近识别的用户意图（如 "query_weather"）
self.turn_id = 0 # 对话轮次计数器，从0开始
self.context_stack = [] # 动态上下文快照栈，用于回溯与分支处理逻辑分析：
context_stack支持在多分支任务（如订票+改签嵌套）中保存中间状态；turn_id驱动时序敏感策略（如超时清槽）；slots采用字典而非固定 schema，适配开放域扩展。
上下文注入策略对比
| 注入方式 | 延迟 | 内存开销 | 适用场景 |
|---|---|---|---|
| 全量拼接历史 | 高 | O(n) | 短对话、强依赖上下文 |
| 槽位摘要 + 最近2轮 | 低 | O(1) | 大多数任务型对话 |
| 向量检索增强 | 中 | O(log n) | 开放域、跨话题连续交互 |
动态注入流程
graph TD
A[新用户输入] --> B{意图识别}
B --> C[更新 slots & intent]
C --> D[基于 turn_id 触发槽校验]
D --> E[从 context_stack 提取关联片段]
E --> F[拼接为结构化 prompt 片段]2.3 基于AST的Prompt结构校验与安全沙箱机制
传统正则匹配无法识别嵌套语法与语义边界，易被绕过。本机制将用户输入的Prompt解析为抽象语法树（AST），实现结构化校验与执行隔离。
校验流程
- 提取
{{ }}模板插值节点，验证变量名是否在白名单中 - 拦截
{% exec %}等危险指令节点 - 检查AST深度是否超过阈值（默认5层）
安全沙箱约束
| 约束维度 | 允许行为 | 禁止行为 |
|---|---|---|
| 变量访问 | user.name, context.lang |
__import__, os.system |
| 函数调用 | len(), upper() |
eval(), open() |
def validate_prompt_ast(prompt: str) -> bool:
tree = ast.parse(prompt, mode='exec') # 解析为AST根节点
visitor = SafeNodeVisitor(whitelist=['user', 'context'])
try:
visitor.visit(tree) # 深度优先遍历所有节点
return True
except UnsafeOperationError:
return False逻辑分析：
ast.parse()生成标准Python AST；SafeNodeVisitor继承ast.NodeVisitor，重写visit_Attribute和visit_Call方法，对属性链与函数调用实施白名单校验。参数whitelist限定顶层命名空间，防止任意模块导入。
graph TD
A[原始Prompt字符串] --> B[ast.parse]
B --> C[AST Root Node]
C --> D{遍历每个Node}
D -->|Attribute| E[检查attr链是否在白名单]
D -->|Call| F[拦截危险函数名]
D -->|Constant| G[允许字面量]
E --> H[校验通过？]
F --> H
H -->|Yes| I[进入沙箱执行]
H -->|No| J[拒绝并报错]2.4 面向领域任务的Prompt DSL设计与go-ai-agent v1.2解析器实现
为提升金融风控、智能客服等垂直场景的Prompt可维护性，v1.2引入轻量级Prompt DSL：支持@entity, @task, @constraint三类语义标记。
核心语法结构
@task("fraud_analysis")：绑定领域任务ID，驱动路由至专用LLM编排链@entity(account: string, amount: float)：声明结构化输入契约@constraint("response_format = json_schema")：注入执行约束元数据
解析器关键逻辑
// ParseDSL 解析带注解的Prompt模板
func (p *DSLParser) ParseDSL(raw string) (*PromptSpec, error) {
tokens := tokenize(raw) // 按@符号切分，保留上下文行
spec := &PromptSpec{Body: extractBody(tokens)}
for _, t := range tokens {
if t.Type == Annotation {
p.applyAnnotation(spec, t) // 动态注册task/entity/constraint
}
}
return spec, nil
}tokenize()按空格与换行预切分，applyAnnotation()通过反射将@constraint键值对注入spec.Metadata映射，确保运行时约束可被Executor读取。
DSL能力对比表
| 特性 | v1.1（纯字符串） | v1.2（DSL） |
|---|---|---|
| 输入校验 | 无 | ✅ 基于entity定义 |
| 任务路由精度 | 模糊关键词匹配 | ✅ task ID精确匹配 |
| 约束可插拔性 | 硬编码 | ✅ annotation动态加载 |
graph TD
A[原始Prompt文本] --> B{含@annotation?}
B -->|是| C[DSLParser.tokenize]
B -->|否| D[直通BaseExecutor]
C --> E[applyAnnotation→Metadata]
E --> F[生成PromptSpec]2.5 A/B测试驱动的Prompt性能评估框架（含Latency/Coherence/TaskAccuracy指标）
为科学量化Prompt迭代效果，我们构建轻量级A/B测试闭环：同一请求流量按Hash分流至对照组（Prompt A）与实验组（Prompt B），实时采集三维度指标。
核心评估指标定义
- Latency：端到端P95响应时延（ms），排除重试与超时样本
- Coherence：基于BERTScore-F1的语义连贯性得分（0–1）
- TaskAccuracy：人工校验或规则引擎判定的任务完成正确率（%）
指标采集代码示例
def log_metrics(prompt_id: str, response: str, start_ts: float):
latency_ms = (time.time() - start_ts) * 1000
coherence = bert_score.compute(predictions=[response], references=["valid output"])[ "f1"][0]
task_acc = rule_checker.validate(response) # 返回bool
# 上报至时序数据库
metrics_client.gauge("prompt.latency.p95", latency_ms, tags={"id": prompt_id})逻辑说明：
bert_score.compute使用microsoft/deberta-xlarge-mnli模型计算F1；rule_checker基于正则+关键词白名单判定任务结果有效性；所有指标带prompt_id标签实现多版本隔离追踪。
A/B分流与指标对比视图
| Prompt ID | Latency (ms) | Coherence | TaskAccuracy |
|---|---|---|---|
| v2.1 | 1420 | 0.83 | 87.2% |
| v2.2 | 1380 | 0.86 | 91.5% |
graph TD
A[用户请求] --> B{Hash分流}
B -->|50%| C[Prompt A]
B -->|50%| D[Prompt B]
C --> E[采集Latency/Coherence/TaskAccuracy]
D --> E
E --> F[双样本t检验]
F --> G[自动判定显著提升]第三章：工具调用与外部系统协同
3.1 工具描述协议（Tool Schema）的Go结构体建模与自动注册机制
工具描述协议需在运行时被LLM调用前精准解析，因此采用强类型 Go 结构体建模，并通过 init() 函数实现零配置自动注册。
核心结构体定义
type ToolSchema struct {
Name string `json:"name" required:"true"`
Description string `json:"description"`
Parameters map[string]Param `json:"parameters"`
}
type Param struct {
Type string `json:"type"` // "string", "number", "boolean"
Description string `json:"description,omitempty"`
Required bool `json:"required,omitempty"`
}ToolSchema 映射 OpenAI Tool Calling 规范；Parameters 使用 map[string]Param 支持动态字段，避免冗余嵌套结构。required tag 用于运行时校验。
自动注册流程
graph TD
A[定义 Tool 实现] --> B[包级 init 函数]
B --> C[调用 RegisterTool]
C --> D[存入全局 registry map[string]ToolSchema]注册表管理
| 字段 | 类型 | 说明 |
|---|---|---|
name |
string |
唯一标识，LLM 调用时匹配 |
registry |
map[string]ToolSchema |
并发安全读写，由 sync.RWMutex 保护 |
工具实例通过 func init() 自动注入，消除手动注册遗漏风险。
3.2 异步工具执行管道与超时熔断策略（基于context和errgroup）
核心设计思想
将多个异步工具调用编排为可取消、可超时、可聚合错误的执行流水线，避免单点阻塞拖垮整体响应。
执行管道构建
使用 errgroup.Group 统一管理 goroutine 生命周期，配合 context.WithTimeout 实现熔断：
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
g, ctx := errgroup.WithContext(ctx)
g.Go(func() error { return runValidator(ctx) })
g.Go(func() error { return runEnricher(ctx) })
g.Go(func() error { return runNotifier(ctx) })
err := g.Wait() // 任一失败或超时即返回逻辑分析：
errgroup.WithContext将ctx注入所有子任务；任一子任务调用ctx.Err()（如超时）会触发其余 goroutine 的上下文取消；g.Wait()阻塞至全部完成或首个错误/超时发生。参数ctx是熔断开关，cancel确保资源及时释放。
超时与错误传播对比
| 策略 | 触发条件 | 错误类型 | 可恢复性 |
|---|---|---|---|
context.WithTimeout |
时间阈值到达 | context.DeadlineExceeded |
否 |
errgroup.Wait() |
任一子任务返回非-nil error | 原始 error | 依业务而定 |
熔断状态流转（mermaid）
graph TD
A[启动管道] --> B{所有任务完成？}
B -- 是 --> C[成功返回]
B -- 否 --> D[检查ctx.Err]
D -- DeadlineExceeded --> E[立即熔断，返回超时]
D -- Canceled --> F[主动取消，清理资源]3.3 工具调用链路追踪与可观测性集成（OpenTelemetry + go-ai-agent中间件）
链路注入时机
go-ai-agent 在工具执行前自动注入 span，封装原始调用为 TracedToolCall：
func (m *OTelMiddleware) Handle(next ToolExecutor) ToolExecutor {
return func(ctx context.Context, req ToolRequest) (ToolResponse, error) {
spanName := fmt.Sprintf("tool.%s.execute", req.ToolName)
ctx, span := otel.Tracer("go-ai-agent").Start(ctx, spanName)
defer span.End()
resp, err := next(ctx, req)
if err != nil {
span.RecordError(err)
span.SetStatus(codes.Error, err.Error())
}
return resp, err
}
}此中间件在
ctx中透传 trace ID，并为每个工具调用生成独立 span；span.SetStatus显式标记失败语义，避免仅靠span.End()隐式判定。
上下文传播机制
OpenTelemetry 自动通过 context.Context 携带 trace 和 span 信息，无需手动传递 traceID。
关键属性映射表
| 属性名 | 来源 | 说明 |
|---|---|---|
tool.name |
req.ToolName |
工具标识符 |
llm.request.id |
req.Metadata["llm_id"] |
关联上游 LLM 请求 |
http.status_code |
响应状态码 | 若工具封装 HTTP 调用 |
graph TD
A[LLM Orchestrator] -->|ctx with trace| B(go-ai-agent)
B --> C[OTelMiddleware]
C --> D[ToolExecutor]
D -->|enriched span| E[OTel Collector]
E --> F[Jaeger/Tempo]第四章：Agent状态管理与持久化架构
4.1 状态机驱动的Agent生命周期模型（Init → Plan → Act → Observe → Reflect）
Agent 的行为不是线性脚本，而是由明确状态跃迁约束的闭环系统：
class AgentState(Enum):
INIT = "init" # 加载配置、初始化记忆与工具
PLAN = "plan" # 调用LLM生成多步推理链
ACT = "act" # 执行工具调用（如API、DB查询）
OBSERVE = "observe" # 解析执行结果，过滤噪声
REFLECT = "reflect" # 评估目标达成度，更新长期策略该枚举定义了五种原子状态，state 变量仅允许按 INIT → PLAN → ACT → OBSERVE → REFLECT → PLAN… 循环跃迁，禁止跨跳（如 ACT → REFLECT）。
状态迁移约束规则
- 每次
transition()必须校验前序状态合法性 REFLECT后必须重入PLAN（支持目标自修正）OBSERVE输出需结构化为(success: bool, data: dict, error: str)
典型迁移路径（Mermaid）
graph TD
INIT --> PLAN
PLAN --> ACT
ACT --> OBSERVE
OBSERVE --> REFLECT
REFLECT --> PLAN| 状态 | 触发条件 | 关键输出 |
|---|---|---|
| INIT | Agent 实例化完成 | 初始化记忆快照、工具注册表 |
| REFLECT | OBSERVE 返回 success=True 且目标未达成 |
新规划约束、记忆强化信号 |
4.2 支持事务语义的StateStore抽象层设计（内存/Redis/PostgreSQL多后端统一接口）
StateStore 抽象层通过 TransactionalStateStore 接口统一屏蔽底层差异，要求所有实现支持 ACID 语义的 begin() / commit() / rollback() 生命周期。
核心接口契约
public interface TransactionalStateStore<K, V> {
void begin(); // 启动事务上下文（如 Redis MULTI 或 PG BEGIN）
V get(K key); // 读操作自动加入当前事务快照（PG 使用 SERIALIZABLE 隔离级）
void put(K key, V value); // 写操作暂存于本地缓冲或事务队列
void commit(); // 原子提交：内存→刷盘、Redis EXEC、PG COMMIT
void rollback(); // 清空缓冲或执行 DISCARD/ROLLBACK
}逻辑分析：put() 不直接落库，而是写入事务私有缓冲区；commit() 触发批量提交——内存后端为引用赋值，Redis 后端聚合为 EXEC 命令序列，PostgreSQL 后端则封装为预编译 INSERT ... ON CONFLICT DO UPDATE 批处理。
后端能力对齐表
| 特性 | 内存Store | RedisStore | PostgreSQLStore |
|---|---|---|---|
| 事务原子性 | ✅（线程局部） | ✅（MULTI/EXEC） | ✅（BEGIN/COMMIT） |
| 读已提交隔离 | — | ✅（WATCH+EXEC） | ✅（READ COMMITTED） |
| 持久化保障 | ❌ | ✅（AOF/RDB） | ✅（WAL） |
数据同步机制
graph TD
A[StateStore.begin()] --> B[获取事务ID]
B --> C{后端类型}
C -->|内存| D[ThreadLocal<Map> 缓冲]
C -->|Redis| E[WATCH + MULTI]
C -->|PostgreSQL| F[START TRANSACTION ISOLATION LEVEL SERIALIZABLE]
D & E & F --> G[StateStore.commit()]4.3 基于WAL（Write-Ahead Logging）的Agent会话一致性保障实现
在分布式Agent系统中，会话状态突变易导致跨节点视图不一致。WAL机制将所有会话变更（如user_message、tool_call_result）以原子日志条目形式先持久化至高可用日志服务（如Apache Pulsar或Raft-based LogStore），再异步应用至本地状态机。
WAL日志结构设计
| 字段 | 类型 | 说明 |
|---|---|---|
log_id |
UUID | 全局唯一日志序列号 |
session_id |
String | 关联会话标识 |
op_type |
ENUM | APPEND, UPDATE, COMMIT |
payload |
JSON | 序列化后的状态变更数据 |
日志写入与回放示例
def append_to_wal(session_id: str, op: dict) -> bool:
entry = {
"log_id": str(uuid4()),
"session_id": session_id,
"op_type": "APPEND",
"payload": op,
"timestamp": time.time_ns() # 纳秒级时序锚点
}
return log_client.append(entry) # 同步刷盘+多数派确认该函数确保日志条目在状态更新前完成持久化；timestamp支撑日志重放时的因果序恢复；log_client.append()内部强制同步落盘并等待≥(N/2+1)节点ACK，满足WAL原子性与持久性要求。
状态机同步流程
graph TD
A[Agent接收用户请求] --> B[生成WAL日志条目]
B --> C{日志服务多数派写入成功？}
C -->|Yes| D[应用变更至内存状态机]
C -->|No| E[返回503重试]
D --> F[广播状态摘要至其他Agent]4.4 快照压缩与增量同步：面向长周期Agent的轻量级持久化方案
长周期运行的智能体需在资源受限设备上维持状态一致性，传统全量快照易引发IO风暴与存储膨胀。
增量差异编码机制
采用基于操作日志（OpLog）的Delta编码，仅序列化自上次同步以来的状态变更：
def compute_delta(prev_state: dict, curr_state: dict) -> dict:
# 返回{key: (old_val, new_val)}格式的变更集
delta = {}
for k in set(prev_state.keys()) | set(curr_state.keys()):
if prev_state.get(k) != curr_state.get(k):
delta[k] = (prev_state.get(k), curr_state.get(k))
return delta逻辑分析：该函数以O(n)时间复杂度识别键值差异；prev_state与curr_state为嵌套字典结构，支持任意深度状态树；返回值可直接序列化为紧凑JSON或Protocol Buffers二进制流。
同步策略对比
| 策略 | 带宽开销 | 恢复耗时 | 适用场景 |
|---|---|---|---|
| 全量快照 | 高 | 低 | 状态极小且不频繁更新 |
| 增量+快照基线 | 中 | 中 | 主流长周期Agent |
| 纯OpLog回放 | 极低 | 高 | 审计强一致场景 |
数据同步机制
graph TD
A[Agent运行时] --> B[状态变更触发delta捕获]
B --> C{变更量 > 阈值?}
C -->|是| D[触发压缩快照+清空OpLog]
C -->|否| E[追加至本地OpLog缓冲区]
D & E --> F[定时/事件驱动同步至中心存储]第五章：开源框架go-ai-agent v1.2内核深度解析
go-ai-agent v1.2 是 2024 年 Q2 正式发布的轻量级 AI 代理运行时框架，已在生产环境支撑某跨境物流智能调度系统（日均处理 87 万条运单意图解析请求）。其内核摒弃传统大模型服务封装范式，转而采用“策略驱动的分层执行器”架构，将 LLM 调用、工具编排、状态持久化与错误熔断解耦为可插拔组件。
核心执行循环机制
内核以 Executor.Run(ctx, *Task) 为入口，启动四阶段原子循环：
- 意图归一化：通过内置
IntentNormalizer将原始用户输入（如“查昨天从深圳发往洛杉矶的空运单号”）映射至预定义 Schema（{action: "track", mode: "air", origin: "SZX", dest: "LAX", date_range: "2024-05-14..2024-05-14"}）； - 工具链动态装配：依据 Schema 中
action字段，从注册中心加载TrackTool实例，并注入CargoAPIAdapter和TimezoneAwareCache两个中间件； - 上下文感知重试：当
CargoAPIAdapter返回 HTTP 429 时，自动触发BackoffPolicy（指数退避 + jitter），并同步更新 Redis 中的rate_limit:carrier:ups计数器； - 结构化输出裁剪：调用
OutputSanitizer移除 LLM 响应中冗余的解释性文本，仅保留 JSON Schema 兼容字段（如"tracking_number":"1Z999AA10123456789","status":"in_transit"）。
关键性能优化实测数据
在 AWS c6i.2xlarge（8vCPU/16GB）节点上，对比 v1.1 版本：
| 指标 | v1.1 | v1.2 | 提升 |
|---|---|---|---|
| 平均任务延迟 | 1280ms | 412ms | 67.8% ↓ |
| 内存常驻占用 | 142MB | 69MB | 51.4% ↓ |
| 工具链热加载耗时 | 840ms | 47ms | 94.4% ↓ |
提升源于两项关键变更：一是将 JSON Schema 验证器从 jsonschema-go 替换为自研 fastschema（基于 AST 预编译校验规则）；二是引入 sync.Pool 管理 TaskContext 对象，避免 GC 频繁触发。
// v1.2 中 TaskContext 的内存复用实现片段
var contextPool = sync.Pool{
New: func() interface{} {
return &TaskContext{
Inputs: make(map[string]interface{}, 16),
Outputs: make(map[string]interface{}, 8),
Metadata: make(map[string]string, 4),
}
},
}
func GetTaskContext() *TaskContext {
return contextPool.Get().(*TaskContext)
}
func PutTaskContext(c *TaskContext) {
c.Reset() // 清空 map 内容但保留底层数组
contextPool.Put(c)
}插件化工具注册体系
框架支持零重启热插拔工具，所有工具需实现 ToolInterface 接口。某客户在不中断服务前提下，于凌晨 2:17 动态上线了 CustomsDutyEstimator 工具——该工具集成海关 HS Code 分类 API 与关税计算模型，通过以下命令完成部署：
go-ai-agent plugin install --url https://plugins.example.com/duty-v2.3.so \
--sha256 f3a7e9b2c1d8a4f5e6b7c8d9a0f1e2b3c4d5e6f7a8b9c0d1e2f3a4b5c6d7e8f9a0插件加载后，内核自动解析其 tool.yaml 元信息，将 estimate_duty action 注册至路由表，并同步更新 Prometheus 指标 go_ai_agent_tool_registered_total{tool="estimate_duty"}。
状态持久化双模设计
任务状态默认写入本地 LevelDB（路径 /var/lib/go-ai-agent/state），但在 Kubernetes 环境中可无缝切换至分布式模式：通过配置 --state-backend=redis://redis-svc:6379/2，所有 TaskState 结构体经 gob 编码后存入 Redis Hash，键格式为 task_state:<task_id>，并设置 TTL 为 72h。实际压测中，Redis 模式下 10K 并发任务的状态读取 P99 延迟稳定在 8.3ms。
flowchart LR
A[User Request] --> B{Intent Normalizer}
B --> C[Tool Router]
C --> D[TrackTool]
C --> E[EstimateDutyTool]
D --> F[API Adapter]
E --> F
F --> G[Output Sanitizer]
G --> H[Structured Response]
style A fill:#4CAF50,stroke:#388E3C
style H fill:#2196F3,stroke:#0D47A1