1
00:00:00,000 --> 00:00:00,920
OK

2
00:00:00,920 --> 00:00:11,600
接下来我们就以项目实战的方式啊

3
00:00:11,600 --> 00:00:13,340
带大家基于Codex

4
00:00:13,340 --> 00:00:17,420
全流程的去开发一个RUG智能客服系统

5
00:00:17,420 --> 00:00:20,060
那首先给大家演示一下这个系统

6
00:00:20,060 --> 00:00:21,340
它的一个功能

7
00:00:21,340 --> 00:00:24,840
那就是一个比较简单的一个对话页面啊

8
00:00:24,840 --> 00:00:25,900
那么首先的话

9
00:00:25,900 --> 00:00:28,480
比如说大家公司内部有一些

10
00:00:28,480 --> 00:00:30,340
行业的一些知识库

11
00:00:30,340 --> 00:00:32,700
比如说是做这个电商的啊

12
00:00:32,700 --> 00:00:34,640
或者是传统的像银行呀

13
00:00:34,640 --> 00:00:35,600
政务啊

14
00:00:35,600 --> 00:00:37,460
各种各样的这个行业是吧

15
00:00:37,460 --> 00:00:40,260
那比如说我们有一些知识库啊

16
00:00:40,260 --> 00:00:41,600
假设大家的这个

17
00:00:41,600 --> 00:00:44,040
是做这个银行客服的

18
00:00:44,040 --> 00:00:45,880
那这个里面比如说我们有一些

19
00:00:45,880 --> 00:00:47,400
常见的问题

20
00:00:47,400 --> 00:00:51,480
比如说哎这个查询一些这个余额呀

21
00:00:51,480 --> 00:00:53,160
什么修改账号密码呀

22
00:00:53,160 --> 00:00:55,620
就是这种常见的一些问题等等的啊

23
00:00:55,620 --> 00:00:57,920
好那就是这么一个知识库

24
00:00:57,920 --> 00:00:59,160
那现在的话

25
00:00:59,160 --> 00:01:00,700
就是我们内部啊

26
00:01:00,700 --> 00:01:02,000
要把这些知识库的话

27
00:01:02,000 --> 00:01:03,820
做一个整合

28
00:01:03,820 --> 00:01:06,980
然后到我们的这个客服系统里面去

29
00:01:06,980 --> 00:01:08,840
因为以前的这个AI的话

30
00:01:08,840 --> 00:01:12,020
其实他去回答问题的时候啊

31
00:01:12,020 --> 00:01:13,220
如果说他没有参考

32
00:01:13,220 --> 00:01:15,120
公司内部的一些知识库的话

33
00:01:15,120 --> 00:01:16,900
他回答的问题的话

34
00:01:16,900 --> 00:01:17,880
就不是特别专业

35
00:01:17,880 --> 00:01:18,900
所以现在的话

36
00:01:18,900 --> 00:01:21,560
我们要做一个这个基于Rug啊

37
00:01:21,560 --> 00:01:22,260
Rug的话

38
00:01:22,260 --> 00:01:25,160
全称叫做检索增强生成

39
00:01:25,160 --> 00:01:26,040
也就是说

40
00:01:26,040 --> 00:01:28,800
我们这个以前AI生成内容的话

41
00:01:28,800 --> 00:01:32,480
都是根据这个AI自己训练的啊

42
00:01:32,480 --> 00:01:33,080
像大模型

43
00:01:33,080 --> 00:01:33,820
他训练一些

44
00:01:33,820 --> 00:01:35,160
预训练的一些数据

45
00:01:35,160 --> 00:01:36,460
然后去生成的

46
00:01:36,460 --> 00:01:38,520
所以说他给你的一个结果的话

47
00:01:38,520 --> 00:01:41,300
他肯定是一些比较通用的一些结果

48
00:01:41,300 --> 00:01:43,020
不是属于我们这个公司

49
00:01:43,020 --> 00:01:44,640
某个行业特定的一个回答

50
00:01:44,640 --> 00:01:47,620
他可能就有那种普世性

51
00:01:47,620 --> 00:01:49,240
但是的话不是特别专业

52
00:01:49,240 --> 00:01:52,280
所以我们既然内部有一些知识库文档的话

53
00:01:52,280 --> 00:01:53,960
我们现在想投位给AI

54
00:01:53,960 --> 00:01:55,040
但是呢

55
00:01:55,040 --> 00:01:57,340
我们又不想去做这个预训练跟微调

56
00:01:57,340 --> 00:01:58,960
因为那个成本比较高是吧

57
00:01:58,960 --> 00:02:01,680
所以说业界的话就有一种解决方案叫Rug

58
00:02:01,680 --> 00:02:05,380
你可以理解就是给这个AI挂了一个知识库

59
00:02:05,380 --> 00:02:08,320
就相当于你在学习的时候

60
00:02:08,320 --> 00:02:11,360
你可以去图书馆里面去查一些这个书籍

61
00:02:11,360 --> 00:02:13,120
然后去写一些文章

62
00:02:13,120 --> 00:02:14,840
这样的话你就会做一个参考

63
00:02:14,840 --> 00:02:17,960
那么AI有了这个参考之后的话

64
00:02:17,960 --> 00:02:21,760
他帮你去生成这个答案的时候

65
00:02:21,760 --> 00:02:25,200
他就会参考里面的一些核心观点

66
00:02:25,200 --> 00:02:26,740
然后去做一些总结回答

67
00:02:26,740 --> 00:02:29,100
比如说我们现在问他一个问题啊

68
00:02:29,100 --> 00:02:31,800
如果说我们没有做一个这个

69
00:02:31,800 --> 00:02:34,400
RAG系统的一个整合的话

70
00:02:34,400 --> 00:02:36,940
那么他你去问这个问题的话

71
00:02:36,940 --> 00:02:39,540
他可能就给你一个啊

72
00:02:39,540 --> 00:02:41,220
他可能你问的都不是这个

73
00:02:41,220 --> 00:02:43,680
这个银行这个行业的是吧

74
00:02:43,680 --> 00:02:44,740
他不是金融行业的

75
00:02:44,740 --> 00:02:46,600
他可能是其他行业的答案就给你了

76
00:02:46,600 --> 00:02:47,720
但是如果说

77
00:02:47,720 --> 00:02:51,240
你给他做了一个知识库的一个整合的话

78
00:02:51,240 --> 00:02:52,680
那大家就会看到啊

79
00:02:52,680 --> 00:02:55,740
他会调用我们的这个银行的这个知识库

80
00:02:55,740 --> 00:02:57,220
进行一个查询啊

81
00:02:57,220 --> 00:02:58,020
大家看啊

82
00:02:58,020 --> 00:03:01,040
这个是他的一个知识的一个检索结果啊

83
00:03:01,040 --> 00:03:03,420
但这个里面这里展示有点问题

84
00:03:03,420 --> 00:03:04,520
我们重新来问一下

85
00:03:04,520 --> 00:03:07,000
就是有了这个结果之后的话

86
00:03:07,000 --> 00:03:09,820
他其实就会跟你去什么呢

87
00:03:09,820 --> 00:03:12,440
做一个向量的数据库的一个

88
00:03:12,440 --> 00:03:14,020
这个相似度的一个检索

89
00:03:14,020 --> 00:03:15,780
那么检索完之后啊

90
00:03:15,780 --> 00:03:18,500
你看这个就是我们知识库检索的一个结果

91
00:03:18,500 --> 00:03:18,780
是吧

92
00:03:18,780 --> 00:03:19,980
那这个结果的话

93
00:03:19,980 --> 00:03:21,600
其实就是在这个里面啊

94
00:03:21,600 --> 00:03:23,380
我们这个知识库文档

95
00:03:23,380 --> 00:03:26,880
这个文档的话是存放到了这个向量数据库里面

96
00:03:26,880 --> 00:03:28,280
那么这个向量数据库的话

97
00:03:28,280 --> 00:03:29,960
它是根据这段话

98
00:03:29,960 --> 00:03:32,100
然后做一个向量的相似度匹配

99
00:03:32,100 --> 00:03:33,540
匹配完了之后的话

100
00:03:33,540 --> 00:03:37,180
再去做一个这个内容的一个生成

101
00:03:37,180 --> 00:03:39,860
所以说这个里面的话

