1
00:00:00,100 --> 00:00:02,105
你好，欢迎收听。

2
00:00:02,105 --> 00:00:08,064
上一集我们讲了上下文工程的心智模型，知道了上下文是稀缺资源。

3
00:00:08,064 --> 00:00:14,086
这一集往下落一层，讲这套理念在框架里是怎么变成具体组件的。

4
00:00:14,086 --> 00:00:23,473
本内容改编自 Datawhale《Hello-Agents：从零开始构建智能体》，采用 CC BY-NC-SA 4.0 授权，为二次演绎配音版。

5
00:00:23,473 --> 00:00:32,331
授权再说一遍，本内容改编自 Datawhale《Hello-Agents》，采用 CC BY-NC-SA 4.0 授权，为二次演绎配音版。

6
00:00:32,331 --> 00:00:36,069
这一集会讲三个组件和一个实战组合。

7
00:00:36,069 --> 00:00:51,157
上下文构建器负责把信息筛好摆好，笔记工具负责把重要的事存到上下文外面，终端工具负责按需去看文件系统，最后我们看它们怎么拼成一个能连续干活好几天的长程智能体。

8
00:00:51,157 --> 00:00:52,768
我们开始。

9
00:00:52,924 --> 00:00:55,217
先说上下文构建器。

10
00:00:55,217 --> 00:00:59,266
在动手之前，得先明确它要解决什么问题。

11
00:00:59,266 --> 00:01:03,965
一个优秀的上下文管理系统，应该回答四个关键问题。

12
00:01:03,965 --> 00:01:06,105
第一，统一入口。

13
00:01:06,105 --> 00:01:15,408
把获取、选择、结构化、压缩抽象成一条可复用的流水线，减少在每个智能体实现里重复写的模板代码。

14
00:01:15,408 --> 00:01:21,453
有了统一接口，开发者不用在每个智能体里再抄一遍上下文管理逻辑。

15
00:01:21,453 --> 00:01:23,581
第二，稳定形态。

16
00:01:23,581 --> 00:01:29,134
输出固定骨架的上下文模板，方便调试、对照实验和评估。

17
00:01:29,134 --> 00:01:40,744
它采用了分区组织的模板结构，一共六块，分别是角色与行为准则、当前任务、当前状态、检索到的证据、历史对话与记忆、期望输出格式。

18
00:01:40,744 --> 00:01:42,872
第三，预算守护。

19
00:01:42,872 --> 00:01:49,602
在词元预算内尽量保留高价值信息，对超限的上下文提供兜底压缩策略。

20
00:01:49,602 --> 00:01:57,992
这确保即使在信息量巨大的场景下，系统也能稳定运行，而不是直接崩掉或者悄悄丢东西。

21
00:01:57,992 --> 00:02:00,179
第四，最小规则。

22
00:02:00,179 --> 00:02:05,023
不引入来源、优先级这些分类维度，避免复杂度增长。

23
00:02:05,023 --> 00:02:12,583
实践表明，基于相关性和新近性的简单评分机制，在大多数场景下已经足够有效。

24
00:02:12,583 --> 00:02:18,304
这一条我特别认同，很多系统是被自己设计出来的分类维度拖死的。

25
00:02:18,304 --> 00:02:22,415
它的设计理念可以概括成四个字，简单高效。

26
00:02:22,415 --> 00:02:31,177
去掉不必要的复杂性，统一用相关性加新近性的分数来做选择，这符合模块化与可维护性的工程取向。

27
00:02:31,177 --> 00:02:34,314
实现上依赖两个核心数据结构。

28
00:02:34,314 --> 00:02:47,126
第一个是候选信息包，它是系统里信息的基本单元，每个候选信息都会被封装成这样一个包，里面包含内容、时间戳、词元数量和相关性分数等核心属性。

29
00:02:47,126 --> 00:02:51,982
统一的数据结构大大简化了后续的排序和选择逻辑。

30
00:02:51,982 --> 00:02:58,400
第二个是配置对象，它封装了所有可配置的参数，让系统行为可以灵活调整。

31
00:02:58,400 --> 00:03:08,232
其中有个预留比例参数特别值得一提，它确保系统指令这类关键信息始终有足够的空间，不会被其他信息挤占。

32
00:03:08,232 --> 00:03:14,879
这个参数看着小，但它决定了你的角色设定会不会在信息洪流里被冲掉。

