1
00:00:00,100 --> 00:00:06,432
本内容改编自小山学堂《学 AI 产品，从入门到精通》，为二次演绎配音版。

2
00:00:06,382 --> 00:00:19,062
这一集是全课程的收官，我们要把四个模块串成一条完整的判断链，然后落到一个很硬的验收标准上，你写的那版提示词，能不能连跑五次都还能用。

3
00:00:19,062 --> 00:00:21,442
先说本集解决什么问题。

4
00:00:21,442 --> 00:00:34,158
学到这里，你手上的知识点已经是全课最密的，原理、提示词、智能体、成本、安全，每一块单看都懂，但合在一起容易变成一堆散落的结论。

5
00:00:34,158 --> 00:00:40,853
这一集给你两个东西，一张成本优化的分层图，和一套判断输出稳不稳的方法。

6
00:00:40,853 --> 00:00:43,689
再说为什么产品经理要关心。

7
00:00:43,689 --> 00:00:49,387
因为成本和安全这两件事，最后都要由你来定，而不是由工程来定。

8
00:00:49,387 --> 00:00:53,281
成本不是固定的，是产品设计决策决定的。

9
00:00:53,281 --> 00:01:00,408
安全也不能靠在提示词里写一句不许说就完事，那只是第一道防线，随时可能被绕过。

10
00:01:00,408 --> 00:01:04,134
这两件事推给工程，工程只能替你猜。

11
00:01:04,134 --> 00:01:06,526
还有一层更现实的考虑。

12
00:01:06,526 --> 00:01:11,562
很多人卡在这一步的表现是，我试过了，效果时好时坏。

13
00:01:11,562 --> 00:01:16,478
时好时坏这四个字，通常不是模型的问题，是要求没钉死。

14
00:01:16,478 --> 00:01:20,012
这一集教你怎么把运气从流程里挤出去。

15
00:01:20,012 --> 00:01:22,487
顺带说明这一集的结构。

16
00:01:22,487 --> 00:01:31,129
前半段讲成本和安全这两套分层框架，这部分偏工程，但它决定你的产品能不能长期跑得下去。

17
00:01:31,129 --> 00:01:36,802
后半段讲稳定性的验收方法，这部分偏实操，你今天就可以动手。

18
00:01:36,802 --> 00:01:42,487
两部分的共同点是，都不需要你写代码，但都需要你做决策。

19
00:01:42,630 --> 00:01:48,180
先快速回一遍四个模块，它们不是并列的知识点，而是一条链。

20
00:01:48,130 --> 00:01:50,859
模块一建立认知直觉。

21
00:01:50,859 --> 00:01:53,179
两个核心认知必须记住。

22
00:01:53,179 --> 00:02:03,695
第一，对话不是学习，训练结束后参数就冻结了，你每次对话它不会记住，也不会变聪明，而且它按词元计费，不按提问次数计费。

23
00:02:03,695 --> 00:02:15,042
第二，幻觉是结构性问题，模型做的是预测下一个词元，不是查数据库，知识截止、自信编造、事实混淆这三类只能缓解，不能消灭。

24
00:02:15,042 --> 00:02:22,517
缓解的办法是把真实文档注入上下文，让它看着资料回答，但它并没有学会新知识。

25
00:02:22,517 --> 00:02:25,570
模块二讲提示词怎么写才管用。

26
00:02:25,570 --> 00:02:34,765
系统提示词定义角色、语气、约束，同一个模型，提示词不同，输出天差地别，这是产品差异化的核心杠杆。

27
00:02:34,765 --> 00:02:41,496
给例子比讲道理管用，与其描述要怎么做，不如直接给两三个完整的输入输出示例。

28
00:02:41,496 --> 00:02:46,736
复杂任务加上一句请一步步分析，准确率会明显提升。

29
00:02:46,736 --> 00:02:53,491
这里最常见的误区是以为提示词越短越好，实际上描述越清晰，输出越稳定。

30
00:02:53,491 --> 00:02:56,941
模块三讲它能干什么、要花多少钱。

31
00:02:56,941 --> 00:03:08,167
智能体等于规划加工具加记忆加行动，它不只是聊天，可以调接口、写文件、循环执行，但也会失败、会打转，需要脚手架兜底。

32
00:03:08,167 --> 00:03:16,784
成本这块要特别小心，多轮对话是指数增长的，因为每一轮都要把完整历史带进去，词元越累越多。