102
00:03:39,860 --> 00:03:41,240
其实就是啊

103
00:03:41,240 --> 00:03:43,580
我们首先要对这个文档做一个向量化

104
00:03:43,580 --> 00:03:45,120
做完向量化之后的话

105
00:03:45,120 --> 00:03:46,640
把它存在到向量数据库里面去

106
00:03:46,640 --> 00:03:48,520
然后当用户提问题的时候

107
00:03:48,520 --> 00:03:50,920
我们要用这个agent

108
00:03:50,920 --> 00:03:54,380
那本次我们的这个agent实现的话

109
00:03:54,380 --> 00:03:55,620
是基于一个框架

110
00:03:55,620 --> 00:03:57,380
叫做这个long graph

111
00:03:57,380 --> 00:03:59,640
然后并且还有一些long chain的一些酷

112
00:03:59,640 --> 00:04:02,940
这个是我们的一个基础的一个框架

113
00:04:02,940 --> 00:04:05,640
那整个相当于我们就基于long graph

114
00:04:05,640 --> 00:04:07,100
去实现一个agent的应用

115
00:04:07,100 --> 00:04:09,940
让他去做一个知识库的一个检索

116
00:04:09,940 --> 00:04:11,700
然后检索完之后的话

117
00:04:11,700 --> 00:04:15,240
相当于做一个这个向量相似度的匹配

118
00:04:15,240 --> 00:04:16,220
评约完之后

119
00:04:16,220 --> 00:04:18,000
再把这些个内容

120
00:04:18,000 --> 00:04:19,320
拼装成提示词

121
00:04:19,320 --> 00:04:21,560
丢给这个大模型

122
00:04:21,560 --> 00:04:23,060
然后总结性的做一个回答

123
00:04:23,060 --> 00:04:25,040
所以大家问这些专业问题的时候

124
00:04:25,040 --> 00:04:26,120
你会发现

125
00:04:26,120 --> 00:04:27,660
他的这些回答的话

126
00:04:27,660 --> 00:04:28,800
是非常准确的

127
00:04:28,800 --> 00:04:30,500
因为他做了这个

128
00:04:30,500 --> 00:04:31,740
相似度的一个匹配

129
00:04:31,740 --> 00:04:32,980
比如说你问的这个

130
00:04:32,980 --> 00:04:34,660
网上银行是吧

131
00:04:34,660 --> 00:04:36,440
你看这个里面

132
00:04:36,440 --> 00:04:39,360
他就基本上是参考这个回答的

133
00:04:39,360 --> 00:04:41,160
所以这个答案会比较精准

134
00:04:41,160 --> 00:04:42,920
这就是我们要做的一个

135
00:04:42,920 --> 00:04:46,120
AI的一个智能客服的这么一个系统

136
00:04:46,120 --> 00:04:48,280
所以这个系统的一个关键点的话

137
00:04:48,280 --> 00:04:50,280
其实就是基于这个RUG的一个系统

138
00:04:50,280 --> 00:04:52,680
目前来说啊

139
00:04:52,680 --> 00:04:54,700
只要是涉及到智能客服系统

140
00:04:54,700 --> 00:04:57,080
你要追求这个答案的准确性的话

141
00:04:57,080 --> 00:05:00,480
基本上都是基于RUG的这个方案去做的

142
00:05:00,480 --> 00:05:03,580
那如果说你有这个模型微调

143
00:05:03,580 --> 00:05:05,220
渲电的这个条件的话

144
00:05:05,220 --> 00:05:06,740
用微调去做的也有

145
00:05:06,740 --> 00:05:09,860
但是像大部分场景啊

146
00:05:09,860 --> 00:05:10,920
为了节省成本的话

147
00:05:10,920 --> 00:05:13,720
其实都是基于Rug的这个模式去做的

148
00:05:13,720 --> 00:05:16,100
所以说我们现在要明确一个需求

149
00:05:16,100 --> 00:05:19,020
我们要做一个这个银行的智能客服系统

150
00:05:19,020 --> 00:05:21,360
然后当用户在提问里面

151
00:05:21,360 --> 00:05:23,480
比如说我们如何去查学那个余额是吧

152
00:05:23,480 --> 00:05:25,560
那么这个系统的话

153
00:05:25,560 --> 00:05:27,360
就要做如下几件事情

154
00:05:27,360 --> 00:05:28,420
首先的话

155
00:05:28,420 --> 00:05:30,340
他从这个行业知识库里面

156
00:05:30,340 --> 00:05:31,620
就这个行业知识库里面

157
00:05:31,620 --> 00:05:32,940
去做一个检索

158
00:05:32,940 --> 00:05:33,920
这个知识库的话

159
00:05:33,920 --> 00:05:35,000
咱们自己可以新增

160
00:05:35,000 --> 00:05:36,760
就是我们在这个里面

161
00:05:36,760 --> 00:05:38,780
我们可以选用OpenAI的这个

162
00:05:38,780 --> 00:05:39,920
Embading模型是吧

163
00:05:39,920 --> 00:05:41,780
做一个向量化存储啊

164
00:05:41,780 --> 00:05:43,680
就是做一个这个向量化的一个转化

165
00:05:43,680 --> 00:05:45,080
把它转换成embedding

166
00:05:45,080 --> 00:05:46,980
它的一些这个向量坐标

167
00:05:46,980 --> 00:05:48,320
然后向量数据库的话

168
00:05:48,320 --> 00:05:49,800
我们这里用的是Clamour啊

169
00:05:49,800 --> 00:05:51,040
这是我们啊

170
00:05:51,040 --> 00:05:52,840
有一个新增知识库啊

171
00:05:52,840 --> 00:05:54,060
因为我们要做一个出手化嘛

172
00:05:54,060 --> 00:05:55,400
所以我们要创建一个知识库

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

174
00:06:02,460 --> 00:06:08,400
然后的话让大模型基于检索到的内容去生成有依据的这个回答啊

175
00:06:08,400 --> 00:06:11,980
就是我不能说让AI就直接去回答了

176
00:06:11,980 --> 00:06:12,220
是吧

177
00:06:12,220 --> 00:06:13,580
你要把检索的内容

178
00:06:13,580 --> 00:06:17,240
组装成提示词丢给这个AI

179
00:06:17,240 --> 00:06:19,420
然后再去做内容的一个生成

180
00:06:19,420 --> 00:06:21,640
并且界面上的话

181
00:06:21,640 --> 00:06:23,060
我们要做一个流逝回答

182
00:06:23,060 --> 00:06:24,540
流逝回答什么意思啊

183
00:06:24,540 --> 00:06:26,300
就比如说你问他一个问题的话

184
00:06:26,300 --> 00:06:29,120
这里是一个字一个字迸穿

185
00:06:29,120 --> 00:06:31,400
就是这种打字机的这种效果

186
00:06:31,400 --> 00:06:32,700
但是这里面的话

187
00:06:32,700 --> 00:06:36,180
我们这里是一次性输出出来的

188
00:06:36,180 --> 00:06:38,040
所以我们其实可以改进一下

189
00:06:38,040 --> 00:06:39,820
把它做一个流逝的回答啊

190
00:06:39,820 --> 00:06:40,660
这里有一个参数

191
00:06:40,660 --> 00:06:43,060
把它做成一个流逝调用就可以了

192
00:06:43,060 --> 00:06:44,380
所以说啊

193
00:06:44,380 --> 00:06:45,660
整个一个过程的话

194
00:06:45,660 --> 00:06:47,060
其实很简单啊

195
00:06:47,060 --> 00:06:49,680
就是做一个知识库的一个检索匹配

196
00:06:49,680 --> 00:06:52,520
然后把拿到的一个结果

197
00:06:52,520 --> 00:06:54,080
去丢给这个大模型

198
00:06:54,080 --> 00:06:54,940
然后的话

199
00:06:54,940 --> 00:06:58,160
再去做一个流逝的一个回答啊

200
00:06:58,160 --> 00:06:59,780
虽然这个步骤很简单

201
00:06:59,780 --> 00:07:01,720
但是我们实现的这个逻辑的话

202
00:07:01,720 --> 00:07:03,760
还是稍微有点复杂的啊

203
00:07:03,760 --> 00:07:04,320
那首先的话

204
00:07:04,320 --> 00:07:05,360
我会给大家讲一下