33
00:03:15,028 --> 00:03:17,634
核心是一条四步流水线。

34
00:03:17,634 --> 00:03:24,964
它有个缩写，取自四个英文单词的首字母，分别是汇集、选择、结构化、压缩。

35
00:03:24,964 --> 00:03:28,040
我们后面就简称它四步流水线。

36
00:03:28,040 --> 00:03:29,795
先看前两步。

37
00:03:29,795 --> 00:03:34,110
第一步是汇集，从多个来源把候选信息收集起来。

38
00:03:34,110 --> 00:03:40,096
这个阶段的关键在于容错性和灵活性，有三个设计考虑很值得学。

39
00:03:40,096 --> 00:03:41,959
一是容错机制。

40
00:03:41,959 --> 00:03:49,062
每个外部数据源的调用都被异常捕获包起来，确保单个源失败不会影响整体流程。

41
00:03:49,062 --> 00:03:54,531
这一点看着基础，但很多系统就是挂在一个检索源超时上。

42
00:03:54,531 --> 00:03:56,334
二是优先级处理。

43
00:03:56,334 --> 00:04:00,889
系统指令被标记为高优先级，确保始终被保留。

44
00:04:00,889 --> 00:04:06,334
角色和行为准则是定调子的东西，它一旦被挤掉，后面全乱。

45
00:04:06,334 --> 00:04:08,305
三是历史限制。

46
00:04:08,305 --> 00:04:14,158
对话历史只保留最近的几条，避免上下文窗口被历史信息占满。

47
00:04:14,158 --> 00:04:17,764
新鲜的历史有用，陈旧的历史是负担。

48
00:04:17,764 --> 00:04:23,365
第二步是选择，根据相关性和新近性对候选信息评分和排序。

49
00:04:23,365 --> 00:04:28,461
这是整条流水线的核心，直接决定最终上下文的质量。

50
00:04:28,461 --> 00:04:30,180
它有三个要点。

51
00:04:30,180 --> 00:04:36,238
一是评分机制，采用相关性和新近性的加权组合，权重可以配置。

52
00:04:36,238 --> 00:04:43,004
相关性回答「跟当前任务有没有关」，新近性回答「是不是刚发生的」，两个维度缺一不可。

53
00:04:43,004 --> 00:04:50,312
二是贪心算法，按分数从高到低填充，确保在有限预算内选中价值最高的信息。

54
00:04:50,312 --> 00:04:58,353
三是过滤机制，通过最低相关性阈值把低质量信息挡在外面，宁可少放，也别放进噪声。

55
00:04:58,492 --> 00:05:04,259
第三步是结构化，把选中的信息组织成结构化的上下文模板。

56
00:05:04,259 --> 00:05:09,678
这一步把散乱的信息包组织成清晰的分区，好处有三条。

57
00:05:09,678 --> 00:05:15,807
一是可读性，清晰的分区让人类和模型都更容易理解上下文结构。

58
00:05:15,807 --> 00:05:22,634
二是可调试性，问题定位更容易，你能快速识别是哪个区域的信息出了问题。

59
00:05:22,634 --> 00:05:27,286
上下文出毛病的时候，最怕的是你不知道毛病在哪。

60
00:05:27,286 --> 00:05:34,077
三是可扩展性，要加新的信息源，只需创建一个新的分区，不用改整体框架。

61
00:05:34,077 --> 00:05:38,307
第四步是压缩，对超限的上下文做兜底处理。

62
00:05:38,307 --> 00:05:42,093
它的设计体现了一个原则，保持结构完整性。

63
00:05:42,093 --> 00:05:51,420
即使在词元预算很紧张的情况下，也要尽量保留每个分区的关键信息，而不是简单粗暴地把某个区整个砍掉。

64
00:05:51,420 --> 00:05:55,315
这里要提醒一句，压缩是兜底不是常态。

65
00:05:55,315 --> 00:06:01,601
如果你的系统天天在触发压缩，说明前面三步没做好，或者预算设得太紧。

66
00:06:01,601 --> 00:06:06,012
压缩解决的应该是偶发峰值，不是日常水位。

67
00:06:06,172 --> 00:06:10,232
讲完流水线，我们看输出的样子和落地建议。

68
00:06:10,232 --> 00:06:13,391
结构化输出包含所有必要的信息。

69
00:06:13,391 --> 00:06:18,055
角色与行为准则明确了智能体的角色和回答要求。

