WEBVTT

00:00:00.000 --> 00:00:00.920
OK

00:00:00.920 --> 00:00:11.600
接下来我们就以项目实战的方式啊

00:00:11.600 --> 00:00:13.340
带大家基于Codex

00:00:13.340 --> 00:00:17.420
全流程的去开发一个RUG智能客服系统

00:00:17.420 --> 00:00:20.060
那首先给大家演示一下这个系统

00:00:20.060 --> 00:00:21.340
它的一个功能

00:00:21.340 --> 00:00:24.840
那就是一个比较简单的一个对话页面啊

00:00:24.840 --> 00:00:25.900
那么首先的话

00:00:25.900 --> 00:00:28.480
比如说大家公司内部有一些

00:00:28.480 --> 00:00:30.340
行业的一些知识库

00:00:30.340 --> 00:00:32.700
比如说是做这个电商的啊

00:00:32.700 --> 00:00:34.640
或者是传统的像银行呀

00:00:34.640 --> 00:00:35.600
政务啊

00:00:35.600 --> 00:00:37.460
各种各样的这个行业是吧

00:00:37.460 --> 00:00:40.260
那比如说我们有一些知识库啊

00:00:40.260 --> 00:00:41.600
假设大家的这个

00:00:41.600 --> 00:00:44.040
是做这个银行客服的

00:00:44.040 --> 00:00:45.880
那这个里面比如说我们有一些

00:00:45.880 --> 00:00:47.400
常见的问题

00:00:47.400 --> 00:00:51.480
比如说哎这个查询一些这个余额呀

00:00:51.480 --> 00:00:53.160
什么修改账号密码呀

00:00:53.160 --> 00:00:55.620
就是这种常见的一些问题等等的啊

00:00:55.620 --> 00:00:57.920
好那就是这么一个知识库

00:00:57.920 --> 00:00:59.160
那现在的话

00:00:59.160 --> 00:01:00.700
就是我们内部啊

00:01:00.700 --> 00:01:02.000
要把这些知识库的话

00:01:02.000 --> 00:01:03.820
做一个整合

00:01:03.820 --> 00:01:06.980
然后到我们的这个客服系统里面去

00:01:06.980 --> 00:01:08.840
因为以前的这个AI的话

00:01:08.840 --> 00:01:12.020
其实他去回答问题的时候啊

00:01:12.020 --> 00:01:13.220
如果说他没有参考

00:01:13.220 --> 00:01:15.120
公司内部的一些知识库的话

00:01:15.120 --> 00:01:16.900
他回答的问题的话

00:01:16.900 --> 00:01:17.880
就不是特别专业

00:01:17.880 --> 00:01:18.900
所以现在的话

00:01:18.900 --> 00:01:21.560
我们要做一个这个基于Rug啊

00:01:21.560 --> 00:01:22.260
Rug的话

00:01:22.260 --> 00:01:25.160
全称叫做检索增强生成

00:01:25.160 --> 00:01:26.040
也就是说

00:01:26.040 --> 00:01:28.800
我们这个以前AI生成内容的话

00:01:28.800 --> 00:01:32.480
都是根据这个AI自己训练的啊

00:01:32.480 --> 00:01:33.080
像大模型

00:01:33.080 --> 00:01:33.820
他训练一些

00:01:33.820 --> 00:01:35.160
预训练的一些数据

00:01:35.160 --> 00:01:36.460
然后去生成的

00:01:36.460 --> 00:01:38.520
所以说他给你的一个结果的话

00:01:38.520 --> 00:01:41.300
他肯定是一些比较通用的一些结果

00:01:41.300 --> 00:01:43.020
不是属于我们这个公司

00:01:43.020 --> 00:01:44.640
某个行业特定的一个回答

00:01:44.640 --> 00:01:47.620
他可能就有那种普世性

00:01:47.620 --> 00:01:49.240
但是的话不是特别专业

00:01:49.240 --> 00:01:52.280
所以我们既然内部有一些知识库文档的话

00:01:52.280 --> 00:01:53.960
我们现在想投位给AI

00:01:53.960 --> 00:01:55.040
但是呢

00:01:55.040 --> 00:01:57.340
我们又不想去做这个预训练跟微调

00:01:57.340 --> 00:01:58.960
因为那个成本比较高是吧

00:01:58.960 --> 00:02:01.680
所以说业界的话就有一种解决方案叫Rug

00:02:01.680 --> 00:02:05.380
你可以理解就是给这个AI挂了一个知识库

00:02:05.380 --> 00:02:08.320
就相当于你在学习的时候

00:02:08.320 --> 00:02:11.360
你可以去图书馆里面去查一些这个书籍

00:02:11.360 --> 00:02:13.120
然后去写一些文章

00:02:13.120 --> 00:02:14.840
这样的话你就会做一个参考

00:02:14.840 --> 00:02:17.960
那么AI有了这个参考之后的话

00:02:17.960 --> 00:02:21.760
他帮你去生成这个答案的时候

00:02:21.760 --> 00:02:25.200
他就会参考里面的一些核心观点

00:02:25.200 --> 00:02:26.740
然后去做一些总结回答

00:02:26.740 --> 00:02:29.100
比如说我们现在问他一个问题啊

00:02:29.100 --> 00:02:31.800
如果说我们没有做一个这个

00:02:31.800 --> 00:02:34.400
RAG系统的一个整合的话

00:02:34.400 --> 00:02:36.940
那么他你去问这个问题的话

00:02:36.940 --> 00:02:39.540
他可能就给你一个啊

00:02:39.540 --> 00:02:41.220
他可能你问的都不是这个

00:02:41.220 --> 00:02:43.680
这个银行这个行业的是吧

00:02:43.680 --> 00:02:44.740
他不是金融行业的

00:02:44.740 --> 00:02:46.600
他可能是其他行业的答案就给你了

00:02:46.600 --> 00:02:47.720
但是如果说

00:02:47.720 --> 00:02:51.240
你给他做了一个知识库的一个整合的话

00:02:51.240 --> 00:02:52.680
那大家就会看到啊

00:02:52.680 --> 00:02:55.740
他会调用我们的这个银行的这个知识库

00:02:55.740 --> 00:02:57.220
进行一个查询啊

00:02:57.220 --> 00:02:58.020
大家看啊

00:02:58.020 --> 00:03:01.040
这个是他的一个知识的一个检索结果啊

00:03:01.040 --> 00:03:03.420
但这个里面这里展示有点问题

00:03:03.420 --> 00:03:04.520
我们重新来问一下

00:03:04.520 --> 00:03:07.000
就是有了这个结果之后的话

00:03:07.000 --> 00:03:09.820
他其实就会跟你去什么呢

00:03:09.820 --> 00:03:12.440
做一个向量的数据库的一个

00:03:12.440 --> 00:03:14.020
这个相似度的一个检索

00:03:14.020 --> 00:03:15.780
那么检索完之后啊

00:03:15.780 --> 00:03:18.500
你看这个就是我们知识库检索的一个结果

00:03:18.500 --> 00:03:18.780
是吧

00:03:18.780 --> 00:03:19.980
那这个结果的话

00:03:19.980 --> 00:03:21.600
其实就是在这个里面啊

00:03:21.600 --> 00:03:23.380
我们这个知识库文档

00:03:23.380 --> 00:03:26.880
这个文档的话是存放到了这个向量数据库里面

00:03:26.880 --> 00:03:28.280
那么这个向量数据库的话

00:03:28.280 --> 00:03:29.960
它是根据这段话

00:03:29.960 --> 00:03:32.100
然后做一个向量的相似度匹配

00:03:32.100 --> 00:03:33.540
匹配完了之后的话

00:03:33.540 --> 00:03:37.180
再去做一个这个内容的一个生成

00:03:37.180 --> 00:03:39.860
所以说这个里面的话