33
00:03:16,784 --> 00:03:20,667
十轮对话的成本，可能是第一轮的五到十倍。

34
00:03:20,667 --> 00:03:22,890
模块四讲安全合规。

35
00:03:22,890 --> 00:03:27,566
这是最容易被跳过的一块，也是出事之后最贵的一块。

36
00:03:27,566 --> 00:03:32,145
这四个模块各自有一个高频误区，值得提前免疫。

37
00:03:32,145 --> 00:03:37,650
模块一的误区，是以为它每次对话都在学习进步，越用越聪明。

38
00:03:37,650 --> 00:03:41,424
模块二的误区，是以为提示词越短越好。

39
00:03:41,424 --> 00:03:45,679
模块三的误区，是以为人工智能的成本是固定的。

40
00:03:45,679 --> 00:03:50,318
模块四的误区，是以为提示词里写了不许说就安全了。

41
00:03:50,318 --> 00:03:56,352
四个误区有一个共同点，都是把模型的自觉，当成了产品的保障。

42
00:03:56,500 --> 00:04:02,303
成本优化有一套五层框架，综合使用能降低百分之七十到九十。

43
00:04:02,253 --> 00:04:05,546
这五层从粗到细，逐层往下拧。

44
00:04:05,546 --> 00:04:07,601
第一层是模型路由。

45
00:04:07,601 --> 00:04:14,068
简单任务用轻量模型，比如分类和抽取；复杂推理才上旗舰模型。

46
00:04:14,068 --> 00:04:20,053
这一层能省百分之六十到八十，是收益最大的一层，因为它动的是单价。

47
00:04:20,053 --> 00:04:22,000
第二层是语法层。

48
00:04:22,000 --> 00:04:28,443
精简数据格式，用更省的格式替代更啰嗦的，能省百分之十五到四十。

49
00:04:28,443 --> 00:04:34,176
比如用表格格式替代数组结构，去掉那些只是好看的装饰标记。

50
00:04:34,176 --> 00:04:36,123
第三层是语义层。

51
00:04:36,123 --> 00:04:41,448
动态匹配示例，长文档先压缩，关键信息放在开头或结尾。

52
00:04:41,448 --> 00:04:47,000
这一层能省百分之六十到八十七，原理是让每一颗词元都更有信息量。

53
00:04:47,000 --> 00:04:48,972
第四层是输出层。

54
00:04:48,972 --> 00:04:58,118
负向约束精准截止废话，只输出改动的部分而不是全文重写，再配合一个明确的停止信号及时收尾。

55
00:04:58,118 --> 00:05:00,558
能省百分之二十到五十。

56
00:05:00,558 --> 00:05:02,866
第五层是键值缓存。

57
00:05:02,866 --> 00:05:11,243
固定系统提示词的前缀，让缓存命中率高；反过来，如果前缀每次都变，缓存就永远不命中。

58
00:05:11,243 --> 00:05:14,092
这一层能省百分之三十到六十。

59
00:05:14,092 --> 00:05:24,476
这五层的顺序很重要，先做模型路由，因为它收益最大成本最低；语法层和语义层是中段主力；输出层和缓存层是精细活。

60
00:05:24,476 --> 00:05:29,176
不要一上来就抠字眼，那点收益远不如先把路由做对。

61
00:05:29,176 --> 00:05:34,056
还要提醒一句，这些百分比是量级参考，不是承诺。

62
00:05:34,056 --> 00:05:38,551
真实能省多少，取决于你的任务结构和当前用法。

63
00:05:38,551 --> 00:05:45,438
正确的做法是先做出可观测数据，知道钱具体花在哪一层，再决定先拧哪一层。

64
00:05:45,438 --> 00:05:50,558
没有数据就去抠字眼，是最常见的浪费时间的方式。

65
00:05:50,690 --> 00:05:56,301
缓存这一层值得单独讲，因为它最容易在不知不觉中被破坏。

66
00:05:56,251 --> 00:06:06,275
原理是这样的，如果系统提示词的前缀保持不变，那么这部分的计算结果可以被缓存下来重复用，命中率高，省钱也快。

67
00:06:06,275 --> 00:06:15,926
但如果前缀里塞了一个动态时间戳，比如写了一句现在是几点几分，那么每一次请求的前缀都不一样，缓存就永远不命中。

68
00:06:15,926 --> 00:06:19,868
为什么前缀变了缓存就失效，可以这么理解。

