你有没有发现，像 Claude Code 这样的 AI 编程助手，用久了会感觉越来越“懂你”？这背后并不是模型本身在实时进化，而是一套精巧的记忆系统在持续发挥作用。它能自动从每次对话中提取经验，存入持久化记忆，并在后续遇到相似场景时自动调用。
通过对 Claude Code CLI 近 50 万行 TypeScript 源码的深入分析，我提炼出其智能体架构的三大核心机制，并且发现：这套架构完全可以平移到量化交易领域，用于构建一个能实现策略、风控和市场认知全面自我进化的交易智能体。
一、Claude Code 的记忆系统：经验沉淀的核心引擎
1.1 五层记忆结构
Claude Code 的记忆并非简单的聊天记录保存，而是一个分层、分类且可检索的长期记忆系统：
┌─────────────────────────────────────────────────────────────┐
│ 记忆层次结构（优先级从低到高） │
├─────────────────────────────────────────────────────────────┤
│ │
│ Level 1: 托管记忆（Managed Memory） │
│ 位置：/etc/claude-code/CLAUDE.md（企业部署） │
│ 内容：组织级全局指令 │
│ │
│ Level 2: 用户记忆（User Memory） │
│ 位置：~/.claude/CLAUDE.md │
│ 内容：用户全局偏好和习惯 │
│ 示例：“用户能看懂 diff，不需要冗长总结” │
│ │
│ Level 3: 项目记忆（Project Memory） │
│ 位置：CLAUDE.md, .claude/CLAUDE.md, .claude/rules/*.md │
│ 内容：项目特定指令和规范 │
│ 发现：从当前目录向上遍历直到根目录 │
│ │
│ Level 4: 本地记忆（Local Memory） │
│ 位置：CLAUDE.local.md │
│ 内容：私有项目指令（不提交到 Git） │
│ │
│ Level 5: 自动记忆（Auto Memory / Memdir）⭐核心 │
│ 位置：~/.claude/projects/<project>/memory/ │
│ 内容：从会话中自动提取的经验和知识 │
│ 触发：每次查询结束后自动运行提取 │
│ │
└─────────────────────────────────────────────────────────────┘
关键设计：文件按优先级加载，后面的覆盖前面的。这允许用户用本地记忆覆盖项目记忆，用自动记忆覆盖手动设置。
1.2 自动记忆提取：实现“自我进化”
这是最精妙的设计——系统在每次对话结束后，自动使用派生的智能体（forked agent）来提取经验并保存。
// services/extractMemories/extractMemories.ts
/**
* 在每次查询循环结束时运行
* 当模型产生最终响应且无工具调用时触发
*/
async function runExtraction() {
// 1. 检查是否启用自动记忆
if (!isAutoMemoryEnabled()) return
// 2. 检查是否有新的对话内容（超过阈值才提取）
const newMessages = countModelVisibleMessagesSince(
messages,
lastExtractionCursor
)
if (newMessages < EXTRACTION_THRESHOLD) return
// 3. 检查主代理是否已经在写记忆（避免重复）
if (hasMemoryWritesSince(messages, lastExtractionCursor)) {
skipExtraction()
return
}
// 4. 使用 forked agent 运行提取（共享父级 prompt 缓存！）
await runForkedAgent({
prompt: buildExtractCombinedPrompt(messages, existingMemories),
tools: [GlobTool, GrepTool, FileReadTool, FileWriteTool],
sharePromptCache: true, // 关键：不破坏缓存，不增加 token
run_in_background: true, // 后台运行，不阻塞主流程
})
// 5. 更新游标
lastExtractionCursor = latestMessageUuid
}
这个设计的精妙之处：
- 使用
runForkedAgent + sharePromptCache: true，提取记忆不增加额外 token 消耗
- 后台异步运行，不阻塞主流程
- 有去重机制，主代理写入记忆时提取自动跳过
1.3 记忆类型系统：明确定义记忆内容
Claude Code 明确规定了四种记忆类型，以及什么内容不该记：
// memdir/memdir.ts
type MemoryType =
| 'user' // 用户角色、责任、目标、知识
| 'feedback' // 用户反馈的偏好（做什么/不做什么）
| 'project' // 正在进行的项目、目标、截止时间
| 'reference' // 外部资源引用（Linear、Slack、Grafana 等）
// 明确排除的内容（可从当前项目状态派生的）
// - 代码模式、架构、文件路径
// - Git 历史、最近更改
// - 调试解决方案、bug 修复记录
这个设计的关键：记忆只存储无法从当前状态派生的信息，避免冗余。
1.4 记忆格式示例
---
name: feedback_testing
description: 用户对测试的偏好
type: feedback
---
## 规则：集成测试不使用 mock 数据库
**Why**: 上季度 mock 测试通过但生产迁移失败的事故
**How to apply**: 集成测试必须连接真实数据库，单元测试可以用 mock
---
name: user_coding_style
description: 用户编码偏好
type: user
---
- 喜欢简洁的函数命名
- 偏好函数式编程风格
- TypeScript 严格模式
---
name: reference_monitoring
description: 监控系统引用
type: reference
---
- Grafana 看板：grafana.internal/d/api-latency
- 告警 Slack 频道：#api-oncall
- 日志系统：logs.internal/api-service
二、工具调用机制：安全与高效的设计
2.1 统一的工具抽象层
所有工具都用 buildTool() 构建，包含完整的输入验证、权限检查、执行逻辑和 UI 渲染：
// Tool.ts
export const BashTool = buildTool({
name: 'Bash',
description: '执行 Shell 命令',
// Schema 验证
inputSchema: z.object({
command: z.string().describe('要执行的命令'),
timeout: z.number().optional(),
}),
// 权限预检查
async checkPermissions(input, context) {
if (isDangerousCommand(input.command)) {
return { decision: 'require_approval' }
}
return { decision: 'approve' }
},
// 输入验证
async validateInput(input, context) {
if (input.command.includes('rm -rf /')) {
return { result: false, message: '危险命令' }
}
},
// 执行逻辑
async run(input, context) {
return await exec(input.command)
},
// UI 渲染
renderToolUseMessage,
renderToolResultMessage,
})
2.2 工具预过滤：模型看不见禁止的操作
在模型产生调用意图前，系统就过滤掉了被禁止的工具。
// utils/permissions/permissions.ts
/**
* 在发送给模型之前就过滤掉被禁止的工具
* 这样模型看不到这些工具，减少 token 消耗和错误调用
*/
function filterToolsByDenyRules(
tools: Tool[],
permissionContext: ToolPermissionContext,
): Tool[] {
return tools.filter(tool => {
const denyRule = getDenyRuleForTool(permissionContext, tool)
return !denyRule // 有 deny rule 的工具直接移除
})
}
// 在发送给模型之前调用
const visibleTools = filterToolsByDenyRules(allTools, permissionContext)
这个设计的价值：比“调用时再拒绝”更高效，从源头杜绝危险意图。
三、多智能体协作：并行执行的架构秘密
3.1 Forked Agent：共享缓存的并行执行
这是最关键的设计——子智能体共享父级的 prompt 缓存，几乎不增加额外 token 成本：
// utils/forkedAgent.ts
async function runForkedAgent(config: ForkedAgentConfig): Promise<Result> {
// 创建 cacheSafeParams，复用父级的 prompt 缓存
const cacheSafeParams = createCacheSafeParams({
sharePromptCache: true, // 关键！
parentSessionId: parentSessionId,
})
// 运行子智能体
const result = await query({
...config,
...cacheSafeParams, // 使用缓存安全的参数
})
return result
}
function createCacheSafeParams(config): CacheSafeParams {
return {
// 保持 system prompt 一致（用于缓存键计算）
systemPrompt: parentSystemPrompt,
// 保持 tools 列表一致
tools: parentTools,
// 但实际执行时使用子智能体的工具池
effectiveTools: config.tools,
}
}
这个设计的价值：你可以并行启动多个子智能体（例如同时进行研究、风控、回测），token 成本几乎不增加。这种高效的并行处理思想，对于构建复杂的后端 & 架构系统极具启发性。
3.2 隔离模式：安全的试验环境
// worktree 隔离模式
async function createAgentWorktree(agentName: string) {
const branch = `agent/${sanitizeName(agentName)}`
const worktreePath = join(getWorktreesDir(), sanitizeName(agentName))
// 创建 git worktree
await exec('git', ['worktree', 'add', '-b', branch, worktreePath])
return { worktreePath, branch }
}
四、量化交易智能体的自我进化架构
现在，让我们将 Claude Code 的架构迁移到量化交易场景，构建一个能够持续学习和进化的人工智能交易系统。
4.1 量化交易的记忆系统
~/.quant-agent/memory/
├── trading_feedback.md # 交易偏好和教训（feedback 类型）
├── strategy_notes.md # 策略笔记（project 类型）
├── market_observations.md # 市场观察（reference 类型）
├── risk_rules.md # 风控规则（feedback 类型）
├── trade_lessons.md # 交易复盘记录（feedback 类型）
└── user_profile.md # 用户风险偏好（user 类型）
记忆类型映射：
| Claude Code |
量化交易 |
示例 |
user |
用户画像 |
风险承受能力、投资目标 |
feedback |
交易教训 |
“不在财报发布日前开仓” |
project |
策略笔记 |
某策略的参数调优记录 |
reference |
数据源引用 |
Wind API、Bloomberg 终端 |
4.2 自我进化完整架构
┌─────────────────────────────────────────────────────────────┐
│ 量化交易智能体自我进化架构 │
├─────────────────────────────────────────────────────────────┤
│ │
│ 交易决策 ──► 执行 ──► 结果 ──► 提取经验 ──► 写入记忆 │
│ ▲ │ │
│ │ ▼ │
│ │ 下次决策时检索 │
│ │ 相关记忆注入 │
│ └──────────────────────────────────────────┘ │
│ │
│ 三个进化方向： │
│ ┌──────────────┐ ┌──────────────┐ ┌──────────────┐ │
│ │ 策略进化 │ │ 风控进化 │ │ 市场认知进化 │ │
│ │ 从盈利交易 │ │ 从亏损交易 │ │ 从市场观察 │ │
│ │ 提取有效模式 │ │ 提取新规则 │ │ 形成模式识别 │ │
│ └──────────────┘ └──────────────┘ └──────────────┘ │
│ │
└─────────────────────────────────────────────────────────────┘
4.3 策略进化：从盈利交易中学习
// services/extractTradeLessons.ts
/**
* 从盈利交易中提取有效策略模式
*/
async function extractWinningPatterns(
winningTrades: Trade[],
): Promise<void> {
await runForkedAgent({
prompt: `
分析以下盈利交易，提取共同模式：
${JSON.stringify(winningTrades, null, 2)}
请回答：
1. 这些交易有什么共同特征？（入场时机、持仓时间、标的类型）
2. 哪个策略参数最有效？
3. 什么市场环境下表现最好？
4. 应该形成什么可复用的交易规则？
将策略笔记写入 memory/strategy_notes.md
`,
tools: [
GlobTool, // 查找现有策略文件
GrepTool, // 搜索相关策略
FileReadTool, // 读取现有策略
FileWriteTool, // 写入新策略笔记
RunBacktestTool, // 验证策略有效性
],
sharePromptCache: true,
run_in_background: true,
})
}
4.4 风控进化：从亏损交易中学习
// services/extractRiskRules.ts
/**
* 从亏损交易中提取新的风控规则
*/
async function extractRiskRules(
losingTrades: Trade[],
existingRules: RiskRule[],
): Promise<void> {
await runForkedAgent({
prompt: `
分析以下亏损交易，提取应添加的风控规则：
亏损交易：
${JSON.stringify(losingTrades, null, 2)}
现有风控规则：
${JSON.stringify(existingRules, null, 2)}
请回答：
1. 这些亏损是否可以避免？被哪条规则阻止？
2. 需要新增什么风控规则？
3. 现有规则有什么漏洞需要修补？
4. 止损设置是否合理？需要调整什么参数？
将新规则写入 memory/risk_rules.md，格式：
---
type: feedback
name: risk_新规则名称
---
## 规则名称
**Why**: 从哪笔交易中吸取的教训
**触发条件**: 什么情况下触发
**执行动作**: 触发后做什么
**例外情况**: 什么情况下可以豁免
`,
tools: [
GlobTool,
GrepTool,
FileReadTool,
FileWriteTool,
RiskCheckTool, // 验证新规则的有效性
],
sharePromptCache: true,
run_in_background: true,
})
}
4.5 市场认知进化：从观察中学习
// services/extractMarketPatterns.ts
/**
* 从市场观察中提取可复用的模式
*/
async function extractMarketPatterns(
marketData: MarketData[],
newsEvents: NewsEvent[],
priceActions: PriceAction[],
): Promise<void> {
await runForkedAgent({
prompt: `
分析以下市场数据，提取可复用的观察模式：
市场数据：
- 价格行为：${JSON.stringify(priceActions)}
- 新闻事件：${JSON.stringify(newsEvents)}
- 宏观数据：${JSON.stringify(marketData)}
请回答：
1. 什么事件/数据发布后，市场有可预测的反应？
2. 哪些板块/标的之间有稳定的联动关系？
3. 什么技术指标组合在当前市场最有效？
4. 有什么应该记录供未来参考的观察？
将市场观察写入 memory/market_observations.md
`,
tools: [
GlobTool,
GrepTool,
FileReadTool,
FileWriteTool,
GetMarketDataTool,
WebFetchTool, // 获取外部研究
],
sharePromptCache: true,
run_in_background: true,
})
}
4.6 交易工具定义：内置风控预检查
以下是一个带有多层风控检查的买入工具定义，体现了工具预过滤的思想：
// tools/BuyTool.ts
export const BuyTool = buildTool({
name: 'buy',
description: '执行买入操作',
inputSchema: z.object({
symbol: z.string().describe('股票代码'),
quantity: z.number().describe('数量'),
price: z.number().optional().describe('限价，不填为市价单'),
order_type: z.enum(['market', 'limit']),
stop_loss: z.number().optional().describe('止损价'),
take_profit: z.number().optional().describe('止盈价'),
time_in_force: z.enum(['day', 'gtc', 'ioc']).optional(),
}),
// 风控预检查 - 模型调用前即过滤
async checkPermissions(input, context) {
const orderValue = input.quantity * (input.price || currentPrice)
// 检查单笔订单金额
if (orderValue > context.maxOrderValue) {
return { decision: 'require_approval', reason: '超过单笔限额' }
}
// 检查标的是否在白名单
if (!context.allowedSymbols.includes(input.symbol)) {
return { decision: 'deny', reason: '标的不在交易白名单' }
}
// 检查是否在黑名单
if (context.blockedSymbols.includes(input.symbol)) {
return { decision: 'deny', reason: '标的在交易黑名单' }
}
// 检查交易时间
if (!isTradingHour()) {
return { decision: 'deny', reason: '非交易时间' }
}
return { decision: 'approve' }
},
// 更细粒度的业务验证
async validateInput(input, context) {
// 检查仓位限制、集中度、财报黑名单期等...
// ...（具体验证逻辑，此处略，见原始内容）
return { result: true }
},
// 执行交易
async run(input, context) {
// 1. 创建订单
// 2. 提交订单
// 3. 记录日志
// 4. 设置监控
return {
status: 'submitted',
orderId: order.id,
message: `买入 ${input.quantity} 股 ${input.symbol} @ ${input.price || '市价'}`,
}
},
// 人类可读的活动描述
getActivityDescription(input) {
return `买入 ${input.quantity} 股 ${input.symbol}`
},
})
4.7 构建多智能体交易团队
我们可以定义多个专业智能体，分工协作：
- 研究智能体：负责市场研究和数据分析。
- 交易智能体：负责交易决策和执行。
- 风控智能体：负责风险控制和合规审批，拥有一票否决权。
- 回测智能体：在隔离环境中回测和验证新策略。
- 监控智能体：后台持续运行，监控仓位和发送告警。
- 协调器智能体：管理整个团队，分解任务并汇总结果。
4.8 记忆检索：决策时注入相关经验
每次决策前，系统自动检索并注入相关的历史记忆、风控规则和相似交易案例。
async function buildTradingPrompt(
marketSignal: MarketSignal,
): Promise<string> {
// 检索相关记忆
const relevantMemories = await findRelevantMemories({
symbol: marketSignal.symbol,
sector: marketSignal.sector,
signalType: marketSignal.type,
})
// 检索风控规则
const riskRules = await loadRiskRules()
// 检索历史相似交易
const similarTrades = await findSimilarTrades(marketSignal)
return `
当前市场信号：
${JSON.stringify(marketSignal, null, 2)}
相关记忆：
${relevantMemories.map(formatMemory).join('\n')}
当前风控规则：
${riskRules.map(formatRule).join('\n')}
历史相似交易：
${similarTrades.map(formatTrade).join('\n')}
请基于以上信息生成交易决策。
`
}
五、实现路线图与核心架构
5.1 分阶段实现
- 阶段一：基础架构（2周）：搭建记忆系统，定义基础交易工具，实现风控检查。
- 阶段二：进化机制（2周）：实现交易后自动经验提取、模式识别和记忆注入流程。
- 阶段三：多智能体（3周）：定义并实现各专业智能体、协调器及并行执行机制。
- 阶段四：生产部署（1周）：接入实盘API，设置监控告警，进行日志审计和性能优化。
5.2 核心代码仓库结构
quant-agent/
├── src/
│ ├── main.tsx # 主入口
│ ├── tools/ # 各种工具定义
│ ├── agents/ # 各专业智能体定义
│ ├── memory/ # 记忆系统核心
│ ├── services/ # 经纪商、行情、风控服务
│ └── utils/ # Forked Agent、权限检查等工具
├── memory/ # 持久化记忆文件
└── config/ # 风控限制、智能体配置
六、总结与启示
通过对 Claude Code CLI 的源码分析，我们获得了一套构建生产级、可进化智能体的成熟架构范式。这套机制给量化交易智能体带来的核心启示可以总结如下：
| 机制 |
核心价值 |
量化交易应用 |
| 分层记忆 |
经验可积累、可检索 |
交易教训、风控规则持久化 |
| 自动提取 |
无需手动整理，闭环学习 |
交易后自动复盘学习 |
| Fork缓存共享 |
低成本并行 |
并行风控/研究不显著增加成本 |
| 工具预过滤 |
减少错误调用，安全性前置 |
风控规则在模型调用前生效 |
| 智能体隔离 |
安全试验环境 |
策略回测隔离环境 |
| 多智能体协作 |
专业分工，协同增效 |
研究/交易/风控/回测专业分离 |
自我进化的本质
量化交易智能体的自我进化，本质是建立一个感知→决策→执行→结果→提取→记忆→注入的闭环学习系统。每一次循环都让智能体变得更“聪明”、更“可靠”。
关键设计原则：
- 必须自动提取：每次交易后自动运行经验提取任务。
- 必须结构化存储：经验需分类（策略/风控/市场）并持久化。
- 必须检索注入：决策时主动检索并注入相关历史经验。
- 必须低成本：利用 Forked Agent 缓存共享，控制进化成本。
最后的思考
Claude Code 展示了一个生产级 AI 智能体应有的特质：记得住、学得会、靠得住。这正是我们对量化交易智能体的期待：
- 记得住：不重复犯相同的交易错误。
- 学得会：能从每一次盈利和亏损中提炼出规律。
- 靠得住：拥有前置且严密的风控体系，杜绝“乱操作”。
将这套经过大规模实践检验的架构思想，应用于量化交易领域，为我们构建下一代自适应、自进化的交易系统提供了清晰的蓝图和坚实的技术基础。对于希望深入探索智能体系统设计与实现细节的开发者，可以参考 开源实战 板块中的更多项目分析与最佳实践。本文的探讨旨在抛砖引玉，欢迎在技术社区进行更深入的交流。
参考资料
免责声明：本文内容仅供技术学习与研究参考，不构成任何投资建议。量化交易风险极高，入市务必谨慎。
发表于 5 天前
|
查看: 32|
回复: 0