00:03:39.860 --> 00:03:41.240
其实就是啊

00:03:41.240 --> 00:03:43.580
我们首先要对这个文档做一个向量化

00:03:43.580 --> 00:03:45.120
做完向量化之后的话

00:03:45.120 --> 00:03:46.640
把它存在到向量数据库里面去

00:03:46.640 --> 00:03:48.520
然后当用户提问题的时候

00:03:48.520 --> 00:03:50.920
我们要用这个agent

00:03:50.920 --> 00:03:54.380
那本次我们的这个agent实现的话

00:03:54.380 --> 00:03:55.620
是基于一个框架

00:03:55.620 --> 00:03:57.380
叫做这个long graph

00:03:57.380 --> 00:03:59.640
然后并且还有一些long chain的一些酷

00:03:59.640 --> 00:04:02.940
这个是我们的一个基础的一个框架

00:04:02.940 --> 00:04:05.640
那整个相当于我们就基于long graph

00:04:05.640 --> 00:04:07.100
去实现一个agent的应用

00:04:07.100 --> 00:04:09.940
让他去做一个知识库的一个检索

00:04:09.940 --> 00:04:11.700
然后检索完之后的话

00:04:11.700 --> 00:04:15.240
相当于做一个这个向量相似度的匹配

00:04:15.240 --> 00:04:16.220
评约完之后

00:04:16.220 --> 00:04:18.000
再把这些个内容

00:04:18.000 --> 00:04:19.320
拼装成提示词

00:04:19.320 --> 00:04:21.560
丢给这个大模型

00:04:21.560 --> 00:04:23.060
然后总结性的做一个回答

00:04:23.060 --> 00:04:25.040
所以大家问这些专业问题的时候

00:04:25.040 --> 00:04:26.120
你会发现

00:04:26.120 --> 00:04:27.660
他的这些回答的话

00:04:27.660 --> 00:04:28.800
是非常准确的

00:04:28.800 --> 00:04:30.500
因为他做了这个

00:04:30.500 --> 00:04:31.740
相似度的一个匹配

00:04:31.740 --> 00:04:32.980
比如说你问的这个

00:04:32.980 --> 00:04:34.660
网上银行是吧

00:04:34.660 --> 00:04:36.440
你看这个里面

00:04:36.440 --> 00:04:39.360
他就基本上是参考这个回答的

00:04:39.360 --> 00:04:41.160
所以这个答案会比较精准

00:04:41.160 --> 00:04:42.920
这就是我们要做的一个

00:04:42.920 --> 00:04:46.120
AI的一个智能客服的这么一个系统

00:04:46.120 --> 00:04:48.280
所以这个系统的一个关键点的话

00:04:48.280 --> 00:04:50.280
其实就是基于这个RUG的一个系统

00:04:50.280 --> 00:04:52.680
目前来说啊

00:04:52.680 --> 00:04:54.700
只要是涉及到智能客服系统

00:04:54.700 --> 00:04:57.080
你要追求这个答案的准确性的话

00:04:57.080 --> 00:05:00.480
基本上都是基于RUG的这个方案去做的

00:05:00.480 --> 00:05:03.580
那如果说你有这个模型微调

00:05:03.580 --> 00:05:05.220
渲电的这个条件的话

00:05:05.220 --> 00:05:06.740
用微调去做的也有

00:05:06.740 --> 00:05:09.860
但是像大部分场景啊

00:05:09.860 --> 00:05:10.920
为了节省成本的话

00:05:10.920 --> 00:05:13.720
其实都是基于Rug的这个模式去做的

00:05:13.720 --> 00:05:16.100
所以说我们现在要明确一个需求

00:05:16.100 --> 00:05:19.020
我们要做一个这个银行的智能客服系统

00:05:19.020 --> 00:05:21.360
然后当用户在提问里面

00:05:21.360 --> 00:05:23.480
比如说我们如何去查学那个余额是吧

00:05:23.480 --> 00:05:25.560
那么这个系统的话

00:05:25.560 --> 00:05:27.360
就要做如下几件事情

00:05:27.360 --> 00:05:28.420
首先的话

00:05:28.420 --> 00:05:30.340
他从这个行业知识库里面

00:05:30.340 --> 00:05:31.620
就这个行业知识库里面

00:05:31.620 --> 00:05:32.940
去做一个检索

00:05:32.940 --> 00:05:33.920
这个知识库的话

00:05:33.920 --> 00:05:35.000
咱们自己可以新增

00:05:35.000 --> 00:05:36.760
就是我们在这个里面

00:05:36.760 --> 00:05:38.780
我们可以选用OpenAI的这个

00:05:38.780 --> 00:05:39.920
Embading模型是吧

00:05:39.920 --> 00:05:41.780
做一个向量化存储啊

00:05:41.780 --> 00:05:43.680
就是做一个这个向量化的一个转化

00:05:43.680 --> 00:05:45.080
把它转换成embedding

00:05:45.080 --> 00:05:46.980
它的一些这个向量坐标

00:05:46.980 --> 00:05:48.320
然后向量数据库的话

00:05:48.320 --> 00:05:49.800
我们这里用的是Clamour啊

00:05:49.800 --> 00:05:51.040
这是我们啊

00:05:51.040 --> 00:05:52.840
有一个新增知识库啊

00:05:52.840 --> 00:05:54.060
因为我们要做一个出手化嘛

00:05:54.060 --> 00:05:55.400
所以我们要创建一个知识库

00:05:55.400 --> 00:06:02.460
所以这个首先这个系统就得从行业知识库里面去检索最相关的一些内容

00:06:02.460 --> 00:06:08.400
然后的话让大模型基于检索到的内容去生成有依据的这个回答啊

00:06:08.400 --> 00:06:11.980
就是我不能说让AI就直接去回答了

00:06:11.980 --> 00:06:12.220
是吧

00:06:12.220 --> 00:06:13.580
你要把检索的内容

00:06:13.580 --> 00:06:17.240
组装成提示词丢给这个AI

00:06:17.240 --> 00:06:19.420
然后再去做内容的一个生成

00:06:19.420 --> 00:06:21.640
并且界面上的话

00:06:21.640 --> 00:06:23.060
我们要做一个流逝回答

00:06:23.060 --> 00:06:24.540
流逝回答什么意思啊

00:06:24.540 --> 00:06:26.300
就比如说你问他一个问题的话

00:06:26.300 --> 00:06:29.120
这里是一个字一个字迸穿

00:06:29.120 --> 00:06:31.400
就是这种打字机的这种效果

00:06:31.400 --> 00:06:32.700
但是这里面的话

00:06:32.700 --> 00:06:36.180
我们这里是一次性输出出来的

00:06:36.180 --> 00:06:38.040
所以我们其实可以改进一下

00:06:38.040 --> 00:06:39.820
把它做一个流逝的回答啊

00:06:39.820 --> 00:06:40.660
这里有一个参数

00:06:40.660 --> 00:06:43.060
把它做成一个流逝调用就可以了

00:06:43.060 --> 00:06:44.380
所以说啊

00:06:44.380 --> 00:06:45.660
整个一个过程的话

00:06:45.660 --> 00:06:47.060
其实很简单啊

00:06:47.060 --> 00:06:49.680
就是做一个知识库的一个检索匹配

00:06:49.680 --> 00:06:52.520
然后把拿到的一个结果

00:06:52.520 --> 00:06:54.080
去丢给这个大模型

00:06:54.080 --> 00:06:54.940
然后的话

00:06:54.940 --> 00:06:58.160
再去做一个流逝的一个回答啊

00:06:58.160 --> 00:06:59.780
虽然这个步骤很简单

00:06:59.780 --> 00:07:01.720
但是我们实现的这个逻辑的话

00:07:01.720 --> 00:07:03.760
还是稍微有点复杂的啊

00:07:03.760 --> 00:07:04.320
那首先的话