205
00:07:05,360 --> 00:07:07,040
这个最终的一个架构啊

206
00:07:07,040 --> 00:07:10,240
然后我们等一下就会带大家去基于Codex

207
00:07:10,240 --> 00:07:12,920
从零到一去搭建这么一个项目啊

208
00:07:12,920 --> 00:07:14,200
因为现在啊

209
00:07:14,200 --> 00:07:16,880
我们有了这个Codex之后啊

210
00:07:16,880 --> 00:07:19,100
这个我们去开发项目的效率会很高

211
00:07:19,100 --> 00:07:22,220
所以说我们让他把这个架构啊

212
00:07:22,220 --> 00:07:24,340
或者说我们自己把架构做出来之后

213
00:07:24,340 --> 00:07:26,580
然后你让他去回答的话啊

214
00:07:26,580 --> 00:07:27,580
去去执行的话

215
00:07:27,580 --> 00:07:31,220
其实这个开发起来效率就会很高

216
00:07:31,220 --> 00:07:35,380
那这个是我之前做的一个这个事例啊

217
00:07:35,380 --> 00:07:37,260
就我之前已经把这个项目写出来了

218
00:07:37,260 --> 00:07:39,480
那么这里面的话

219
00:07:39,480 --> 00:07:40,420
我们就给大家看一下

220
00:07:40,420 --> 00:07:41,740
我们这个架构的一个设计

221
00:07:41,740 --> 00:07:42,720
首先的话

222
00:07:42,720 --> 00:07:44,240
我们整个前端页面啊

223
00:07:44,240 --> 00:07:45,960
这个前端页面是基于一个叫

224
00:07:45,960 --> 00:07:48,240
Streamlit的一个库去实现的

225
00:07:48,240 --> 00:07:49,540
那么这个库的话

226
00:07:49,540 --> 00:07:52,380
就是一个python前端开发的一个库啊

227
00:07:52,380 --> 00:07:54,780
非常方便做一些python的

228
00:07:54,780 --> 00:07:56,700
这种前端页面的一个展示啊

229
00:07:56,700 --> 00:07:56,940
是吧

230
00:07:56,940 --> 00:07:58,460
比如说做一个聊天的这种界面

231
00:07:58,460 --> 00:08:00,380
它的空间非常丰富啊

232
00:08:00,380 --> 00:08:01,720
所以我们整个的话

233
00:08:01,720 --> 00:08:03,040
是基于了这个框架

234
00:08:03,040 --> 00:08:04,600
去做了一个前端应用啊

235
00:08:04,600 --> 00:08:05,169
好

236
00:08:05,169 --> 00:08:07,069
然后包括侧边栏啊

237
00:08:07,069 --> 00:08:08,169
还有这个logo是吧

238
00:08:08,169 --> 00:08:09,029
你看这个侧边栏

239
00:08:09,029 --> 00:08:10,329
我们可以隐藏跟展示

240
00:08:10,329 --> 00:08:12,689
就是一个多页面的这么一个导航

241
00:08:12,689 --> 00:08:13,769
对话加设置

242
00:08:13,769 --> 00:08:17,389
然后我们的这个智能客服对话啊

243
00:08:17,389 --> 00:08:19,689
就是Rog这一块的一个核心技术的话

244
00:08:19,689 --> 00:08:21,569
是基于Long Graph去实现的

245
00:08:21,569 --> 00:08:22,189
Long Graph

246
00:08:22,189 --> 00:08:24,629
大家应该都有听说过

247
00:08:24,629 --> 00:08:25,909
大家可能听说过Long Chain

248
00:08:25,909 --> 00:08:27,049
Long Chain的话

249
00:08:27,049 --> 00:08:30,589
是目前做AI制整体应用开发的一个框架

250
00:08:30,589 --> 00:08:30,889
是吧

251
00:08:30,889 --> 00:08:35,109
就是我们可以做一些AI应用

252
00:08:35,109 --> 00:08:35,449
是吧

253
00:08:35,449 --> 00:08:36,549
不光光是制整体

254
00:08:36,549 --> 00:08:38,309
它可以做很多AI应用

255
00:08:38,309 --> 00:08:40,289
但是它主要还是做制整体

256
00:08:40,289 --> 00:08:42,029
那么Long Graph的话

257
00:08:42,029 --> 00:08:44,409
它就专门是做一些复杂的制整体

258
00:08:44,409 --> 00:08:46,489
它是一种工作流的这种方式

259
00:08:46,489 --> 00:08:47,909
叫这个流程

260
00:08:47,909 --> 00:08:48,229
是吧

261
00:08:48,229 --> 00:08:49,589
就是这种图形制的

262
00:08:49,589 --> 00:08:52,009
就是面向这个图形式的啊

263
00:08:52,009 --> 00:08:53,029
流程式的这种

264
00:08:53,029 --> 00:08:55,509
多智能体的这种代理啊

265
00:08:55,509 --> 00:08:56,209
这种场景啊

266
00:08:56,209 --> 00:08:58,269
就是比较企业级的这种复杂的

267
00:08:58,269 --> 00:09:00,589
agent的这种开发啊

268
00:09:00,589 --> 00:09:02,689
这种多智能体开发

269
00:09:02,689 --> 00:09:04,869
目前一般是基于Langgraph去做的

270
00:09:04,869 --> 00:09:06,689
是一个非常成熟的一个框架

271
00:09:06,689 --> 00:09:10,509
所以我们要基于Langgraph

272
00:09:10,509 --> 00:09:12,569
去实现整个Rug的一个核心流程

273
00:09:12,569 --> 00:09:16,609
然后包括一些这个行业的一些知识库啊

274
00:09:16,609 --> 00:09:18,289
比如说我们要做一些这个

275
00:09:18,289 --> 00:09:20,529
上传切分

276
00:09:20,529 --> 00:09:21,209
下量化

277
00:09:21,209 --> 00:09:21,589
是吧

278
00:09:21,589 --> 00:09:23,669
那对应到我们这个工作里面

279
00:09:23,669 --> 00:09:25,809
我们现在要上传这个下量数据库

280
00:09:25,809 --> 00:09:26,489
是吧

281
00:09:26,489 --> 00:09:29,889
就是文档上传上传这个知识库

282
00:09:29,889 --> 00:09:31,229
新增一个知识库

283
00:09:31,229 --> 00:09:32,649
然后去给他做一些处理

284
00:09:32,649 --> 00:09:35,089
然后的话就是

285
00:09:35,089 --> 00:09:36,369
还要做切分

286
00:09:36,369 --> 00:09:37,909
比如说你这个文件很大

287
00:09:37,909 --> 00:09:38,649
你有一兆

288
00:09:38,649 --> 00:09:40,149
那我们不能直接说

289
00:09:40,149 --> 00:09:41,449
称到下量数据库里去了

290
00:09:41,449 --> 00:09:43,049
因为你把这个一兆的文件

291
00:09:43,049 --> 00:09:44,609
直接给他转化成下量的话

292
00:09:44,609 --> 00:09:46,969
首先这个上下文可能会抄

293
00:09:46,969 --> 00:09:47,309
是吧

294
00:09:47,309 --> 00:09:48,849
那有些啊

295
00:09:48,849 --> 00:09:50,409
那个模型

296
00:09:50,409 --> 00:09:51,929
它不只是这么大的一个上下文

297
00:09:51,929 --> 00:09:53,989
那这里就会涉及到一个切分的问题

298
00:09:53,989 --> 00:09:55,089
啊

299
00:09:55,089 --> 00:09:55,969
就是一个切分策略

300
00:09:55,969 --> 00:09:58,609
比如说我这么大的一个文档啊

301
00:09:58,609 --> 00:09:59,969
应该怎么来切分

302
00:09:59,969 --> 00:10:01,709
是按这个段落来切

303
00:10:01,709 --> 00:10:02,649
换行来切

304
00:10:02,649 --> 00:10:03,649
还是怎么样来切

305
00:10:03,649 --> 00:10:07,409
这个都是有这个对应的一个策略的

306
00:10:07,409 --> 00:10:08,729
包括做一些向量化

307
00:10:08,729 --> 00:10:09,089
是吧

308
00:10:09,089 --> 00:10:12,709
这个整个是我们有一套成熟的一个方案啊

309
00:10:12,709 --> 00:10:13,729
然后这个

