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

2
00:00:02,105 --> 00:00:11,141
前面几集我们把智能体的来龙去脉讲了一遍，这一集开始进入动手的部分，讲第一个也是最经典的一个智能体范式。

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

4
00:00:20,528 --> 00:00:29,387
授权再说一遍，本内容改编自 Datawhale《Hello-Agents》，采用 CC BY-NC-SA 4.0 授权，为二次演绎配音版。

5
00:00:29,387 --> 00:00:36,430
这个范式把推理和行动显式地绑在一起，形成一个思考、行动、观察的循环。

6
00:00:36,430 --> 00:00:41,790
它思路简单，但今天绝大多数智能体框架骨子里都还是它。

7
00:00:41,790 --> 00:00:47,331
这一集我们会把它从原理讲到实现，再讲到它的局限和调试方法。

8
00:00:47,331 --> 00:00:48,942
我们开始。

9
00:00:49,108 --> 00:00:52,844
在它诞生之前，主流方法可以分成两类。

10
00:00:52,844 --> 00:00:56,520
一类是纯思考型，最典型的是思维链。

11
00:00:56,520 --> 00:01:03,791
它能引导模型做复杂的逻辑推理，把大问题拆成一串小步骤，一步步推到答案。

12
00:01:03,791 --> 00:01:09,152
但它的致命伤是没法跟外部世界交互，容易产生事实幻觉。

13
00:01:09,152 --> 00:01:15,714
模型其实是被关在自己的参数壳子里的，再怎么推，也推不出它没见过的事实。

14
00:01:15,714 --> 00:01:24,476
你让它算一道复杂算术，它可能一本正经地给你一个错答案，因为推理过程再严密，输入的事实本身是编的。

15
00:01:24,476 --> 00:01:30,065
另一类是纯行动型，模型直接输出要执行的动作，干脆利落。

16
00:01:30,065 --> 00:01:37,974
但问题是缺少规划和纠错能力，动作发出去，对不对全凭运气，走错了也没有机制把它拉回来。

17
00:01:37,974 --> 00:01:43,647
它不知道自己为什么做这个动作，也不知道做完之后下一步该怎么办。

18
00:01:43,647 --> 00:01:48,959
它的巧妙之处在于，认识到思考和行动是相辅相成的。

19
00:01:48,959 --> 00:01:53,731
思考指导行动，而行动的结果又反过来修正思考。

20
00:01:53,731 --> 00:02:02,253
它通过一种特殊的提示工程来引导模型，让每一步的输出都遵循一个固定的轨迹，于是就有了三步。

21
00:02:02,253 --> 00:02:06,015
第一步是思考，这是智能体的内心独白。

22
00:02:06,015 --> 00:02:12,457
它会分析当前情况、分解任务、制定下一步计划，或者反思上一步的结果。

23
00:02:12,457 --> 00:02:18,911
第二步是行动，这是智能体决定采取的具体动作，通常是调用一个外部工具。

24
00:02:18,911 --> 00:02:24,212
第三步是观察，这是执行行动之后从外部工具返回的结果。

25
00:02:24,212 --> 00:02:36,964
智能体不断重复这个循环，把新的观察结果追加进历史记录，形成一个不断增长的上下文，直到它在思考里认为已经找到了最终答案，然后输出结果。

26
00:02:37,108 --> 00:02:44,894
这个过程形成了一个强大的协同效应，推理让行动更有目的性，行动为推理提供了事实依据。

27
00:02:44,894 --> 00:02:47,741
我们还可以把它讲得更形式化一点。

28
00:02:47,741 --> 00:02:59,375
在每个时间步，智能体的策略，也就是那个大语言模型，会根据初始问题和之前所有步骤的行动与观察历史，来生成当前的思考和行动。

29
00:02:59,375 --> 00:03:04,832
随后环境里的工具会执行这个行动，返回一个新的观察结果。

30
00:03:04,832 --> 00:03:12,801
这个循环不断进行，新的行动与观察对被追加进历史，直到模型在思考里判断任务已经完成。

31
00:03:12,801 --> 00:03:15,842
这种机制特别适合三类场景。