00:07:04.320 --> 00:07:05.360
我会给大家讲一下

00:07:05.360 --> 00:07:07.040
这个最终的一个架构啊

00:07:07.040 --> 00:07:10.240
然后我们等一下就会带大家去基于Codex

00:07:10.240 --> 00:07:12.920
从零到一去搭建这么一个项目啊

00:07:12.920 --> 00:07:14.200
因为现在啊

00:07:14.200 --> 00:07:16.880
我们有了这个Codex之后啊

00:07:16.880 --> 00:07:19.100
这个我们去开发项目的效率会很高

00:07:19.100 --> 00:07:22.220
所以说我们让他把这个架构啊

00:07:22.220 --> 00:07:24.340
或者说我们自己把架构做出来之后

00:07:24.340 --> 00:07:26.580
然后你让他去回答的话啊

00:07:26.580 --> 00:07:27.580
去去执行的话

00:07:27.580 --> 00:07:31.220
其实这个开发起来效率就会很高

00:07:31.220 --> 00:07:35.380
那这个是我之前做的一个这个事例啊

00:07:35.380 --> 00:07:37.260
就我之前已经把这个项目写出来了

00:07:37.260 --> 00:07:39.480
那么这里面的话

00:07:39.480 --> 00:07:40.420
我们就给大家看一下

00:07:40.420 --> 00:07:41.740
我们这个架构的一个设计

00:07:41.740 --> 00:07:42.720
首先的话

00:07:42.720 --> 00:07:44.240
我们整个前端页面啊

00:07:44.240 --> 00:07:45.960
这个前端页面是基于一个叫

00:07:45.960 --> 00:07:48.240
Streamlit的一个库去实现的

00:07:48.240 --> 00:07:49.540
那么这个库的话

00:07:49.540 --> 00:07:52.380
就是一个python前端开发的一个库啊

00:07:52.380 --> 00:07:54.780
非常方便做一些python的

00:07:54.780 --> 00:07:56.700
这种前端页面的一个展示啊

00:07:56.700 --> 00:07:56.940
是吧

00:07:56.940 --> 00:07:58.460
比如说做一个聊天的这种界面

00:07:58.460 --> 00:08:00.380
它的空间非常丰富啊

00:08:00.380 --> 00:08:01.720
所以我们整个的话

00:08:01.720 --> 00:08:03.040
是基于了这个框架

00:08:03.040 --> 00:08:04.600
去做了一个前端应用啊

00:08:04.600 --> 00:08:05.169
好

00:08:05.169 --> 00:08:07.069
然后包括侧边栏啊

00:08:07.069 --> 00:08:08.169
还有这个logo是吧

00:08:08.169 --> 00:08:09.029
你看这个侧边栏

00:08:09.029 --> 00:08:10.329
我们可以隐藏跟展示

00:08:10.329 --> 00:08:12.689
就是一个多页面的这么一个导航

00:08:12.689 --> 00:08:13.769
对话加设置

00:08:13.769 --> 00:08:17.389
然后我们的这个智能客服对话啊

00:08:17.389 --> 00:08:19.689
就是Rog这一块的一个核心技术的话

00:08:19.689 --> 00:08:21.569
是基于Long Graph去实现的

00:08:21.569 --> 00:08:22.189
Long Graph

00:08:22.189 --> 00:08:24.629
大家应该都有听说过

00:08:24.629 --> 00:08:25.909
大家可能听说过Long Chain

00:08:25.909 --> 00:08:27.049
Long Chain的话

00:08:27.049 --> 00:08:30.589
是目前做AI制整体应用开发的一个框架

00:08:30.589 --> 00:08:30.889
是吧

00:08:30.889 --> 00:08:35.109
就是我们可以做一些AI应用

00:08:35.109 --> 00:08:35.449
是吧

00:08:35.449 --> 00:08:36.549
不光光是制整体

00:08:36.549 --> 00:08:38.309
它可以做很多AI应用

00:08:38.309 --> 00:08:40.289
但是它主要还是做制整体

00:08:40.289 --> 00:08:42.029
那么Long Graph的话

00:08:42.029 --> 00:08:44.409
它就专门是做一些复杂的制整体

00:08:44.409 --> 00:08:46.489
它是一种工作流的这种方式

00:08:46.489 --> 00:08:47.909
叫这个流程

00:08:47.909 --> 00:08:48.229
是吧

00:08:48.229 --> 00:08:49.589
就是这种图形制的

00:08:49.589 --> 00:08:52.009
就是面向这个图形式的啊

00:08:52.009 --> 00:08:53.029
流程式的这种

00:08:53.029 --> 00:08:55.509
多智能体的这种代理啊

00:08:55.509 --> 00:08:56.209
这种场景啊

00:08:56.209 --> 00:08:58.269
就是比较企业级的这种复杂的

00:08:58.269 --> 00:09:00.589
agent的这种开发啊

00:09:00.589 --> 00:09:02.689
这种多智能体开发

00:09:02.689 --> 00:09:04.869
目前一般是基于Langgraph去做的

00:09:04.869 --> 00:09:06.689
是一个非常成熟的一个框架

00:09:06.689 --> 00:09:10.509
所以我们要基于Langgraph

00:09:10.509 --> 00:09:12.569
去实现整个Rug的一个核心流程

00:09:12.569 --> 00:09:16.609
然后包括一些这个行业的一些知识库啊

00:09:16.609 --> 00:09:18.289
比如说我们要做一些这个

00:09:18.289 --> 00:09:20.529
上传切分

00:09:20.529 --> 00:09:21.209
下量化

00:09:21.209 --> 00:09:21.589
是吧

00:09:21.589 --> 00:09:23.669
那对应到我们这个工作里面

00:09:23.669 --> 00:09:25.809
我们现在要上传这个下量数据库

00:09:25.809 --> 00:09:26.489
是吧

00:09:26.489 --> 00:09:29.889
就是文档上传上传这个知识库

00:09:29.889 --> 00:09:31.229
新增一个知识库

00:09:31.229 --> 00:09:32.649
然后去给他做一些处理

00:09:32.649 --> 00:09:35.089
然后的话就是

00:09:35.089 --> 00:09:36.369
还要做切分

00:09:36.369 --> 00:09:37.909
比如说你这个文件很大

00:09:37.909 --> 00:09:38.649
你有一兆

00:09:38.649 --> 00:09:40.149
那我们不能直接说

00:09:40.149 --> 00:09:41.449
称到下量数据库里去了

00:09:41.449 --> 00:09:43.049
因为你把这个一兆的文件

00:09:43.049 --> 00:09:44.609
直接给他转化成下量的话

00:09:44.609 --> 00:09:46.969
首先这个上下文可能会抄

00:09:46.969 --> 00:09:47.309
是吧

00:09:47.309 --> 00:09:48.849
那有些啊

00:09:48.849 --> 00:09:50.409
那个模型

00:09:50.409 --> 00:09:51.929
它不只是这么大的一个上下文

00:09:51.929 --> 00:09:53.989
那这里就会涉及到一个切分的问题

00:09:53.989 --> 00:09:55.089
啊

00:09:55.089 --> 00:09:55.969
就是一个切分策略

00:09:55.969 --> 00:09:58.609
比如说我这么大的一个文档啊

00:09:58.609 --> 00:09:59.969
应该怎么来切分

00:09:59.969 --> 00:10:01.709
是按这个段落来切

00:10:01.709 --> 00:10:02.649
换行来切

00:10:02.649 --> 00:10:03.649
还是怎么样来切

00:10:03.649 --> 00:10:07.409
这个都是有这个对应的一个策略的

00:10:07.409 --> 00:10:08.729
包括做一些向量化

00:10:08.729 --> 00:10:09.089
是吧

00:10:09.089 --> 00:10:12.709
这个整个是我们有一套成熟的一个方案啊