69
00:06:19,868 --> 00:06:27,933
缓存是按前缀匹配来复用的，只要开头那段文字一模一样，中间的计算结果就能直接拿来用。

70
00:06:27,933 --> 00:06:35,662
你往系统提示词里塞一个每分每秒都在变的时间，等于每一次都换了一把新钥匙，锁自然打不开。

71
00:06:35,662 --> 00:06:46,467
所以判断标准很简单，系统提示词里只放那些长期不变的东西，身份、规则、格式要求；会变的信息一律放进用户消息。

72
00:06:46,467 --> 00:06:53,727
正确的做法很朴素，时间信息放进用户消息里，不要放进系统提示词，让缓存持续命中。

73
00:06:53,727 --> 00:06:58,835
就这么一个位置上的差别，能差出百分之三十到六十的成本。

74
00:06:58,835 --> 00:07:01,587
还有一个隐藏的陷阱是图片。

75
00:07:01,587 --> 00:07:06,623
很多人默认图片越清晰越好，但分辨率不等于质量。

76
00:07:06,623 --> 00:07:15,842
粗分类的任务，五百一十二像素就够；做文字识别，一千到两千像素；只有高精度检测才需要四千像素。

77
00:07:15,842 --> 00:07:21,311
按任务匹配分辨率，可以降低百分之六十到九十的图片成本。

78
00:07:21,311 --> 00:07:27,933
这两个例子说明同一件事，成本藏在细节里，而细节是产品设计决定的。

79
00:07:27,933 --> 00:07:34,255
你写的每一句提示词，你选的每一个参数，最后都会出现在账单上。

80
00:07:34,390 --> 00:07:38,150
安全风险里最典型的是提示词注入。

81
00:07:38,100 --> 00:07:46,934
原理很简单，模型看到的是一整条消息，它分不清哪一句是你写的系统指令，哪一句是用户输入的内容。

82
00:07:46,934 --> 00:07:52,499
恶意用户可以用精心构造的输入，让模型去做你不想让它做的事。

83
00:07:52,499 --> 00:07:54,638
常见的攻击有四类。

84
00:07:54,638 --> 00:07:58,809
第一类是越权注入，直接下指令覆盖你的设定。

85
00:07:58,809 --> 00:08:02,607
第二类是角色逃逸，让它忘记自己的身份。

86
00:08:02,607 --> 00:08:07,042
第三类是示例污染，用假的例子带偏它的判断。

87
00:08:07,042 --> 00:08:11,934
第四类是符号注入，用特殊符号截断或伪造结构。

88
00:08:11,934 --> 00:08:15,179
防御要分三层，缺一层就有漏洞。

89
00:08:15,179 --> 00:08:19,205
第一层是输入层，过滤关键词和异常结构。

90
00:08:19,205 --> 00:08:28,196
第二层是提示词层，加角色锁定和约束声明，并且把用户输入用分隔符围起来，让它知道哪一段是不可信的数据。

91
00:08:28,196 --> 00:08:34,674
第三层是输出层，检测有没有泄露系统提示词，有没有输出不该输出的东西。

92
00:08:34,674 --> 00:08:37,162
这里有个必须记住的红线。

93
00:08:37,162 --> 00:08:46,321
合规边界、品牌风险、竞品信息，这些不能靠模型自觉，也不能只在提示词里写一句不许说。

94
00:08:46,321 --> 00:08:49,806
那只是第一道防线，随时可能被绕过。

95
00:08:49,806 --> 00:08:53,881
真正的防线必须在产品层用技术手段拦截。

96
00:08:53,881 --> 00:08:58,544
以为提示词里写了禁止就算安全了，是最危险的误区。

97
00:08:58,544 --> 00:09:02,006
还有一层容易被漏掉，就是审计日志。

98
00:09:02,006 --> 00:09:11,333
前三层拦得住已知的攻击，但拦不住所有未知的情况，所以每一次拦截、每一次异常都要留下记录，事后能追溯。

99
00:09:11,333 --> 00:09:19,722
另外权限分层也是防御的一部分，能不给的权限就不要给，最小权限原则在这里同样成立。

100
00:09:19,870 --> 00:09:23,834
回到开头那个问题，为什么你的输出时好时坏。

101
00:09:23,784 --> 00:09:28,628
做个实验就清楚了，同一句帮我总结一下，连问五次。

