實際影片長度:17:54.000。原文、繁中、雙語可點擊句子跳轉影片。
0:00.120–0:01.700
zh离开你 谁还把我当小孩教
0:01.700–0:03.520
zh最近国内顶尖高校上海交大
0:03.520–0:06.440
zh在GitHub上开源了一套动手学AI的实操教程
0:06.440–0:08.840
zh这套教程没有任何水分 全是硬核干货
0:08.840–0:12.100
zh完整学下来就能在自己电脑上部署专属于自己的大模型
0:12.100–0:14.260
zh不用依赖外网 隐私安全更有保障
0:14.260–0:16.000
zh该教程由张卓胜教授主导
0:16.000–0:17.940
zh凝聚了多位业内专家的智慧结晶
0:17.940–0:19.220
zh非常适合小白学习
0:19.220–0:20.660
zh从最简单的API调用
0:20.660–0:22.640
zh一步步深入到模型部署与微调
0:22.640–0:24.260
zh甚至连模型安全防御
0:24.260–0:26.320
zh以及自动化智能体开发都交给你了
0:26.320–0:27.440
zh这套教程属于是
0:27.440–0:28.740
zh直接把知识味到你嘴里
0:28.740–0:29.760
zh知道大家懒得去找
0:29.760–0:31.920
zh我已经把配套资源和学习路线整理好了
0:31.920–0:32.700
zh照着学就行
0:32.700–0:34.620
zh留下学习直接暴走
0:34.620–0:36.780
zh劝你别再盲目自学AI开发了
0:36.780–0:38.080
zh看了几百个教程
0:38.080–0:39.680
zh收藏了几十个热门工作流
0:39.680–0:42.000
zh最后自己想做个自动化工具还是跑不通
0:42.000–0:42.440
zh为什么
0:42.440–0:44.360
zh因为大模型这个东西
0:44.360–0:45.420
zh它的思维逻辑
0:45.420–0:47.760
zh跟我们传统的软件开发是完全相反的
0:47.760–0:50.080
zh以前是一加一肯定等于二
0:50.080–0:51.700
zh但现在大模型给你的
0:51.700–0:52.880
zh是一个大体上不错
0:52.880–0:54.800
zh但是偶尔会瞎编的一个概率
0:54.800–0:57.560
zh如果你搞不懂怎么去规避这种不确定性
0:57.560–0:59.620
zh学再多的框架也是在做无用功
0:59.620–1:02.080
zh想要做出一款真正能自动干活
1:02.080–1:03.820
zh甚至能拿去变现的AI产品
1:03.820–1:05.640
zh其实关键就在于四项能力
1:05.640–1:07.640
zh这四项能力也直接决定了
1:07.640–1:09.420
zh你做出来的到底是个不好用的玩具
1:09.420–1:11.380
zh还是能真正落地的商业产品
1:11.380–1:13.680
zh它们分别是任务拆解能力
1:13.680–1:14.780
zh工具调用能力
1:14.780–1:16.260
zh评测和可观测性
1:16.260–1:18.300
zh以及最硬核的生产环境能力
1:18.300–1:20.160
zh接下来我们一个一个讲清楚
1:20.160–1:22.300
zh我们做大模型应用开发
1:22.300–1:23.500
zh接手一个新项目的时候
1:23.500–1:24.940
zh第一件事是要干什么
1:24.940–1:27.180
zh其实不是急着去写代码
1:27.180–1:29.060
zh也不是去挑什么酷炫的框架
1:29.060–1:30.440
zh我们最先要做的
1:30.440–1:32.340
zh就是判断这个业务到底有多复杂
1:32.340–1:34.440
zh然后给它配一个最合适的技术架构
1:34.440–1:36.180
zh你看我们平时做项目
1:36.180–1:37.300
zh最容易犯两个错
1:37.300–1:39.220
zh一种叫做技术降维
1:39.220–1:41.080
zh就是不管业务有多复杂
1:41.080–1:42.780
zh我们都只想用一段prompt解决
1:42.780–1:44.680
zh结果模型疯狂产生幻觉
1:44.680–1:46.940
zh另一种叫做过度设计
1:46.940–1:48.820
zh明明是个很简单的事情
1:48.820–1:50.920
zh非要套一个很繁琐的智能体框架
1:50.920–1:53.800
zh这两种做法在企业里其实都是要踩坑的
1:53.800–1:55.300
zh那为了精准匹配
1:55.300–1:57.720
zh我们一般能把业务复杂度分成了三档
1:57.720–1:59.800
zh第一档是那种低复杂度
1:59.800–2:01.360
zh不需要记住状态的任务
2:01.360–2:03.940
zh比如你想要模型帮你写一封桌报邮件
2:03.940–2:07.580
zh或者让他帮忙看一下这段代码里面有没有拼写错误
2:07.580–2:08.680
zh这种一次性的交互
2:08.680–2:10.540
zh我们直接用Damp Prompt方案就行了
2:10.540–2:12.380
zh这就好比我们在路上问路
2:12.380–2:13.480
zh电铁站怎么走
2:13.480–2:14.840
zh对方给你指个方向
2:14.840–2:15.580
zh这事就结了
2:15.580–2:17.880
zh不需要复杂的逻辑单次解决
2:17.880–2:20.700
zh但是如果我们的任务变复杂了
2:20.700–2:21.460
zh到了第二档
2:21.460–2:23.140
zh我们需要在整个过程中
2:23.140–2:25.260
zh保持很高的一个可控性
2:25.260–2:27.180
zh比如说我们要让模型
2:27.180–2:28.660
zh帮我们审批合同
2:28.660–2:30.820
zh或者去跑一个标准的财务报表
2:30.820–2:32.140
zh这个时候呢
2:32.140–2:33.320
zhDamp Prompt肯定顶不住
2:33.320–2:35.860
zh我们需要使用Workflow工作流方案
2:35.860–2:38.080
zh这就像我们去银行里面办业务
2:38.080–2:41.180
zh先取号填表柜台办理最后签字
2:41.180–2:42.420
zh每一步怎么走
2:42.420–2:43.960
zh节点之间怎么传递信息
2:43.960–2:45.380
zh都是定死的显性的
2:45.380–2:47.420
zh这种流逝的步骤设计
2:47.420–2:49.260
zh最适合用来跑标准的SOP
2:49.260–2:50.840
zh出来的结果非常稳定
2:50.840–2:52.440
zh那再往上走
2:52.440–2:53.220
zh到了第三档
2:53.220–2:54.480
zh就是高复杂度
2:54.480–2:55.380
zh长周期
2:55.380–2:57.380
zh需要多角色分工的混沌任务了
2:57.380–2:59.260
zh比如我们想要大模型
2:59.260–3:00.740
zh去写一个完整的软件模块
3:00.740–3:02.800
zh这个里面设计的需求就太多了
3:02.800–3:05.660
zh我们必须用多智能体协同的方案
3:05.660–3:06.740
zh那在这个架构下
3:06.740–3:07.680
zh我们需要引入
3:07.680–3:09.260
zh人机协同的安全红线
3:09.260–3:11.200
zh比如智能体写完了代码
3:11.200–3:12.780
zh在准备部署上线的那一步
3:12.780–3:13.740
zh必须停下来
3:13.740–3:15.020
zh等待人工审核确认
3:15.020–3:16.360
zh确认过了才能继续
3:16.360–3:17.440
zh同时
3:17.440–3:18.700
zh各个智能体之间
3:18.700–3:20.040
zh还有自己的独立上下文
3:20.040–3:21.620
zh不能够把信息给混在一起
3:21.620–3:23.340
zh不然模型自己就糊涂了
3:23.340–3:25.680
zh那么面对这种高复杂度的
3:25.680–3:26.500
zh多智能体任务
3:26.500–3:27.540
zh我们在工程上
3:27.540–3:28.660
zh到底该怎么去编排
3:28.660–3:29.220
zh怎么设计
3:29.220–3:31.040
zh才能够保证它输出的质量呢
3:31.040–3:32.880
zh其实现在行业里
3:32.880–3:34.080
zh有一个挺成熟的思路
3:34.080–3:35.420
zh是分布循环
3:35.420–3:36.660
zh加上格力子智能体
3:36.660–3:38.240
zh听起来是有点专业
3:38.240–3:39.300
zh我们拆开来聊
3:39.300–3:40.320
zh其实非常简单
3:40.320–3:41.540
zh先说分布循环
3:41.540–3:43.620
zh就是把任务交给模型之后
3:43.620–3:45.200
zh它一上来又直接开始写
3:45.200–3:47.160
zh结果写出来的东西完全不能用
3:47.440–3:49.960
zh所以我们需要在框架上来限制它的行为
3:49.960–3:53.400
zh比如我们可以采用一个探索规划执行的一个循环
3:53.400–3:54.960
zh第一步是探索
3:54.960–3:57.980
zh这能体现去读取相关的文档或者搜索代码库
3:57.980–4:01.140
zh所以在这个阶段我们只给它只读的权限
4:01.140–4:02.600
zh它只能看不能改
4:02.600–4:04.080
zh第二步是规划
4:04.080–4:07.340
zh它根据看懂的信息做一个具体的执行计划
4:07.340–4:09.000
zh那么在计划做好之后
4:09.000–4:10.340
zh我们可以加入人工确认
4:10.340–4:11.480
zh也就是人机协同
4:11.480–4:13.620
zh人类觉得计划可行再放行
4:13.620–4:15.540
zh第三步才是执行
4:15.540–4:16.920
zh他开始去写文件
4:16.920–4:17.680
zh运行命令
4:17.680–4:20.600
zh这个时候他才能拿到完整的操作权限
4:20.600–4:21.480
zh执行完之后
4:21.480–4:22.420
zh如果发现报错了
4:22.420–4:24.480
zh他会自动回到第一步重新探索
4:24.480–4:26.160
zh这样一套循环下来
4:26.160–4:28.140
zh任务就会被框得非常稳
4:28.140–4:29.440
zh那么除了这个循环
4:29.440–4:30.820
zh还有一个更关键的点
4:30.820–4:32.980
zh叫做上下文隔离子智能体
4:32.980–4:36.140
zh你看如果一个智能体要做的事情太多
4:36.140–4:38.420
zh它的上下文里就会塞满各种各样信息
4:38.420–4:40.580
zh这就好比我们自己开一家公司
4:40.580–4:43.140
zh你不能让一个人既当销售又当财务
4:43.140–4:44.540
zh还要当程序员对吧
4:44.540–4:46.240
zh信息一多他肯定会记错
4:46.240–4:48.460
zh所以呢我们要设立岗位
4:48.460–4:50.460
zh比如我们有一个主智能体
4:50.460–4:53.600
zh他手底下呢有三个上下文隔离的子智能体
4:53.600–4:56.180
zh一个专门找资料的搜索智能体
4:56.180–4:57.980
zh一个做计划的规划智能体
4:57.980–4:59.820
zh一个负责写代码的执行智能体
4:59.820–5:00.960
zh最关键的是
5:00.960–5:03.480
zh他们每个人只拥有自己专属的上下文
5:03.480–5:05.440
zh写代码的不知道财务数据
5:05.440–5:07.560
zh找资料的也不需要管代码里的bug
5:07.560–5:12.240
zh他们之间只通过主智能体进行最标准最干净的数据传递
5:12.240–5:14.700
zh通过这种各干各的相互隔离的设计
5:14.700–5:17.520
zh每个子智能体面对的信息量都会极大减少
5:17.520–5:19.400
zh任务被彻底拆干净了
5:19.400–5:20.980
zh模型的准确率自然就上去了
5:20.980–5:23.440
zhOK 聊完了业务怎么拆解
5:23.440–5:25.260
zh接下来我们讲第二个核心能力
5:25.260–5:26.980
zh工具调用的能力
5:26.980–5:29.200
zh其实大模型项目在线上翻车
5:29.200–5:31.820
zh绝大部分问题都不是出在模型不够聪明上
5:31.820–5:33.740
zh而是我们的工具设计出了问题
5:33.740–5:36.340
zh我们很多刚入行做应用开发的朋友
5:36.340–5:39.240
zh在让大模型去修改文件或者运行命令的时候
5:39.240–5:42.180
zh特别喜欢给他一个全能的Mesh工具
5:42.180–5:44.120
zh也就是我们今天常说的命令行
5:44.120–5:46.120
zh大模型想要读文件
5:46.120–5:46.780
zh改代码
5:46.780–5:47.740
zh搜索关键词
5:47.740–5:49.480
zh全都通过这一个命令行
5:49.480–5:50.860
zh去敲各种指令来解决
5:50.860–5:53.760
zh他们觉得这样模型很自由很省事对吧
5:53.760–5:55.760
zh但实际上在工业级开发里
5:55.760–5:57.540
zh这是一个非常危险的反面模式
5:57.540–5:59.100
zh为什么这么说呢
5:59.100–6:00.160
zh你想想
6:00.160–6:02.060
zh如果大模型手里拿的是一个
6:02.060–6:03.800
zh可以为所欲为的万能命令行
6:03.800–6:06.200
zh它能干的事情就太多了
6:06.200–6:07.800
zh一旦它某一次产生了幻觉
6:07.800–6:09.100
zh或者拼错了一个字符
6:09.100–6:10.800
zh就非常容易拼接出一个
6:10.800–6:12.580
zh把系统文件彻底弄坏的错误指令
6:12.580–6:14.380
zh而且作为开发者
6:14.380–6:15.800
zh你怎么去审查它的权限
6:15.800–6:17.400
zh你根本没有办法
6:17.400–6:18.820
zh给它做精细化的安全授权
6:18.820–6:20.840
zh这就像是你给新来的实习生
6:20.840–6:21.980
zh配了一把万能钥匙
6:21.980–6:23.500
zh能拔开公司所有的门
6:23.500–6:25.480
zh这个安全隐患应该是非常大的
6:25.480–6:27.460
zh所以我们更提倡一种
6:27.460–6:28.800
zh单一职责工具模式
6:28.800–6:30.060
zh简单来说
6:30.060–6:31.820
zh就是把这些大而全的命令行
6:31.820–6:34.420
zh拆成一个个只盖一键小式的专业工具
6:34.420–6:36.360
zh读文件的工具就是read
6:36.360–6:38.260
zh改文件的呢就是edit
6:38.260–6:39.960
zh查找关键词的工具是grab
6:39.960–6:41.800
zh写文件的工具呢是write
6:41.800–6:43.560
zh这样设计的好处显而易见
6:43.560–6:46.280
zh每一个工具都有非常严格的参数规范
6:46.280–6:47.040
zh也就是schema
6:47.040–6:48.760
zh大模型在调用的时候
6:48.760–6:49.820
zh边界非常明确
6:49.820–6:52.940
zh而且我们还可以给不同的工具分配独立的权限
6:52.940–6:54.820
zh接口的确定性变高了
6:54.820–6:56.840
zh模型的理解偏差自然就小了
6:56.840–6:59.100
zh那这时候新的问题就来了
6:59.100–7:01.240
zh随着我们的项目越做越大
7:01.240–7:03.200
zh大模型需要用的工具越来越多
7:03.200–7:05.720
zh我们该怎么去管理和扩展这些工具呢
7:05.720–7:09.200
zh另外如果大模型确实需要跑一些像删除文件
7:09.200–7:11.100
zh还有推送代法这些高风险的命令
7:11.100–7:13.400
zh我们又该怎么控制它的安全风险呢
7:13.400–7:15.080
zh在实际工程落地中
7:15.080–7:16.760
zh我们一般要遵循两个原则
7:16.760–7:19.320
zh第一个原则叫渐进式工具扩展
7:19.320–7:20.400
zh什么意思呢
7:20.400–7:21.620
zh就是我们一开始
7:21.620–7:24.380
zh千万别一上来就把几十个上百个工具
7:24.380–7:25.460
zh全都喂给大木型
7:25.460–7:26.920
zh工具给的太多
7:26.920–7:28.240
zh大木型在做选择的时候
7:28.240–7:29.300
zh非常容易挑花眼
7:29.300–7:30.360
zh最后选错工具
7:30.360–7:32.000
zh刚开始的时候
7:32.000–7:33.560
zh我们本地只给他提供
7:33.560–7:35.480
zh一二十个最常用最基础的工具
7:35.480–7:37.900
zh像读写修改就完全够了
7:37.900–7:40.880
zh如果后面我们发现需要接入一些外部系统
7:40.880–7:42.400
zh比如要读公司的数据库
7:42.400–7:44.180
zh要调用外部的第三方服务
7:44.180–7:45.960
zh那我们再加上MCP
7:45.960–7:47.620
zh也就是模型上下文协议
7:47.620–7:50.180
zh标准化的把这些外部工具给加载进来
7:50.180–7:53.440
zh如果再往后需要调用远程云端的主机
7:53.440–7:54.300
zh或远程的数据库
7:54.300–7:55.920
zh我们再介入远程工具
7:55.920–7:57.980
zh一步一步按需加载
7:57.980–8:00.440
zh这样模型的工具调用准确率才不会崩
8:00.440–8:02.140
zh那么第二个原则
8:02.140–8:04.440
zh是必须在底层建立一个安全杀箱
8:04.440–8:06.140
zh做好命令的风险分级
8:06.783–8:08.743
zh大模型它毕竟是模型
8:08.743–8:10.163
zh它有时候可能会失控
8:10.163–8:13.203
zh所以我们必须给它调用的所有命令定下规则
8:13.203–8:14.343
zh分出安全等级
8:14.343–8:17.443
zh比如像跑个测试或者看一下文件差异
8:17.443–8:19.343
zh这些完全是安全的命令
8:19.343–8:20.863
zh我们可以设置为自动执行
8:20.863–8:22.083
zh不需要打扰用户
8:22.083–8:24.983
zh但如果是像强推代码这样的操作
8:24.983–8:26.263
zh这就有一定的风险了
8:26.263–8:27.923
zh系统在跑这个命令之前
8:27.923–8:29.183
zh必须暂停下来
8:29.183–8:30.643
zh弹出来要用户确认一下
8:30.643–8:32.483
zh必须等我们人肉确认了
8:32.483–8:33.103
zh他才能跑
8:33.103–8:34.763
zh而如果是像这种
8:34.763–8:36.383
zh会煽光系统的毁灭性指令
8:36.383–8:38.183
zh不用问我们在沙箱底层
8:38.183–8:39.403
zh直接硬变码彻底拉黑
8:39.403–8:40.883
zh不给他任何运行的机会
8:40.883–8:43.163
zh你看我们只有在底层
8:43.163–8:45.403
zh把这一套分级拦截的沙箱机制打好了
8:45.403–8:47.423
zh才能真正放心的把工具
8:47.423–8:48.923
zh交到大模型手里去跑对吧
8:48.923–8:52.043
zh那接下来我们讲第三个很容易被忽略
8:52.043–8:54.843
zh但是却决定了项目能不能真正交付的能力
8:54.843–8:56.263
zh评测和可观测性
8:56.263–8:58.523
zh平时我们自己调模型的时候
8:58.523–8:59.343
zh经常会想
8:59.343–9:01.963
zh我测了几次感觉效果还挺不错的
9:01.963–9:04.783
zh但是企业级最怕的就是感觉这两个字
9:04.783–9:07.383
zh你改了一个prompt或者换了一个模型
9:07.383–9:08.483
zh你感觉变好了
9:08.483–9:10.763
zh但可能在某个你没测到的业务角落
9:10.763–9:11.643
zh它其实退化了
9:11.643–9:13.803
zh这在工程上叫做静默退化
9:13.803–9:15.903
zh你根本不知道它什么时候
9:15.903–9:17.243
zh在什么地方变差了
9:17.243–9:19.803
zh所以我们必须告别主观体感
9:19.803–9:22.303
zh建立一套体系化的量化评测流程
9:22.303–9:23.963
zh这就像去医院体检
9:23.963–9:26.123
zh不能只靠医生问你感觉怎么样
9:26.123–9:27.543
zh而是要抽血化验
9:27.543–9:28.883
zh看各项指标的数值
9:28.883–9:30.363
zh具体在开发里
9:30.363–9:31.523
zh这个流程分为三步
9:31.523–9:34.343
zh第一步我们要构建一个黄金数据集
9:34.343–9:36.783
zh这个数据集要覆盖我们最核心
9:36.783–9:37.983
zh最真实的业务场景
9:37.983–9:41.443
zh比如包含50个或者100个经典的客户提问
9:41.443–9:42.403
zh和对应的标准答案
9:42.403–9:44.163
zh这就是我们的考试试卷
9:44.163–9:45.923
zh第二步有了试卷
9:45.923–9:48.543
zh我们得找个客观的乐卷老师来自动进行打分
9:48.543–9:51.003
zh我们一般会引入一个强推力模型
9:51.003–9:52.523
zh让大模型当裁判
9:52.523–9:54.203
zh也就是业内常说的
9:54.203–9:55.523
enLM as a judge
9:55.523–9:57.583
zh这样每次我们改的代码
9:57.583–9:58.963
zh直接自动化跑一遍考试
9:58.963–10:00.943
zh摆脱人工人肉测试的低效
10:00.943–10:03.283
zh那第三步看成绩单
10:03.283–10:05.623
zh这个成绩单不能只有一个总分
10:05.623–10:07.923
zh而是要有一个多维度的指标体系
10:07.923–10:10.423
zh比如我们要看幻觉率有没有上升
10:10.423–10:12.763
zh模型给出的答案跟问题相不相关
10:12.763–10:14.783
zh检索知识库的召回率高不高
10:14.783–10:17.563
zh还有最实际的响应耗时有没有变慢
10:17.563–10:19.543
zh通过这样的一套闭环评测
10:19.543–10:21.023
zh我们每次迭代升级
10:21.023–10:22.243
zh心里才是有底的对吧
10:22.243–10:24.023
zh有了这一套评测流程
10:24.023–10:26.363
zh只能说明我们的应用在模拟考试的时候
10:26.363–10:27.143
zh表现还不错
10:27.143–10:29.123
zh但如果项目真的上线了
10:29.123–10:30.963
zh用户在使用过程中遇到了爆错
10:30.963–10:32.663
zh或者突然输出了一堆乱码
10:32.663–10:33.783
zh我们该怎么排查呢
10:33.783–10:35.483
zh很多项目上线之后
10:35.483–10:36.283
zh一旦爆错了
10:36.283–10:37.183
zh开发者就懵了
10:37.183–10:39.423
zh因为大模型应用就像个黑盒
10:39.423–10:41.543
zh你根本不知道中间哪一步出了问题
10:41.543–10:44.943
zh所以我们必须要做全链路可观测性设计
10:44.943–10:47.123
zh每次推理每次工具调用
10:47.123–10:49.743
zh它的整个生命周期都必须被完整的记录下来
10:49.743–10:51.583
zh首先在输入阶段
10:51.583–10:55.463
zh我们要捕获最原始的prompt和系统当时的状态
10:55.463–10:56.863
zh接着在推理中间菜
10:56.863–10:58.563
zh我们要监控模型的思维链
10:58.563–11:00.283
zh看它是怎么一步步思考
11:00.283–11:02.163
zh同时记录它消耗了多少token
11:02.163–11:03.903
zh这直接关系到我们的账单成本
11:03.903–11:05.903
zh然后在工具调用阶段
11:05.903–11:07.843
zh大模型传了什么参数
11:07.843–11:09.143
zh调用了什么接口
11:09.143–11:10.743
zh接口响应花了多少时间
11:10.743–11:11.683
zh也要记下来
11:11.683–11:13.283
zh最后在输出阶段
11:13.283–11:14.603
zh如果发生了异常
11:14.603–11:15.843
zh比如说超时了呀
11:15.843–11:16.923
zh或者是格式不对
11:16.923–11:18.983
zh或者触发了我们的服务降级策略
11:18.983–11:20.823
zh系统也要能够精准的捕捉
11:20.823–11:23.303
zh把这些数据完整的记录下来之后
11:23.303–11:24.343
zh最核心的好处
11:24.343–11:25.603
zh就是我们可以进行一次
11:25.603–11:27.383
zh故障复现和回放调试
11:27.383–11:29.623
zh比如线上用户反馈说
11:29.623–11:30.623
zh模型刚才瞎编了
11:30.623–11:31.903
zh我们不需要去猜
11:31.903–11:33.863
zh直接把那次调用的数据给导出来
11:33.863–11:35.283
zh在本地重新跑一遍
11:35.283–11:37.763
zh看看大模型在思维链的哪一步走偏了
11:37.763–11:39.143
zh或者是调工具的时候
11:39.143–11:40.503
zh传哪个参数传错了
11:40.503–11:42.903
zh然后我们就可以精准优化prompt
11:42.903–11:44.883
zh或者加上超时重视
11:44.883–11:46.563
zh格式纠错这样的容错机制
11:46.563–11:49.183
zh这才是真正的工程化调试思维
11:49.183–11:50.163
zh
11:50.163–11:52.163
zh有了这个评测和可观测性
11:52.163–11:53.783
zh我们的应用在开发阶段
11:53.783–11:55.083
zh已经看起来很健康了
11:55.083–11:57.543
zh但是如果要真正推上线上
11:57.543–11:59.303
zh交给成千上万的用户去用
11:59.303–12:01.343
zh这就到了最拉开差距的地方
12:01.343–12:02.863
zh我们的第四个核心能力
12:02.863–12:04.063
zh生产环境能力
12:04.063–12:06.463
zh生产环境里有一个非常实际的痛点
12:06.463–12:07.923
zh就是模型特别健忘
12:07.923–12:09.483
zh而且绘画越长
12:09.483–12:10.563
zh上下文塞的越满
12:10.563–12:12.343
zh不仅模型响应变得越来越慢
12:12.343–12:14.843
zh公司的token资费也会像流水一样花出去
12:14.843–12:17.623
zh我们不能指望用户每次跟智能体聊天
12:17.623–12:19.423
zh都把项目规则和历史对话
12:19.423–12:20.503
zh复制粘贴一遍吧
12:20.503–12:22.843
zh所以在生产及状态管理里
12:22.843–12:24.363
zh我们首先要在代码库里
12:24.363–12:26.103
zh放一个持久化的配置指令文件
12:26.103–12:27.723
zh比如说cloud.md
12:27.723–12:30.203
zh这个文件是随我们的代码库
12:30.203–12:31.323
zh一起做版本控制的
12:31.323–12:32.863
zh当绘画启动时
12:32.863–12:34.763
zh系统会自动把项目级的规范
12:34.763–12:36.743
zh测试命令自动加载进去
12:36.743–12:37.583
zh模型一上线
12:37.583–12:39.523
zh立刻就知道自己身处什么项目
12:39.523–12:40.743
zh需要遵守什么规则
12:40.743–12:42.303
zh总进一步呢
12:42.303–12:44.183
zh我们要建立一个分层记忆机制
12:44.183–12:46.443
zh对对上计算机有缓存
12:46.443–12:47.103
zh有内存
12:47.103–12:47.663
zh有硬盘
12:47.663–12:50.743
zh第一层是永远加载的核心索引
12:50.743–12:53.423
zh这部分一般控制在200行以内
12:53.423–12:54.863
zh保持极低的响应延迟
12:54.863–12:58.983
zh然后第二层是按需加载的相关文档和当前状态
12:58.983–13:01.683
zh比如模型当前要修改某个代码文件
13:01.683–13:05.183
zh我们就只要把这个文件和当前的锻点状态加载进来
13:05.183–13:06.783
zh这里非常重要的一点
13:06.783–13:08.023
zh是支持断点恢复
13:08.023–13:09.683
zh万一服务中断了
13:09.683–13:10.823
zh智能体重启之后
13:10.823–13:11.903
zh能接着上次的进度干
13:11.903–13:12.763
zh不用从头跑
13:12.763–13:14.303
zh那第三层
13:14.303–13:16.043
zh则是只支持检索的
13:16.043–13:17.223
zh完整历史对话转录
13:17.223–13:18.823
zh不用到的历史记录
13:18.823–13:19.663
zh全部打包归档
13:19.663–13:21.343
zh只有需要的时候才去搜索
13:21.343–13:22.743
zh通过这种分层
13:22.743–13:24.563
zh我们既能处理长周期的任务
13:24.563–13:26.723
zh又能帮公司省下一大笔的投肯开销
13:26.723–13:29.043
zh不过有了分层记忆
13:29.043–13:30.923
zh如果用户一直跟智能体聊下去
13:30.923–13:32.103
zh聊了上百轮
13:32.103–13:33.583
zh当前的绘画窗口
13:33.583–13:35.283
zh还是会面临一个爆满的风险
13:35.283–13:38.183
zh这时候我们要怎么防止上下纹爆掉呢
13:38.183–13:41.403
zh其实智能体在这一方面和我们人类很像
13:41.403–13:44.163
zh人总不能一直不睡觉拼命公渡对吧
13:44.163–13:46.623
zh所以我们可以给智能体引入一个
13:46.623–13:47.963
zh记忆睡眠巩固机制
13:47.963–13:50.643
zh在系统空闲的时候默默运行
13:50.643–13:52.703
zh我们可以让一个后台智能体
13:52.703–13:54.263
zh在用户不说话的闲时
13:54.263–13:56.063
zh去帮我们整理零段的上下纹
13:56.063–13:59.643
zh它会自动把过期的冲突的事实给修剪掉
13:59.643–14:02.423
zh去虫之后合并成一个干净的核心索引
14:02.423–14:04.563
zh这就像我们睡觉做梦的时候
14:04.563–14:06.383
zh大脑会自动整理白天的记忆
14:06.383–14:07.583
zh丢弃无用信息一样
14:07.583–14:09.583
zh这是一种应用的自我进化
14:09.583–14:11.603
zh同时在绘画进行中
14:11.603–14:13.863
zh我们还要配合渐进式上下文压缩
14:13.863–14:15.883
zh随着对话轮次的增加
14:15.883–14:18.483
zh我们不是粗暴的直接截掉前面的对话
14:18.483–14:21.163
zh而是施加不同强度的压缩
14:21.163–14:23.183
zh近期对话保留最详细的明气
14:23.183–14:25.203
zh中期对话做轻度总结
14:25.203–14:27.663
zh而远期对话则进行一个极限折叠
14:27.663–14:29.263
zh这样层层递进
14:29.263–14:30.903
zh既保证了模型不会失忆
14:30.903–14:33.443
zh又彻底解决了上下文窗口爆棚的问题
14:33.443–14:34.663
enOK
14:34.663–14:36.063
zh在生产环境里
14:36.063–14:36.963
zh除了记忆管理
14:36.963–14:38.303
zh我们还要解决两个问题
14:38.303–14:40.063
zh一个是系统的安全合规
14:40.063–14:42.243
zh另一个是高昂的API障碍成本
14:42.243–14:43.763
zh首先是系统安全
14:43.763–14:46.283
zh我们不能全指望prompt去叮嘱大模型
14:46.283–14:47.183
zh你不要违规
14:47.183–14:48.383
zh格式千万要写对
14:48.383–14:50.483
zh因为模型总有遗忘的时候
14:50.483–14:51.743
zh我们的原则是
14:51.743–14:53.807
zh必须把硬逻辑剥离到prompt
14:54.807–14:56.367
zh用一个确定性的生命周期钩子。
14:57.027–14:59.007
zh比如,在大模型调用外部工具之前,
14:59.507–15:01.787
zh系统在底层强行的插入一个前置钩子,
15:02.147–15:03.407
zh自动降业命令安不安全。
15:04.167–15:05.147
zh工具跑完了之后,
15:05.387–15:07.207
zh我们再强行插入一个后置钩子,
15:07.207–15:09.707
zh自动去跑一次代码格式化和测试
15:09.707–15:10.947
zh从再配置文件
15:10.947–15:14.187
zh这些钩子是在系统底层用代码硬编码的
15:14.187–15:16.067
zh不管大模型怎么产生幻觉
15:16.067–15:18.147
zh这些安全红线它绝对越不过去
15:18.147–15:20.407
zh然后就是商业化成本的控制
15:20.407–15:22.687
zh如果每天接上万个用户请求
15:22.687–15:25.227
zh所有请求都用最贵最强的大模型
15:25.227–15:26.947
zh公司可能很快就撑不住了
15:26.947–15:29.527
zh所以我们要设计一个混合模型路由机制
15:29.527–15:31.667
zh当用户的请求进来的时候
15:31.667–15:33.187
zh先过一个路由节点
15:33.187–15:34.487
zh做动态难度分发
15:34.487–15:37.127
zh如果是写系统架构这种高难度任务
15:37.127–15:39.827
zh路由就把请求分发给大型颗粒模型
15:39.827–15:42.007
zh那如果是问路打招呼
15:42.007–15:44.107
zh或者是简单做一个格式化这种任务
15:44.107–15:46.127
zh路由就自动分流给急速小模型
15:46.127–15:48.187
zh或者直接命中我们的提示词缓存
15:48.187–15:50.947
zh这样既兼顾了系统的高并发响应
15:50.947–15:53.047
zh又帮我们省下了大量的API资费
15:53.047–15:54.867
zh这才是合格的商业级架构
15:54.867–15:57.167
zh而在高频的业务场景里
15:57.167–15:58.967
zh我们最常碰到的落地项目
15:58.967–16:00.227
zh其实还是企业知识库
16:00.227–16:01.547
zh也就是RG系统
16:01.547–16:03.567
zh但是在生产环境里
16:03.567–16:05.787
zh一个合格的RG绝对不是单向的
16:05.787–16:06.907
zh检索完就丢给模型
16:06.907–16:09.267
zh它应该是一个能自我进化的闭环
16:09.267–16:10.647
zh在生产环境里
16:10.647–16:13.087
zh我们要打通混合检索和重排架构
16:13.087–16:15.707
zh形成一个数据沉淀模型反母的飞轮
16:15.707–16:17.387
zh第一步混合检索
16:17.387–16:19.007
zh当用户提出问题的时候
16:19.007–16:21.287
zh我们把向量检索和关键词检索
16:21.287–16:22.387
zh融合在一起
16:22.387–16:24.107
zh保证无论用户怎么提问
16:24.107–16:26.307
zh我们都能精准定位底层的原始文档
16:26.307–16:28.707
zh然后第二步重排提纯
16:28.707–16:31.347
zh搜出来的文档可能有几十个
16:31.347–16:33.107
zh那模型看不完也看不过来
16:33.367–16:35.187
zh我们用专门的重排模型
16:35.187–16:37.047
zh挑选出最精准的几个节点
16:37.047–16:38.307
zh送进大幕型的上下文窗口
16:38.307–16:39.847
zh接下来第三步
16:39.847–16:41.147
zh就是结合业务逻辑
16:41.147–16:42.987
zh生成最终的一个融合输出
16:42.987–16:44.647
zh重点在第四步
16:44.647–16:45.387
zh数据沉淀
16:45.387–16:47.887
zh我们要补获用户的真实反馈
16:47.887–16:49.687
zh记录高频的查询盲区
16:49.687–16:51.227
zh那最后一步
16:51.227–16:52.187
zh反补迭代
16:52.187–16:53.587
zh根据这些反馈
16:53.587–16:54.647
zh自动去更新
16:54.647–16:56.287
zh修正和强化我们的企业知识库
16:56.287–16:58.867
zh那么当这一套流程运转起来之后
16:58.867–17:00.727
zh知识库里的盲区就会越来越少
17:00.727–17:02.347
zh下一轮检索就会更准
17:02.347–17:04.147
zh我们的应用也会越用越聪明
17:04.147–17:05.847
zh好 聊到这里
17:05.847–17:07.647
zh我们基本上把一个工业级的
17:07.647–17:08.847
zh大模型应用开发工程师
17:08.847–17:10.727
zh需要具备的能力全都梳理了一遍
17:10.727–17:12.567
zh但最后我们来做一个复盘
17:12.567–17:14.947
zh其实一个真正合格
17:14.947–17:17.467
zh能够帮企业解决实际大模型落地的工程师
17:17.467–17:20.147
zh它的成长路径其实是非常清晰的
17:20.147–17:21.167
zh在业务架构上
17:21.167–17:23.447
zh我们要从只会写单一prompt
17:23.447–17:25.587
zh升级到能够驾驭多智能体编排
17:25.587–17:27.427
zh在工具与协议上
17:27.427–17:29.907
zh我们要从硬编码施API
17:29.907–17:32.067
zh升级到运用标准的AMCP协议
17:32.067–17:33.347
zh和单一职责工具
17:33.347–17:35.027
zh在生产机状态上
17:35.027–17:37.027
zh我们要从粗暴的内存阶段
17:37.027–17:39.987
zh升级到分层记忆和动态上下纹压缩
17:39.987–17:41.387
zh那在系统级整合上
17:41.387–17:43.067
zh我们要从基础的检索
17:43.067–17:46.027
zh升级到刚才讲的RG飞轮和模型路由
17:46.027–17:48.027
zh然后在质量可观测性上
17:48.027–17:50.307
zh升级到全列路追踪和量化评测
0:00.120–0:01.700
離開你 誰還把我當小孩教
0:01.700–0:03.520
最近國內頂尖高校上海交通大學
0:03.520–0:06.440
在GitHub上開源了一套動手學AI的實操教程
0:06.440–0:08.840
這套教程沒有任何水分 全是硬核乾貨
0:08.840–0:12.100
完整學下來就能在自己電腦上部署專屬於自己的大模型
0:12.100–0:14.260
不用依賴外網 隱私安全更有保障
0:14.260–0:16.000
該教程由張卓勝教授主導
0:16.000–0:17.940
凝聚了多位業內專家的智慧結晶
0:17.940–0:19.220
非常適合小白學習
0:19.220–0:20.660
從最簡單的API呼叫
0:20.660–0:22.640
一步步深入到模型部署與微調
0:22.640–0:24.260
甚至連模型安全防禦
0:24.260–0:26.320
以及自動化智能體開發都交給你了
0:26.320–0:27.440
這套教程屬於是
0:27.440–0:28.740
直接把知識喂到你嘴裡
0:28.740–0:29.760
知道大家懶得去找
0:29.760–0:31.920
我已經把配套資源和學習路線整理好了
0:31.920–0:32.700
照著學就行
0:32.700–0:34.620
留下學習直接暴走
0:34.620–0:36.780
勸你別再盲目自學AI開發了
0:36.780–0:38.080
看了幾百個教程
0:38.080–0:39.680
收藏了幾十個熱門工作流
0:39.680–0:42.000
最後自己想做個自動化工具還是跑不通
0:42.000–0:42.440
為什麼
0:42.440–0:44.360
因為大模型這個東西
0:44.360–0:45.420
它的思維邏輯
0:45.420–0:47.760
跟我們傳統的軟體開發是完全相反的
0:47.760–0:50.080
以前是一加一肯定等於二
0:50.080–0:51.700
但現在大模型給你的
0:51.700–0:52.880
是一個大体上不錯
0:52.880–0:54.800
但是偶爾會瞎編的一個機率
0:54.800–0:57.560
如果你搞不懂怎麼去規避這種不確定性
0:57.560–0:59.620
學再多的框架也是在作無用功
0:59.620–1:02.080
想要做出一款真正能自動幹活
1:02.080–1:03.820
甚至能拿去變現的AI產品
1:03.820–1:05.640
其實關鍵就在於四項能力
1:05.640–1:07.640
這四項能力也直接決定了
1:07.640–1:09.420
你做出來的到底是個不好用的玩具
1:09.420–1:11.380
還是能真正落地的商業產品
1:11.380–1:13.680
它們分別是任務拆解能力
1:13.680–1:14.780
工具呼叫能力
1:14.780–1:16.260
評估與可觀測性
1:16.260–1:18.300
以及最硬核的生產環境能力
1:18.300–1:20.160
接下來我們一個一個講清楚
1:20.160–1:22.300
我們做大模型應用開發
1:22.300–1:23.500
接手新專案的時候
1:23.500–1:24.940
第一件事是要做什麼
1:24.940–1:27.180
其實不是急著去寫程式碼
1:27.180–1:29.060
也不是去挑選什麼酷炫的框架
1:29.060–1:30.440
我們最先要做的
1:30.440–1:32.340
就是判斷這個業務到底有多複雜
1:32.340–1:34.440
然後給它配一個最合適的技術架構
1:34.440–1:36.180
你看我們平時做專案
1:36.180–1:37.300
最容易犯兩個錯
1:37.300–1:39.220
一種叫做技術降維
1:39.220–1:41.080
就是不管業務有多複雜
1:41.080–1:42.780
我們都只想用一段 prompt 解決
1:42.780–1:44.680
結果模型瘋狂產生幻覺
1:44.680–1:46.940
另一種叫做過度設計
1:46.940–1:48.820
明明是個很簡單的事情
1:48.820–1:50.920
非要套一個很繁瑣的代理框架
1:50.920–1:53.800
這兩種做法在企業裡其實都是要踩坑的
1:53.800–1:55.300
那為了精準匹配
1:55.300–1:57.720
我們一般能把業務複雜度分成三檔
1:57.720–1:59.800
第一檔是那種低複雜度
1:59.800–2:01.360
不需要記住狀態的任務
2:01.360–2:03.940
比如你想要模型幫你寫一封週報郵件
2:03.940–2:07.580
或者讓他幫忙看一下這段程式碼裡面有沒有拼寫錯誤
2:07.580–2:08.680
這種一次性的互動
2:08.680–2:10.540
我們直接用 Damp Prompt 方案就行了
2:10.540–2:12.380
這就好比我们在路上問路
2:12.380–2:13.480
地鐵站怎麼走
2:13.480–2:14.840
對方給你指個方向
2:14.840–2:15.580
這事就結束了
2:15.580–2:17.880
不需要複雜的邏輯單次解決
2:17.880–2:20.700
但是如果我們的任務變複雜了
2:20.700–2:21.460
到了第二檔
2:21.460–2:23.140
我們需要在整個過程中
2:23.140–2:25.260
保持很高的可控性
2:25.260–2:27.180
比如說我們要讓模型
2:27.180–2:28.660
協助我們審批合約
2:28.660–2:30.820
或是執行標準的財務報表
2:30.820–2:32.140
這時候呢
2:32.140–2:33.320
單純的 Prompt 肯定無法應付
2:33.320–2:35.860
我們需要採用 Workflow 工作流方案
2:35.860–2:38.080
這就像我們去銀行辦理業務
2:38.080–2:41.180
先取號、填表、櫃檯辦理,最後簽字
2:41.180–2:42.420
每一步該怎麼走
2:42.420–2:43.960
節點之間如何傳遞資訊
2:43.960–2:45.380
都是固定且顯性的
2:45.380–2:47.420
這種線性的步驟設計
2:47.420–2:49.260
最適合用來執行標準的 SOP
2:49.260–2:50.840
出來的結果非常穩定
2:50.840–2:52.440
接著往上走
2:52.440–2:53.220
到了第三檔
2:53.220–2:54.480
就是高複雜度
2:54.480–2:55.380
長週期
2:55.380–2:57.380
需要多角色分工的混沌任務了
2:57.380–2:59.260
比如我們想要大模型
2:59.260–3:00.740
去撰寫一個完整的軟體模組
3:00.740–3:02.800
這個裡面涉及的需求就太多了
3:02.800–3:05.660
我們必須採用多智能體協同的方案
3:05.660–3:06.740
那在這個架構下
3:06.740–3:07.680
我們需要引入
3:07.680–3:09.260
人機協同的安全紅線
3:09.260–3:11.200
比如智能體寫完了程式碼
3:11.200–3:12.780
在準備部署上線的那一步
3:12.780–3:13.740
必須停下來
3:13.740–3:15.020
等待人工審核確認
3:15.020–3:16.360
確認通過後才能繼續
3:16.360–3:17.440
同時
3:17.440–3:18.700
各個智能體之間
3:18.700–3:20.040
還有各自的獨立上下文
3:20.040–3:21.620
不能把資訊混在一起
3:21.620–3:23.340
不然模型自己就會搞混
3:23.340–3:25.680
那麼面對這種高複雜度的
3:25.680–3:26.500
多智能體任務
3:26.500–3:27.540
我們在工程上
3:27.540–3:28.660
到底該怎麼去編排
3:28.660–3:29.220
怎麼設計
3:29.220–3:31.040
才能確保輸出的品質呢
3:31.040–3:32.880
其實現在業界裡
3:32.880–3:34.080
有一個相當成熟的思路
3:34.080–3:35.420
是分散式循環
3:35.420–3:36.660
加上格力子智能體
3:36.660–3:38.240
聽起來有點專業
3:38.240–3:39.300
我們拆開來聊
3:39.300–3:40.320
其實非常簡單
3:40.320–3:41.540
先說分散式循環
3:41.540–3:43.620
就是把任務交給模型之後
3:43.620–3:45.200
它一上來就直接開始寫
3:45.200–3:47.160
結果寫出來的東西完全不能用
3:47.440–3:49.960
所以我們需要在框架上限制它的行為
3:49.960–3:53.400
例如我們可以採用探索、規劃、執行的循環
3:53.400–3:54.960
[未翻譯]
3:54.960–3:57.980
這能體現去讀取相關文件或搜尋程式碼庫
3:57.980–4:01.140
所以在這個階段我們只給它唯讀權限
4:01.140–4:02.600
它只能讀取,不能修改
4:02.600–4:04.080
第二步是規劃
4:04.080–4:07.340
它根據理解到的資訊制定具體的執行計畫
4:07.340–4:09.000
那麼在計畫做好之後
4:09.000–4:10.340
我們可以加入人工確認
4:10.340–4:11.480
也就是人機協同
4:11.480–4:13.620
人類覺得計畫可行再放行
4:13.620–4:15.540
第三步才是執行
4:15.540–4:16.920
他開始去寫檔案
4:16.920–4:17.680
執行指令
4:17.680–4:20.600
這個時候他才能拿到完整的操作權限
4:20.600–4:21.480
執行完之後
4:21.480–4:22.420
如果發現報錯
4:22.420–4:24.480
他會自動回到第一步重新探索
4:24.480–4:26.160
這樣一套循環下來
4:26.160–4:28.140
任務就會被框得非常穩
4:28.140–4:29.440
那麼除了這個循環
4:29.440–4:30.820
還有一個更關鍵的點
4:30.820–4:32.980
叫做上下文隔离子智能體
4:32.980–4:36.140
你看如果一個智能體要做的事情太多
4:36.140–4:38.420
它的上下文裡就會塞滿各種各樣的資訊
4:38.420–4:40.580
這就好比我們自己開一家公司
4:40.580–4:43.140
你不能讓一個人既當銷售又當財務
4:43.140–4:44.540
還要當程式設計師,對吧
4:44.540–4:46.240
資訊一多,他肯定會記錯
4:46.240–4:48.460
所以呢,我們要設立職位
4:48.460–4:50.460
比如我們有一個主智能體
4:50.460–4:53.600
他手底下呢,有三個上下文隔離的子智能體
4:53.600–4:56.180
一個專門找資料的搜尋智能體
4:56.180–4:57.980
一個做計畫的規劃智能體
4:57.980–4:59.820
一個負責寫程式的執行智能體
4:59.820–5:00.960
最關鍵的是
5:00.960–5:03.480
他們每個人只擁有自己專屬的上下文
5:03.480–5:05.440
寫程式的不知道財務資料
5:05.440–5:07.560
找資料的也不需要管程式裡的 bug
5:07.560–5:12.240
他們之間只透過主智能體進行最標準、最乾淨的資料傳遞
5:12.240–5:14.700
透過這種各幹各的、相互隔離的設計
5:14.700–5:17.520
每個子智能體面對的資訊量都會極大減少
5:17.520–5:19.400
任務被徹底拆乾淨了
5:19.400–5:20.980
模型的準確率自然就上去了
5:20.980–5:23.440
OK,聊完了業務怎麼拆解
5:23.440–5:25.260
接下來我們講第二個核心能力
5:25.260–5:26.980
工具呼叫的能力
5:26.980–5:29.200
其實大模型專案在線上翻車
5:29.200–5:31.820
絕大部分問題都不是出在模型不夠聰明上
5:31.820–5:33.740
而是我們的工具設計出了問題
5:33.740–5:36.340
我們很多剛入行做應用開發的朋友
5:36.340–5:39.240
在讓大模型去修改檔案或執行命令的時候
5:39.240–5:42.180
特別喜歡給他一個全能的 Mesh 工具
5:42.180–5:44.120
也就是我們今天常說的命令列
5:44.120–5:46.120
大模型想要讀檔案
5:46.120–5:46.780
改程式
5:46.780–5:47.740
搜尋關鍵字
5:47.740–5:49.480
全都透過這一個命令列
5:49.480–5:50.860
去敲各種指令來解決
5:50.860–5:53.760
他們覺得這樣模型很自由、很省事,對吧
5:53.760–5:55.760
但實際上在工業級開發裡
5:55.760–5:57.540
這是一個非常危險的反面模式
5:57.540–5:59.100
為什麼這麼說呢
5:59.100–6:00.160
你想想看
6:00.160–6:02.060
如果大模型手裡拿的是個
6:02.060–6:03.800
可以為所欲為的萬能命令列
6:03.800–6:06.200
它能幹的事情就太多了
6:06.200–6:07.800
一旦它某次產生幻覺
6:07.800–6:09.100
或者拼錯了一個字符
6:09.100–6:10.800
就非常容易拼接出一個
6:10.800–6:12.580
把系統文件徹底弄壞的錯誤指令
6:12.580–6:14.380
而且作為開發者
6:14.380–6:15.800
你怎麼去審查它的權限
6:15.800–6:17.400
你根本沒有辦法
6:17.400–6:18.820
給它做精細化的安全授權
6:18.820–6:20.840
這就像是你給新來的實習生
6:20.840–6:21.980
配了一把萬能鑰匙
6:21.980–6:23.500
能打開公司所有的門
6:23.500–6:25.480
這個安全隱患應該是非常大的
6:25.480–6:27.460
所以我們更提倡一種
6:27.460–6:28.800
單一職責工具模式
6:28.800–6:30.060
簡單來說
6:30.060–6:31.820
就是這些大而全的命令行
6:31.820–6:34.420
拆成一個個只蓋一鍵小式的專業工具
6:34.420–6:36.360
讀文件的工具就是read
6:36.360–6:38.260
修改文件的部分就是edit
6:38.260–6:39.960
查找關鍵詞的工具是grab
6:39.960–6:41.800
寫文件的工具呢是write
6:41.800–6:43.560
這樣設計的好處顯而易見
6:43.560–6:46.280
每一個工具都有非常嚴格的參數規範
6:46.280–6:47.040
也就是結構定義
6:47.040–6:48.760
大模型在調用的時候
6:48.760–6:49.820
邊界非常明確
6:49.820–6:52.940
而且我們還可以給不同的工具分配獨立的權限
6:52.940–6:54.820
接口的確定性變高了
6:54.820–6:56.840
模型的理解偏差自然就會減少
6:56.840–6:59.100
那這時候新的問題就來了
6:59.100–7:01.240
隨著我們的項目越做越大
7:01.240–7:03.200
大模型需要用的工具越來越多
7:03.200–7:05.720
我們該怎麼去管理和擴展這些工具呢
7:05.720–7:09.200
另外如果大模型確實需要跑一些像刪除文件
7:09.200–7:11.100
還有推送代法這些高風險的命令
7:11.100–7:13.400
我們又該怎麼控制它的安全風險呢
7:13.400–7:15.080
在實際工程落地中
7:15.080–7:16.760
我們一般要遵循兩個原則
7:16.760–7:19.320
第一個原則叫漸進式工具擴展
7:19.320–7:20.400
什麼意思呢
7:20.400–7:21.620
就是我們一開始
7:21.620–7:24.380
千萬不要一上來就把幾十個上百個工具
7:24.380–7:25.460
全都餵給大模型
7:25.460–7:26.920
工具給的太多
7:26.920–7:28.240
大模型在做選擇的時候
7:28.240–7:29.300
很容易讓人眼花撩亂
7:29.300–7:30.360
最後選錯工具
7:30.360–7:32.000
剛開始的時候
7:32.000–7:33.560
我們本地只給他提供
7:33.560–7:35.480
一二十個最常用最基礎的工具
7:35.480–7:37.900
像讀寫修改就完全夠了
7:37.900–7:40.880
如果後面我們發現需要接入一些外部系統
7:40.880–7:42.400
比如要讀公司的資料庫
7:42.400–7:44.180
要呼叫外部的第三方服務
7:44.180–7:45.960
那我們再加上MCP
7:45.960–7:47.620
也就是模型上下文協議
7:47.620–7:50.180
標準化的把這些外部工具給載入進來
7:50.180–7:53.440
如果再往後需要呼叫遠端雲端的主機
7:53.440–7:54.300
或遠端的資料庫
7:54.300–7:55.920
我們再介入遠端工具
7:55.920–7:57.980
一步一步按需載入
7:57.980–8:00.440
這樣模型的工具呼叫準確率才不會崩
8:00.440–8:02.140
那麼第二個原則
8:02.140–8:04.440
是必須在底層建立一個安全沙箱
8:04.440–8:06.140
做好命令的風險分級
8:06.783–8:08.743
大模型它畢竟是模型
8:08.743–8:10.163
它有時候可能會失控
8:10.163–8:13.203
所以我們必須給它呼叫的所有命令定下規則
8:13.203–8:14.343
分出安全等級
8:14.343–8:17.443
比如像跑個測試或者看一下檔案差異
8:17.443–8:19.343
這些完全是安全的命令
8:19.343–8:20.863
我們可以設定為自動執行
8:20.863–8:22.083
不需要打擾使用者
8:22.083–8:24.983
但如果是像強推程式碼這樣的操作
8:24.983–8:26.263
這就有一定的風險了
8:26.263–8:27.923
系統在跑這個命令之前
8:27.923–8:29.183
必須暫停下來
8:29.183–8:30.643
彈出來要使用者確認一下
8:30.643–8:32.483
必須等我們人肉確認了
8:32.483–8:33.103
他才能執行
8:33.103–8:34.763
而如果是像這種情況
8:34.763–8:36.383
會觸發光系統毀滅性指令
8:36.383–8:38.183
不用問我們,在沙箱底層
8:38.183–8:39.403
直接硬編碼徹底拉黑
8:39.403–8:40.883
不給它任何運行的機會
8:40.883–8:43.163
你看,我們只有在底層
8:43.163–8:45.403
把這套分級攔截的沙箱機制打好
8:45.403–8:47.423
才能真正放心地把工具
8:47.423–8:48.923
交到大模型手裡去跑,對吧
8:48.923–8:52.043
那接下來我們講第三個很容易被忽略
8:52.043–8:54.843
但卻決定了專案能不能真正交付的能力
8:54.843–8:56.263
評測與可觀測性
8:56.263–8:58.523
平時我們自己調校模型的時候
8:58.523–8:59.343
經常會想
8:59.343–9:01.963
我測了好幾次,感覺效果還不錯
9:01.963–9:04.783
但企業級應用最怕的就是「感覺」這兩個字
9:04.783–9:07.383
你改了一個 prompt 或者換了一個模型
9:07.383–9:08.483
你感覺變好了
9:08.483–9:10.763
但可能在某個你沒測到的業務角落
9:10.763–9:11.643
它其實退化了
9:11.643–9:13.803
這在工程上叫做靜默退化
9:13.803–9:15.903
你根本不知道它什麼時候
9:15.903–9:17.243
在什麼地方變差了
9:17.243–9:19.803
所以我們必須告別主觀體感
9:19.803–9:22.303
建立一套體系化的量化評測流程
9:22.303–9:23.963
這就像去醫院體檢
9:23.963–9:26.123
不能只靠醫生問你感覺怎麼樣
9:26.123–9:27.543
而是要抽血化驗
9:27.543–9:28.883
看各項指標的數值
9:28.883–9:30.363
具體在開發裡
9:30.363–9:31.523
這個流程分為三步
9:31.523–9:34.343
第一步我們要建構一個黃金數據集
9:34.343–9:36.783
這個數據集要涵蓋我們最核心
9:36.783–9:37.983
最真實的業務場景
9:37.983–9:41.443
比如包含 50 個或 100 個經典的客戶提問
9:41.443–9:42.403
和對應的標準答案
9:42.403–9:44.163
這就是我們的考試試卷
9:44.163–9:45.923
第二步有了試卷
9:45.923–9:48.543
我們得找個客觀的閱卷老師來自動進行打分
9:48.543–9:51.003
我們一般會引入一個強大的推論模型
9:51.003–9:52.523
讓大模型擔任裁判
9:52.523–9:54.203
也就是業界常說的
9:54.203–9:55.523
以語言模型作為評判者
9:55.523–9:57.583
這樣每次我們修改程式碼
9:57.583–9:58.963
直接自動化執行一次考試
9:58.963–10:00.943
擺脫人工測試的低效率
10:00.943–10:03.283
那第三步是查看成績單
10:03.283–10:05.623
這份成績單不能只有一個總分
10:05.623–10:07.923
而是要有一套多維度的指標體系
10:07.923–10:10.423
例如我們要觀察幻覺率是否上升
10:10.423–10:12.763
模型給出的答案與問題是否相關
10:12.763–10:14.783
檢索知識庫的召回率是否夠高
10:14.783–10:17.563
還有最實際的回應耗時是否變慢
10:17.563–10:19.543
透過這樣一套閉環評測
10:19.543–10:21.023
我們每次迭代升級
10:21.023–10:22.243
心裡才有底,對吧
10:22.243–10:24.023
有了這套評測流程
10:24.023–10:26.363
只能說明我們的應用在模擬考試時
10:26.363–10:27.143
表現還不錯
10:27.143–10:29.123
但如果專案真的上線了
10:29.123–10:30.963
用戶在使用過程中遇到錯誤
10:30.963–10:32.663
或者突然輸出一堆亂碼
10:32.663–10:33.783
我們該怎麼進行排查呢
10:33.783–10:35.483
很多專案上線之後
10:35.483–10:36.283
一旦發生錯誤
10:36.283–10:37.183
開發者就會感到困惑
10:37.183–10:39.423
因為大模型應用就像個黑盒子
10:39.423–10:41.543
你根本不知道中間哪一步出了問題
10:41.543–10:44.943
所以我們必須要做全鏈路可觀測性設計
10:44.943–10:47.123
每次推理每次工具呼叫
10:47.123–10:49.743
它的整個生命週期都必須被完整記錄下來
10:49.743–10:51.583
首先在輸入階段
10:51.583–10:55.463
我們要捕獲最原始的 prompt 和系統當時的狀態
10:55.463–10:56.863
接著在推理過程中
10:56.863–10:58.563
我們要監控模型的思維鏈
10:58.563–11:00.283
看它是如何一步步思考
11:00.283–11:02.163
同時記錄它消耗了多少 token
11:02.163–11:03.903
這直接關係到我們的帳單成本
11:03.903–11:05.903
然後在工具呼叫階段
11:05.903–11:07.843
大模型傳了什麼參數
11:07.843–11:09.143
呼叫了什麼介面
11:09.143–11:10.743
介面回應花了多少時間
11:10.743–11:11.683
也要記錄下來
11:11.683–11:13.283
最後在輸出階段
11:13.283–11:14.603
如果發生了異常
11:14.603–11:15.843
例如超時了
11:15.843–11:16.923
或是格式不正確
11:16.923–11:18.983
或是觸發了我們的服務降級策略
11:18.983–11:20.823
系統也要能夠精準捕捉
11:20.823–11:23.303
在完整記錄這些數據之後
11:23.303–11:24.343
最核心的好處
11:24.343–11:25.603
就是我們可以進行一次
11:25.603–11:27.383
故障復現與回放除錯
11:27.383–11:29.623
例如線上用戶反饋說
11:29.623–11:30.623
模型剛才胡亂編造了
11:30.623–11:31.903
我們不需要去猜測
11:31.903–11:33.863
直接將那次呼叫的數據導出
11:33.863–11:35.283
在本地重新執行一次
11:35.283–11:37.763
看看大模型在思維鏈的哪一步走偏了
11:37.763–11:39.143
或是呼叫工具時
11:39.143–11:40.503
傳錯了哪個參數
11:40.503–11:42.903
然後我們就可以精準優化 prompt
11:42.903–11:44.883
或是加上超時重試
11:44.883–11:46.563
格式糾錯等容錯機制
11:46.563–11:49.183
這才是真正的工程化除錯思維
11:49.183–11:50.163
[未翻譯]
11:50.163–11:52.163
有了這個評估與可觀測性
11:52.163–11:53.783
我們的應用在開發階段
11:53.783–11:55.083
已經看起來很健康了
11:55.083–11:57.543
但是如果要真正上線
11:57.543–11:59.303
交給成千上萬的用戶去使用
11:59.303–12:01.343
這就到了最拉開差距的地方
12:01.343–12:02.863
我們的第四個核心能力
12:02.863–12:04.063
生產環境能力
12:04.063–12:06.463
生產環境裡有一個非常實際的痛點
12:06.463–12:07.923
就是模型特別健忘
12:07.923–12:09.483
而且對話越長
12:09.483–12:10.563
上下文塞得越滿
12:10.563–12:12.343
不僅模型回應變得越來越慢
12:12.343–12:14.843
公司的 token 費用也會像流水一樣花出去
12:14.843–12:17.623
我們不能指望用戶每次與智能體聊天時
12:17.623–12:19.423
都把專案規則和歷史對話
12:19.423–12:20.503
複製貼上一次
12:20.503–12:22.843
因此,在生產環境的狀態管理中
12:22.843–12:24.363
我們首先要在程式碼庫中
12:24.363–12:26.103
放置一個持久化的配置指令文件
12:26.103–12:27.723
例如 cloud.md
12:27.723–12:30.203
這個文件會隨著我們的程式碼庫
12:30.203–12:31.323
一起進行版本控制
12:31.323–12:32.863
當繪圖啟動時
12:32.863–12:34.763
系統會自動將專案級的規範
12:34.763–12:36.743
測試命令自動載入
12:36.743–12:37.583
模型一上線
12:37.583–12:39.523
立刻就知道自己身處什麼專案
12:39.523–12:40.743
需要遵守什麼規則
12:40.743–12:42.303
再進一步
12:42.303–12:44.183
我們要建立分層記憶機制
12:44.183–12:46.443
就像電腦有快取
12:46.443–12:47.103
有記憶體
12:47.103–12:47.663
有硬碟一樣
12:47.663–12:50.743
第一層是永遠載入的核心索引
12:50.743–12:53.423
這部分通常控制在 200 行以內
12:53.423–12:54.863
保持極低的回應延遲
12:54.863–12:58.983
然後第二層是按需載入的相關文件與當前狀態
12:58.983–13:01.683
例如模型當前要修改某個程式碼文件
13:01.683–13:05.183
我們就只要把這個文件和當前的斷點狀態載入進來
13:05.183–13:06.783
這裡非常重要的一點
13:06.783–13:08.023
是支援斷點恢復
13:08.023–13:09.683
萬一服務中斷了
13:09.683–13:10.823
智能體重啟之後
13:10.823–13:11.903
能接著上次的進度繼續進行
13:11.903–13:12.763
不用從頭開始
13:12.763–13:14.303
那第三層
13:14.303–13:16.043
則是僅支援檢索的
13:16.043–13:17.223
完整歷史對話記錄
13:17.223–13:18.823
用不到的歷史記錄
13:18.823–13:19.663
全部打包歸檔
13:19.663–13:21.343
只有需要時才去搜尋
13:21.343–13:22.743
透過這種分層方式
13:22.743–13:24.563
我們既能處理長週期的任務
13:24.563–13:26.723
又能幫公司省下大筆的投肯開銷
13:26.723–13:29.043
不過有了分層記憶
13:29.043–13:30.923
如果用戶一直跟智能體聊下去
13:30.923–13:32.103
聊了上百輪
13:32.103–13:33.583
當前的繪畫視窗
13:33.583–13:35.283
還是會面臨一個爆滿的風險
13:35.283–13:38.183
這時候我們要怎麼防止上下文爆掉呢
13:38.183–13:41.403
其實智能體在這一方面跟我們人類很像
13:41.403–13:44.163
人总不能一直不睡覺拼命公渡對吧
13:44.163–13:46.623
所以我們可以給智能體引入一個
13:46.623–13:47.963
記憶睡眠鞏固機制
13:47.963–13:50.643
在系統空閒的時候默默運行
13:50.643–13:52.703
我們可以讓一個後台智能體
13:52.703–13:54.263
在用戶不說話的閒時
13:54.263–13:56.063
去幫我們整理零段的上下文
13:56.063–13:59.643
它會自動把過期的衝突的事實給修剪掉
13:59.643–14:02.423
去蟲之後合併成一個乾淨的核心索引
14:02.423–14:04.563
這就像我們睡覺做夢的時候
14:04.563–14:06.383
大腦會自動整理白天的記憶
14:06.383–14:07.583
丟棄無用資訊一樣
14:07.583–14:09.583
這是一種應用的自我進化
14:09.583–14:11.603
同時在繪畫進行中
14:11.603–14:13.863
我們還要配合漸進式上下文壓縮
14:13.863–14:15.883
隨著對話輪次的增加
14:15.883–14:18.483
我們不是粗暴的直接截掉前面的對話
14:18.483–14:21.163
而是施加不同強度的壓縮
14:21.163–14:23.183
近期對話保留最詳細的明氣
14:23.183–14:25.203
中期對話做輕度總結
14:25.203–14:27.663
而遠期對話則進行一個極限摺疊
14:27.663–14:29.263
這樣層層遞進
14:29.263–14:30.903
既保證了模型不會失憶
14:30.903–14:33.443
又徹底解決了上下文視窗爆棚的問題
14:33.443–14:34.663
好的
14:34.663–14:36.063
在生產環境裡
14:36.063–14:36.963
除了記憶管理
14:36.963–14:38.303
我們還要解決兩個問題
14:38.303–14:40.063
一個是系統的安全合規
14:40.063–14:42.243
另一個是高昂的API障礙成本
14:42.243–14:43.763
首先是系統安全
14:43.763–14:46.283
我們不能全指望prompt去叮囑大模型
14:46.283–14:47.183
你不要違規
14:47.183–14:48.383
格式千萬要寫對
14:48.383–14:50.483
因為模型總有遺忘的時候
14:50.483–14:51.743
我們的原則是
14:51.743–14:53.807
必須把硬邏輯剝離到prompt
14:54.807–14:56.367
用一個確定性的生命週期鉤子。
14:57.027–14:59.007
比如,在大模型呼叫外部工具之前,
14:59.507–15:01.787
系統在底層強行插入一個前置鉤子,
15:02.147–15:03.407
自動檢查命令安不安全。
15:04.167–15:05.147
工具跑完了之後,
15:05.387–15:07.207
我們再強行插入一個後置鉤子,
15:07.207–15:09.707
自動去跑一次程式碼格式化和測試
15:09.707–15:10.947
從再配置檔案
15:10.947–15:14.187
這些鉤子是在系統底層用程式碼硬編碼的
15:14.187–15:16.067
不管大模型怎麼產生幻覺
15:16.067–15:18.147
這些安全紅線它絕對越不過去
15:18.147–15:20.407
然後就是商業化成本的控制
15:20.407–15:22.687
如果每天接上萬個使用者請求
15:22.687–15:25.227
所有請求都用最貴最強的大模型
15:25.227–15:26.947
公司可能很快就撐不住了
15:26.947–15:29.527
所以我們要設計一個混合模型路由機制
15:29.527–15:31.667
當使用者的請求進來的時候
15:31.667–15:33.187
先過一個路由節點
15:33.187–15:34.487
做動態難度分發
15:34.487–15:37.127
如果是寫系統架構這種高難度任務
15:37.127–15:39.827
路由就把請求分發給大型顆粒模型
15:39.827–15:42.007
那如果是問路打招呼
15:42.007–15:44.107
或者是簡單做一個格式化這種任務
15:44.107–15:46.127
路由就自動分流給急速小模型
15:46.127–15:48.187
或者直接命中我們的提示詞快取
15:48.187–15:50.947
這樣既兼顧了系統的高併發響應
15:50.947–15:53.047
又幫我們省下了大量的API資費
15:53.047–15:54.867
這才是合格的商業級架構
15:54.867–15:57.167
而在高頻的業務場景裡
15:57.167–15:58.967
我們最常碰到的落地專案
15:58.967–16:00.227
其實還是企業知識庫
16:00.227–16:01.547
也就是RG系統
16:01.547–16:03.567
但是在生產環境裡
16:03.567–16:05.787
一個合格的RG絕對不是單向的
16:05.787–16:06.907
檢索完就丟給模型
16:06.907–16:09.267
它應該是一個能夠自我進化的閉環
16:09.267–16:10.647
在生產環境中
16:10.647–16:13.087
我們要打通混合檢索和重排架構
16:13.087–16:15.707
形成一個數據沉澱模型反饋的飛輪
16:15.707–16:17.387
第一步混合檢索
16:17.387–16:19.007
當用戶提出問題時
16:19.007–16:21.287
我們將向量檢索和關鍵字檢索
16:21.287–16:22.387
將兩者結合
16:22.387–16:24.107
確保無論用戶如何提問
16:24.107–16:26.307
我們都能精準定位底層的原始文件
16:26.307–16:28.707
然後第二步重排提純
16:28.707–16:31.347
搜尋出來的文件可能有幾十個
16:31.347–16:33.107
模型看不完也看不過來
16:33.367–16:35.187
我們使用專門的重排模型
16:35.187–16:37.047
挑選出最精準的幾個片段
16:37.047–16:38.307
送入大模型的上下文視窗
16:38.307–16:39.847
接下來第三步
16:39.847–16:41.147
就是結合業務邏輯
16:41.147–16:42.987
生成最終的融合輸出
16:42.987–16:44.647
重點在第四步
16:44.647–16:45.387
數據沉澱
16:45.387–16:47.887
我們要捕捉用戶的真實反饋
16:47.887–16:49.687
記錄高頻的查詢盲區
16:49.687–16:51.227
那最後一步
16:51.227–16:52.187
反饋迭代
16:52.187–16:53.587
根據這些反饋
16:53.587–16:54.647
自動去更新
16:54.647–16:56.287
修正和強化我們的企業知識庫
16:56.287–16:58.867
那麼當這套流程運轉起來之後
16:58.867–17:00.727
知識庫裡的盲區就會越來越少
17:00.727–17:02.347
下一輪檢索就會更準確
17:02.347–17:04.147
我們的應用也會越用越聰明
17:04.147–17:05.847
好聊到這裡
17:05.847–17:07.647
我們基本上把一個工業級的
17:07.647–17:08.847
大模型應用開發工程師
17:08.847–17:10.727
需要具備的能力全都梳理了一遍
17:10.727–17:12.567
但最後我們來做一個復盤
17:12.567–17:14.947
其實一個真正合格
17:14.947–17:17.467
能夠幫助企業解決實際大模型落地的工程師
17:17.467–17:20.147
它的成長路徑其實是非常清晰的
17:20.147–17:21.167
在業務架構上
17:21.167–17:23.447
我們要從只會撰寫單一提示
17:23.447–17:25.587
升級到能夠駕馭多智能體編排
17:25.587–17:27.427
在工具與協議上
17:27.427–17:29.907
我們要從硬編碼呼叫 API
17:29.907–17:32.067
升級到運用標準的 MCP 協議
17:32.067–17:33.347
和單一職責工具
17:33.347–17:35.027
在生產環境狀態上
17:35.027–17:37.027
我們要從粗暴的記憶體階段
17:37.027–17:39.987
升級到分層記憶與動態上下文壓縮
17:39.987–17:41.387
那在系統級整合上
17:41.387–17:43.067
我們要從基礎的檢索
17:43.067–17:46.027
升級到剛才提到的 RAG 飛輪與模型路由
17:46.027–17:48.027
然後在質量可觀測性上
17:48.027–17:50.307
升級到全链路追蹤與量化評估
0:00.120–0:01.700
zh离开你 谁还把我当小孩教
離開你 誰還把我當小孩教
0:01.700–0:03.520
zh最近国内顶尖高校上海交大
最近國內頂尖高校上海交通大學
0:03.520–0:06.440
zh在GitHub上开源了一套动手学AI的实操教程
在GitHub上開源了一套動手學AI的實操教程
0:06.440–0:08.840
zh这套教程没有任何水分 全是硬核干货
這套教程沒有任何水分 全是硬核乾貨
0:08.840–0:12.100
zh完整学下来就能在自己电脑上部署专属于自己的大模型
完整學下來就能在自己電腦上部署專屬於自己的大模型
0:12.100–0:14.260
zh不用依赖外网 隐私安全更有保障
不用依賴外網 隱私安全更有保障
0:14.260–0:16.000
zh该教程由张卓胜教授主导
該教程由張卓勝教授主導
0:16.000–0:17.940
zh凝聚了多位业内专家的智慧结晶
凝聚了多位業內專家的智慧結晶
0:17.940–0:19.220
zh非常适合小白学习
非常適合小白學習
0:19.220–0:20.660
zh从最简单的API调用
從最簡單的API呼叫
0:20.660–0:22.640
zh一步步深入到模型部署与微调
一步步深入到模型部署與微調
0:22.640–0:24.260
zh甚至连模型安全防御
甚至連模型安全防禦
0:24.260–0:26.320
zh以及自动化智能体开发都交给你了
以及自動化智能體開發都交給你了
0:26.320–0:27.440
zh这套教程属于是
這套教程屬於是
0:27.440–0:28.740
zh直接把知识味到你嘴里
直接把知識喂到你嘴裡
0:28.740–0:29.760
zh知道大家懒得去找
知道大家懶得去找
0:29.760–0:31.920
zh我已经把配套资源和学习路线整理好了
我已經把配套資源和學習路線整理好了
0:31.920–0:32.700
zh照着学就行
照著學就行
0:32.700–0:34.620
zh留下学习直接暴走
留下學習直接暴走
0:34.620–0:36.780
zh劝你别再盲目自学AI开发了
勸你別再盲目自學AI開發了
0:36.780–0:38.080
zh看了几百个教程
看了幾百個教程
0:38.080–0:39.680
zh收藏了几十个热门工作流
收藏了幾十個熱門工作流
0:39.680–0:42.000
zh最后自己想做个自动化工具还是跑不通
最後自己想做個自動化工具還是跑不通
0:42.000–0:42.440
zh为什么
為什麼
0:42.440–0:44.360
zh因为大模型这个东西
因為大模型這個東西
0:44.360–0:45.420
zh它的思维逻辑
它的思維邏輯
0:45.420–0:47.760
zh跟我们传统的软件开发是完全相反的
跟我們傳統的軟體開發是完全相反的
0:47.760–0:50.080
zh以前是一加一肯定等于二
以前是一加一肯定等於二
0:50.080–0:51.700
zh但现在大模型给你的
但現在大模型給你的
0:51.700–0:52.880
zh是一个大体上不错
是一個大体上不錯
0:52.880–0:54.800
zh但是偶尔会瞎编的一个概率
但是偶爾會瞎編的一個機率
0:54.800–0:57.560
zh如果你搞不懂怎么去规避这种不确定性
如果你搞不懂怎麼去規避這種不確定性
0:57.560–0:59.620
zh学再多的框架也是在做无用功
學再多的框架也是在作無用功
0:59.620–1:02.080
zh想要做出一款真正能自动干活
想要做出一款真正能自動幹活
1:02.080–1:03.820
zh甚至能拿去变现的AI产品
甚至能拿去變現的AI產品
1:03.820–1:05.640
zh其实关键就在于四项能力
其實關鍵就在於四項能力
1:05.640–1:07.640
zh这四项能力也直接决定了
這四項能力也直接決定了
1:07.640–1:09.420
zh你做出来的到底是个不好用的玩具
你做出來的到底是個不好用的玩具
1:09.420–1:11.380
zh还是能真正落地的商业产品
還是能真正落地的商業產品
1:11.380–1:13.680
zh它们分别是任务拆解能力
它們分別是任務拆解能力
1:13.680–1:14.780
zh工具调用能力
工具呼叫能力
1:14.780–1:16.260
zh评测和可观测性
評估與可觀測性
1:16.260–1:18.300
zh以及最硬核的生产环境能力
以及最硬核的生產環境能力
1:18.300–1:20.160
zh接下来我们一个一个讲清楚
接下來我們一個一個講清楚
1:20.160–1:22.300
zh我们做大模型应用开发
我們做大模型應用開發
1:22.300–1:23.500
zh接手一个新项目的时候
接手新專案的時候
1:23.500–1:24.940
zh第一件事是要干什么
第一件事是要做什麼
1:24.940–1:27.180
zh其实不是急着去写代码
其實不是急著去寫程式碼
1:27.180–1:29.060
zh也不是去挑什么酷炫的框架
也不是去挑選什麼酷炫的框架
1:29.060–1:30.440
zh我们最先要做的
我們最先要做的
1:30.440–1:32.340
zh就是判断这个业务到底有多复杂
就是判斷這個業務到底有多複雜
1:32.340–1:34.440
zh然后给它配一个最合适的技术架构
然後給它配一個最合適的技術架構
1:34.440–1:36.180
zh你看我们平时做项目
你看我們平時做專案
1:36.180–1:37.300
zh最容易犯两个错
最容易犯兩個錯
1:37.300–1:39.220
zh一种叫做技术降维
一種叫做技術降維
1:39.220–1:41.080
zh就是不管业务有多复杂
就是不管業務有多複雜
1:41.080–1:42.780
zh我们都只想用一段prompt解决
我們都只想用一段 prompt 解決
1:42.780–1:44.680
zh结果模型疯狂产生幻觉
結果模型瘋狂產生幻覺
1:44.680–1:46.940
zh另一种叫做过度设计
另一種叫做過度設計
1:46.940–1:48.820
zh明明是个很简单的事情
明明是個很簡單的事情
1:48.820–1:50.920
zh非要套一个很繁琐的智能体框架
非要套一個很繁瑣的代理框架
1:50.920–1:53.800
zh这两种做法在企业里其实都是要踩坑的
這兩種做法在企業裡其實都是要踩坑的
1:53.800–1:55.300
zh那为了精准匹配
那為了精準匹配
1:55.300–1:57.720
zh我们一般能把业务复杂度分成了三档
我們一般能把業務複雜度分成三檔
1:57.720–1:59.800
zh第一档是那种低复杂度
第一檔是那種低複雜度
1:59.800–2:01.360
zh不需要记住状态的任务
不需要記住狀態的任務
2:01.360–2:03.940
zh比如你想要模型帮你写一封桌报邮件
比如你想要模型幫你寫一封週報郵件
2:03.940–2:07.580
zh或者让他帮忙看一下这段代码里面有没有拼写错误
或者讓他幫忙看一下這段程式碼裡面有沒有拼寫錯誤
2:07.580–2:08.680
zh这种一次性的交互
這種一次性的互動
2:08.680–2:10.540
zh我们直接用Damp Prompt方案就行了
我們直接用 Damp Prompt 方案就行了
2:10.540–2:12.380
zh这就好比我们在路上问路
這就好比我们在路上問路
2:12.380–2:13.480
zh电铁站怎么走
地鐵站怎麼走
2:13.480–2:14.840
zh对方给你指个方向
對方給你指個方向
2:14.840–2:15.580
zh这事就结了
這事就結束了
2:15.580–2:17.880
zh不需要复杂的逻辑单次解决
不需要複雜的邏輯單次解決
2:17.880–2:20.700
zh但是如果我们的任务变复杂了
但是如果我們的任務變複雜了
2:20.700–2:21.460
zh到了第二档
到了第二檔
2:21.460–2:23.140
zh我们需要在整个过程中
我們需要在整個過程中
2:23.140–2:25.260
zh保持很高的一个可控性
保持很高的可控性
2:25.260–2:27.180
zh比如说我们要让模型
比如說我們要讓模型
2:27.180–2:28.660
zh帮我们审批合同
協助我們審批合約
2:28.660–2:30.820
zh或者去跑一个标准的财务报表
或是執行標準的財務報表
2:30.820–2:32.140
zh这个时候呢
這時候呢
2:32.140–2:33.320
zhDamp Prompt肯定顶不住
單純的 Prompt 肯定無法應付
2:33.320–2:35.860
zh我们需要使用Workflow工作流方案
我們需要採用 Workflow 工作流方案
2:35.860–2:38.080
zh这就像我们去银行里面办业务
這就像我們去銀行辦理業務
2:38.080–2:41.180
zh先取号填表柜台办理最后签字
先取號、填表、櫃檯辦理,最後簽字
2:41.180–2:42.420
zh每一步怎么走
每一步該怎麼走
2:42.420–2:43.960
zh节点之间怎么传递信息
節點之間如何傳遞資訊
2:43.960–2:45.380
zh都是定死的显性的
都是固定且顯性的
2:45.380–2:47.420
zh这种流逝的步骤设计
這種線性的步驟設計
2:47.420–2:49.260
zh最适合用来跑标准的SOP
最適合用來執行標準的 SOP
2:49.260–2:50.840
zh出来的结果非常稳定
出來的結果非常穩定
2:50.840–2:52.440
zh那再往上走
接著往上走
2:52.440–2:53.220
zh到了第三档
到了第三檔
2:53.220–2:54.480
zh就是高复杂度
就是高複雜度
2:54.480–2:55.380
zh长周期
長週期
2:55.380–2:57.380
zh需要多角色分工的混沌任务了
需要多角色分工的混沌任務了
2:57.380–2:59.260
zh比如我们想要大模型
比如我們想要大模型
2:59.260–3:00.740
zh去写一个完整的软件模块
去撰寫一個完整的軟體模組
3:00.740–3:02.800
zh这个里面设计的需求就太多了
這個裡面涉及的需求就太多了
3:02.800–3:05.660
zh我们必须用多智能体协同的方案
我們必須採用多智能體協同的方案
3:05.660–3:06.740
zh那在这个架构下
那在這個架構下
3:06.740–3:07.680
zh我们需要引入
我們需要引入
3:07.680–3:09.260
zh人机协同的安全红线
人機協同的安全紅線
3:09.260–3:11.200
zh比如智能体写完了代码
比如智能體寫完了程式碼
3:11.200–3:12.780
zh在准备部署上线的那一步
在準備部署上線的那一步
3:12.780–3:13.740
zh必须停下来
必須停下來
3:13.740–3:15.020
zh等待人工审核确认
等待人工審核確認
3:15.020–3:16.360
zh确认过了才能继续
確認通過後才能繼續
3:16.360–3:17.440
zh同时
同時
3:17.440–3:18.700
zh各个智能体之间
各個智能體之間
3:18.700–3:20.040
zh还有自己的独立上下文
還有各自的獨立上下文
3:20.040–3:21.620
zh不能够把信息给混在一起
不能把資訊混在一起
3:21.620–3:23.340
zh不然模型自己就糊涂了
不然模型自己就會搞混
3:23.340–3:25.680
zh那么面对这种高复杂度的
那麼面對這種高複雜度的
3:25.680–3:26.500
zh多智能体任务
多智能體任務
3:26.500–3:27.540
zh我们在工程上
我們在工程上
3:27.540–3:28.660
zh到底该怎么去编排
到底該怎麼去編排
3:28.660–3:29.220
zh怎么设计
怎麼設計
3:29.220–3:31.040
zh才能够保证它输出的质量呢
才能確保輸出的品質呢
3:31.040–3:32.880
zh其实现在行业里
其實現在業界裡
3:32.880–3:34.080
zh有一个挺成熟的思路
有一個相當成熟的思路
3:34.080–3:35.420
zh是分布循环
是分散式循環
3:35.420–3:36.660
zh加上格力子智能体
加上格力子智能體
3:36.660–3:38.240
zh听起来是有点专业
聽起來有點專業
3:38.240–3:39.300
zh我们拆开来聊
我們拆開來聊
3:39.300–3:40.320
zh其实非常简单
其實非常簡單
3:40.320–3:41.540
zh先说分布循环
先說分散式循環
3:41.540–3:43.620
zh就是把任务交给模型之后
就是把任務交給模型之後
3:43.620–3:45.200
zh它一上来又直接开始写
它一上來就直接開始寫
3:45.200–3:47.160
zh结果写出来的东西完全不能用
結果寫出來的東西完全不能用
3:47.440–3:49.960
zh所以我们需要在框架上来限制它的行为
所以我們需要在框架上限制它的行為
3:49.960–3:53.400
zh比如我们可以采用一个探索规划执行的一个循环
例如我們可以採用探索、規劃、執行的循環
3:53.400–3:54.960
zh第一步是探索
[未翻譯]
3:54.960–3:57.980
zh这能体现去读取相关的文档或者搜索代码库
這能體現去讀取相關文件或搜尋程式碼庫
3:57.980–4:01.140
zh所以在这个阶段我们只给它只读的权限
所以在這個階段我們只給它唯讀權限
4:01.140–4:02.600
zh它只能看不能改
它只能讀取,不能修改
4:02.600–4:04.080
zh第二步是规划
第二步是規劃
4:04.080–4:07.340
zh它根据看懂的信息做一个具体的执行计划
它根據理解到的資訊制定具體的執行計畫
4:07.340–4:09.000
zh那么在计划做好之后
那麼在計畫做好之後
4:09.000–4:10.340
zh我们可以加入人工确认
我們可以加入人工確認
4:10.340–4:11.480
zh也就是人机协同
也就是人機協同
4:11.480–4:13.620
zh人类觉得计划可行再放行
人類覺得計畫可行再放行
4:13.620–4:15.540
zh第三步才是执行
第三步才是執行
4:15.540–4:16.920
zh他开始去写文件
他開始去寫檔案
4:16.920–4:17.680
zh运行命令
執行指令
4:17.680–4:20.600
zh这个时候他才能拿到完整的操作权限
這個時候他才能拿到完整的操作權限
4:20.600–4:21.480
zh执行完之后
執行完之後
4:21.480–4:22.420
zh如果发现报错了
如果發現報錯
4:22.420–4:24.480
zh他会自动回到第一步重新探索
他會自動回到第一步重新探索
4:24.480–4:26.160
zh这样一套循环下来
這樣一套循環下來
4:26.160–4:28.140
zh任务就会被框得非常稳
任務就會被框得非常穩
4:28.140–4:29.440
zh那么除了这个循环
那麼除了這個循環
4:29.440–4:30.820
zh还有一个更关键的点
還有一個更關鍵的點
4:30.820–4:32.980
zh叫做上下文隔离子智能体
叫做上下文隔离子智能體
4:32.980–4:36.140
zh你看如果一个智能体要做的事情太多
你看如果一個智能體要做的事情太多
4:36.140–4:38.420
zh它的上下文里就会塞满各种各样信息
它的上下文裡就會塞滿各種各樣的資訊
4:38.420–4:40.580
zh这就好比我们自己开一家公司
這就好比我們自己開一家公司
4:40.580–4:43.140
zh你不能让一个人既当销售又当财务
你不能讓一個人既當銷售又當財務
4:43.140–4:44.540
zh还要当程序员对吧
還要當程式設計師,對吧
4:44.540–4:46.240
zh信息一多他肯定会记错
資訊一多,他肯定會記錯
4:46.240–4:48.460
zh所以呢我们要设立岗位
所以呢,我們要設立職位
4:48.460–4:50.460
zh比如我们有一个主智能体
比如我們有一個主智能體
4:50.460–4:53.600
zh他手底下呢有三个上下文隔离的子智能体
他手底下呢,有三個上下文隔離的子智能體
4:53.600–4:56.180
zh一个专门找资料的搜索智能体
一個專門找資料的搜尋智能體
4:56.180–4:57.980
zh一个做计划的规划智能体
一個做計畫的規劃智能體
4:57.980–4:59.820
zh一个负责写代码的执行智能体
一個負責寫程式的執行智能體
4:59.820–5:00.960
zh最关键的是
最關鍵的是
5:00.960–5:03.480
zh他们每个人只拥有自己专属的上下文
他們每個人只擁有自己專屬的上下文
5:03.480–5:05.440
zh写代码的不知道财务数据
寫程式的不知道財務資料
5:05.440–5:07.560
zh找资料的也不需要管代码里的bug
找資料的也不需要管程式裡的 bug
5:07.560–5:12.240
zh他们之间只通过主智能体进行最标准最干净的数据传递
他們之間只透過主智能體進行最標準、最乾淨的資料傳遞
5:12.240–5:14.700
zh通过这种各干各的相互隔离的设计
透過這種各幹各的、相互隔離的設計
5:14.700–5:17.520
zh每个子智能体面对的信息量都会极大减少
每個子智能體面對的資訊量都會極大減少
5:17.520–5:19.400
zh任务被彻底拆干净了
任務被徹底拆乾淨了
5:19.400–5:20.980
zh模型的准确率自然就上去了
模型的準確率自然就上去了
5:20.980–5:23.440
zhOK 聊完了业务怎么拆解
OK,聊完了業務怎麼拆解
5:23.440–5:25.260
zh接下来我们讲第二个核心能力
接下來我們講第二個核心能力
5:25.260–5:26.980
zh工具调用的能力
工具呼叫的能力
5:26.980–5:29.200
zh其实大模型项目在线上翻车
其實大模型專案在線上翻車
5:29.200–5:31.820
zh绝大部分问题都不是出在模型不够聪明上
絕大部分問題都不是出在模型不夠聰明上
5:31.820–5:33.740
zh而是我们的工具设计出了问题
而是我們的工具設計出了問題
5:33.740–5:36.340
zh我们很多刚入行做应用开发的朋友
我們很多剛入行做應用開發的朋友
5:36.340–5:39.240
zh在让大模型去修改文件或者运行命令的时候
在讓大模型去修改檔案或執行命令的時候
5:39.240–5:42.180
zh特别喜欢给他一个全能的Mesh工具
特別喜歡給他一個全能的 Mesh 工具
5:42.180–5:44.120
zh也就是我们今天常说的命令行
也就是我們今天常說的命令列
5:44.120–5:46.120
zh大模型想要读文件
大模型想要讀檔案
5:46.120–5:46.780
zh改代码
改程式
5:46.780–5:47.740
zh搜索关键词
搜尋關鍵字
5:47.740–5:49.480
zh全都通过这一个命令行
全都透過這一個命令列
5:49.480–5:50.860
zh去敲各种指令来解决
去敲各種指令來解決
5:50.860–5:53.760
zh他们觉得这样模型很自由很省事对吧
他們覺得這樣模型很自由、很省事,對吧
5:53.760–5:55.760
zh但实际上在工业级开发里
但實際上在工業級開發裡
5:55.760–5:57.540
zh这是一个非常危险的反面模式
這是一個非常危險的反面模式
5:57.540–5:59.100
zh为什么这么说呢
為什麼這麼說呢
5:59.100–6:00.160
zh你想想
你想想看
6:00.160–6:02.060
zh如果大模型手里拿的是一个
如果大模型手裡拿的是個
6:02.060–6:03.800
zh可以为所欲为的万能命令行
可以為所欲為的萬能命令列
6:03.800–6:06.200
zh它能干的事情就太多了
它能幹的事情就太多了
6:06.200–6:07.800
zh一旦它某一次产生了幻觉
一旦它某次產生幻覺
6:07.800–6:09.100
zh或者拼错了一个字符
或者拼錯了一個字符
6:09.100–6:10.800
zh就非常容易拼接出一个
就非常容易拼接出一個
6:10.800–6:12.580
zh把系统文件彻底弄坏的错误指令
把系統文件徹底弄壞的錯誤指令
6:12.580–6:14.380
zh而且作为开发者
而且作為開發者
6:14.380–6:15.800
zh你怎么去审查它的权限
你怎麼去審查它的權限
6:15.800–6:17.400
zh你根本没有办法
你根本沒有辦法
6:17.400–6:18.820
zh给它做精细化的安全授权
給它做精細化的安全授權
6:18.820–6:20.840
zh这就像是你给新来的实习生
這就像是你給新來的實習生
6:20.840–6:21.980
zh配了一把万能钥匙
配了一把萬能鑰匙
6:21.980–6:23.500
zh能拔开公司所有的门
能打開公司所有的門
6:23.500–6:25.480
zh这个安全隐患应该是非常大的
這個安全隱患應該是非常大的
6:25.480–6:27.460
zh所以我们更提倡一种
所以我們更提倡一種
6:27.460–6:28.800
zh单一职责工具模式
單一職責工具模式
6:28.800–6:30.060
zh简单来说
簡單來說
6:30.060–6:31.820
zh就是把这些大而全的命令行
就是這些大而全的命令行
6:31.820–6:34.420
zh拆成一个个只盖一键小式的专业工具
拆成一個個只蓋一鍵小式的專業工具
6:34.420–6:36.360
zh读文件的工具就是read
讀文件的工具就是read
6:36.360–6:38.260
zh改文件的呢就是edit
修改文件的部分就是edit
6:38.260–6:39.960
zh查找关键词的工具是grab
查找關鍵詞的工具是grab
6:39.960–6:41.800
zh写文件的工具呢是write
寫文件的工具呢是write
6:41.800–6:43.560
zh这样设计的好处显而易见
這樣設計的好處顯而易見
6:43.560–6:46.280
zh每一个工具都有非常严格的参数规范
每一個工具都有非常嚴格的參數規範
6:46.280–6:47.040
zh也就是schema
也就是結構定義
6:47.040–6:48.760
zh大模型在调用的时候
大模型在調用的時候
6:48.760–6:49.820
zh边界非常明确
邊界非常明確
6:49.820–6:52.940
zh而且我们还可以给不同的工具分配独立的权限
而且我們還可以給不同的工具分配獨立的權限
6:52.940–6:54.820
zh接口的确定性变高了
接口的確定性變高了
6:54.820–6:56.840
zh模型的理解偏差自然就小了
模型的理解偏差自然就會減少
6:56.840–6:59.100
zh那这时候新的问题就来了
那這時候新的問題就來了
6:59.100–7:01.240
zh随着我们的项目越做越大
隨著我們的項目越做越大
7:01.240–7:03.200
zh大模型需要用的工具越来越多
大模型需要用的工具越來越多
7:03.200–7:05.720
zh我们该怎么去管理和扩展这些工具呢
我們該怎麼去管理和擴展這些工具呢
7:05.720–7:09.200
zh另外如果大模型确实需要跑一些像删除文件
另外如果大模型確實需要跑一些像刪除文件
7:09.200–7:11.100
zh还有推送代法这些高风险的命令
還有推送代法這些高風險的命令
7:11.100–7:13.400
zh我们又该怎么控制它的安全风险呢
我們又該怎麼控制它的安全風險呢
7:13.400–7:15.080
zh在实际工程落地中
在實際工程落地中
7:15.080–7:16.760
zh我们一般要遵循两个原则
我們一般要遵循兩個原則
7:16.760–7:19.320
zh第一个原则叫渐进式工具扩展
第一個原則叫漸進式工具擴展
7:19.320–7:20.400
zh什么意思呢
什麼意思呢
7:20.400–7:21.620
zh就是我们一开始
就是我們一開始
7:21.620–7:24.380
zh千万别一上来就把几十个上百个工具
千萬不要一上來就把幾十個上百個工具
7:24.380–7:25.460
zh全都喂给大木型
全都餵給大模型
7:25.460–7:26.920
zh工具给的太多
工具給的太多
7:26.920–7:28.240
zh大木型在做选择的时候
大模型在做選擇的時候
7:28.240–7:29.300
zh非常容易挑花眼
很容易讓人眼花撩亂
7:29.300–7:30.360
zh最后选错工具
最後選錯工具
7:30.360–7:32.000
zh刚开始的时候
剛開始的時候
7:32.000–7:33.560
zh我们本地只给他提供
我們本地只給他提供
7:33.560–7:35.480
zh一二十个最常用最基础的工具
一二十個最常用最基礎的工具
7:35.480–7:37.900
zh像读写修改就完全够了
像讀寫修改就完全夠了
7:37.900–7:40.880
zh如果后面我们发现需要接入一些外部系统
如果後面我們發現需要接入一些外部系統
7:40.880–7:42.400
zh比如要读公司的数据库
比如要讀公司的資料庫
7:42.400–7:44.180
zh要调用外部的第三方服务
要呼叫外部的第三方服務
7:44.180–7:45.960
zh那我们再加上MCP
那我們再加上MCP
7:45.960–7:47.620
zh也就是模型上下文协议
也就是模型上下文協議
7:47.620–7:50.180
zh标准化的把这些外部工具给加载进来
標準化的把這些外部工具給載入進來
7:50.180–7:53.440
zh如果再往后需要调用远程云端的主机
如果再往後需要呼叫遠端雲端的主機
7:53.440–7:54.300
zh或远程的数据库
或遠端的資料庫
7:54.300–7:55.920
zh我们再介入远程工具
我們再介入遠端工具
7:55.920–7:57.980
zh一步一步按需加载
一步一步按需載入
7:57.980–8:00.440
zh这样模型的工具调用准确率才不会崩
這樣模型的工具呼叫準確率才不會崩
8:00.440–8:02.140
zh那么第二个原则
那麼第二個原則
8:02.140–8:04.440
zh是必须在底层建立一个安全杀箱
是必須在底層建立一個安全沙箱
8:04.440–8:06.140
zh做好命令的风险分级
做好命令的風險分級
8:06.783–8:08.743
zh大模型它毕竟是模型
大模型它畢竟是模型
8:08.743–8:10.163
zh它有时候可能会失控
它有時候可能會失控
8:10.163–8:13.203
zh所以我们必须给它调用的所有命令定下规则
所以我們必須給它呼叫的所有命令定下規則
8:13.203–8:14.343
zh分出安全等级
分出安全等級
8:14.343–8:17.443
zh比如像跑个测试或者看一下文件差异
比如像跑個測試或者看一下檔案差異
8:17.443–8:19.343
zh这些完全是安全的命令
這些完全是安全的命令
8:19.343–8:20.863
zh我们可以设置为自动执行
我們可以設定為自動執行
8:20.863–8:22.083
zh不需要打扰用户
不需要打擾使用者
8:22.083–8:24.983
zh但如果是像强推代码这样的操作
但如果是像強推程式碼這樣的操作
8:24.983–8:26.263
zh这就有一定的风险了
這就有一定的風險了
8:26.263–8:27.923
zh系统在跑这个命令之前
系統在跑這個命令之前
8:27.923–8:29.183
zh必须暂停下来
必須暫停下來
8:29.183–8:30.643
zh弹出来要用户确认一下
彈出來要使用者確認一下
8:30.643–8:32.483
zh必须等我们人肉确认了
必須等我們人肉確認了
8:32.483–8:33.103
zh他才能跑
他才能執行
8:33.103–8:34.763
zh而如果是像这种
而如果是像這種情況
8:34.763–8:36.383
zh会煽光系统的毁灭性指令
會觸發光系統毀滅性指令
8:36.383–8:38.183
zh不用问我们在沙箱底层
不用問我們,在沙箱底層
8:38.183–8:39.403
zh直接硬变码彻底拉黑
直接硬編碼徹底拉黑
8:39.403–8:40.883
zh不给他任何运行的机会
不給它任何運行的機會
8:40.883–8:43.163
zh你看我们只有在底层
你看,我們只有在底層
8:43.163–8:45.403
zh把这一套分级拦截的沙箱机制打好了
把這套分級攔截的沙箱機制打好
8:45.403–8:47.423
zh才能真正放心的把工具
才能真正放心地把工具
8:47.423–8:48.923
zh交到大模型手里去跑对吧
交到大模型手裡去跑,對吧
8:48.923–8:52.043
zh那接下来我们讲第三个很容易被忽略
那接下來我們講第三個很容易被忽略
8:52.043–8:54.843
zh但是却决定了项目能不能真正交付的能力
但卻決定了專案能不能真正交付的能力
8:54.843–8:56.263
zh评测和可观测性
評測與可觀測性
8:56.263–8:58.523
zh平时我们自己调模型的时候
平時我們自己調校模型的時候
8:58.523–8:59.343
zh经常会想
經常會想
8:59.343–9:01.963
zh我测了几次感觉效果还挺不错的
我測了好幾次,感覺效果還不錯
9:01.963–9:04.783
zh但是企业级最怕的就是感觉这两个字
但企業級應用最怕的就是「感覺」這兩個字
9:04.783–9:07.383
zh你改了一个prompt或者换了一个模型
你改了一個 prompt 或者換了一個模型
9:07.383–9:08.483
zh你感觉变好了
你感覺變好了
9:08.483–9:10.763
zh但可能在某个你没测到的业务角落
但可能在某個你沒測到的業務角落
9:10.763–9:11.643
zh它其实退化了
它其實退化了
9:11.643–9:13.803
zh这在工程上叫做静默退化
這在工程上叫做靜默退化
9:13.803–9:15.903
zh你根本不知道它什么时候
你根本不知道它什麼時候
9:15.903–9:17.243
zh在什么地方变差了
在什麼地方變差了
9:17.243–9:19.803
zh所以我们必须告别主观体感
所以我們必須告別主觀體感
9:19.803–9:22.303
zh建立一套体系化的量化评测流程
建立一套體系化的量化評測流程
9:22.303–9:23.963
zh这就像去医院体检
這就像去醫院體檢
9:23.963–9:26.123
zh不能只靠医生问你感觉怎么样
不能只靠醫生問你感覺怎麼樣
9:26.123–9:27.543
zh而是要抽血化验
而是要抽血化驗
9:27.543–9:28.883
zh看各项指标的数值
看各項指標的數值
9:28.883–9:30.363
zh具体在开发里
具體在開發裡
9:30.363–9:31.523
zh这个流程分为三步
這個流程分為三步
9:31.523–9:34.343
zh第一步我们要构建一个黄金数据集
第一步我們要建構一個黃金數據集
9:34.343–9:36.783
zh这个数据集要覆盖我们最核心
這個數據集要涵蓋我們最核心
9:36.783–9:37.983
zh最真实的业务场景
最真實的業務場景
9:37.983–9:41.443
zh比如包含50个或者100个经典的客户提问
比如包含 50 個或 100 個經典的客戶提問
9:41.443–9:42.403
zh和对应的标准答案
和對應的標準答案
9:42.403–9:44.163
zh这就是我们的考试试卷
這就是我們的考試試卷
9:44.163–9:45.923
zh第二步有了试卷
第二步有了試卷
9:45.923–9:48.543
zh我们得找个客观的乐卷老师来自动进行打分
我們得找個客觀的閱卷老師來自動進行打分
9:48.543–9:51.003
zh我们一般会引入一个强推力模型
我們一般會引入一個強大的推論模型
9:51.003–9:52.523
zh让大模型当裁判
讓大模型擔任裁判
9:52.523–9:54.203
zh也就是业内常说的
也就是業界常說的
9:54.203–9:55.523
enLM as a judge
以語言模型作為評判者
9:55.523–9:57.583
zh这样每次我们改的代码
這樣每次我們修改程式碼
9:57.583–9:58.963
zh直接自动化跑一遍考试
直接自動化執行一次考試
9:58.963–10:00.943
zh摆脱人工人肉测试的低效
擺脫人工測試的低效率
10:00.943–10:03.283
zh那第三步看成绩单
那第三步是查看成績單
10:03.283–10:05.623
zh这个成绩单不能只有一个总分
這份成績單不能只有一個總分
10:05.623–10:07.923
zh而是要有一个多维度的指标体系
而是要有一套多維度的指標體系
10:07.923–10:10.423
zh比如我们要看幻觉率有没有上升
例如我們要觀察幻覺率是否上升
10:10.423–10:12.763
zh模型给出的答案跟问题相不相关
模型給出的答案與問題是否相關
10:12.763–10:14.783
zh检索知识库的召回率高不高
檢索知識庫的召回率是否夠高
10:14.783–10:17.563
zh还有最实际的响应耗时有没有变慢
還有最實際的回應耗時是否變慢
10:17.563–10:19.543
zh通过这样的一套闭环评测
透過這樣一套閉環評測
10:19.543–10:21.023
zh我们每次迭代升级
我們每次迭代升級
10:21.023–10:22.243
zh心里才是有底的对吧
心裡才有底,對吧
10:22.243–10:24.023
zh有了这一套评测流程
有了這套評測流程
10:24.023–10:26.363
zh只能说明我们的应用在模拟考试的时候
只能說明我們的應用在模擬考試時
10:26.363–10:27.143
zh表现还不错
表現還不錯
10:27.143–10:29.123
zh但如果项目真的上线了
但如果專案真的上線了
10:29.123–10:30.963
zh用户在使用过程中遇到了爆错
用戶在使用過程中遇到錯誤
10:30.963–10:32.663
zh或者突然输出了一堆乱码
或者突然輸出一堆亂碼
10:32.663–10:33.783
zh我们该怎么排查呢
我們該怎麼進行排查呢
10:33.783–10:35.483
zh很多项目上线之后
很多專案上線之後
10:35.483–10:36.283
zh一旦爆错了
一旦發生錯誤
10:36.283–10:37.183
zh开发者就懵了
開發者就會感到困惑
10:37.183–10:39.423
zh因为大模型应用就像个黑盒
因為大模型應用就像個黑盒子
10:39.423–10:41.543
zh你根本不知道中间哪一步出了问题
你根本不知道中間哪一步出了問題
10:41.543–10:44.943
zh所以我们必须要做全链路可观测性设计
所以我們必須要做全鏈路可觀測性設計
10:44.943–10:47.123
zh每次推理每次工具调用
每次推理每次工具呼叫
10:47.123–10:49.743
zh它的整个生命周期都必须被完整的记录下来
它的整個生命週期都必須被完整記錄下來
10:49.743–10:51.583
zh首先在输入阶段
首先在輸入階段
10:51.583–10:55.463
zh我们要捕获最原始的prompt和系统当时的状态
我們要捕獲最原始的 prompt 和系統當時的狀態
10:55.463–10:56.863
zh接着在推理中间菜
接著在推理過程中
10:56.863–10:58.563
zh我们要监控模型的思维链
我們要監控模型的思維鏈
10:58.563–11:00.283
zh看它是怎么一步步思考
看它是如何一步步思考
11:00.283–11:02.163
zh同时记录它消耗了多少token
同時記錄它消耗了多少 token
11:02.163–11:03.903
zh这直接关系到我们的账单成本
這直接關係到我們的帳單成本
11:03.903–11:05.903
zh然后在工具调用阶段
然後在工具呼叫階段
11:05.903–11:07.843
zh大模型传了什么参数
大模型傳了什麼參數
11:07.843–11:09.143
zh调用了什么接口
呼叫了什麼介面
11:09.143–11:10.743
zh接口响应花了多少时间
介面回應花了多少時間
11:10.743–11:11.683
zh也要记下来
也要記錄下來
11:11.683–11:13.283
zh最后在输出阶段
最後在輸出階段
11:13.283–11:14.603
zh如果发生了异常
如果發生了異常
11:14.603–11:15.843
zh比如说超时了呀
例如超時了
11:15.843–11:16.923
zh或者是格式不对
或是格式不正確
11:16.923–11:18.983
zh或者触发了我们的服务降级策略
或是觸發了我們的服務降級策略
11:18.983–11:20.823
zh系统也要能够精准的捕捉
系統也要能夠精準捕捉
11:20.823–11:23.303
zh把这些数据完整的记录下来之后
在完整記錄這些數據之後
11:23.303–11:24.343
zh最核心的好处
最核心的好處
11:24.343–11:25.603
zh就是我们可以进行一次
就是我們可以進行一次
11:25.603–11:27.383
zh故障复现和回放调试
故障復現與回放除錯
11:27.383–11:29.623
zh比如线上用户反馈说
例如線上用戶反饋說
11:29.623–11:30.623
zh模型刚才瞎编了
模型剛才胡亂編造了
11:30.623–11:31.903
zh我们不需要去猜
我們不需要去猜測
11:31.903–11:33.863
zh直接把那次调用的数据给导出来
直接將那次呼叫的數據導出
11:33.863–11:35.283
zh在本地重新跑一遍
在本地重新執行一次
11:35.283–11:37.763
zh看看大模型在思维链的哪一步走偏了
看看大模型在思維鏈的哪一步走偏了
11:37.763–11:39.143
zh或者是调工具的时候
或是呼叫工具時
11:39.143–11:40.503
zh传哪个参数传错了
傳錯了哪個參數
11:40.503–11:42.903
zh然后我们就可以精准优化prompt
然後我們就可以精準優化 prompt
11:42.903–11:44.883
zh或者加上超时重视
或是加上超時重試
11:44.883–11:46.563
zh格式纠错这样的容错机制
格式糾錯等容錯機制
11:46.563–11:49.183
zh这才是真正的工程化调试思维
這才是真正的工程化除錯思維
11:49.183–11:50.163
zh
[未翻譯]
11:50.163–11:52.163
zh有了这个评测和可观测性
有了這個評估與可觀測性
11:52.163–11:53.783
zh我们的应用在开发阶段
我們的應用在開發階段
11:53.783–11:55.083
zh已经看起来很健康了
已經看起來很健康了
11:55.083–11:57.543
zh但是如果要真正推上线上
但是如果要真正上線
11:57.543–11:59.303
zh交给成千上万的用户去用
交給成千上萬的用戶去使用
11:59.303–12:01.343
zh这就到了最拉开差距的地方
這就到了最拉開差距的地方
12:01.343–12:02.863
zh我们的第四个核心能力
我們的第四個核心能力
12:02.863–12:04.063
zh生产环境能力
生產環境能力
12:04.063–12:06.463
zh生产环境里有一个非常实际的痛点
生產環境裡有一個非常實際的痛點
12:06.463–12:07.923
zh就是模型特别健忘
就是模型特別健忘
12:07.923–12:09.483
zh而且绘画越长
而且對話越長
12:09.483–12:10.563
zh上下文塞的越满
上下文塞得越滿
12:10.563–12:12.343
zh不仅模型响应变得越来越慢
不僅模型回應變得越來越慢
12:12.343–12:14.843
zh公司的token资费也会像流水一样花出去
公司的 token 費用也會像流水一樣花出去
12:14.843–12:17.623
zh我们不能指望用户每次跟智能体聊天
我們不能指望用戶每次與智能體聊天時
12:17.623–12:19.423
zh都把项目规则和历史对话
都把專案規則和歷史對話
12:19.423–12:20.503
zh复制粘贴一遍吧
複製貼上一次
12:20.503–12:22.843
zh所以在生产及状态管理里
因此,在生產環境的狀態管理中
12:22.843–12:24.363
zh我们首先要在代码库里
我們首先要在程式碼庫中
12:24.363–12:26.103
zh放一个持久化的配置指令文件
放置一個持久化的配置指令文件
12:26.103–12:27.723
zh比如说cloud.md
例如 cloud.md
12:27.723–12:30.203
zh这个文件是随我们的代码库
這個文件會隨著我們的程式碼庫
12:30.203–12:31.323
zh一起做版本控制的
一起進行版本控制
12:31.323–12:32.863
zh当绘画启动时
當繪圖啟動時
12:32.863–12:34.763
zh系统会自动把项目级的规范
系統會自動將專案級的規範
12:34.763–12:36.743
zh测试命令自动加载进去
測試命令自動載入
12:36.743–12:37.583
zh模型一上线
模型一上線
12:37.583–12:39.523
zh立刻就知道自己身处什么项目
立刻就知道自己身處什麼專案
12:39.523–12:40.743
zh需要遵守什么规则
需要遵守什麼規則
12:40.743–12:42.303
zh总进一步呢
再進一步
12:42.303–12:44.183
zh我们要建立一个分层记忆机制
我們要建立分層記憶機制
12:44.183–12:46.443
zh对对上计算机有缓存
就像電腦有快取
12:46.443–12:47.103
zh有内存
有記憶體
12:47.103–12:47.663
zh有硬盘
有硬碟一樣
12:47.663–12:50.743
zh第一层是永远加载的核心索引
第一層是永遠載入的核心索引
12:50.743–12:53.423
zh这部分一般控制在200行以内
這部分通常控制在 200 行以內
12:53.423–12:54.863
zh保持极低的响应延迟
保持極低的回應延遲
12:54.863–12:58.983
zh然后第二层是按需加载的相关文档和当前状态
然後第二層是按需載入的相關文件與當前狀態
12:58.983–13:01.683
zh比如模型当前要修改某个代码文件
例如模型當前要修改某個程式碼文件
13:01.683–13:05.183
zh我们就只要把这个文件和当前的锻点状态加载进来
我們就只要把這個文件和當前的斷點狀態載入進來
13:05.183–13:06.783
zh这里非常重要的一点
這裡非常重要的一點
13:06.783–13:08.023
zh是支持断点恢复
是支援斷點恢復
13:08.023–13:09.683
zh万一服务中断了
萬一服務中斷了
13:09.683–13:10.823
zh智能体重启之后
智能體重啟之後
13:10.823–13:11.903
zh能接着上次的进度干
能接著上次的進度繼續進行
13:11.903–13:12.763
zh不用从头跑
不用從頭開始
13:12.763–13:14.303
zh那第三层
那第三層
13:14.303–13:16.043
zh则是只支持检索的
則是僅支援檢索的
13:16.043–13:17.223
zh完整历史对话转录
完整歷史對話記錄
13:17.223–13:18.823
zh不用到的历史记录
用不到的歷史記錄
13:18.823–13:19.663
zh全部打包归档
全部打包歸檔
13:19.663–13:21.343
zh只有需要的时候才去搜索
只有需要時才去搜尋
13:21.343–13:22.743
zh通过这种分层
透過這種分層方式
13:22.743–13:24.563
zh我们既能处理长周期的任务
我們既能處理長週期的任務
13:24.563–13:26.723
zh又能帮公司省下一大笔的投肯开销
又能幫公司省下大筆的投肯開銷
13:26.723–13:29.043
zh不过有了分层记忆
不過有了分層記憶
13:29.043–13:30.923
zh如果用户一直跟智能体聊下去
如果用戶一直跟智能體聊下去
13:30.923–13:32.103
zh聊了上百轮
聊了上百輪
13:32.103–13:33.583
zh当前的绘画窗口
當前的繪畫視窗
13:33.583–13:35.283
zh还是会面临一个爆满的风险
還是會面臨一個爆滿的風險
13:35.283–13:38.183
zh这时候我们要怎么防止上下纹爆掉呢
這時候我們要怎麼防止上下文爆掉呢
13:38.183–13:41.403
zh其实智能体在这一方面和我们人类很像
其實智能體在這一方面跟我們人類很像
13:41.403–13:44.163
zh人总不能一直不睡觉拼命公渡对吧
人总不能一直不睡覺拼命公渡對吧
13:44.163–13:46.623
zh所以我们可以给智能体引入一个
所以我們可以給智能體引入一個
13:46.623–13:47.963
zh记忆睡眠巩固机制
記憶睡眠鞏固機制
13:47.963–13:50.643
zh在系统空闲的时候默默运行
在系統空閒的時候默默運行
13:50.643–13:52.703
zh我们可以让一个后台智能体
我們可以讓一個後台智能體
13:52.703–13:54.263
zh在用户不说话的闲时
在用戶不說話的閒時
13:54.263–13:56.063
zh去帮我们整理零段的上下纹
去幫我們整理零段的上下文
13:56.063–13:59.643
zh它会自动把过期的冲突的事实给修剪掉
它會自動把過期的衝突的事實給修剪掉
13:59.643–14:02.423
zh去虫之后合并成一个干净的核心索引
去蟲之後合併成一個乾淨的核心索引
14:02.423–14:04.563
zh这就像我们睡觉做梦的时候
這就像我們睡覺做夢的時候
14:04.563–14:06.383
zh大脑会自动整理白天的记忆
大腦會自動整理白天的記憶
14:06.383–14:07.583
zh丢弃无用信息一样
丟棄無用資訊一樣
14:07.583–14:09.583
zh这是一种应用的自我进化
這是一種應用的自我進化
14:09.583–14:11.603
zh同时在绘画进行中
同時在繪畫進行中
14:11.603–14:13.863
zh我们还要配合渐进式上下文压缩
我們還要配合漸進式上下文壓縮
14:13.863–14:15.883
zh随着对话轮次的增加
隨著對話輪次的增加
14:15.883–14:18.483
zh我们不是粗暴的直接截掉前面的对话
我們不是粗暴的直接截掉前面的對話
14:18.483–14:21.163
zh而是施加不同强度的压缩
而是施加不同強度的壓縮
14:21.163–14:23.183
zh近期对话保留最详细的明气
近期對話保留最詳細的明氣
14:23.183–14:25.203
zh中期对话做轻度总结
中期對話做輕度總結
14:25.203–14:27.663
zh而远期对话则进行一个极限折叠
而遠期對話則進行一個極限摺疊
14:27.663–14:29.263
zh这样层层递进
這樣層層遞進
14:29.263–14:30.903
zh既保证了模型不会失忆
既保證了模型不會失憶
14:30.903–14:33.443
zh又彻底解决了上下文窗口爆棚的问题
又徹底解決了上下文視窗爆棚的問題
14:33.443–14:34.663
enOK
好的
14:34.663–14:36.063
zh在生产环境里
在生產環境裡
14:36.063–14:36.963
zh除了记忆管理
除了記憶管理
14:36.963–14:38.303
zh我们还要解决两个问题
我們還要解決兩個問題
14:38.303–14:40.063
zh一个是系统的安全合规
一個是系統的安全合規
14:40.063–14:42.243
zh另一个是高昂的API障碍成本
另一個是高昂的API障礙成本
14:42.243–14:43.763
zh首先是系统安全
首先是系統安全
14:43.763–14:46.283
zh我们不能全指望prompt去叮嘱大模型
我們不能全指望prompt去叮囑大模型
14:46.283–14:47.183
zh你不要违规
你不要違規
14:47.183–14:48.383
zh格式千万要写对
格式千萬要寫對
14:48.383–14:50.483
zh因为模型总有遗忘的时候
因為模型總有遺忘的時候
14:50.483–14:51.743
zh我们的原则是
我們的原則是
14:51.743–14:53.807
zh必须把硬逻辑剥离到prompt
必須把硬邏輯剝離到prompt
14:54.807–14:56.367
zh用一个确定性的生命周期钩子。
用一個確定性的生命週期鉤子。
14:57.027–14:59.007
zh比如,在大模型调用外部工具之前,
比如,在大模型呼叫外部工具之前,
14:59.507–15:01.787
zh系统在底层强行的插入一个前置钩子,
系統在底層強行插入一個前置鉤子,
15:02.147–15:03.407
zh自动降业命令安不安全。
自動檢查命令安不安全。
15:04.167–15:05.147
zh工具跑完了之后,
工具跑完了之後,
15:05.387–15:07.207
zh我们再强行插入一个后置钩子,
我們再強行插入一個後置鉤子,
15:07.207–15:09.707
zh自动去跑一次代码格式化和测试
自動去跑一次程式碼格式化和測試
15:09.707–15:10.947
zh从再配置文件
從再配置檔案
15:10.947–15:14.187
zh这些钩子是在系统底层用代码硬编码的
這些鉤子是在系統底層用程式碼硬編碼的
15:14.187–15:16.067
zh不管大模型怎么产生幻觉
不管大模型怎麼產生幻覺
15:16.067–15:18.147
zh这些安全红线它绝对越不过去
這些安全紅線它絕對越不過去
15:18.147–15:20.407
zh然后就是商业化成本的控制
然後就是商業化成本的控制
15:20.407–15:22.687
zh如果每天接上万个用户请求
如果每天接上萬個使用者請求
15:22.687–15:25.227
zh所有请求都用最贵最强的大模型
所有請求都用最貴最強的大模型
15:25.227–15:26.947
zh公司可能很快就撑不住了
公司可能很快就撐不住了
15:26.947–15:29.527
zh所以我们要设计一个混合模型路由机制
所以我們要設計一個混合模型路由機制
15:29.527–15:31.667
zh当用户的请求进来的时候
當使用者的請求進來的時候
15:31.667–15:33.187
zh先过一个路由节点
先過一個路由節點
15:33.187–15:34.487
zh做动态难度分发
做動態難度分發
15:34.487–15:37.127
zh如果是写系统架构这种高难度任务
如果是寫系統架構這種高難度任務
15:37.127–15:39.827
zh路由就把请求分发给大型颗粒模型
路由就把請求分發給大型顆粒模型
15:39.827–15:42.007
zh那如果是问路打招呼
那如果是問路打招呼
15:42.007–15:44.107
zh或者是简单做一个格式化这种任务
或者是簡單做一個格式化這種任務
15:44.107–15:46.127
zh路由就自动分流给急速小模型
路由就自動分流給急速小模型
15:46.127–15:48.187
zh或者直接命中我们的提示词缓存
或者直接命中我們的提示詞快取
15:48.187–15:50.947
zh这样既兼顾了系统的高并发响应
這樣既兼顧了系統的高併發響應
15:50.947–15:53.047
zh又帮我们省下了大量的API资费
又幫我們省下了大量的API資費
15:53.047–15:54.867
zh这才是合格的商业级架构
這才是合格的商業級架構
15:54.867–15:57.167
zh而在高频的业务场景里
而在高頻的業務場景裡
15:57.167–15:58.967
zh我们最常碰到的落地项目
我們最常碰到的落地專案
15:58.967–16:00.227
zh其实还是企业知识库
其實還是企業知識庫
16:00.227–16:01.547
zh也就是RG系统
也就是RG系統
16:01.547–16:03.567
zh但是在生产环境里
但是在生產環境裡
16:03.567–16:05.787
zh一个合格的RG绝对不是单向的
一個合格的RG絕對不是單向的
16:05.787–16:06.907
zh检索完就丢给模型
檢索完就丟給模型
16:06.907–16:09.267
zh它应该是一个能自我进化的闭环
它應該是一個能夠自我進化的閉環
16:09.267–16:10.647
zh在生产环境里
在生產環境中
16:10.647–16:13.087
zh我们要打通混合检索和重排架构
我們要打通混合檢索和重排架構
16:13.087–16:15.707
zh形成一个数据沉淀模型反母的飞轮
形成一個數據沉澱模型反饋的飛輪
16:15.707–16:17.387
zh第一步混合检索
第一步混合檢索
16:17.387–16:19.007
zh当用户提出问题的时候
當用戶提出問題時
16:19.007–16:21.287
zh我们把向量检索和关键词检索
我們將向量檢索和關鍵字檢索
16:21.287–16:22.387
zh融合在一起
將兩者結合
16:22.387–16:24.107
zh保证无论用户怎么提问
確保無論用戶如何提問
16:24.107–16:26.307
zh我们都能精准定位底层的原始文档
我們都能精準定位底層的原始文件
16:26.307–16:28.707
zh然后第二步重排提纯
然後第二步重排提純
16:28.707–16:31.347
zh搜出来的文档可能有几十个
搜尋出來的文件可能有幾十個
16:31.347–16:33.107
zh那模型看不完也看不过来
模型看不完也看不過來
16:33.367–16:35.187
zh我们用专门的重排模型
我們使用專門的重排模型
16:35.187–16:37.047
zh挑选出最精准的几个节点
挑選出最精準的幾個片段
16:37.047–16:38.307
zh送进大幕型的上下文窗口
送入大模型的上下文視窗
16:38.307–16:39.847
zh接下来第三步
接下來第三步
16:39.847–16:41.147
zh就是结合业务逻辑
就是結合業務邏輯
16:41.147–16:42.987
zh生成最终的一个融合输出
生成最終的融合輸出
16:42.987–16:44.647
zh重点在第四步
重點在第四步
16:44.647–16:45.387
zh数据沉淀
數據沉澱
16:45.387–16:47.887
zh我们要补获用户的真实反馈
我們要捕捉用戶的真實反饋
16:47.887–16:49.687
zh记录高频的查询盲区
記錄高頻的查詢盲區
16:49.687–16:51.227
zh那最后一步
那最後一步
16:51.227–16:52.187
zh反补迭代
反饋迭代
16:52.187–16:53.587
zh根据这些反馈
根據這些反饋
16:53.587–16:54.647
zh自动去更新
自動去更新
16:54.647–16:56.287
zh修正和强化我们的企业知识库
修正和強化我們的企業知識庫
16:56.287–16:58.867
zh那么当这一套流程运转起来之后
那麼當這套流程運轉起來之後
16:58.867–17:00.727
zh知识库里的盲区就会越来越少
知識庫裡的盲區就會越來越少
17:00.727–17:02.347
zh下一轮检索就会更准
下一輪檢索就會更準確
17:02.347–17:04.147
zh我们的应用也会越用越聪明
我們的應用也會越用越聰明
17:04.147–17:05.847
zh好 聊到这里
好聊到這裡
17:05.847–17:07.647
zh我们基本上把一个工业级的
我們基本上把一個工業級的
17:07.647–17:08.847
zh大模型应用开发工程师
大模型應用開發工程師
17:08.847–17:10.727
zh需要具备的能力全都梳理了一遍
需要具備的能力全都梳理了一遍
17:10.727–17:12.567
zh但最后我们来做一个复盘
但最後我們來做一個復盤
17:12.567–17:14.947
zh其实一个真正合格
其實一個真正合格
17:14.947–17:17.467
zh能够帮企业解决实际大模型落地的工程师
能夠幫助企業解決實際大模型落地的工程師
17:17.467–17:20.147
zh它的成长路径其实是非常清晰的
它的成長路徑其實是非常清晰的
17:20.147–17:21.167
zh在业务架构上
在業務架構上
17:21.167–17:23.447
zh我们要从只会写单一prompt
我們要從只會撰寫單一提示
17:23.447–17:25.587
zh升级到能够驾驭多智能体编排
升級到能夠駕馭多智能體編排
17:25.587–17:27.427
zh在工具与协议上
在工具與協議上
17:27.427–17:29.907
zh我们要从硬编码施API
我們要從硬編碼呼叫 API
17:29.907–17:32.067
zh升级到运用标准的AMCP协议
升級到運用標準的 MCP 協議
17:32.067–17:33.347
zh和单一职责工具
和單一職責工具
17:33.347–17:35.027
zh在生产机状态上
在生產環境狀態上
17:35.027–17:37.027
zh我们要从粗暴的内存阶段
我們要從粗暴的記憶體階段
17:37.027–17:39.987
zh升级到分层记忆和动态上下纹压缩
升級到分層記憶與動態上下文壓縮
17:39.987–17:41.387
zh那在系统级整合上
那在系統級整合上
17:41.387–17:43.067
zh我们要从基础的检索
我們要從基礎的檢索
17:43.067–17:46.027
zh升级到刚才讲的RG飞轮和模型路由
升級到剛才提到的 RAG 飛輪與模型路由
17:46.027–17:48.027
zh然后在质量可观测性上
然後在質量可觀測性上
17:48.027–17:50.307
zh升级到全列路追踪和量化评测
升級到全链路追蹤與量化評估