00:10:12.709 --> 00:10:13.729
然后这个

00:10:13.729 --> 00:10:16.669
然后就是检索是吧

00:10:17.309 --> 00:10:20.289
检索我们这里可以给它封做一个工具啊

00:10:20.289 --> 00:10:23.369
这个工具的话主要就是做用来做Rug的一个检索的

00:10:23.369 --> 00:10:26.969
那这里面我们相当于是共用了限量数据库啊

00:10:26.969 --> 00:10:29.789
就是我们定义了一个限量数据库啊

00:10:29.789 --> 00:10:32.909
然后我们不管是存储也好还是检索也好

00:10:32.909 --> 00:10:34.409
都要用到这个限量数据库

00:10:34.409 --> 00:10:36.729
所以这里面是一个公共的一个模块

00:10:36.729 --> 00:10:41.349
然后包括我们还要去做一些这个模型的一个揭露是吧

00:10:41.349 --> 00:10:47.289
那这里面的模型我默认用的是OpenAI的这个GPT4O的这么一个模型啊

00:10:47.309 --> 00:10:49.569
当然大家你也可以选择其他模型

00:10:49.569 --> 00:10:51.949
用Deep Seek或者是本地部署模型

00:10:51.949 --> 00:10:53.689
或者千万都是OK的

00:10:53.689 --> 00:10:57.969
关键是看大家就是你目前有哪些模型

00:10:57.969 --> 00:10:59.869
你可以自由的去选择

00:10:59.869 --> 00:11:03.209
只是说你如果用的是千万的一个模型的话

00:11:03.209 --> 00:11:04.689
那可能有一些这个参数

00:11:04.689 --> 00:11:05.789
可能就要做一些调整

00:11:05.789 --> 00:11:07.889
我这里用的是OpenAI的这个模型

00:11:07.889 --> 00:11:11.809
然后包括我们还可以去用一些这个

00:11:11.809 --> 00:11:13.409
embedding是吧

00:11:13.409 --> 00:11:14.709
他会用一些工具类

00:11:14.709 --> 00:11:18.909
所以我们这里面要写一个这个工具的这么一个啊

00:11:18.909 --> 00:11:19.869
这个脚本是吧

00:11:19.869 --> 00:11:21.229
这个脚本啊

00:11:21.229 --> 00:11:24.049
主要是就是用来去做一些模型的一些介入的

00:11:24.049 --> 00:11:25.889
比如说掉接口啊等等啊

00:11:25.889 --> 00:11:27.909
那向量数据库我们用的是Clamour啊

00:11:27.909 --> 00:11:30.909
这个是底层的一个向量数据库存储啊

00:11:30.909 --> 00:11:32.369
然后embedding啊

00:11:32.369 --> 00:11:38.129
就是比如说将我们的文本转化成这个向量坐标啊

00:11:38.129 --> 00:11:39.109
我们用的是embedding

00:11:39.109 --> 00:11:40.849
然后做了这个chart

00:11:40.849 --> 00:11:44.329
就整个是用OpenAI的这个embedding

00:11:44.329 --> 00:11:45.549
这个模型去实验的

00:11:45.549 --> 00:11:47.129
所以这里给他梳理一下

00:11:47.129 --> 00:11:49.729
我们目前核心的一个技术战有哪些啊

00:11:49.729 --> 00:11:50.989
首先是Streamlit

00:11:50.989 --> 00:11:52.289
Streamlit的话

00:11:52.289 --> 00:11:56.169
是一个前端的一个快速开发的一个库啊

00:11:56.169 --> 00:11:57.349
那这个库的话

00:11:57.349 --> 00:11:59.309
大家你也可以自己去搜一下

00:11:59.309 --> 00:12:02.169
比如说你去可以去看到啊

00:12:02.169 --> 00:12:02.689
Streamlit

00:12:02.689 --> 00:12:04.989
这个它是一个你看

00:12:04.989 --> 00:12:08.909
一个快速的这么一个做前端页面的啊

00:12:08.909 --> 00:12:10.009
就做各种应用的

00:12:10.009 --> 00:12:12.569
它的这个语法的话非常简单啊

00:12:12.569 --> 00:12:17.529
大家目前基本上你可以用AI去做各种各样的一些前端是吧

00:12:17.529 --> 00:12:21.789
然后你看他可以做出比较好的一些效果出来

00:12:21.789 --> 00:12:27.749
所以大家你如果整个这个RUG系统是基于Python去开发的话

00:12:27.749 --> 00:12:29.549
那你其实可以什么呢

00:12:29.549 --> 00:12:30.709
前端你可以

00:12:30.709 --> 00:12:36.089
因为我们专业的前端可能还是用这个Node.js那一套嘛

00:12:36.089 --> 00:12:37.769
是吧我们ReactVU

00:12:37.769 --> 00:12:40.249
但是你如果想快速去构建一个

00:12:40.249 --> 00:12:42.949
标准的外部交付页面的话

00:12:42.949 --> 00:12:45.389
说白了就是这个给自己测试演示的话

00:12:45.389 --> 00:12:46.609
你用Streamlit

00:12:46.609 --> 00:12:48.729
肯定是没什么问题的

00:12:48.729 --> 00:12:50.089
所以这个主要目标

00:12:50.089 --> 00:12:51.669
它就是要做快速构建

00:12:51.669 --> 00:12:55.549
所以目前市面上一些python的这种项目的话

00:12:55.549 --> 00:12:56.249
前单的话

00:12:56.249 --> 00:12:58.609
做演示用的话

00:12:58.609 --> 00:13:00.869
基本上都是基于这个Streamlit

00:13:00.869 --> 00:13:03.569
你像有一些大模型的一些训练

00:13:03.569 --> 00:13:04.729
部署是吧

00:13:04.729 --> 00:13:06.469
那个操作的界面的话

00:13:06.469 --> 00:13:08.929
很多都是基于stream里的去用

00:13:08.929 --> 00:13:12.149
因为他非常方便做快速去做一些外部页面

00:13:12.149 --> 00:13:15.109
然后long turn他要做的一个事情

00:13:15.109 --> 00:13:18.009
long turn的话大家也可以去了解一下

00:13:18.009 --> 00:13:20.009
如果说你没接触过的话

00:13:20.009 --> 00:13:21.049
你可以去搜一下

00:13:21.049 --> 00:13:24.069
那么这个long turn的话

00:13:24.069 --> 00:13:25.789
主要就是我们可以看到

00:13:25.789 --> 00:13:27.349
他这个里面的话

00:13:27.349 --> 00:13:29.929
他是目前来说

00:13:29.929 --> 00:13:32.149
做一些AI智能体应用开发

00:13:32.149 --> 00:13:34.649
他是比较推荐的一个框架

00:13:34.649 --> 00:13:38.369
那这个他的一个迭代速度的话也非常快啊

00:13:38.369 --> 00:13:41.049
我们可以看到他的功能其实也非常强大

00:13:41.049 --> 00:13:43.229
可以做各种这个支柔体的一个应用

00:13:43.229 --> 00:13:46.229
然后long graph的话啊

00:13:46.229 --> 00:13:48.769
就是上面这个long chain跟long graph的一个分工

00:13:48.769 --> 00:13:51.089
就是long chain主要是管模型揭露

00:13:51.089 --> 00:13:52.889
文档切分与加载

00:13:52.889 --> 00:13:54.529
然后检索工具封装

00:13:54.529 --> 00:13:56.409
那么这个long graph的话

00:13:56.409 --> 00:13:58.909
他就去管这个agent状态机

00:13:58.909 --> 00:14:01.509
然后模型工具循环啊

00:14:01.509 --> 00:14:04.429
就是他主要是管这个agent的一个构建的

00:14:04.429 --> 00:14:05.829
包括他的一个状态啊

00:14:05.829 --> 00:14:06.869
数据流转啊