70
00:06:18,055 --> 00:06:20,903
任务清晰地表达了用户的问题。

71
00:06:20,903 --> 00:06:24,629
证据是从检索系统里拿到的相关知识。

72
00:06:24,629 --> 00:06:28,812
上下文提供对话历史和相关记忆作为背景。

73
00:06:28,812 --> 00:06:31,997
输出则指导模型怎么组织回答。

74
00:06:31,997 --> 00:06:34,954
这六块分区的价值在于稳定。

75
00:06:34,954 --> 00:06:42,838
你每次看到的上下文长得都一样，做对照实验的时候变量就少，评估的时候也知道该看哪一块。

76
00:06:42,838 --> 00:06:46,889
实际应用时有五条最佳实践值得记下来。

77
00:06:46,889 --> 00:06:49,689
第一，动态调整词元预算。

78
00:06:49,689 --> 00:06:56,252
根据任务复杂度动态设定上限，简单任务用小预算，复杂任务增加预算。

79
00:06:56,252 --> 00:06:59,737
一刀切的预算不是太浪费就是不够用。

80
00:06:59,737 --> 00:07:02,285
第二，相关性计算优化。

81
00:07:02,285 --> 00:07:10,182
在生产环境里，把简单的关键词重叠换成向量相似度计算，检索质量会有明显提升。

82
00:07:10,182 --> 00:07:12,430
第三，缓存机制。

83
00:07:12,430 --> 00:07:18,704
对于不变的系统指令和知识库内容，实现缓存，避免每次重复计算。

84
00:07:18,704 --> 00:07:21,047
第四，监控与日志。

85
00:07:21,047 --> 00:07:28,307
记录每次上下文构建的统计信息，比如选中信息数量、词元使用率，便于后续优化。

86
00:07:28,307 --> 00:07:31,456
没有这些数据，你调参就是瞎调。

87
00:07:31,456 --> 00:07:33,451
第五，对照实验。

88
00:07:33,451 --> 00:07:41,516
对于关键参数，比如相关性权重和新近性权重，通过对照实验找最优配置，别拍脑袋。

89
00:07:41,668 --> 00:07:44,682
第二个组件是结构化笔记工具。

90
00:07:44,682 --> 00:07:57,397
它是为长时程任务准备的外部记忆组件，用标记语言文件作为载体，文件头部用一段元数据记录关键信息，正文用来记录状态、结论、阻塞与行动项。

91
00:07:57,397 --> 00:07:59,068
为什么需要它？

92
00:07:59,068 --> 00:08:06,279
前面介绍过的记忆工具主要关注对话式记忆，短期工作记忆、情景记忆和语义记忆。

93
00:08:06,279 --> 00:08:14,128
但对于需要长期追踪、结构化管理的项目式任务，我们需要一种更轻量、更人类友好的记录方式。

94
00:08:14,128 --> 00:08:17,962
笔记工具填补了这个空档，它提供四个特性。

95
00:08:17,962 --> 00:08:25,522
一是结构化记录，标记语言加元数据的组合，既适合机器解析，也方便人类阅读和编辑。

96
00:08:25,522 --> 00:08:30,426
二是版本友好，纯文本格式天然支持版本控制系统。

97
00:08:30,426 --> 00:08:34,368
三是低开销，不需要复杂的数据库操作。

98
00:08:34,368 --> 00:08:40,053
四是灵活分类，通过类型和标签组织笔记，支持多维度检索。

99
00:08:40,053 --> 00:08:42,325
它特别适合三类场景。

100
00:08:42,325 --> 00:08:53,178
第一类是长期项目追踪，智能体协助做一个可能持续几周的代码库重构，笔记可以记录任务状态、阶段结论、阻塞点和下一步行动。

101
00:08:53,178 --> 00:09:01,159
第二类是研究任务管理，记录每篇论文的核心观点、待深入调研的主题、重要的参考资料。

102
00:09:01,159 --> 00:09:08,779
第三类是跟上下文构建器配合，每轮对话前先检索相关笔记，再注入上下文。

103
00:09:08,932 --> 00:09:10,781
存储上有两层。

104
00:09:10,781 --> 00:09:14,817
一是笔记文件，每个笔记是一个独立的文件。

105
00:09:14,817 --> 00:09:27,005
头部元数据机器可解析，支持精确的字段提取和检索；正文人类可读，支持标题、列表这些格式化；文件名就是它的唯一标识，简化管理。