影片筆記:我愿称之为AI圈最具诚意的入门教程!#ai #程序员 #人工智能 #agent

一句話總結

上海交大張卓勝教授主導的開源教程強調,從「小白」轉向「工業級落地」需具備四大核心能力:任務拆解、工具調用、評測與可觀測性,以及生產環境能力,以應對大模型概率性輸出與幻覺帶來的挑戰。

核心重點

  1. 思維轉變:傳統軟體開發追求確定性(1+1=2),而大模型開發基於概率且存在幻覺,開發者需適應這種不確定性。
  2. 四大核心能力
  • 任務拆解能力:根據業務複雜度選擇架構(單次 Prompt、Workflow、多智能體)。
  • 工具調用能力:採用單一職責工具模式、漸進式擴展及沙箱安全分級。
  • 評測與可觀測性:建立黃金數據集、使用 LM as a judge 量化評測,並實現全鏈路可觀測性以支持故障復現。
  • 生產環境能力:包含持久化配置、分層記憶、上下文壓縮、系統安全鉤子、混合模型路由及 RAG 飛輪。
  1. 架構選擇邏輯
  • 低複雜度:單次 Prompt。
  • 中等複雜度:Workflow 工作流(節點固定,信息傳遞顯性)。
  • 高複雜度:多智能體協同(需引入人機協同安全紅線,智能體間獨立上下文)。
  1. 工程設計思路
  • 分佈循環:探索(只讀)-> 規劃(人工確認)-> 執行(寫文件/命令)-> 反饋。
  • 上下文隔離:主智能體與子智能體(搜索、規劃、執行)擁有專屬上下文,僅通過主智能體傳遞標準數據。
  1. 工具與安全
  • 推薦單一職責工具(read, edit, grab, write),避免全能 Mesh 工具。
  • 使用 MCP 標準化加載外部系統。
  • 底層安全沙箱分級:安全命令自動執行,風險命令暫停確認,毀滅性指令硬編碼拉黑。
  1. 生產環境優化
  • 記憶機制:分層記憶(核心索引、按需加載、歷史歸檔)及上下文壓縮(記憶睡眠鞏固、漸進式壓縮)。
  • 安全與成本:硬邏輯剝離至生命週期鉤子(前置檢查、後置格式化/測試);混合模型路由(動態難度分發)。
  • RAG 飛輪:混合檢索、重排提純、融合輸出、數據沉澱與反補迭代。