00:14:06.869 --> 00:14:08.709
然后工具的一个调用啊

00:14:08.709 --> 00:14:09.929
循环啊等等的

00:14:09.929 --> 00:14:11.309
所以这个目标

00:14:11.309 --> 00:14:13.389
他主要就是围绕着这个agent

00:14:13.389 --> 00:14:14.909
去做一个展开的

00:14:14.909 --> 00:14:16.169
然后long chain就是

00:14:16.169 --> 00:14:19.629
主要是做一些rug的这个应用的一些集成

00:14:19.629 --> 00:14:20.829
啊

00:14:20.829 --> 00:14:24.969
那个clama的话就是一款这个向上数据库啊

00:14:24.969 --> 00:14:26.869
这个是一款快开源的向上数据库

00:14:26.869 --> 00:14:27.869
这个数据库

00:14:27.869 --> 00:14:29.129
他既支持本地部署

00:14:29.129 --> 00:14:31.029
也支持服务器的那个部署啊

00:14:31.029 --> 00:14:33.749
主要就是用来存储这个向上数据库

00:14:33.749 --> 00:14:35.949
做一些数据的一些存储

00:14:35.949 --> 00:14:39.769
然后我们还可以去整合一些多平台的一些

00:14:39.769 --> 00:14:40.369
这个什么的

00:14:40.369 --> 00:14:42.769
比如说大家想用这个本地部署是吧

00:14:42.769 --> 00:14:43.849
那你就用欧拉玛

00:14:43.849 --> 00:14:47.469
所以这里面我们其实提供了一些个路口啊

00:14:47.469 --> 00:14:49.049
我们可以通过欧拉玛

00:14:49.049 --> 00:14:51.409
然后或者是其他的一些啊

00:14:51.409 --> 00:14:52.249
XEference

00:14:52.249 --> 00:14:54.969
可以做一些模型的一个加载

00:14:54.969 --> 00:14:59.609
也就是我们可以用这个在线的一个模型啊

00:14:59.609 --> 00:15:00.469
就是公网的一个模型

00:15:00.469 --> 00:15:01.989
也可以用私有化的欧拉玛模型

00:15:01.989 --> 00:15:03.229
这个都是OK的啊

00:15:03.229 --> 00:15:04.109
给大家的一个需要

00:15:04.109 --> 00:15:07.949
那么我们为什么用Codex开发啊

00:15:07.949 --> 00:15:09.529
首先Codex的话

00:15:09.529 --> 00:15:11.889
本身你可以把它看作是一个整体啊

00:15:11.889 --> 00:15:13.369
因为它不仅可以生成代码

00:15:13.369 --> 00:15:14.769
还能读项目改文件

00:15:14.769 --> 00:15:15.609
跑命理修bug

00:15:15.609 --> 00:15:16.769
所以说

00:15:16.769 --> 00:15:18.549
我们这里面的话

00:15:18.549 --> 00:15:19.789
基于Codex开发

00:15:19.789 --> 00:15:21.329
逻辑就不太一样了

00:15:21.329 --> 00:15:23.589
那就是以提示词啊

00:15:23.589 --> 00:15:25.309
像我们前面给大家讲的是

00:15:25.309 --> 00:15:27.689
这个面向规范的

00:15:27.689 --> 00:15:29.329
这么一个驱动的方式开发啊

00:15:29.329 --> 00:15:30.829
所以说我们其实

00:15:30.829 --> 00:15:32.289
现在去开发项目的话

00:15:32.289 --> 00:15:34.289
大家只要把提示词梳理出来就可以了

00:15:34.289 --> 00:15:35.569
不需要你去写代码了

00:15:35.569 --> 00:15:37.669
然后他就可以快速去开发一个模块

00:15:37.669 --> 00:15:41.789
所以这个就是正常的一个AI编程的一个正确的姿势

00:15:41.789 --> 00:15:43.969
所以我们等下的一个开发的话

00:15:43.969 --> 00:15:46.389
基本上自己是不用手写一行代码的

00:15:46.389 --> 00:15:49.349
都是交给Codex去做代码生成

00:15:49.349 --> 00:15:53.789
然后由他去做一个这个功能一个开发

00:15:53.789 --> 00:15:55.789
所以大家首先第一步要做的就是

00:15:55.789 --> 00:15:58.129
我们要把Codex的一个环境准备好

00:15:58.129 --> 00:16:01.289
那么大家听到之前的这个章节的话

00:16:01.289 --> 00:16:02.649
我相信这个codex环境

00:16:02.649 --> 00:16:03.549
大家都已经装好了

00:16:03.549 --> 00:16:05.649
所以这一步我就简单介绍一下

00:16:05.649 --> 00:16:07.229
就是咱们得把codex

00:16:07.229 --> 00:16:09.129
我这里安装方式的话

00:16:09.129 --> 00:16:10.229
主要是讲的这个

00:16:10.574 --> 00:16:12.214
主要是讲了这个他的命令行方式啊

00:16:12.214 --> 00:16:13.754
所以大家不管是命令行

00:16:13.754 --> 00:16:16.234
还是我们之前讲的这个啊

00:16:16.234 --> 00:16:20.054
Codex app或者是这个啊

00:16:20.054 --> 00:16:21.774
Withcode的那个插件啊

00:16:21.774 --> 00:16:23.174
都都是可以的啊

00:16:23.174 --> 00:16:24.394
看大家习惯用哪一种

00:16:24.394 --> 00:16:26.634
然后完了之后的话

00:16:26.634 --> 00:16:28.754
你可以去配置一下这个API密钥啊

00:16:28.754 --> 00:16:32.114
因为我采用的是这种API key的这种方式去连接的

00:16:32.114 --> 00:16:33.734
所以看大家的一个实际情况

00:16:33.734 --> 00:16:35.854
我们前面有给大家讲连接方式

00:16:35.854 --> 00:16:38.214
就是你要么是登录啊

00:16:38.214 --> 00:16:42.194
用官方那个ChatGBT的这个网站跳转做授权

00:16:42.194 --> 00:16:47.494
还有一种的话是你可以这个配一个API密钥啊

00:16:47.494 --> 00:16:48.394
这个都是OK的

00:16:48.394 --> 00:16:50.754
看大家的一个实际需求吧

00:16:50.754 --> 00:16:53.374
就是你的一个实际情况是什么

00:16:53.374 --> 00:16:57.174
然后我这里面就是去配一下这个环境变量

00:16:57.174 --> 00:16:58.734
它基本上就可以用了啊

00:16:58.734 --> 00:17:00.634
但是你这里配完之后

00:17:00.634 --> 00:17:03.214
你需要把终端这个重启一下才能生效啊

00:17:03.214 --> 00:17:04.794
这个是呃

00:17:04.794 --> 00:17:07.294
这个是在Mac或者Linux上面的一个配置

00:17:07.294 --> 00:17:08.574
这个是Windows上面

00:17:08.574 --> 00:17:11.834
我们用的是SateX这么一个命令啊

00:17:11.834 --> 00:17:13.494
好

00:17:13.494 --> 00:17:14.414
完了之后的话

00:17:14.414 --> 00:17:18.634
就是我们现在就可以进入到我们的一个项目应用开发了啊

00:17:18.634 --> 00:17:22.034
就是接下来我们要建一个项目录是吧

00:17:22.034 --> 00:17:25.334
那比如说我现在这个里面

00:17:25.334 --> 00:17:26.134
给他看一下

00:17:26.134 --> 00:17:30.434
我们进入到这个Codex

00:17:30.434 --> 00:17:30.994
是吧

00:17:30.994 --> 00:17:33.394
进入到这个Codex里面去

00:17:33.394 --> 00:17:34.694
然后的话

00:17:34.694 --> 00:17:36.994
这里面我们建一个目的

00:17:36.994 --> 00:17:39.874
叫做这个Rack