310
00:10:13,729 --> 00:10:16,669
然后就是检索是吧

311
00:10:17,309 --> 00:10:20,289
检索我们这里可以给它封做一个工具啊

312
00:10:20,289 --> 00:10:23,369
这个工具的话主要就是做用来做Rug的一个检索的

313
00:10:23,369 --> 00:10:26,969
那这里面我们相当于是共用了限量数据库啊

314
00:10:26,969 --> 00:10:29,789
就是我们定义了一个限量数据库啊

315
00:10:29,789 --> 00:10:32,909
然后我们不管是存储也好还是检索也好

316
00:10:32,909 --> 00:10:34,409
都要用到这个限量数据库

317
00:10:34,409 --> 00:10:36,729
所以这里面是一个公共的一个模块

318
00:10:36,729 --> 00:10:41,349
然后包括我们还要去做一些这个模型的一个揭露是吧

319
00:10:41,349 --> 00:10:47,289
那这里面的模型我默认用的是OpenAI的这个GPT4O的这么一个模型啊

320
00:10:47,309 --> 00:10:49,569
当然大家你也可以选择其他模型

321
00:10:49,569 --> 00:10:51,949
用Deep Seek或者是本地部署模型

322
00:10:51,949 --> 00:10:53,689
或者千万都是OK的

323
00:10:53,689 --> 00:10:57,969
关键是看大家就是你目前有哪些模型

324
00:10:57,969 --> 00:10:59,869
你可以自由的去选择

325
00:10:59,869 --> 00:11:03,209
只是说你如果用的是千万的一个模型的话

326
00:11:03,209 --> 00:11:04,689
那可能有一些这个参数

327
00:11:04,689 --> 00:11:05,789
可能就要做一些调整

328
00:11:05,789 --> 00:11:07,889
我这里用的是OpenAI的这个模型

329
00:11:07,889 --> 00:11:11,809
然后包括我们还可以去用一些这个

330
00:11:11,809 --> 00:11:13,409
embedding是吧

331
00:11:13,409 --> 00:11:14,709
他会用一些工具类

332
00:11:14,709 --> 00:11:18,909
所以我们这里面要写一个这个工具的这么一个啊

333
00:11:18,909 --> 00:11:19,869
这个脚本是吧

334
00:11:19,869 --> 00:11:21,229
这个脚本啊

335
00:11:21,229 --> 00:11:24,049
主要是就是用来去做一些模型的一些介入的

336
00:11:24,049 --> 00:11:25,889
比如说掉接口啊等等啊

337
00:11:25,889 --> 00:11:27,909
那向量数据库我们用的是Clamour啊

338
00:11:27,909 --> 00:11:30,909
这个是底层的一个向量数据库存储啊

339
00:11:30,909 --> 00:11:32,369
然后embedding啊

340
00:11:32,369 --> 00:11:38,129
就是比如说将我们的文本转化成这个向量坐标啊

341
00:11:38,129 --> 00:11:39,109
我们用的是embedding

342
00:11:39,109 --> 00:11:40,849
然后做了这个chart

343
00:11:40,849 --> 00:11:44,329
就整个是用OpenAI的这个embedding

344
00:11:44,329 --> 00:11:45,549
这个模型去实验的

345
00:11:45,549 --> 00:11:47,129
所以这里给他梳理一下

346
00:11:47,129 --> 00:11:49,729
我们目前核心的一个技术战有哪些啊

347
00:11:49,729 --> 00:11:50,989
首先是Streamlit

348
00:11:50,989 --> 00:11:52,289
Streamlit的话

349
00:11:52,289 --> 00:11:56,169
是一个前端的一个快速开发的一个库啊

350
00:11:56,169 --> 00:11:57,349
那这个库的话

351
00:11:57,349 --> 00:11:59,309
大家你也可以自己去搜一下

352
00:11:59,309 --> 00:12:02,169
比如说你去可以去看到啊

353
00:12:02,169 --> 00:12:02,689
Streamlit

354
00:12:02,689 --> 00:12:04,989
这个它是一个你看

355
00:12:04,989 --> 00:12:08,909
一个快速的这么一个做前端页面的啊

356
00:12:08,909 --> 00:12:10,009
就做各种应用的

357
00:12:10,009 --> 00:12:12,569
它的这个语法的话非常简单啊

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

359
00:12:17,529 --> 00:12:21,789
然后你看他可以做出比较好的一些效果出来

360
00:12:21,789 --> 00:12:27,749
所以大家你如果整个这个RUG系统是基于Python去开发的话

361
00:12:27,749 --> 00:12:29,549
那你其实可以什么呢

362
00:12:29,549 --> 00:12:30,709
前端你可以

363
00:12:30,709 --> 00:12:36,089
因为我们专业的前端可能还是用这个Node.js那一套嘛

364
00:12:36,089 --> 00:12:37,769
是吧我们ReactVU

365
00:12:37,769 --> 00:12:40,249
但是你如果想快速去构建一个

366
00:12:40,249 --> 00:12:42,949
标准的外部交付页面的话

367
00:12:42,949 --> 00:12:45,389
说白了就是这个给自己测试演示的话

368
00:12:45,389 --> 00:12:46,609
你用Streamlit

369
00:12:46,609 --> 00:12:48,729
肯定是没什么问题的

370
00:12:48,729 --> 00:12:50,089
所以这个主要目标

371
00:12:50,089 --> 00:12:51,669
它就是要做快速构建

372
00:12:51,669 --> 00:12:55,549
所以目前市面上一些python的这种项目的话

373
00:12:55,549 --> 00:12:56,249
前单的话

374
00:12:56,249 --> 00:12:58,609
做演示用的话

375
00:12:58,609 --> 00:13:00,869
基本上都是基于这个Streamlit

376
00:13:00,869 --> 00:13:03,569
你像有一些大模型的一些训练

377
00:13:03,569 --> 00:13:04,729
部署是吧

378
00:13:04,729 --> 00:13:06,469
那个操作的界面的话

379
00:13:06,469 --> 00:13:08,929
很多都是基于stream里的去用

380
00:13:08,929 --> 00:13:12,149
因为他非常方便做快速去做一些外部页面

381
00:13:12,149 --> 00:13:15,109
然后long turn他要做的一个事情

382
00:13:15,109 --> 00:13:18,009
long turn的话大家也可以去了解一下

383
00:13:18,009 --> 00:13:20,009
如果说你没接触过的话

384
00:13:20,009 --> 00:13:21,049
你可以去搜一下

385
00:13:21,049 --> 00:13:24,069
那么这个long turn的话

386
00:13:24,069 --> 00:13:25,789
主要就是我们可以看到

387
00:13:25,789 --> 00:13:27,349
他这个里面的话

388
00:13:27,349 --> 00:13:29,929
他是目前来说

389
00:13:29,929 --> 00:13:32,149
做一些AI智能体应用开发

390
00:13:32,149 --> 00:13:34,649
他是比较推荐的一个框架

391
00:13:34,649 --> 00:13:38,369
那这个他的一个迭代速度的话也非常快啊

392
00:13:38,369 --> 00:13:41,049
我们可以看到他的功能其实也非常强大

393
00:13:41,049 --> 00:13:43,229
可以做各种这个支柔体的一个应用

394
00:13:43,229 --> 00:13:46,229
然后long graph的话啊

395
00:13:46,229 --> 00:13:48,769
就是上面这个long chain跟long graph的一个分工

396
00:13:48,769 --> 00:13:51,089
就是long chain主要是管模型揭露

397
00:13:51,089 --> 00:13:52,889
文档切分与加载

398
00:13:52,889 --> 00:13:54,529
然后检索工具封装

399
00:13:54,529 --> 00:13:56,409
那么这个long graph的话

400
00:13:56,409 --> 00:13:58,909
他就去管这个agent状态机

401
00:13:58,909 --> 00:14:01,509
然后模型工具循环啊

402
00:14:01,509 --> 00:14:04,429
就是他主要是管这个agent的一个构建的

403
00:14:04,429 --> 00:14:05,829
包括他的一个状态啊

404
00:14:05,829 --> 00:14:06,869
数据流转啊

405
00:14:06,869 --> 00:14:08,709
然后工具的一个调用啊

406
00:14:08,709 --> 00:14:09,929
循环啊等等的