32
00:03:15,842 --> 00:03:27,548
第一类是需要外部知识的任务，比如查询实时信息，天气、新闻、股价，或者搜索专业领域的知识，这些信息每天都在变，写不进模型参数里。

33
00:03:27,548 --> 00:03:42,620
第二类是需要精确计算的任务，把数学问题交给计算器工具，避开模型自己算错的坑，模型擅长理解题意，但不擅长算数，让它只管拆解、把算交给工具，准确率能上一个台阶。

34
00:03:42,620 --> 00:03:56,298
第三类是需要跟接口交互的任务，比如操作数据库、调用某个服务来完成特定功能，这类任务的关键是参数构造和错误处理，正好是模型加工具的组合能搞定的。

35
00:03:56,298 --> 00:04:02,380
举本节设定的那个问题，华为最新的手机是哪一款，它的主要卖点是什么。

36
00:04:02,380 --> 00:04:07,464
这个问题靠模型自己的知识库答不上来，因为它有时效性。

37
00:04:07,464 --> 00:04:15,385
智能体得先意识到自己知识不足，需要上网搜索，然后调用工具，拿到结果再总结成答案。

38
00:04:15,385 --> 00:04:28,005
在一次真实的运行里，智能体清晰地展示了它的思考链条，先承认知识不足要用搜索工具，再根据搜索结果推理总结，两步之内就给出了最终答案。

39
00:04:28,005 --> 00:04:34,856
截止本节内容编写的时候，搜索结果里点名的确实是华为当时最新的旗舰系列。

40
00:04:34,856 --> 00:04:39,892
这充分展示了这个范式在处理时效性问题上的能力。

41
00:04:40,036 --> 00:04:46,764
如果说大语言模型是智能体的大脑，那么工具就是它跟外部世界交互的手和脚。

42
00:04:46,764 --> 00:04:51,859
要让它真正解决问题，就必须具备调用外部工具的能力。

43
00:04:51,859 --> 00:04:55,969
一个良好定义的工具应该包含三个核心要素。

44
00:04:55,969 --> 00:05:01,835
第一是名称，一个简洁、唯一的标识符，供智能体在行动里调用。

45
00:05:01,835 --> 00:05:09,587
第二是描述，一段清晰的自然语言说明，讲清楚这个工具的用途、什么时候该用、输入长什么样。

46
00:05:09,587 --> 00:05:17,592
这是整个机制里最关键的部分，因为大语言模型会依赖这段描述来判断什么时候该用哪个工具。

47
00:05:17,592 --> 00:05:22,616
模型看不到你的代码，它唯一能读到的就是这段描述。

48
00:05:22,616 --> 00:05:27,327
描述写砸了，工具就等于不存在，再好的实现也白搭。

49
00:05:27,327 --> 00:05:32,159
第三是执行逻辑，真正去干活的那个函数或方法。

50
00:05:32,159 --> 00:05:39,034
它接收参数、发起请求、处理异常，最后把结果整理成模型能读懂的样子返回。

51
00:05:39,034 --> 00:05:48,157
这里有个容易忽略的点，执行逻辑要负责把原始返回做清洗和裁剪，别把一大坨冗余信息直接塞回上下文。

52
00:05:48,157 --> 00:05:54,130
拿搜索工具举例，它的作用是接收一个查询字符串，返回搜索结果。

53
00:05:54,130 --> 00:06:10,156
实现上有个小讲究，它会先检查返回里有没有答案摘要框或者知识图谱这类精确信息，如果有就直接返回这些最精确的答案；如果没有，才退而求其次返回前几条常规搜索结果的摘要。

54
00:06:10,156 --> 00:06:15,841
这种智能解析能为模型提供质量更高的信息输入，减少噪声。

55
00:06:15,841 --> 00:06:24,951
当智能体需要多种工具时，比如除了搜索还要计算、还要查数据库，就需要一个统一的管理器来注册和调度。

56
00:06:24,951 --> 00:06:34,326
这个管理器做的事很直白，把工具按名字登记进一张表，行动来了就按名字查表、取函数、执行、拿结果。