詳細大綱

一、 思維轉變與核心能力概覽

  • 傳統開發 vs. 大模型開發
  • 傳統開發:確定性邏輯。
  • 大模型開發:概率性輸出,存在幻覺與不確定性。
  • 四大核心能力
  1. 任務拆解能力
  2. 工具調用能力
  3. 評測和可觀測性
  4. 生產環境能力

二、 核心能力一:任務拆解能力

  • 業務複雜度分級與架構匹配
  • 第一檔:低複雜度
  • 特徵:一次性交互,無需記憶狀態。
  • 方案:Damp Prompt(單次提示詞)。
  • 範例:寫郵件、檢查拼寫錯誤。
  • 第二檔:中等複雜度
  • 特徵:需保持高可控性,標準 SOP。
  • 方案:Workflow 工作流
  • 範例:合同審批、財務報表。
  • 特點:節點固定,信息傳遞顯性。
  • 第三檔:高複雜度
  • 特徵:長週期、多角色分工、混沌任務。
  • 方案:多智能體協同
  • 範例:完整軟體模組開發。
  • 要求:引入「人機協同安全紅線」(部署前需人工審核),智能體間獨立上下文。
  • 工程設計思路:分佈循環 + 上下文隔离子智能體
  • 分佈循環(探索-規劃-執行)
  1. 探索:只讀權限(讀文檔、搜代碼)。
  2. 規劃:制定執行計劃,加入人工確認。
  3. 執行:獲得完整操作權限(寫文件、運命令)。
  4. 反饋:若報錯,回到探索階段。
  • 上下文隔离子智能體
  • 設立主智能體與子智能體(搜索、規劃、執行)。
  • 各子智能體擁有專屬上下文,僅通過主智能體進行標準數據傳遞,避免信息混淆。