407
00:14:09,929 --> 00:14:11,309
所以这个目标

408
00:14:11,309 --> 00:14:13,389
他主要就是围绕着这个agent

409
00:14:13,389 --> 00:14:14,909
去做一个展开的

410
00:14:14,909 --> 00:14:16,169
然后long chain就是

411
00:14:16,169 --> 00:14:19,629
主要是做一些rug的这个应用的一些集成

412
00:14:19,629 --> 00:14:20,829
啊

413
00:14:20,829 --> 00:14:24,969
那个clama的话就是一款这个向上数据库啊

414
00:14:24,969 --> 00:14:26,869
这个是一款快开源的向上数据库

415
00:14:26,869 --> 00:14:27,869
这个数据库

416
00:14:27,869 --> 00:14:29,129
他既支持本地部署

417
00:14:29,129 --> 00:14:31,029
也支持服务器的那个部署啊

418
00:14:31,029 --> 00:14:33,749
主要就是用来存储这个向上数据库

419
00:14:33,749 --> 00:14:35,949
做一些数据的一些存储

420
00:14:35,949 --> 00:14:39,769
然后我们还可以去整合一些多平台的一些

421
00:14:39,769 --> 00:14:40,369
这个什么的

422
00:14:40,369 --> 00:14:42,769
比如说大家想用这个本地部署是吧

423
00:14:42,769 --> 00:14:43,849
那你就用欧拉玛

424
00:14:43,849 --> 00:14:47,469
所以这里面我们其实提供了一些个路口啊

425
00:14:47,469 --> 00:14:49,049
我们可以通过欧拉玛

426
00:14:49,049 --> 00:14:51,409
然后或者是其他的一些啊

427
00:14:51,409 --> 00:14:52,249
XEference

428
00:14:52,249 --> 00:14:54,969
可以做一些模型的一个加载

429
00:14:54,969 --> 00:14:59,609
也就是我们可以用这个在线的一个模型啊

430
00:14:59,609 --> 00:15:00,469
就是公网的一个模型

431
00:15:00,469 --> 00:15:01,989
也可以用私有化的欧拉玛模型

432
00:15:01,989 --> 00:15:03,229
这个都是OK的啊

433
00:15:03,229 --> 00:15:04,109
给大家的一个需要

434
00:15:04,109 --> 00:15:07,949
那么我们为什么用Codex开发啊

435
00:15:07,949 --> 00:15:09,529
首先Codex的话

436
00:15:09,529 --> 00:15:11,889
本身你可以把它看作是一个整体啊

437
00:15:11,889 --> 00:15:13,369
因为它不仅可以生成代码

438
00:15:13,369 --> 00:15:14,769
还能读项目改文件

439
00:15:14,769 --> 00:15:15,609
跑命理修bug

440
00:15:15,609 --> 00:15:16,769
所以说

441
00:15:16,769 --> 00:15:18,549
我们这里面的话

442
00:15:18,549 --> 00:15:19,789
基于Codex开发

443
00:15:19,789 --> 00:15:21,329
逻辑就不太一样了

444
00:15:21,329 --> 00:15:23,589
那就是以提示词啊

445
00:15:23,589 --> 00:15:25,309
像我们前面给大家讲的是

446
00:15:25,309 --> 00:15:27,689
这个面向规范的

447
00:15:27,689 --> 00:15:29,329
这么一个驱动的方式开发啊

448
00:15:29,329 --> 00:15:30,829
所以说我们其实

449
00:15:30,829 --> 00:15:32,289
现在去开发项目的话

450
00:15:32,289 --> 00:15:34,289
大家只要把提示词梳理出来就可以了

451
00:15:34,289 --> 00:15:35,569
不需要你去写代码了

452
00:15:35,569 --> 00:15:37,669
然后他就可以快速去开发一个模块

453
00:15:37,669 --> 00:15:41,789
所以这个就是正常的一个AI编程的一个正确的姿势

454
00:15:41,789 --> 00:15:43,969
所以我们等下的一个开发的话

455
00:15:43,969 --> 00:15:46,389
基本上自己是不用手写一行代码的

456
00:15:46,389 --> 00:15:49,349
都是交给Codex去做代码生成

457
00:15:49,349 --> 00:15:53,789
然后由他去做一个这个功能一个开发

458
00:15:53,789 --> 00:15:55,789
所以大家首先第一步要做的就是

459
00:15:55,789 --> 00:15:58,129
我们要把Codex的一个环境准备好

460
00:15:58,129 --> 00:16:01,289
那么大家听到之前的这个章节的话

461
00:16:01,289 --> 00:16:02,649
我相信这个codex环境

462
00:16:02,649 --> 00:16:03,549
大家都已经装好了

463
00:16:03,549 --> 00:16:05,649
所以这一步我就简单介绍一下

464
00:16:05,649 --> 00:16:07,229
就是咱们得把codex

465
00:16:07,229 --> 00:16:09,129
我这里安装方式的话

466
00:16:09,129 --> 00:16:10,229
主要是讲的这个

467
00:16:10,574 --> 00:16:12,214
主要是讲了这个他的命令行方式啊

468
00:16:12,214 --> 00:16:13,754
所以大家不管是命令行

469
00:16:13,754 --> 00:16:16,234
还是我们之前讲的这个啊

470
00:16:16,234 --> 00:16:20,054
Codex app或者是这个啊

471
00:16:20,054 --> 00:16:21,774
Withcode的那个插件啊

472
00:16:21,774 --> 00:16:23,174
都都是可以的啊

473
00:16:23,174 --> 00:16:24,394
看大家习惯用哪一种

474
00:16:24,394 --> 00:16:26,634
然后完了之后的话

475
00:16:26,634 --> 00:16:28,754
你可以去配置一下这个API密钥啊

476
00:16:28,754 --> 00:16:32,114
因为我采用的是这种API key的这种方式去连接的

477
00:16:32,114 --> 00:16:33,734
所以看大家的一个实际情况

478
00:16:33,734 --> 00:16:35,854
我们前面有给大家讲连接方式

479
00:16:35,854 --> 00:16:38,214
就是你要么是登录啊

480
00:16:38,214 --> 00:16:42,194
用官方那个ChatGBT的这个网站跳转做授权

481
00:16:42,194 --> 00:16:47,494
还有一种的话是你可以这个配一个API密钥啊

482
00:16:47,494 --> 00:16:48,394
这个都是OK的

483
00:16:48,394 --> 00:16:50,754
看大家的一个实际需求吧

484
00:16:50,754 --> 00:16:53,374
就是你的一个实际情况是什么

485
00:16:53,374 --> 00:16:57,174
然后我这里面就是去配一下这个环境变量

486
00:16:57,174 --> 00:16:58,734
它基本上就可以用了啊

487
00:16:58,734 --> 00:17:00,634
但是你这里配完之后

488
00:17:00,634 --> 00:17:03,214
你需要把终端这个重启一下才能生效啊

489
00:17:03,214 --> 00:17:04,794
这个是呃

490
00:17:04,794 --> 00:17:07,294
这个是在Mac或者Linux上面的一个配置

491
00:17:07,294 --> 00:17:08,574
这个是Windows上面

492
00:17:08,574 --> 00:17:11,834
我们用的是SateX这么一个命令啊

493
00:17:11,834 --> 00:17:13,494
好

494
00:17:13,494 --> 00:17:14,414
完了之后的话

495
00:17:14,414 --> 00:17:18,634
就是我们现在就可以进入到我们的一个项目应用开发了啊

496
00:17:18,634 --> 00:17:22,034
就是接下来我们要建一个项目录是吧

497
00:17:22,034 --> 00:17:25,334
那比如说我现在这个里面

498
00:17:25,334 --> 00:17:26,134
给他看一下

499
00:17:26,134 --> 00:17:30,434
我们进入到这个Codex

500
00:17:30,434 --> 00:17:30,994
是吧

501
00:17:30,994 --> 00:17:33,394
进入到这个Codex里面去

502
00:17:33,394 --> 00:17:34,694
然后的话

503
00:17:34,694 --> 00:17:36,994
这里面我们建一个目的

504
00:17:36,994 --> 00:17:39,874
叫做这个Rack

505
00:17:39,874 --> 00:17:42,014
System

506
00:17:42,014 --> 00:17:44,474
Rack系统