57
00:06:34,468 --> 00:06:37,110
接下来我们把零件组装起来。

58
00:06:37,110 --> 00:06:43,430
提示词是整个机制的基石，它为大语言模型提供了行动的操作指令。

59
00:06:43,430 --> 00:06:49,512
模板里需要动态插入可用工具、用户问题，以及中间步骤的交互历史。

60
00:06:49,512 --> 00:06:51,795
具体来说有四个部分。

61
00:06:51,795 --> 00:06:53,887
第一部分是角色定义。

62
00:06:53,887 --> 00:07:00,317
比如你是一个有能力调用外部工具的智能助手，这一句把模型的角色定下来。

63
00:07:00,317 --> 00:07:08,779
别小看这句话，它决定了模型接下来用什么姿态回应你，是主动调用工具，还是直接编一段话糊弄过去。

64
00:07:08,779 --> 00:07:11,038
第二部分是工具清单。

65
00:07:11,038 --> 00:07:17,276
告诉模型它有哪些可用的手脚，也就是把所有工具的名称和描述列给它。

66
00:07:17,276 --> 00:07:22,228
这份清单是动态的，你注册了几个工具，它就看到几个。

67
00:07:22,228 --> 00:07:28,935
控制在十来个以内比较好，太多会让模型挑花眼，也会挤占宝贵的上下文。

68
00:07:28,935 --> 00:07:31,110
第三部分是格式规约。

69
00:07:31,110 --> 00:07:38,911
这是最重要的部分，它强制模型的输出具有结构性，让我们能用代码精确解析它的意图。

70
00:07:38,911 --> 00:07:46,038
思考后面跟什么分隔符，行动后面跟什么分隔符，结束指令长什么样，都要在这里写死。

71
00:07:46,038 --> 00:07:52,480
格式规约是整个机制能跑起来的前提，没有它，后面的解析全是空谈。

72
00:07:52,480 --> 00:07:58,851
第四部分是动态上下文，包括用户的原始问题和不断累积的交互历史。

73
00:07:58,851 --> 00:08:05,557
把历史注进去，模型才能基于完整的上下文做决策，而不是每轮都从零开始。

74
00:08:05,557 --> 00:08:12,396
这一步也是上下文会不断变长的原因，下面讲到局限时我们还会回来谈它。

75
00:08:12,556 --> 00:08:15,715
有了提示词，核心就是一个循环。

76
00:08:15,715 --> 00:08:25,484
它不断地做四件事，格式化提示词，调用模型，执行动作，整合结果，直到任务完成或者达到最大步数限制。

77
00:08:25,484 --> 00:08:29,775
这里有个重要的安全阀，就是最大步数参数。

78
00:08:29,775 --> 00:08:33,790
它防止智能体陷入无限循环把资源耗尽。

79
00:08:33,790 --> 00:08:39,763
你在工程上一定要设这个上限，不然一次失控的调用就能烧掉不少钱。

80
00:08:39,763 --> 00:08:46,698
具体设多少取决于任务复杂度，一般五到十步够用，超过就该怀疑是不是卡住了。

81
00:08:46,698 --> 00:08:52,119
模型返回的是纯文本，我们需要从中精确提取出思考和行动。

82
00:08:52,119 --> 00:08:56,398
这一步靠解析函数完成，通常用正则来做。

83
00:08:56,398 --> 00:09:08,934
一个负责把完整响应拆成思考和行动两大块，另一个负责进一步解析行动字符串，比如从「搜索，华为最新手机」这样的格式里提取出工具名和工具输入。

84
00:09:08,934 --> 00:09:18,585
这里要注意，模型有时候会自作主张多说几句，所以解析一定要容错，宁可多几种匹配模式，也别一不匹配就崩。

85
00:09:18,585 --> 00:09:20,460
然后是工具调用。

86
00:09:20,460 --> 00:09:28,501
代码首先检查是不是结束指令，如果是，流程就收尾，把累积的思考过程整理成最终答案返回。

87
00:09:28,501 --> 00:09:34,607
否则就通过执行管理器拿到对应的工具函数并执行，得到观察结果。