三、 核心能力二:工具調用能力

  • 工具設計模式
  • 反面模式:全能 Mesh 工具(類似通用命令行),風險高,難以授權審查。
  • 推薦模式單一職責工具模式
  • 將工具拆分為 read, edit, grab, write 等專業工具。
  • 嚴格參數規範(Schema),邊界明確。
  • 可分配獨立權限,降低理解偏差。
  • 工具管理與擴展原則
  1. 漸進式工具擴展
  • 初期僅提供基礎工具(讀寫修改)。
  • 後續按需接入外部系統,使用 MCP(模型上下文協議) 標準化加載。
  • 遠程主機或數據庫介入遠程工具。
  1. 底層安全沙箱與風險分級
  • 安全命令(測試、看差異):自動執行。
  • 風險命令(強推代碼):暫停並彈出用戶確認。
  • 毀滅性指令:在沙箱底層硬編碼拉黑,禁止運行。

四、 核心能力三:評測和可觀測性

  • 量化評測流程(告別主觀體感)
  1. 構建黃金數據集:覆蓋核心真實業務場景(經典提問與標準答案)。
  2. 自動打分:引入強推理模型作為裁判(LM as a judge)。
  3. 多維度指標體系
  • 幻覺率。
  • 答案相關性。
  • 檢索召回率。
  • 響應耗時。
  • 全鏈路可觀測性設計
  • 目的:解決大模型「黑盒」問題,支持故障復現。
  • 記錄階段
  1. 輸入階段:原始 Prompt 及系統狀態。
  2. 推理中間:思維鏈(Chain of Thought)、Token 消耗(成本)。
  3. 工具調用階段:參數、接口、響應時間。
  4. 輸出階段:異常捕捉(超時、格式錯誤、服務降級)。
  • 應用:導出調用數據在本地重新跑,定位思維鏈偏差或參數錯誤,優化 Prompt 或增加容錯機制。