507
00:17:44,474 --> 00:17:46,054
然后在这个里面的话

508
00:17:46,054 --> 00:17:49,054
我们要用终端管理员的方式打开

509
00:17:49,054 --> 00:17:54,154
然后切换到地盘

510
00:17:54,154 --> 00:17:56,914
切换到Codex

511
00:17:56,914 --> 00:17:59,394
下面有一个目录叫做RockSystem

512
00:17:59,394 --> 00:18:01,754
然后我们进入Codex

513
00:18:01,754 --> 00:18:08,234
进入Codex之后

514
00:18:08,234 --> 00:18:09,794
我首先调一下这个权限

515
00:18:09,794 --> 00:18:14,254
把这个权限改成这个不需要授权的

516
00:18:14,254 --> 00:18:16,154
因为我不想反复的去确认

517
00:18:16,154 --> 00:18:18,514
这里因为怎么正常编码开发了

518
00:18:18,514 --> 00:18:19,994
所以就不需要确认了

519
00:18:19,994 --> 00:18:21,114
直接让他干活就行了

520
00:18:21,114 --> 00:18:22,894
我们把这个权限放开

521
00:18:22,894 --> 00:18:25,274
就是不需要再用户再确认了

522
00:18:25,274 --> 00:18:27,154
好

523
00:18:27,154 --> 00:18:28,974
然后这个地方的话就是

524
00:18:28,974 --> 00:18:31,674
你看我刚刚讲的这个授权模式

525
00:18:31,674 --> 00:18:33,454
我就是用的这一种

526
00:18:33,454 --> 00:18:35,054
就把权限全部全自动了

527
00:18:35,054 --> 00:18:37,054
这个是我们因为

528
00:18:37,054 --> 00:18:40,514
我们前面给大家讲了这几种权限

529
00:18:40,514 --> 00:18:42,214
就是涉及到一些敏感操作

530
00:18:42,214 --> 00:18:43,614
一些敏感命令执行的时候

531
00:18:43,614 --> 00:18:46,334
我建议大家就是需要用户去确认

532
00:18:46,334 --> 00:18:47,954
就如果是你个初学者

533
00:18:47,954 --> 00:18:49,414
你要保证安全的

534
00:18:49,414 --> 00:18:50,534
你就用这种模式

535
00:18:50,534 --> 00:18:53,454
如果说你已经熟悉了

536
00:18:53,454 --> 00:18:53,754
是吧

537
00:18:53,754 --> 00:18:55,274
那你要快速提效

538
00:18:55,274 --> 00:18:56,874
你就用auto的这个模式

539
00:18:56,874 --> 00:18:58,474
但以前叫auto edit

540
00:18:58,474 --> 00:18:59,854
现在叫auto review

541
00:18:59,854 --> 00:19:01,374
差不多的一个意思

542
00:19:01,374 --> 00:19:03,694
就是他会根据实际一个情况

543
00:19:03,694 --> 00:19:05,474
自动帮你去授权访问

544
00:19:05,474 --> 00:19:06,654
但是在某一些

545
00:19:06,654 --> 00:19:09,454
比如说要执行一些RM跟RF的

546
00:19:09,454 --> 00:19:10,214
一些命令的时候

547
00:19:10,214 --> 00:19:11,874
这些敏感操作的时候

548
00:19:11,874 --> 00:19:12,914
他还是需要授权

549
00:19:12,914 --> 00:19:13,794
所以

550
00:19:13,794 --> 00:19:16,434
但是他大部分命令都会放开

551
00:19:16,434 --> 00:19:19,874
所以这个就看大家的一个实际情况

552
00:19:19,874 --> 00:19:21,434
如果说你属于这个阶段

553
00:19:21,434 --> 00:19:22,194
你就用这种模式

554
00:19:22,194 --> 00:19:24,014
我目前用的是这种模式

555
00:19:24,014 --> 00:19:26,714
就是我需要他全自动去帮我去跑了

556
00:19:26,714 --> 00:19:29,694
所以我不需要关注那么多授权的东西

557
00:19:29,694 --> 00:19:34,614
那么首先就是我们要做一个需求的一个拆解跟架构设计

558
00:19:34,614 --> 00:19:34,914
是吧

559
00:19:34,914 --> 00:19:38,914
就大家你用Codex做项目

560
00:19:38,914 --> 00:19:41,714
你不是一上来就直接让Codex帮我写一个智能客服系统

561
00:19:41,714 --> 00:19:44,254
那这样生成的这个效果肯定是不行的

562
00:19:44,254 --> 00:19:46,434
因为你需求都没描述清楚呢

563
00:19:46,434 --> 00:19:47,994
你首先啊

564
00:19:47,994 --> 00:19:50,454
我们虽然是用Codex去提效

565
00:19:50,454 --> 00:19:52,194
但是的话

566
00:19:52,194 --> 00:19:53,794
大家不要觉得就是

567
00:19:53,794 --> 00:19:55,854
AI就能模拟搞定一切了是吧

568
00:19:55,854 --> 00:19:58,714
就是你的整个软件开发的这个过程

569
00:19:58,714 --> 00:19:59,674
你还是得有的

570
00:19:59,674 --> 00:20:00,894
比如说做技术方案

571
00:20:00,894 --> 00:20:01,754
做架构设计

572
00:20:01,754 --> 00:20:02,834
这个跑不了的

573
00:20:02,834 --> 00:20:05,214
因为这是个系统

574
00:20:05,214 --> 00:20:06,094
这个系统的话

575
00:20:06,094 --> 00:20:07,554
会涉及到非常多的模块

576
00:20:07,554 --> 00:20:09,494
需求的话会有大需求

577
00:20:09,494 --> 00:20:11,414
然后每个任务要做拆分的

578
00:20:11,414 --> 00:20:12,394
那AI的话

579
00:20:12,394 --> 00:20:15,634
他比较适合的是执行某一个任务

580
00:20:15,634 --> 00:20:17,514
所以说你如果没有帮他

581
00:20:17,514 --> 00:20:19,714
没有帮他把任务拆出来的话

582
00:20:19,714 --> 00:20:21,614
那他帮你干活的时候

583
00:20:21,614 --> 00:20:22,974
可能就会出现各种各样的问题

584
00:20:22,974 --> 00:20:24,474
所以大家尽量要细化

585
00:20:24,474 --> 00:20:26,294
这是一个非常大的一个原则

586
00:20:26,294 --> 00:20:29,294
所以我们第一步的话

587
00:20:29,294 --> 00:20:31,114
就大家要把认知给他对齐一下

588
00:20:31,114 --> 00:20:33,734
要按照一个正常的软件开发的一个流程

589
00:20:33,734 --> 00:20:35,414
去做一个交互

590
00:20:35,414 --> 00:20:37,374
比如说第一步

591
00:20:37,374 --> 00:20:40,294
我们你现在要做一个Rug的这个系统的话

592
00:20:40,294 --> 00:20:41,894
你首先得输出技术方案吧

593
00:20:41,894 --> 00:20:43,194
那那技术方案

594
00:20:43,194 --> 00:20:44,374
以前我们做价格设计

595
00:20:44,374 --> 00:20:46,394
大家要画这个什么流程图啊

596
00:20:46,394 --> 00:20:47,614
架构图啊

597
00:20:47,614 --> 00:20:48,954
各种各样的一些图是吧

598
00:20:48,954 --> 00:20:51,854
那现在其实有了这些个东西之后的话

599
00:20:51,854 --> 00:20:54,414
有了AI有了Codex之后的话

600
00:20:54,414 --> 00:20:55,874
那这些工作的话

601
00:20:55,874 --> 00:20:57,334
其实都可以交给AI去做了

602
00:20:57,334 --> 00:20:57,994
但是的话

603
00:20:57,994 --> 00:21:00,754
你的一个前提就是你这个提示词

604
00:21:00,754 --> 00:21:02,054
你得写清楚是吧

605
00:21:02,054 --> 00:21:02,874
比如说我们这里

606
00:21:02,874 --> 00:21:05,354
我要开发一个Rug智能客服系统

607
00:21:05,354 --> 00:21:07,334
技术在限定为Web页面

608
00:21:07,334 --> 00:21:09,414
然后Agent的编盘是什么什么

609
00:21:09,414 --> 00:21:10,994
向量数据库是什么