106
00:09:27,005 --> 00:09:32,365
二是索引文件，单独维护一份索引用于快速检索和管理。

107
00:09:32,365 --> 00:09:43,086
它的作用是，不用打开每个文件就能找到要找的笔记；集中管理所有笔记的元数据；还能做完整性校验，检测文件缺失或损坏。

108
00:09:43,086 --> 00:09:52,702
操作上提供七个核心动作，覆盖笔记的完整生命周期，分别是创建、读取、更新、搜索、列出、摘要、删除。

109
00:09:52,702 --> 00:09:54,661
最佳实践有四条。

110
00:09:54,661 --> 00:10:07,966
第一，笔记分类要合理，建议分五类，任务状态记阶段性进展，结论记重要发现，阻塞项记卡住的问题且优先级最高，行动项记下一步计划，参考资料记重要出处。

111
00:10:07,966 --> 00:10:10,454
第二，定期清理和归档。

112
00:10:10,454 --> 00:10:17,702
已解决的阻塞项要转成结论，过时的行动项及时删除或更新，用标签做版本管理。

113
00:10:17,702 --> 00:10:33,546
第三，跟上下文构建器配合时，每轮对话前检索相关笔记，并按笔记类型设置不同的相关性分数，顺序是阻塞项高于行动项、行动项高于结论，同时限制笔记数量避免上下文过载。

114
00:10:33,546 --> 00:10:35,578
第四，人机协作。

115
00:10:35,578 --> 00:10:45,962
笔记是人类可读的格式，支持手动编辑；可以用版本控制系统追踪演化；在关键阶段安排人工审核智能体生成的笔记。

116
00:10:46,108 --> 00:10:58,930
第三个组件是终端工具，它为智能体提供安全的命令行执行能力，支持常用的文件系统和文本处理命令，同时通过多层安全机制确保系统安全。

117
00:10:58,930 --> 00:11:00,551
为什么需要它？

118
00:11:00,551 --> 00:11:09,986
在很多实际场景里，智能体需要即时访问和探索文件系统，看日志、分析代码库结构、检索配置文件。

119
00:11:09,986 --> 00:11:18,688
前面提到的即时上下文理念正好落在这里，智能体不需要预先加载所有文件，而是按需探索和检索。

120
00:11:18,688 --> 00:11:20,791
它体现了三层设计。

121
00:11:20,791 --> 00:11:30,551
第一层是命令白名单，只允许安全的只读命令，完全禁止任何可能修改系统的操作，不在名单上的命令会立即被拒绝。

122
00:11:30,551 --> 00:11:39,277
第二层是工作目录限制，也就是沙箱，它只能访问指定的工作目录及其子目录，够不到系统其他部分。

123
00:11:39,277 --> 00:11:46,380
第三层是超时控制，每个命令都有执行时间限制，防止无限循环或者资源耗尽。

124
00:11:46,380 --> 00:11:52,221
第四层是输出大小限制，限制单次命令的输出量，防止把内存撑爆。

125
00:11:52,221 --> 00:11:57,919
这四层里，白名单和沙箱是保命的，超时和输出限制是保稳的。

126
00:11:57,919 --> 00:12:01,993
少了前两层，你等于把机器的钥匙交了出去。

127
00:12:01,993 --> 00:12:04,193
功能上聚焦两件事。

128
00:12:04,193 --> 00:12:23,559
一是命令执行，关键点有四个，当前目录感知，在正确的目录下执行；错误处理，捕获并合并标准错误，提供完整诊断信息；返回码检查，非零返回码标记为警告；容错设计，超时和异常都妥善处理，不会让智能体崩溃。

129
00:12:23,559 --> 00:12:31,708
二是目录导航，切换目录的命令做了特殊处理，支持智能体在文件系统里做多步骤探索。

130
00:12:31,708 --> 00:12:34,076
它还能跟其他工具协同。

131
00:12:34,076 --> 00:12:42,802
发现的信息可以存进记忆系统，重要发现可以记成结构化笔记，输出也可以直接作为上下文的一部分。

132
00:12:42,940 --> 00:12:47,589
最后看一个把它们拼起来的实战，代码库维护助手。

133
00:12:47,589 --> 00:13:02,743
场景是这样的，我们维护一个中型的网络应用，代码库大约五十个文件，用某个网络框架搭建，涵盖数据模型、业务逻辑、接口等多个模块，同时存在一些技术债务需要逐步清理。