五、 核心能力四:生產環境能力

  • 狀態管理與記憶機制
  1. 持久化配置:代碼庫中放置持久化配置指令文件(如 cloud.md),隨版本控制,自動加載項目規範。
  2. 分層記憶機制
  • 第一層(核心索引):永遠加載,控制在 200 行以內,低延遲。
  • 第二層(按需加載):相關文檔與當前狀態(支持斷點恢復)。
  • 第三層(歷史歸檔):僅支持檢索的完整歷史對話,按需搜索。
  1. 上下文壓縮與管理
  • 記憶睡眠鞏固機制:閒時由後台智能體整理零散上下文,修剪衝突事實,合併為核心索引。
  • 漸進式上下文壓縮
  • 近期對話:保留詳細細節。
  • 中期對話:輕度總結。
  • 遠期對話:極限摺疊。
  • 系統安全與成本優化
  1. 系統安全(硬邏輯)
  • 將硬邏輯剝離出 Prompt,使用確定性的生命週期鉤子。
  • 前置鉤子:強行檢查命令安全性。
  • 後置鉤子:強行執行代碼格式化與測試。
  1. 混合模型路由機制
  • 動態難度分發。
  • 高難度任務(寫架構):大型顆粒模型。
  • 簡單任務(問路、格式化):急速小模型或命中提示詞緩存。
  • 企業知識庫(RAG)飛輪
  1. 混合檢索:向量檢索 + 關鍵詞檢索。
  2. 重排提純:使用重排模型篩選精準節點。
  3. 融合輸出:結合業務邏輯生成最終結果。
  4. 數據沉澱:捕獲用戶反饋,記錄高頻查詢盲區。
  5. 反補迭代:自動更新、修正和強化企業知識庫。