88
00:09:34,607 --> 00:09:45,472
工具找不到、参数不合法、调用超时，这些都要在这一层兜住，把错误包装成一段自然语言回给模型，让它有机会换个说法重试。

89
00:09:45,472 --> 00:09:52,912
最后一步，也是形成闭环的关键，是把行动本身和工具执行后的观察一起加回历史记录。

90
00:09:52,912 --> 00:10:01,278
这样下一轮生成提示词时，智能体就能看到上一步行动的结果，并据此做新一轮的思考和规划。

91
00:10:01,278 --> 00:10:04,306
少了这一步，循环就断了。

92
00:10:04,444 --> 00:10:08,204
讲完实现，我们看看这个范式到底好在哪。

93
00:10:08,204 --> 00:10:10,161
第一，高可解释性。

94
00:10:10,161 --> 00:10:13,322
这是它最大的优点之一，透明。

95
00:10:13,322 --> 00:10:21,507
通过思考链，我们能清楚看到智能体每一步的心路历程，它为什么选这个工具，下一步打算做什么。

96
00:10:21,507 --> 00:10:25,377
这对理解、信任和调试都至关重要。

97
00:10:25,377 --> 00:10:33,045
出了问题你能顺着思考链往回追溯，定位是哪一步想歪了，而不是对着一个黑箱干瞪眼。

98
00:10:33,045 --> 00:10:38,731
在很多要过合规评审的场景里，这份可追溯性本身就是刚需。

99
00:10:38,731 --> 00:10:41,675
第二，动态规划与纠错能力。

100
00:10:41,675 --> 00:10:46,663
跟一次性生成完整计划的范式不同，它是走一步看一步。

101
00:10:46,663 --> 00:10:52,529
它根据每一步从外部世界拿到的观察，动态调整后续的思考和行动。

102
00:10:52,529 --> 00:11:01,411
如果上一步搜索结果不理想，它下一步可以修正搜索词重新尝试；如果工具报错，它能换个参数再来一次。

103
00:11:01,411 --> 00:11:10,317
这比一次性把计划写死要抗造得多，因为真实世界的信息永远是不完整的，你没法在第一步就把所有情况想全。

104
00:11:10,317 --> 00:11:12,745
第三，工具协同能力。

105
00:11:12,745 --> 00:11:18,370
它天然地把大语言模型的推理能力和外部工具的执行能力结合起来。

106
00:11:18,370 --> 00:11:26,074
模型负责运筹帷幄，做规划和推理；工具负责解决具体问题，搜索、计算、读写数据。

107
00:11:26,074 --> 00:11:32,769
两者协同，突破了单一模型在知识时效性、计算准确性上的固有局限。

108
00:11:32,769 --> 00:11:37,264
模型不用知道今天几号，它只要知道该去问谁。

109
00:11:37,420 --> 00:11:40,819
但它的局限也很明确，一共四条。

110
00:11:40,819 --> 00:11:44,002
第一，对模型自身能力的强依赖。

111
00:11:44,002 --> 00:11:47,957
流程成败高度依赖底层模型的综合能力。

112
00:11:47,957 --> 00:12:01,779
如果模型的逻辑推理、指令遵循或者格式化输出能力不足，就很容易在思考环节产生错误规划，或者在行动环节生成不符合格式的指令，导致整个流程中断。

113
00:12:01,779 --> 00:12:04,110
第二，执行效率问题。

114
00:12:04,110 --> 00:12:12,067
由于循序渐进，完成一个任务通常要多次调用模型，每一次都伴随网络延迟和计算成本。

115
00:12:12,067 --> 00:12:18,942
对步骤多的复杂任务，这种串行的思考行动循环会导致较高的总耗时和费用。

116
00:12:18,942 --> 00:12:21,586
第三，提示词的脆弱性。

117
00:12:21,586 --> 00:12:26,971
整个机制的稳定运行建立在一个精心设计的提示词模板上。

118
00:12:26,971 --> 00:12:32,332
模板里任何微小变动甚至用词差异，都可能影响模型行为。