00:17:39.874 --> 00:17:42.014
System

00:17:42.014 --> 00:17:44.474
Rack系统

00:17:44.474 --> 00:17:46.054
然后在这个里面的话

00:17:46.054 --> 00:17:49.054
我们要用终端管理员的方式打开

00:17:49.054 --> 00:17:54.154
然后切换到地盘

00:17:54.154 --> 00:17:56.914
切换到Codex

00:17:56.914 --> 00:17:59.394
下面有一个目录叫做RockSystem

00:17:59.394 --> 00:18:01.754
然后我们进入Codex

00:18:01.754 --> 00:18:08.234
进入Codex之后

00:18:08.234 --> 00:18:09.794
我首先调一下这个权限

00:18:09.794 --> 00:18:14.254
把这个权限改成这个不需要授权的

00:18:14.254 --> 00:18:16.154
因为我不想反复的去确认

00:18:16.154 --> 00:18:18.514
这里因为怎么正常编码开发了

00:18:18.514 --> 00:18:19.994
所以就不需要确认了

00:18:19.994 --> 00:18:21.114
直接让他干活就行了

00:18:21.114 --> 00:18:22.894
我们把这个权限放开

00:18:22.894 --> 00:18:25.274
就是不需要再用户再确认了

00:18:25.274 --> 00:18:27.154
好

00:18:27.154 --> 00:18:28.974
然后这个地方的话就是

00:18:28.974 --> 00:18:31.674
你看我刚刚讲的这个授权模式

00:18:31.674 --> 00:18:33.454
我就是用的这一种

00:18:33.454 --> 00:18:35.054
就把权限全部全自动了

00:18:35.054 --> 00:18:37.054
这个是我们因为

00:18:37.054 --> 00:18:40.514
我们前面给大家讲了这几种权限

00:18:40.514 --> 00:18:42.214
就是涉及到一些敏感操作

00:18:42.214 --> 00:18:43.614
一些敏感命令执行的时候

00:18:43.614 --> 00:18:46.334
我建议大家就是需要用户去确认

00:18:46.334 --> 00:18:47.954
就如果是你个初学者

00:18:47.954 --> 00:18:49.414
你要保证安全的

00:18:49.414 --> 00:18:50.534
你就用这种模式

00:18:50.534 --> 00:18:53.454
如果说你已经熟悉了

00:18:53.454 --> 00:18:53.754
是吧

00:18:53.754 --> 00:18:55.274
那你要快速提效

00:18:55.274 --> 00:18:56.874
你就用auto的这个模式

00:18:56.874 --> 00:18:58.474
但以前叫auto edit

00:18:58.474 --> 00:18:59.854
现在叫auto review

00:18:59.854 --> 00:19:01.374
差不多的一个意思

00:19:01.374 --> 00:19:03.694
就是他会根据实际一个情况

00:19:03.694 --> 00:19:05.474
自动帮你去授权访问

00:19:05.474 --> 00:19:06.654
但是在某一些

00:19:06.654 --> 00:19:09.454
比如说要执行一些RM跟RF的

00:19:09.454 --> 00:19:10.214
一些命令的时候

00:19:10.214 --> 00:19:11.874
这些敏感操作的时候

00:19:11.874 --> 00:19:12.914
他还是需要授权

00:19:12.914 --> 00:19:13.794
所以

00:19:13.794 --> 00:19:16.434
但是他大部分命令都会放开

00:19:16.434 --> 00:19:19.874
所以这个就看大家的一个实际情况

00:19:19.874 --> 00:19:21.434
如果说你属于这个阶段

00:19:21.434 --> 00:19:22.194
你就用这种模式

00:19:22.194 --> 00:19:24.014
我目前用的是这种模式

00:19:24.014 --> 00:19:26.714
就是我需要他全自动去帮我去跑了

00:19:26.714 --> 00:19:29.694
所以我不需要关注那么多授权的东西

00:19:29.694 --> 00:19:34.614
那么首先就是我们要做一个需求的一个拆解跟架构设计

00:19:34.614 --> 00:19:34.914
是吧

00:19:34.914 --> 00:19:38.914
就大家你用Codex做项目

00:19:38.914 --> 00:19:41.714
你不是一上来就直接让Codex帮我写一个智能客服系统

00:19:41.714 --> 00:19:44.254
那这样生成的这个效果肯定是不行的

00:19:44.254 --> 00:19:46.434
因为你需求都没描述清楚呢

00:19:46.434 --> 00:19:47.994
你首先啊

00:19:47.994 --> 00:19:50.454
我们虽然是用Codex去提效

00:19:50.454 --> 00:19:52.194
但是的话

00:19:52.194 --> 00:19:53.794
大家不要觉得就是

00:19:53.794 --> 00:19:55.854
AI就能模拟搞定一切了是吧

00:19:55.854 --> 00:19:58.714
就是你的整个软件开发的这个过程

00:19:58.714 --> 00:19:59.674
你还是得有的

00:19:59.674 --> 00:20:00.894
比如说做技术方案

00:20:00.894 --> 00:20:01.754
做架构设计

00:20:01.754 --> 00:20:02.834
这个跑不了的

00:20:02.834 --> 00:20:05.214
因为这是个系统

00:20:05.214 --> 00:20:06.094
这个系统的话

00:20:06.094 --> 00:20:07.554
会涉及到非常多的模块

00:20:07.554 --> 00:20:09.494
需求的话会有大需求

00:20:09.494 --> 00:20:11.414
然后每个任务要做拆分的

00:20:11.414 --> 00:20:12.394
那AI的话

00:20:12.394 --> 00:20:15.634
他比较适合的是执行某一个任务

00:20:15.634 --> 00:20:17.514
所以说你如果没有帮他

00:20:17.514 --> 00:20:19.714
没有帮他把任务拆出来的话

00:20:19.714 --> 00:20:21.614
那他帮你干活的时候

00:20:21.614 --> 00:20:22.974
可能就会出现各种各样的问题

00:20:22.974 --> 00:20:24.474
所以大家尽量要细化

00:20:24.474 --> 00:20:26.294
这是一个非常大的一个原则

00:20:26.294 --> 00:20:29.294
所以我们第一步的话

00:20:29.294 --> 00:20:31.114
就大家要把认知给他对齐一下

00:20:31.114 --> 00:20:33.734
要按照一个正常的软件开发的一个流程

00:20:33.734 --> 00:20:35.414
去做一个交互

00:20:35.414 --> 00:20:37.374
比如说第一步

00:20:37.374 --> 00:20:40.294
我们你现在要做一个Rug的这个系统的话

00:20:40.294 --> 00:20:41.894
你首先得输出技术方案吧

00:20:41.894 --> 00:20:43.194
那那技术方案

00:20:43.194 --> 00:20:44.374
以前我们做价格设计

00:20:44.374 --> 00:20:46.394
大家要画这个什么流程图啊

00:20:46.394 --> 00:20:47.614
架构图啊

00:20:47.614 --> 00:20:48.954
各种各样的一些图是吧

00:20:48.954 --> 00:20:51.854
那现在其实有了这些个东西之后的话

00:20:51.854 --> 00:20:54.414
有了AI有了Codex之后的话

00:20:54.414 --> 00:20:55.874
那这些工作的话

00:20:55.874 --> 00:20:57.334
其实都可以交给AI去做了

00:20:57.334 --> 00:20:57.994
但是的话

00:20:57.994 --> 00:21:00.754
你的一个前提就是你这个提示词

00:21:00.754 --> 00:21:02.054
你得写清楚是吧

00:21:02.054 --> 00:21:02.874
比如说我们这里

00:21:02.874 --> 00:21:05.354
我要开发一个Rug智能客服系统

00:21:05.354 --> 00:21:07.334
技术在限定为Web页面

00:21:07.334 --> 00:21:09.414
然后Agent的编盘是什么什么