六、 總結:工程師成長路徑

  • 業務架構:單一 Prompt -> 多智能體編排。
  • 工具與協議:硬編碼 API -> 標準 MCP 協議 與單一職責工具。
  • 生產機狀態:粗暴內存階段 -> 分層記憶與動態上下文壓縮。
  • 系統級整合:基礎檢索 -> RAG 飛輪與模型路由。
  • 質量可觀測性:基礎檢索 -> 全鏈路追蹤與量化評測。

工具 / 模型 / 名詞整理

  • GitHub
  • 上海交大(開源教程來源)
  • 張卓勝教授
  • API
  • Prompt(提示詞)
  • Damp Prompt(文中提及的低複雜度方案名稱)
  • Workflow(工作流)
  • 智能體 / 大模型
  • MCP(模型上下文協議,Model Context Protocol)
  • LM as a judge(大模型作為裁判)
  • RAG(檢索增強生成,文中提及「RG系統」)
  • cloud.md(示例配置文件名)
  • AMCP(文中總結部分提及)
  • Chain of Thought(思維鏈)
  • RAG 飛輪(企業知識庫迭代機制)
  • 靜默退化(模型在未被測試到的角落變差的情況)

操作流程整理

任務架構選擇流程

  1. 評估業務複雜度
  • 若為一次性交互、無狀態:選擇 Damp Prompt
  • 若需高可控性、標準 SOP:選擇 Workflow 工作流
  • 若為長週期、多角色、混沌任務:選擇 多智能體協同
  1. 多智能體協同執行步驟
  • 探索階段:智能體獲得只讀權限(讀文檔、搜代碼)。
  • 規劃階段:智能體制定執行計劃,觸發人工確認(安全紅線)。
  • 執行階段:智能體獲得完整操作權限(寫文件、運命令)。
  • 反饋階段:若執行報錯,返回探索階段重新分析。