119
00:12:32,332 --> 00:12:39,759
而且并不是所有模型都能持续稳定地遵循预设格式，这增加了实际落地的不确定性。

120
00:12:39,759 --> 00:12:42,584
第四，可能陷入局部最优。

121
00:12:42,584 --> 00:12:46,334
步进式决策意味着缺乏全局长远规划。

122
00:12:46,334 --> 00:12:56,130
它可能因为眼前的观察选了一条看似正确、长远看并非最优的路径，甚至在某些情况下原地打转，反复循环。

123
00:12:56,130 --> 00:12:58,341
那出问题了怎么调试？

124
00:12:58,341 --> 00:13:00,048
给你五条心法。

125
00:13:00,048 --> 00:13:02,896
第一，检查完整的提示词。

126
00:13:02,896 --> 00:13:12,824
在每次调用模型之前，把最终格式化好的、包含所有历史的完整提示词打印出来，这是追溯决策源头最直接的方式。

127
00:13:12,824 --> 00:13:15,288
第二，分析原始输出。

128
00:13:15,288 --> 00:13:26,226
当解析失败时，务必把模型返回的、未经处理的原始文本打印出来，这能帮你判断是模型没遵循格式，还是你的解析逻辑写错了。

129
00:13:26,226 --> 00:13:29,291
第三，验证工具的输入与输出。

130
00:13:29,291 --> 00:13:38,413
检查生成的工具入参是不是工具函数期望的格式，同时确保工具返回的观察格式是智能体能理解和处理的。

131
00:13:38,413 --> 00:13:41,262
第四，调整提示词里的示例。

132
00:13:41,262 --> 00:13:49,820
如果模型频繁出错，可以在提示词里加入一两个完整的成功案例，用示例引导它更好地遵循指令。

133
00:13:49,820 --> 00:13:53,029
第五，尝试不同的模型或参数。

134
00:13:53,029 --> 00:14:00,961
换个能力更强的模型，或者把随机性参数调到零以保证输出确定，有时能直接解决问题。

135
00:14:01,108 --> 00:14:06,142
好，我们把这一集收一下，给你几条能直接带走的判断依据。

136
00:14:06,142 --> 00:14:09,950
第一，记住它要解决的是两条路的偏科。

137
00:14:09,950 --> 00:14:15,515
纯思考没有事实依据，会幻觉；纯行动没有规划，会失控。

138
00:14:15,515 --> 00:14:22,209
把思考和行动显式绑成一个循环，两边互相纠偏，这就是它最核心的洞见。

139
00:14:22,209 --> 00:14:26,140
第二，三步循环是思考、行动、观察。

140
00:14:26,140 --> 00:14:31,440
思考是内心独白，行动是调工具，观察是工具返回的结果。

141
00:14:31,440 --> 00:14:38,532
观察被追加进历史，形成不断增长的上下文，直到模型自己判断任务完成。

142
00:14:38,532 --> 00:14:47,342
第三，工具的三要素是名称、描述、执行逻辑，其中描述最关键，模型靠它决定用不用这个工具。

143
00:14:47,342 --> 00:14:54,721
第四，提示词模板的四个部分是角色定义、工具清单、格式规约、动态上下文。

144
00:14:54,721 --> 00:14:58,315
最大步数是必须留的安全阀，别省。

145
00:14:58,315 --> 00:15:06,681
第五，也是我觉得最实用的一条，上这个范式之前先问自己，我的任务是不是真的需要多步外部交互。

146
00:15:06,681 --> 00:15:15,262
如果一步就能答，别上；如果必须查实时信息、必须精确计算、必须调接口，那它就是最合适的起点。

147
00:15:15,262 --> 00:15:26,068
同时记住它的四条局限，依赖模型能力、串行效率低、提示词脆弱、容易陷入局部最优，提前把最大步数和成本上限设好。

148
00:15:26,068 --> 00:15:28,207
这一集我们就到这里。

149
00:15:28,207 --> 00:15:31,476
下一集我们继续讲另一个经典范式。

150
00:15:31,476 --> 00:15:34,469
感谢你的收听，我们下期见。