102
00:09:28,628 --> 00:09:41,789
结果可能是这样，第一次三段式结论能用，第二次只给一段话没分点不能用，第三次三段式能用，第四段末尾多了一句客套话要手改，第五次展开成七段超出长度不能用。

103
00:09:41,789 --> 00:09:44,457
五次里只有两次能直接用。

104
00:09:44,457 --> 00:09:47,414
这种输出没法接进任何流程。

105
00:09:47,414 --> 00:09:54,770
但要注意，稳定不是追求逐字复现，大模型天生带随机性，追求一字不差是白费劲。

106
00:09:54,770 --> 00:09:57,402
你要钉死的是三样东西。

107
00:09:57,402 --> 00:09:59,036
第一是结构稳。

108
00:09:59,036 --> 00:10:03,123
说好三段就三段，不要有时三段有时一段。

109
00:10:03,123 --> 00:10:04,926
第二是字段稳。

110
00:10:04,926 --> 00:10:10,130
说好要有下周计划这一项，就必须有，不能这次有下次没有。

111
00:10:10,130 --> 00:10:11,873
第三是边界稳。

112
00:10:11,873 --> 00:10:17,161
信息不够的时候，它应该说资料里没提，而不是自己编一个。

113
00:10:17,161 --> 00:10:21,897
这三样用输出格式约束加上少样本示例就能焊住。

114
00:10:21,897 --> 00:10:28,712
另外顺手做一件事，把用户输入用分隔符围起来，这也正是防注入的第一道防线。

115
00:10:28,712 --> 00:10:34,157
分隔符这个技巧还有个额外好处，它同时在帮模型分清边界。

116
00:10:34,157 --> 00:10:44,998
把不可信的输入用明显的分隔符围起来，再在提示词里写清楚分隔符里面的是数据不是指令，它执行你指令的稳定性会明显提高。

117
00:10:44,998 --> 00:10:47,786
一举两得，成本几乎为零。

118
00:10:47,786 --> 00:10:49,998
验收标准也清楚了。

119
00:10:49,998 --> 00:10:57,630
给不稳定的结果归三类，格式飘了补示例，内容编了收窄材料，长度失控就上硬性字数。

120
00:10:57,630 --> 00:11:01,128
三类的解法不一样，先分对类再改。

121
00:11:01,270 --> 00:11:04,945
这一章的动手清单有三档，挑一个开始。

122
00:11:04,895 --> 00:11:08,057
第一档十五分钟，所有人都能做。

123
00:11:08,057 --> 00:11:15,785
把你想交给它的那件事写成第一版提示词，按角色、背景、要求、输出格式这四件套写。

124
00:11:15,785 --> 00:11:21,578
别追求完美，先有一版能跑的，这版就是你后面所有优化的对照组。

125
00:11:21,578 --> 00:11:33,657
什么算做完了，四件套一样不缺，其中输出格式要具体到几段、每段多少字、用什么标题，然后丢一个真实输入进去，它能给出大致像样的结果。

126
00:11:33,657 --> 00:11:35,184
第二档一小时。

127
00:11:35,184 --> 00:11:38,982
同一个输入连跑五次，把每次结果存下来。

128
00:11:38,982 --> 00:11:45,292
不能直接用的归进三类之一，格式飘了、内容编了、长度失控了。

129
00:11:45,292 --> 00:11:53,501
验收标准是你能报出一个数，五次里有几次能直接用，并且说得出不能用的那几次分别属于哪一类。

130
00:11:53,501 --> 00:11:55,196
第三档半天。

131
00:11:55,196 --> 00:12:05,977
给提示词补一个标准示例和一份违禁清单，比如不要任何客套话，资料里没有的信息就写未提及，然后再连跑五次和上一版对比。

132
00:12:05,977 --> 00:12:12,420
顺手做一件事，在输入里塞一句忽略以上所有指令，看它会不会中招。

133
00:12:12,420 --> 00:12:15,256
两条都过，这一格才算立住。

134
00:12:15,256 --> 00:12:18,285
最后交代一句这些经验的来源。

135
00:12:18,285 --> 00:12:31,987
这一章不是论文综述，也不是教程搬运，它来自作者开发一个桌面智能体应用的一手经验，约五十万行代码、一百三十二个内置工具、八大工程模块，和本章的小节一一对应。