610
00:21:10,994 --> 00:21:12,614
知识的模型是什么是吧

611
00:21:12,614 --> 00:21:14,414
然后功能需求

612
00:21:14,414 --> 00:21:16,034
一个知识库页面

613
00:21:16,034 --> 00:21:18,754
然后可以新建知识库

614
00:21:18,754 --> 00:21:20,774
上传markdown文档自动切分

615
00:21:20,774 --> 00:21:24,154
就是咱们得把需求描述的非常清楚

616
00:21:24,154 --> 00:21:26,534
并且这个知识库多选

617
00:21:26,534 --> 00:21:27,234
是吧可选

618
00:21:27,234 --> 00:21:29,374
然后对话的时候可以启用哪些知识库

619
00:21:29,374 --> 00:21:31,754
然后我们写了功能需求之后

620
00:21:31,754 --> 00:21:33,774
我们还就是要一定要提出来啊

621
00:21:33,774 --> 00:21:35,514
就是请先不要写代码

622
00:21:35,514 --> 00:21:39,614
先输出这个推荐项目的一个目录结构

623
00:21:39,614 --> 00:21:41,194
每个模块的一个工程职责

624
00:21:41,194 --> 00:21:42,874
然后建议的开发顺序

625
00:21:42,874 --> 00:21:44,594
从底层到上层

626
00:21:44,594 --> 00:21:47,054
这个就是要我们要做一个架构设计

627
00:21:47,054 --> 00:21:48,834
把一些相关的文档给它输出出来

628
00:21:48,834 --> 00:21:50,574
而不是说直接就开发了

629
00:21:50,574 --> 00:21:52,074
所以第一步的话

630
00:21:52,074 --> 00:21:54,214
大家首先要复制一下

631
00:21:54,214 --> 00:21:55,314
就是把这个提示词

632
00:21:55,314 --> 00:21:56,554
我们要一步的去生成

633
00:21:56,554 --> 00:21:59,294
那这个里面我用这个

634
00:21:59,294 --> 00:22:01,054
我们打开

635
00:22:01,054 --> 00:22:02,474
我们在这个里面给它来看

636
00:22:02,474 --> 00:22:03,414
会比较清新一些

637
00:22:03,414 --> 00:22:05,654
因为这个看起来不是很方便

638
00:22:05,654 --> 00:22:07,994
然后我们打开这个目录

639
00:22:07,994 --> 00:22:12,334
然后这个目录我们选择这个RackSystem

640
00:22:12,334 --> 00:22:15,994
然后在这个里面发起一个对话

641
00:22:15,994 --> 00:22:19,674
在这个大家会看得更清晰一些啊

642
00:22:19,674 --> 00:22:22,734
在这个里面他有时候看的不是很方便

643
00:22:22,734 --> 00:22:27,254
然后大家看啊

644
00:22:27,254 --> 00:22:28,294
在这个里面你看

645
00:22:28,294 --> 00:22:31,194
他就开始帮我们去规划了啊

646
00:22:31,194 --> 00:22:34,334
因为我之前规范里面写到DDD分层来组织

647
00:22:34,334 --> 00:22:36,314
所以他也把这个规范加入进来了

648
00:22:36,314 --> 00:22:39,054
你看这个是他就是规划的一个目入结构

649
00:22:39,054 --> 00:22:40,634
是吧什么RAG系统啊是吧

650
00:22:40,634 --> 00:22:42,954
然后配置啊数据啊

651
00:22:42,954 --> 00:22:45,594
然后包括一些模块啊是吧

652
00:22:45,594 --> 00:22:48,954
然后一些应用程序啊是吧

653
00:22:48,954 --> 00:22:50,774
你看是不是帮我们规划的非常清楚

654
00:22:50,774 --> 00:22:52,694
什么agent state node是吧

655
00:22:52,694 --> 00:22:55,694
你看按照模块职责划分

656
00:22:55,694 --> 00:22:57,614
负责stream里的钱的交互

657
00:22:57,614 --> 00:23:02,534
然后这个放核心的一些什么模块是吧

658
00:23:02,534 --> 00:23:06,494
然后还有一些这个规划相关的

659
00:23:06,494 --> 00:23:09,994
你看他包括建议的这个开发步骤都帮我们调好了

660
00:23:09,994 --> 00:23:12,214
比如说先定义领域模型

661
00:23:12,214 --> 00:23:16,954
然后再去实现基础的一些配置与模型的一个适配

662
00:23:16,954 --> 00:23:20,994
再包括去做一些什么markdown加载与切分是吧

663
00:23:20,994 --> 00:23:24,594
然后还有一些实现crama向量库的一些适配

664
00:23:24,594 --> 00:23:28,194
包括这个知识库这个啊

665
00:23:28,194 --> 00:23:29,434
路库的一些用力

666
00:23:29,434 --> 00:23:30,914
然后去实现一些

667
00:23:30,914 --> 00:23:33,334
这个检索的用力啊

668
00:23:33,334 --> 00:23:35,774
包括Longraph的这个Agent等等的是吧

669
00:23:35,774 --> 00:23:38,394
他会帮你把这个步骤

670
00:23:38,394 --> 00:23:39,954
全部给树立清楚

671
00:23:39,954 --> 00:23:42,134
所以说这个里面的话

672
00:23:42,134 --> 00:23:43,814
大家首先你要看一下

673
00:23:43,814 --> 00:23:44,634
他基本的逻辑

674
00:23:44,634 --> 00:23:46,914
是不是按照你的一个要求去做的啊

675
00:23:46,914 --> 00:23:50,254
这个有没有达到你的一个要求

676
00:23:50,254 --> 00:23:52,594
包括他的一些这个

677
00:23:52,594 --> 00:23:54,514
模块是吧

678
00:23:54,514 --> 00:23:55,814
然后开发顺序

679
00:23:55,814 --> 00:23:57,054
这些东西有没有问题

680
00:23:57,054 --> 00:24:00,914
然后这个就是确认没问题之后

681
00:24:00,914 --> 00:24:03,494
你可以开始让他干嘛呢

682
00:24:03,494 --> 00:24:08,634
接下来我们就开始去生成一些这个文档了

683
00:24:08,634 --> 00:24:08,934
是吧

684
00:24:09,331 --> 00:24:10,551
但我们其实

685
00:24:10,551 --> 00:24:12,411
他现在是按DDG做的

686
00:24:12,411 --> 00:24:13,091
我们其实

687
00:24:13,091 --> 00:24:15,111
还不需要那么多

688
00:24:15,111 --> 00:24:16,331
这个DDG的一些规范

689
00:24:16,331 --> 00:24:19,931
所以这里面我先是先调一下

690
00:24:19,931 --> 00:24:21,951
因为按他按DDG规划的话

691
00:24:21,951 --> 00:24:23,711
那个模块会插得很细啊

692
00:24:23,711 --> 00:24:28,711
但其实我们可以不需要用到那么细啊

693
00:24:28,711 --> 00:24:35,551
所以这个里面看一下

694
00:24:35,551 --> 00:24:42,571
我们可以这里面可以调整一下

695
00:24:42,571 --> 00:24:45,571
全局的这个DDD的一些规范啊

696
00:24:45,571 --> 00:24:47,811
我们找到那个用户目录

697
00:24:47,811 --> 00:24:52,211
然后找到点Codex

698
00:24:53,711 --> 00:24:56,711
嗯

699
00:25:00,711 --> 00:25:01,211
嗯

700
00:25:01,211 --> 00:25:05,211
然后Codex里面有我之前看一下啊

701
00:25:05,211 --> 00:25:07,211
Liless

702
00:25:13,211 --> 00:25:17,711
之前应该是我去写过一个这个Agence.md啊

703
00:25:23,711 --> 00:25:29,351
或者说咱们找不到的时候

704
00:25:29,351 --> 00:25:30,271
你机器可以Goend的

705
00:25:30,271 --> 00:25:38,651
帮我读取下系统全局的agents.md

706
00:25:38,651 --> 00:25:43,711
当前用户

707
00:25:43,711 --> 00:25:48,711
因为我之前那个agents.md里面写了一些这个

708
00:25:48,711 --> 00:25:50,891
dd的一些规范

709
00:25:50,891 --> 00:25:52,791
所以我现在要把这个规范给去掉