工具調用與安全管理流程

  1. 工具設計:採用單一職責工具(read, edit, grab, write),嚴格定義 Schema。
  2. 擴展機制
  • 初期提供基礎讀寫工具。
  • 後續通過 MCP 協議 標準化加載外部系統或遠程數據庫。
  1. 沙箱執行分級
  • 安全命令(如測試、看差異):系統自動執行。
  • 風險命令(如強推代碼):系統暫停,彈出用戶確認。
  • 毀滅性指令:在沙箱底層硬編碼拉黑,禁止運行。

評測與可觀測性實施流程

  1. 構建黃金數據集:整理核心真實業務場景的經典提問與標準答案。
  2. 自動化評測
  • 使用強推理模型作為裁判(LM as a judge)進行自動打分。
  • 計算指標:幻覺率、答案相關性、檢索召回率、響應耗時。
  1. 全鏈路追蹤記錄
  • 記錄輸入(Prompt、系統狀態)。
  • 記錄推理中間過程(思維鏈、Token 消耗)。
  • 記錄工具調用(參數、接口、響應時間)。
  • 記錄輸出異常(超時、格式錯誤、服務降級)。
  1. 故障復現與優化:導出調用數據在本地重新運行,定位思維鏈偏差或參數錯誤,進而優化 Prompt 或增加容錯機制。