134
00:13:02,743 --> 00:13:15,928
系统采用三层架构，最上层是智能体本体，负责对话和决策；中间层是上下文构建器，负责筛选和组织；下层是笔记工具和终端工具，负责存取和探索。

135
00:13:15,928 --> 00:13:21,638
分层的意义在于，每一层可以独立替换和优化，不会牵一发动全身。

136
00:13:21,638 --> 00:13:25,327
这个场景有三个典型的长程任务挑战。

137
00:13:25,327 --> 00:13:28,957
第一个挑战是信息量超出上下文窗口。

138
00:13:28,957 --> 00:13:34,150
整个代码库可能有数万行代码，不可能一次性塞进上下文。

139
00:13:34,150 --> 00:13:41,541
解决方案是用终端工具做即时、按需的代码探索，只在需要时查看具体文件。

140
00:13:41,541 --> 00:13:44,775
第二个挑战是跨会话的状态管理。

141
00:13:44,775 --> 00:13:49,763
重构任务可能持续数天，需要跨多个会话保持进度。

142
00:13:49,763 --> 00:13:55,977
解决方案是用笔记工具记录阶段性进展、待办事项和关键决策。

143
00:13:55,977 --> 00:13:59,450
第三个挑战是上下文质量与相关性。

144
00:13:59,450 --> 00:14:04,642
每次对话都要回顾相关历史，但又不能被无关信息淹没。

145
00:14:04,642 --> 00:14:11,133
解决方案是用上下文构建器智能筛选和组织，确保高信号密度。

146
00:14:11,133 --> 00:14:14,354
跑起来之后能看到四个关键特性。

147
00:14:14,354 --> 00:14:25,856
一是跨会话连贯性，第一天探索的问题在第二天分析时被自动考虑，第三天规划时能综合前两天的发现，一周后检查时完整历史都还在。

148
00:14:25,856 --> 00:14:34,017
二是智能的上下文管理，自动汇集相关笔记尤其是阻塞项，在词元预算内选最相关的信息。

149
00:14:34,017 --> 00:14:43,501
三是即时的文件系统访问，不需要预先索引整个代码库，可以即时查看具体文件，支持复杂的文本处理。

150
00:14:43,501 --> 00:14:51,746
四是自动化知识管理，发现问题时自动创建阻塞笔记，讨论计划时自动创建行动笔记。

151
00:14:51,746 --> 00:14:56,782
好，我们把这一集收一下，给你几条能直接带走的判断依据。

152
00:14:56,782 --> 00:15:04,594
第一，上下文构建器的四个设计目标是统一入口、稳定形态、预算守护、最小规则。

153
00:15:04,594 --> 00:15:14,174
其中最容易被忽略的是最小规则，别一上来就设计一堆分类维度，相关性和新近性两个维度在大多数场景已经够用。

154
00:15:14,174 --> 00:15:19,438
第二，四步流水线是汇集、选择、结构化、压缩。

155
00:15:19,438 --> 00:15:34,630
汇集要容错、要保证系统指令优先、要限制历史条数；选择靠相关性和新近性加权评分加贪心填充加阈值过滤；结构化输出六块固定分区；压缩只是兜底，保持结构完整。

156
00:15:34,630 --> 00:15:39,258
第三，笔记工具解决的是长时程任务的外部记忆。

157
00:15:39,258 --> 00:15:48,705
标记语言加元数据的格式兼顾机器解析和人类阅读，索引文件负责快速检索，五个分类里阻塞项优先级最高。

158
00:15:48,705 --> 00:15:54,041
第四，终端工具把即时上下文理念落到了文件系统访问上。

159
00:15:54,041 --> 00:16:00,051
四层安全机制缺一不可，白名单和沙箱保命，超时和输出限制保稳。

160
00:16:00,051 --> 00:16:06,397
第五，也是最能指导落地的一条，长程智能体的三个难题各有其解。

161
00:16:06,397 --> 00:16:13,957
信息超窗口用按需探索，跨会话状态用外部笔记，上下文质量用构建器筛选。

162
00:16:13,957 --> 00:16:20,003
先想清楚你的任务卡在哪一条，再决定先上哪个组件，别一次全上。

163
00:16:20,003 --> 00:16:22,142
这一集我们就到这里。

164
00:16:22,142 --> 00:16:24,594
下一集我们继续往下讲。

165
00:16:24,594 --> 00:16:27,587
感谢你的收听，我们下期见。