00:21:09.414 --> 00:21:10.994
向量数据库是什么

00:21:10.994 --> 00:21:12.614
知识的模型是什么是吧

00:21:12.614 --> 00:21:14.414
然后功能需求

00:21:14.414 --> 00:21:16.034
一个知识库页面

00:21:16.034 --> 00:21:18.754
然后可以新建知识库

00:21:18.754 --> 00:21:20.774
上传markdown文档自动切分

00:21:20.774 --> 00:21:24.154
就是咱们得把需求描述的非常清楚

00:21:24.154 --> 00:21:26.534
并且这个知识库多选

00:21:26.534 --> 00:21:27.234
是吧可选

00:21:27.234 --> 00:21:29.374
然后对话的时候可以启用哪些知识库

00:21:29.374 --> 00:21:31.754
然后我们写了功能需求之后

00:21:31.754 --> 00:21:33.774
我们还就是要一定要提出来啊

00:21:33.774 --> 00:21:35.514
就是请先不要写代码

00:21:35.514 --> 00:21:39.614
先输出这个推荐项目的一个目录结构

00:21:39.614 --> 00:21:41.194
每个模块的一个工程职责

00:21:41.194 --> 00:21:42.874
然后建议的开发顺序

00:21:42.874 --> 00:21:44.594
从底层到上层

00:21:44.594 --> 00:21:47.054
这个就是要我们要做一个架构设计

00:21:47.054 --> 00:21:48.834
把一些相关的文档给它输出出来

00:21:48.834 --> 00:21:50.574
而不是说直接就开发了

00:21:50.574 --> 00:21:52.074
所以第一步的话

00:21:52.074 --> 00:21:54.214
大家首先要复制一下

00:21:54.214 --> 00:21:55.314
就是把这个提示词

00:21:55.314 --> 00:21:56.554
我们要一步的去生成

00:21:56.554 --> 00:21:59.294
那这个里面我用这个

00:21:59.294 --> 00:22:01.054
我们打开

00:22:01.054 --> 00:22:02.474
我们在这个里面给它来看

00:22:02.474 --> 00:22:03.414
会比较清新一些

00:22:03.414 --> 00:22:05.654
因为这个看起来不是很方便

00:22:05.654 --> 00:22:07.994
然后我们打开这个目录

00:22:07.994 --> 00:22:12.334
然后这个目录我们选择这个RackSystem

00:22:12.334 --> 00:22:15.994
然后在这个里面发起一个对话

00:22:15.994 --> 00:22:19.674
在这个大家会看得更清晰一些啊

00:22:19.674 --> 00:22:22.734
在这个里面他有时候看的不是很方便

00:22:22.734 --> 00:22:27.254
然后大家看啊

00:22:27.254 --> 00:22:28.294
在这个里面你看

00:22:28.294 --> 00:22:31.194
他就开始帮我们去规划了啊

00:22:31.194 --> 00:22:34.334
因为我之前规范里面写到DDD分层来组织

00:22:34.334 --> 00:22:36.314
所以他也把这个规范加入进来了

00:22:36.314 --> 00:22:39.054
你看这个是他就是规划的一个目入结构

00:22:39.054 --> 00:22:40.634
是吧什么RAG系统啊是吧

00:22:40.634 --> 00:22:42.954
然后配置啊数据啊

00:22:42.954 --> 00:22:45.594
然后包括一些模块啊是吧

00:22:45.594 --> 00:22:48.954
然后一些应用程序啊是吧

00:22:48.954 --> 00:22:50.774
你看是不是帮我们规划的非常清楚

00:22:50.774 --> 00:22:52.694
什么agent state node是吧

00:22:52.694 --> 00:22:55.694
你看按照模块职责划分

00:22:55.694 --> 00:22:57.614
负责stream里的钱的交互

00:22:57.614 --> 00:23:02.534
然后这个放核心的一些什么模块是吧

00:23:02.534 --> 00:23:06.494
然后还有一些这个规划相关的

00:23:06.494 --> 00:23:09.994
你看他包括建议的这个开发步骤都帮我们调好了

00:23:09.994 --> 00:23:12.214
比如说先定义领域模型

00:23:12.214 --> 00:23:16.954
然后再去实现基础的一些配置与模型的一个适配

00:23:16.954 --> 00:23:20.994
再包括去做一些什么markdown加载与切分是吧

00:23:20.994 --> 00:23:24.594
然后还有一些实现crama向量库的一些适配

00:23:24.594 --> 00:23:28.194
包括这个知识库这个啊

00:23:28.194 --> 00:23:29.434
路库的一些用力

00:23:29.434 --> 00:23:30.914
然后去实现一些

00:23:30.914 --> 00:23:33.334
这个检索的用力啊

00:23:33.334 --> 00:23:35.774
包括Longraph的这个Agent等等的是吧

00:23:35.774 --> 00:23:38.394
他会帮你把这个步骤

00:23:38.394 --> 00:23:39.954
全部给树立清楚

00:23:39.954 --> 00:23:42.134
所以说这个里面的话

00:23:42.134 --> 00:23:43.814
大家首先你要看一下

00:23:43.814 --> 00:23:44.634
他基本的逻辑

00:23:44.634 --> 00:23:46.914
是不是按照你的一个要求去做的啊

00:23:46.914 --> 00:23:50.254
这个有没有达到你的一个要求

00:23:50.254 --> 00:23:52.594
包括他的一些这个

00:23:52.594 --> 00:23:54.514
模块是吧

00:23:54.514 --> 00:23:55.814
然后开发顺序

00:23:55.814 --> 00:23:57.054
这些东西有没有问题

00:23:57.054 --> 00:24:00.914
然后这个就是确认没问题之后

00:24:00.914 --> 00:24:03.494
你可以开始让他干嘛呢

00:24:03.494 --> 00:24:08.634
接下来我们就开始去生成一些这个文档了

00:24:08.634 --> 00:24:08.934
是吧

00:24:09.331 --> 00:24:10.551
但我们其实

00:24:10.551 --> 00:24:12.411
他现在是按DDG做的

00:24:12.411 --> 00:24:13.091
我们其实

00:24:13.091 --> 00:24:15.111
还不需要那么多

00:24:15.111 --> 00:24:16.331
这个DDG的一些规范

00:24:16.331 --> 00:24:19.931
所以这里面我先是先调一下

00:24:19.931 --> 00:24:21.951
因为按他按DDG规划的话

00:24:21.951 --> 00:24:23.711
那个模块会插得很细啊

00:24:23.711 --> 00:24:28.711
但其实我们可以不需要用到那么细啊

00:24:28.711 --> 00:24:35.551
所以这个里面看一下

00:24:35.551 --> 00:24:42.571
我们可以这里面可以调整一下

00:24:42.571 --> 00:24:45.571
全局的这个DDD的一些规范啊

00:24:45.571 --> 00:24:47.811
我们找到那个用户目录

00:24:47.811 --> 00:24:52.211
然后找到点Codex

00:24:53.711 --> 00:24:56.711
嗯

00:25:00.711 --> 00:25:01.211
嗯

00:25:01.211 --> 00:25:05.211
然后Codex里面有我之前看一下啊

00:25:05.211 --> 00:25:07.211
Liless

00:25:13.211 --> 00:25:17.711
之前应该是我去写过一个这个Agence.md啊

00:25:23.711 --> 00:25:29.351
或者说咱们找不到的时候

00:25:29.351 --> 00:25:30.271
你机器可以Goend的

00:25:30.271 --> 00:25:38.651
帮我读取下系统全局的agents.md

00:25:38.651 --> 00:25:43.711
当前用户

00:25:43.711 --> 00:25:48.711
因为我之前那个agents.md里面写了一些这个

00:25:48.711 --> 00:25:50.891
dd的一些规范