生產環境配置與維護流程

  1. 持久化配置:在代碼庫放置 cloud.md 等配置文件,隨版本控制自動加載項目規範。
  2. 記憶管理
  • 核心索引:永遠加載(<200行)。
  • 按需加載:相關文檔與當前狀態(支持斷點恢復)。
  • 歷史歸檔:完整歷史對話,按需檢索。
  1. 上下文壓縮
  • 閒時鞏固:後台智能體整理零散上下文,修剪衝突,合併為核心索引。
  • 漸進壓縮:近期保留細節,中期輕度總結,遠期極限摺疊。
  1. 路由與檢索
  • 混合模型路由:高難度任務分發至大型模型,簡單任務使用小模型或命中緩存。
  • RAG 飛輪:混合檢索(向量+關鍵詞)-> 重排提純 -> 融合輸出 -> 數據沉澱 -> 反補迭代更新知識庫。

值得注意的限制或風險

  1. 大模型的不確定性:基於概率輸出,存在幻覺,無法像傳統軟體開發那樣追求絕對確定性。
  2. 全能工具的風險:全能 Mesh 工具(類似通用命令行)風險高,難以進行授權審查。
  3. 靜默退化:模型可能在未被測試到的角落變差,需通過量化評測和全鏈路可觀測性來發現。
  4. 安全紅線:高複雜度多智能體任務需引入「人機協同安全紅線」,部署前需人工審核。
  5. 上下文混淆:若子智能體間未進行上下文隔離,僅通過主智能體傳遞標準數據,可能導致信息混淆。
  6. 成本與效率平衡:需通過混合模型路由和上下文壓縮來控制 Token 開銷與響應延遲。

逐字稿辨識疑點

  • Damp Prompt:逐字稿中多次提及「Damp Prompt」作為低複雜度任務的解決方案。在 AI 領域通常稱為「Simple Prompt」或僅稱「Prompt」。此處「Damp」可能為聽寫錯誤或口誤。
  • RG系統:逐字稿最後部分提及「企業知識庫,也就是RG系統」。標準術語通常為「RAG」(Retrieval-Augmented Generation)。此處「RG」可能為聽寫錯誤。
  • AMCP協議:逐字稿總結部分提及「運用標準的AMCP協議」。前文提及的是「MCP」(Model Context Protocol)。此處「AMCP」可能為聽寫錯誤或口誤。
  • 大木型:逐字稿中出現「喂給大木型」、「工具給太多,大木型在做選擇」。應為「大模型」的聽寫錯誤。
  • 強推代碼:在安全分級部分提及「強推代碼」。通常術語為「強推代碼」或「強制推送代碼」(Force Push),此處表述尚可,但需注意語境。
  • 投肯開銷:逐字稿提及「省下一大筆的投肯開銷」。應為「Token 開銷」的聽寫錯誤。
  • 明氣:逐字稿提及「保留最詳細的明氣」。應為「細節」或「信息」的聽寫錯誤。
  • 去虫:逐字稿提及「去虫之後合併」。應為「去重」的聽寫錯誤。
  • 公渡:逐字稿提及「拼命公渡」。應為「溝通」或「工作」的聽寫錯誤。
  • 靜默退化:文中提及此術語,

尚未產生學習筆記

請在 Telegram 指令最後加上「學習」,例如:videonote 網址 英文 雙語 學習