710
00:25:52,791 --> 00:25:54,811
不然到时候生人代码的时候

711
00:25:54,811 --> 00:25:56,911
可能会有一些这个问题啊

712
00:25:56,911 --> 00:25:59,191
但是他这个模块就这样去分

713
00:25:59,191 --> 00:25:59,851
也没什么问题

714
00:25:59,851 --> 00:26:01,731
只是说他这里拆的太细了

715
00:26:01,731 --> 00:26:03,191
你看什么DOMEN啊

716
00:26:03,191 --> 00:26:05,651
其实我们这么一个项目的话

717
00:26:05,651 --> 00:26:07,271
暂时还不需要用到DDD啊

718
00:26:07,271 --> 00:26:09,491
DDD一般是用在一些复杂的

719
00:26:09,491 --> 00:26:10,611
一些大型系统上面

720
00:26:10,611 --> 00:26:12,291
比如说一些ERP系统

721
00:26:12,291 --> 00:26:13,591
模块非常多的场景下

722
00:26:13,591 --> 00:26:14,811
用DDD没问题

723
00:26:14,811 --> 00:26:17,991
但实际上我们不需要那么麻烦啊

724
00:26:17,991 --> 00:26:20,611
你看我之前这个文档里面

725
00:26:20,611 --> 00:26:23,451
我写了一个什么 dv 驱动的方式开发

726
00:26:23,571 --> 00:26:25,511
这是之前的我规范

727
00:26:25,511 --> 00:26:27,171
那我现在要把它去掉

728
00:26:29,211 --> 00:26:31,171
codex下面有一个

729
00:26:32,451 --> 00:26:33,611
agents

730
00:26:33,611 --> 00:26:35,051
你看这是我之前加的

731
00:26:36,171 --> 00:26:39,451
我现在把它去掉

732
00:26:40,771 --> 00:26:42,971
然后这里面我们重新发起一个对话

733
00:26:43,851 --> 00:26:46,651
把之前的提示词复制一下

734
00:26:46,651 --> 00:26:48,171
重新发起一个对话

735
00:26:48,171 --> 00:26:50,951
我们再来让它生成一下

736
00:26:50,951 --> 00:27:01,591
我们这里看一下

737
00:27:01,591 --> 00:27:02,351
这个里面

738
00:27:02,351 --> 00:27:05,171
你看现在就不是DDD了

739
00:27:05,171 --> 00:27:08,411
后面同时也按照DDD风格推进

740
00:27:08,411 --> 00:27:12,051
这里面还是DDD没有生效

741
00:27:12,051 --> 00:27:14,391
没有保存

742
00:27:14,391 --> 00:27:18,851
我直接跟他说

743
00:27:18,851 --> 00:27:22,391
我再发几个对话

744
00:27:22,391 --> 00:27:28,131
可能是不是要重启一下

745
00:27:44,391 --> 00:27:57,191
那现在模块就少了一些了

746
00:27:57,191 --> 00:27:59,631
应该那个DDD的那个已经失效了

747
00:27:59,631 --> 00:28:01,091
模块少了一些了

748
00:28:01,091 --> 00:28:05,291
然后的话就是我们看一下整个的一个逻辑啊

749
00:28:05,291 --> 00:28:05,991
你像这个APP

750
00:28:05,991 --> 00:28:08,111
它只负责stream里的界面的交互

751
00:28:08,111 --> 00:28:12,591
domain的话就负责一些这个核心的一个业务概念啊

752
00:28:12,591 --> 00:28:13,691
然后application是什么

753
00:28:13,691 --> 00:28:15,791
然后外部技术实现是什么

754
00:28:15,791 --> 00:28:18,911
然后包括他的一些细节

755
00:28:18,911 --> 00:28:19,411
是吧

756
00:28:19,411 --> 00:28:20,471
就怎么来实现

757
00:28:20,471 --> 00:28:21,851
好

758
00:28:21,851 --> 00:28:23,031
这一步之后的话

759
00:28:23,031 --> 00:28:24,151
接下来干嘛呢

760
00:28:24,151 --> 00:28:26,251
接下来就是我们要去逐步实现

761
00:28:26,251 --> 00:28:28,011
整个的一个逻辑

762
00:28:28,011 --> 00:28:29,391
比如说

763
00:28:29,391 --> 00:28:31,171
这里面有两块

764
00:28:31,171 --> 00:28:33,851
就一块你可以按照他的一个目录结构去生成

765
00:28:33,851 --> 00:28:34,931
还有一块的话

766
00:28:34,931 --> 00:28:37,071
就是你有自己的一个规划

767
00:28:37,071 --> 00:28:40,671
你想按你的方式去做一个目录生成

768
00:28:40,671 --> 00:28:42,131
那你就可以把这个复制一下

769
00:28:42,131 --> 00:28:43,371
请

770
00:28:43,371 --> 00:28:53,051
参考我的目录结构规范进行调整

771
00:28:53,051 --> 00:29:03,071
生成对应的目录结构

772
00:29:03,071 --> 00:29:15,251
就是你自己有一套规范是吧

773
00:29:15,251 --> 00:29:16,951
你把这些东西你都定好了

774
00:29:16,951 --> 00:29:20,731
那你就让让他去按你的方式去做就可以了

775
00:29:20,731 --> 00:29:22,991
如果说你没有特定的一个要求

776
00:29:22,991 --> 00:29:24,931
你想用他的这个方案的话

777
00:29:24,931 --> 00:29:25,691
其实也是可以

778
00:29:25,691 --> 00:29:27,331
就我们前面的话

779
00:29:27,331 --> 00:29:29,211
只是让他去帮我们分析一下

780
00:29:29,211 --> 00:29:30,911
让他去完全去做一个

781
00:29:30,911 --> 00:29:31,891
所以说

782
00:29:31,891 --> 00:29:34,471
比如说我们可以把这个TS加起来

783
00:29:34,471 --> 00:29:34,711
是吧

784
00:29:34,711 --> 00:29:38,071
你可以把这两个东西组合起来

785
00:29:38,071 --> 00:29:39,611
你要开发这么一个

786
00:29:39,611 --> 00:29:42,191
然后你的一个目入结构应该是下面这种

787
00:29:42,191 --> 00:29:42,651
是吧

788
00:29:42,651 --> 00:29:44,531
或者说你就直接用它的方案都是可以

789
00:29:44,531 --> 00:29:45,531
或者大家

790
00:29:45,531 --> 00:29:47,551
你觉得它的结构太复杂了

791
00:29:47,551 --> 00:29:48,391
不太合适

792
00:29:48,391 --> 00:29:49,591
然后

793
00:29:49,591 --> 00:29:53,971
你可以去具体去调整一下

794
00:29:53,971 --> 00:29:54,411
是吧

795
00:29:54,411 --> 00:29:56,831
那我们可以再发起一个对话

796
00:29:56,831 --> 00:30:01,411
你可以让他参考你的目录结构去实现啊

797
00:30:01,411 --> 00:30:02,271
这个都是OK的

798
00:30:19,371 --> 00:30:21,991
这个里面大家可以不断的去调整啊

799
00:30:21,991 --> 00:30:23,271
做一些微调处理

800
00:30:23,271 --> 00:30:30,811
你看这是他给你的一个建议啊

801
00:30:30,811 --> 00:30:32,371
然后去梳理出来的

802
00:30:32,371 --> 00:30:33,551
哎他还善滴滴滴啊

803
00:30:33,551 --> 00:30:34,411
那个就没生效

804
00:30:34,411 --> 00:30:37,191
我的滴滴滴这个都去掉了

805
00:30:37,191 --> 00:30:39,791
但这个应该是要重启一下

806
00:30:39,791 --> 00:30:42,491
来重启一下

807
00:30:42,491 --> 00:30:45,991
我这个重启啊

808
00:30:45,991 --> 00:30:49,271
然后重新打开一下

809
00:30:49,271 --> 00:30:54,171
他可能没有加载啊

810
00:30:54,171 --> 00:30:55,711
当前那个对话可能

811
00:30:55,711 --> 00:30:58,011
要要重启一下这个APP

812
00:30:58,011 --> 00:30:58,691
可能才可以

813
00:30:58,691 --> 00:31:00,671
再试一下

814
00:31:00,671 --> 00:31:06,991
看现在应该