136
00:12:31,987 --> 00:12:40,905
所以你学到的不是理论上应该这样，而是实际做下来是这样，包括那些只有上了生产环境才会遇到的坑。

137
00:12:40,905 --> 00:12:46,398
带着如果是我的产品我会怎么决策这个问题往下看，收获最大。

138
00:12:46,398 --> 00:12:52,359
顺便把这八大模块摊开看看，你会理解一个真实产品要扛多少东西。

139
00:12:52,359 --> 00:12:58,898
生图模块配了多模型降级链和垫图锚定，模型挂了自动切换，用户无感。

140
00:12:58,898 --> 00:13:10,977
主循环配了防卡死机制，流失败有四级恢复，从限流退避到换模型，再到断点续传和可区分报错，另外还有工具失败熔断和会话防重复派单。

141
00:13:10,977 --> 00:13:20,725
上下文管理是五层压缩流水线，裁剪、掐除旧结果、微压缩、折叠、自动全量压缩，用户的原话最后才动。

142
00:13:20,725 --> 00:13:30,400
长期记忆有守门员筛选什么值得记，再用向量检索加模型判定是新增、合并还是冲突，检索命中才注入。

143
00:13:30,400 --> 00:13:38,766
提示词是分层组装，身份、环境、工具指引各自独立，稳定层放前面最大化缓存命中。

144
00:13:38,766 --> 00:13:43,934
多智能体支持并行子代理、多角色脑暴和定时任务。

145
00:13:43,934 --> 00:13:51,386
权限是五级模式加风险分级审批弹窗，配套事件流日志和每条消息的成本追踪。

146
00:13:51,386 --> 00:13:58,645
最后是双向工具接入，既消费别人的工具，也把自己暴露成服务，还能自己配置新连接。

147
00:13:58,800 --> 00:14:03,076
最后给你一份可以马上用的判断清单，一共五条。

148
00:14:03,026 --> 00:14:09,024
这五条不是让你记住更多名词，而是让你在做方案的时候有地方可查。

149
00:14:09,024 --> 00:14:18,567
成本、安全、稳定性这三件事都属于上线之后才会暴露的问题，等到那时候再补，代价比现在高一个量级。

150
00:14:18,567 --> 00:14:22,594
第一条，记住对话不是学习，参数是冻结的。

151
00:14:22,594 --> 00:14:25,659
它按词元计费，不按提问次数。

152
00:14:25,659 --> 00:14:36,127
幻觉是结构性的，知识截止、自信编造、事实混淆这三类只能缓解不能消灭，把真实文档注入上下文是主要手段。

153
00:14:36,127 --> 00:14:40,731
第二条，把成本当成设计变量，而不是固定支出。

154
00:14:40,731 --> 00:14:50,466
五层框架从粗到细，模型路由、语法层、语义层、输出层、键值缓存，综合使用能降低百分之七十到九十。

155
00:14:50,466 --> 00:14:53,327
先做模型路由，收益最大。

156
00:14:53,327 --> 00:14:57,365
图片按任务匹配分辨率，别默认越高越好。

157
00:14:57,365 --> 00:15:01,596
第三条，盯紧那些悄悄破坏缓存的细节。

158
00:15:01,596 --> 00:15:06,692
系统提示词要保持固定前缀，时间信息放进用户消息。

159
00:15:06,692 --> 00:15:10,454
前缀每变一次，缓存就永远不会命中。

160
00:15:10,454 --> 00:15:14,793
第四条，安全必须做三层，缺一层就是漏洞。

161
00:15:14,793 --> 00:15:22,221
输入层过滤、提示词层加角色锁定并且用分隔符围住用户输入、输出层检测泄露。

162
00:15:22,221 --> 00:15:30,034
尤其记住，合规边界和品牌风险不能靠在提示词里写一句不许说，那道防线随时会被绕过。

163
00:15:30,034 --> 00:15:33,243
第五条，用五连跑来验收稳定性。

164
00:15:33,243 --> 00:15:38,387
你要钉死的是结构稳、字段稳、边界稳，不是一字不差。

165
00:15:38,387 --> 00:15:46,740
不稳定的结果分成格式飘了、内容编了、长度失控三类，分别补示例、收窄材料、上硬性字数。

166
00:15:46,740 --> 00:15:51,067
这五条的共同点是，把运气从流程里挤出去。

167
00:15:51,067 --> 00:15:56,007
模型天生带随机性，但你的产品不能靠运气上线。