00:25:50.891 --> 00:25:52.791
所以我现在要把这个规范给去掉

00:25:52.791 --> 00:25:54.811
不然到时候生人代码的时候

00:25:54.811 --> 00:25:56.911
可能会有一些这个问题啊

00:25:56.911 --> 00:25:59.191
但是他这个模块就这样去分

00:25:59.191 --> 00:25:59.851
也没什么问题

00:25:59.851 --> 00:26:01.731
只是说他这里拆的太细了

00:26:01.731 --> 00:26:03.191
你看什么DOMEN啊

00:26:03.191 --> 00:26:05.651
其实我们这么一个项目的话

00:26:05.651 --> 00:26:07.271
暂时还不需要用到DDD啊

00:26:07.271 --> 00:26:09.491
DDD一般是用在一些复杂的

00:26:09.491 --> 00:26:10.611
一些大型系统上面

00:26:10.611 --> 00:26:12.291
比如说一些ERP系统

00:26:12.291 --> 00:26:13.591
模块非常多的场景下

00:26:13.591 --> 00:26:14.811
用DDD没问题

00:26:14.811 --> 00:26:17.991
但实际上我们不需要那么麻烦啊

00:26:17.991 --> 00:26:20.611
你看我之前这个文档里面

00:26:20.611 --> 00:26:23.451
我写了一个什么 dv 驱动的方式开发

00:26:23.571 --> 00:26:25.511
这是之前的我规范

00:26:25.511 --> 00:26:27.171
那我现在要把它去掉

00:26:29.211 --> 00:26:31.171
codex下面有一个

00:26:32.451 --> 00:26:33.611
agents

00:26:33.611 --> 00:26:35.051
你看这是我之前加的

00:26:36.171 --> 00:26:39.451
我现在把它去掉

00:26:40.771 --> 00:26:42.971
然后这里面我们重新发起一个对话

00:26:43.851 --> 00:26:46.651
把之前的提示词复制一下

00:26:46.651 --> 00:26:48.171
重新发起一个对话

00:26:48.171 --> 00:26:50.951
我们再来让它生成一下

00:26:50.951 --> 00:27:01.591
我们这里看一下

00:27:01.591 --> 00:27:02.351
这个里面

00:27:02.351 --> 00:27:05.171
你看现在就不是DDD了

00:27:05.171 --> 00:27:08.411
后面同时也按照DDD风格推进

00:27:08.411 --> 00:27:12.051
这里面还是DDD没有生效

00:27:12.051 --> 00:27:14.391
没有保存

00:27:14.391 --> 00:27:18.851
我直接跟他说

00:27:18.851 --> 00:27:22.391
我再发几个对话

00:27:22.391 --> 00:27:28.131
可能是不是要重启一下

00:27:44.391 --> 00:27:57.191
那现在模块就少了一些了

00:27:57.191 --> 00:27:59.631
应该那个DDD的那个已经失效了

00:27:59.631 --> 00:28:01.091
模块少了一些了

00:28:01.091 --> 00:28:05.291
然后的话就是我们看一下整个的一个逻辑啊

00:28:05.291 --> 00:28:05.991
你像这个APP

00:28:05.991 --> 00:28:08.111
它只负责stream里的界面的交互

00:28:08.111 --> 00:28:12.591
domain的话就负责一些这个核心的一个业务概念啊

00:28:12.591 --> 00:28:13.691
然后application是什么

00:28:13.691 --> 00:28:15.791
然后外部技术实现是什么

00:28:15.791 --> 00:28:18.911
然后包括他的一些细节

00:28:18.911 --> 00:28:19.411
是吧

00:28:19.411 --> 00:28:20.471
就怎么来实现

00:28:20.471 --> 00:28:21.851
好

00:28:21.851 --> 00:28:23.031
这一步之后的话

00:28:23.031 --> 00:28:24.151
接下来干嘛呢

00:28:24.151 --> 00:28:26.251
接下来就是我们要去逐步实现

00:28:26.251 --> 00:28:28.011
整个的一个逻辑

00:28:28.011 --> 00:28:29.391
比如说

00:28:29.391 --> 00:28:31.171
这里面有两块

00:28:31.171 --> 00:28:33.851
就一块你可以按照他的一个目录结构去生成

00:28:33.851 --> 00:28:34.931
还有一块的话

00:28:34.931 --> 00:28:37.071
就是你有自己的一个规划

00:28:37.071 --> 00:28:40.671
你想按你的方式去做一个目录生成

00:28:40.671 --> 00:28:42.131
那你就可以把这个复制一下

00:28:42.131 --> 00:28:43.371
请

00:28:43.371 --> 00:28:53.051
参考我的目录结构规范进行调整

00:28:53.051 --> 00:29:03.071
生成对应的目录结构

00:29:03.071 --> 00:29:15.251
就是你自己有一套规范是吧

00:29:15.251 --> 00:29:16.951
你把这些东西你都定好了

00:29:16.951 --> 00:29:20.731
那你就让让他去按你的方式去做就可以了

00:29:20.731 --> 00:29:22.991
如果说你没有特定的一个要求

00:29:22.991 --> 00:29:24.931
你想用他的这个方案的话

00:29:24.931 --> 00:29:25.691
其实也是可以

00:29:25.691 --> 00:29:27.331
就我们前面的话

00:29:27.331 --> 00:29:29.211
只是让他去帮我们分析一下

00:29:29.211 --> 00:29:30.911
让他去完全去做一个

00:29:30.911 --> 00:29:31.891
所以说

00:29:31.891 --> 00:29:34.471
比如说我们可以把这个TS加起来

00:29:34.471 --> 00:29:34.711
是吧

00:29:34.711 --> 00:29:38.071
你可以把这两个东西组合起来

00:29:38.071 --> 00:29:39.611
你要开发这么一个

00:29:39.611 --> 00:29:42.191
然后你的一个目入结构应该是下面这种

00:29:42.191 --> 00:29:42.651
是吧

00:29:42.651 --> 00:29:44.531
或者说你就直接用它的方案都是可以

00:29:44.531 --> 00:29:45.531
或者大家

00:29:45.531 --> 00:29:47.551
你觉得它的结构太复杂了

00:29:47.551 --> 00:29:48.391
不太合适

00:29:48.391 --> 00:29:49.591
然后

00:29:49.591 --> 00:29:53.971
你可以去具体去调整一下

00:29:53.971 --> 00:29:54.411
是吧

00:29:54.411 --> 00:29:56.831
那我们可以再发起一个对话

00:29:56.831 --> 00:30:01.411
你可以让他参考你的目录结构去实现啊

00:30:01.411 --> 00:30:02.271
这个都是OK的

00:30:19.371 --> 00:30:21.991
这个里面大家可以不断的去调整啊

00:30:21.991 --> 00:30:23.271
做一些微调处理

00:30:23.271 --> 00:30:30.811
你看这是他给你的一个建议啊

00:30:30.811 --> 00:30:32.371
然后去梳理出来的

00:30:32.371 --> 00:30:33.551
哎他还善滴滴滴啊

00:30:33.551 --> 00:30:34.411
那个就没生效

00:30:34.411 --> 00:30:37.191
我的滴滴滴这个都去掉了

00:30:37.191 --> 00:30:39.791
但这个应该是要重启一下

00:30:39.791 --> 00:30:42.491
来重启一下

00:30:42.491 --> 00:30:45.991
我这个重启啊

00:30:45.991 --> 00:30:49.271
然后重新打开一下

00:30:49.271 --> 00:30:54.171
他可能没有加载啊

00:30:54.171 --> 00:30:55.711
当前那个对话可能

00:30:55.711 --> 00:30:58.011
要要重启一下这个APP

00:30:58.011 --> 00:30:58.691
可能才可以

00:30:58.691 --> 00:31:00.671
再试一下

00:31:00.671 --> 00:31:06.991
看现在应该