1
00:00:00,360 --> 00:00:03,640
好吧，下一篇很无聊，因为你知道的。

2
00:00:03,680 --> 00:00:09,440
好吧，我引入了我们之前使用过的相同的发送电子邮件工具。

3
00:00:09,680 --> 00:00:13,880
这就是我们正在使用装饰器的功能工具。

4
00:00:13,880 --> 00:00:18,640
如果您还记得如果您想将函数转换为可以的东西，则可以使用该装饰器

5
00:00:18,640 --> 00:00:19,040
一个工具。

6
00:00:19,040 --> 00:00:23,000
它会在幕后为您生成所有 JSON。

7
00:00:23,320 --> 00:00:29,280
因此，这是发送电子邮件的主题和正文，它会发送一封包含给定主题的电子邮件

8
00:00:29,280 --> 00:00:29,560
身体。

9
00:00:29,560 --> 00:00:31,680
我们将像以前一样使用 SendGrid。

10
00:00:31,720 --> 00:00:35,960
希望您仍然拥有您的帐户并且将其保存在您的 env 文件中。

11
00:00:35,960 --> 00:00:38,400
请记住更改此电子邮件。

12
00:00:38,440 --> 00:00:44,280
让我将其更改为您经过验证的电子邮件。

13
00:00:44,840 --> 00:00:49,000
是的，请也更改这一点。

14
00:00:49,000 --> 00:00:54,840
再次强调，不要向我发送大量包含人工智能生成内容的电子邮件，但请务必向我发送包含以下内容的电子邮件：

15
00:00:54,840 --> 00:00:55,640
你的问题。

16
00:00:55,680 --> 00:01:02,600
当然，我总是欢迎他们，但我不太欢迎人工智能生成的搜索深度研究的东西。

17
00:01:03,070 --> 00:01:11,150
呃，那么呃，内容就是，呃，HTML 版本，然后我们像以前一样发送电子邮件。

18
00:01:11,350 --> 00:01:12,510
那是我们的工具。

19
00:01:12,710 --> 00:01:15,590
你不需要看到这个，但无论如何我都会向你展示它。

20
00:01:15,590 --> 00:01:19,030
如果我把这个打印出来你就记得了。

21
00:01:19,070 --> 00:01:20,110
它在这里做什么？

22
00:01:20,110 --> 00:01:26,590
如果我只是打印出来，我们应该看到我们得到一个带有描述等的功能工具。

23
00:01:26,590 --> 00:01:30,710
如果您不确定为什么会发生这种情况，请查找装饰器。

24
00:01:30,750 --> 00:01:35,830
确保您了解装饰器的工作原理以及它们如何转换这样的函数。

25
00:01:36,590 --> 00:01:41,390
好吧，考虑到这一点，这是一个电子邮件代理。

26
00:01:41,390 --> 00:01:42,910
这对你来说已经是老生常谈了。

27
00:01:42,910 --> 00:01:44,590
现在我们已经这样做了好几次了。

28
00:01:44,790 --> 00:01:50,870
根据说明，您可以根据详细报告发送一封格式良好的 HTML 电子邮件。

29
00:01:51,310 --> 00:01:56,830
您将收到一份详细报告，您应该使用您的工具发送一封电子邮件，提供

30
00:01:56,830 --> 00:01:57,390
报告。

31
00:01:57,390 --> 00:02:05,310
将其转换为带有主题行的干净、呈现良好的 HTML，以便您可以看到我不再尝试

32
00:02:05,310 --> 00:02:06,150
打破局面。

33
00:02:06,260 --> 00:02:11,740
我给予该代理完全自由裁量权来提出主题行、重写电子邮件、执行以下操作

34
00:02:11,740 --> 00:02:19,220
整个过程都使用 GPT 4 mini，我们为它提供了一个实际发送电子邮件的工具。

35
00:02:19,220 --> 00:02:21,140
这就是我们的电子邮件代理。

36
00:02:21,140 --> 00:02:23,580
这对你来说已经是旧闻了。

37
00:02:23,580 --> 00:02:24,500
你知道，这太棒了。

38
00:02:24,500 --> 00:02:26,220
好吧，好吧。

39
00:02:26,580 --> 00:02:28,900
我们即将成为现实。

40
00:02:29,100 --> 00:02:36,060
所以我会，呃，暂停一下，然后我们将进入该项目的真正内容。

41
00:02:36,740 --> 00:02:37,420
好的。

42
00:02:37,740 --> 00:02:43,060
因此，我们再次有了另一个将使用结构化输出的代理。

43
00:02:43,340 --> 00:02:45,740
这就是研究员。

44
00:02:46,260 --> 00:02:51,260
因此，您是一名高级研究员，负责为查询编写一份有凝聚力的报告。

45
00:02:51,420 --> 00:02:56,900
研究助理将为您提供原始查询和一些初步研究。

46
00:02:56,940 --> 00:03:01,860
您提出报告大纲，描述报告的结构和流程，并且

47
00:03:01,860 --> 00:03:08,340
然后生成报告并返回，因为您的最终输出应该是 markdown 格式，所以它应该很长，

48
00:03:08,340 --> 00:03:13,050
详细的5到10页的内容至少一千字。

49
00:03:13,330 --> 00:03:16,530
好的，情况就这样了。

50
00:03:16,930 --> 00:03:18,730
现在我们将使用结构化输出。

51
00:03:18,770 --> 00:03:24,530
同样，我们将有一个报告数据迂腐对象，它是基本模型的子类。

52
00:03:24,650 --> 00:03:30,010
它有一个简短的摘要，我们以 2 到 3 句话的简短摘要开始。

53
00:03:30,170 --> 00:03:35,570
完整的 Markdown 最终报告以及一些后续建议。

54
00:03:35,770 --> 00:03:38,570
建议进一步研究的主题。

55
00:03:39,370 --> 00:03:41,370
所以这是一个代理。

56
00:03:41,530 --> 00:03:43,010
它将接受这些指示。

57
00:03:43,010 --> 00:03:46,010
它将使用 GPT 4 或 mini 输出类型。

58
00:03:46,010 --> 00:03:49,330
您可以在此处指定我们使用结构化输出。

59
00:03:49,330 --> 00:03:52,410
输出类型是报告数据。

60
00:03:52,610 --> 00:03:56,290
这就是我们的报告作者。

61
00:03:56,570 --> 00:03:58,330
这是我们的作家经纪人。

62
00:03:58,330 --> 00:04:05,010
这是我们进入该项目的实际流程之前的最后一个构建块。

63
00:04:05,850 --> 00:04:06,530
好的。

64
00:04:06,530 --> 00:04:07,490
所以现在是关键时刻。

65
00:04:07,490 --> 00:04:10,770
我们有五个功能让我向您展示。

66
00:04:10,770 --> 00:04:12,400
但它们相对简单。

67
00:04:12,400 --> 00:04:14,040
它们非常简单。

68
00:04:14,040 --> 00:04:18,120
我将向您展示其中三个，然后是两个。

69
00:04:18,560 --> 00:04:25,800
前三个将使用我们之前定义的两个代理来执行搜索

70
00:04:25,840 --> 00:04:28,280
规划代理和搜索代理。

71
00:04:28,280 --> 00:04:30,520
而这些函数，你可以看到它们非常短。

72
00:04:30,520 --> 00:04:31,480
它们非常简单。

73
00:04:31,480 --> 00:04:34,920
让我告诉你他们各自的搜索计划。

74
00:04:34,960 --> 00:04:35,400
好的。

75
00:04:35,400 --> 00:04:41,520
这非常简单地调用 runner run 来让我们的规划器代理传入查询。

76
00:04:41,960 --> 00:04:45,160
我们进行查询并将其传递给规划代理。

77
00:04:45,160 --> 00:04:49,880
请记住，计划代理将进行多次搜索。

78
00:04:50,280 --> 00:04:52,920
因此，我们将计算有多少搜索并打印出来。

79
00:04:52,920 --> 00:04:59,560
我们将返回最终输出，该输出采用搜索列表的形式。

80
00:04:59,600 --> 00:05:00,720
这就是格式化它的原因。

81
00:05:00,720 --> 00:05:06,600
再说一次，这里就是这个东西，网络搜索计划，网络搜索项目的列表。

82
00:05:07,080 --> 00:05:07,760
好的。

83
00:05:07,800 --> 00:05:08,640
我们回去吧。

84
00:05:09,240 --> 00:05:09,960
好的。

85
00:05:10,600 --> 00:05:16,310
那么下一个功能就是执行搜索。

86
00:05:16,310 --> 00:05:19,750
这是我们真正要对其中每一个进行搜索的时候。

87
00:05:19,950 --> 00:05:23,990
现在你还记得我不久前向你展示过 asyncio 吗？

88
00:05:24,030 --> 00:05:26,670
这是并行运行事物的好方法。

89
00:05:26,870 --> 00:05:28,550
现在正是时候。

90
00:05:28,830 --> 00:05:38,710
因此，我们将创建一堆异步任务来搜索结果中的每个项目

91
00:05:38,710 --> 00:05:39,630
这些搜索。

92
00:05:39,670 --> 00:05:45,910
这是 Pydantic 对象，搜索感觉为您提供搜索项列表。

93
00:05:45,910 --> 00:05:48,790
对于每个项目，我们将称之为搜索搜索。

94
00:05:48,830 --> 00:05:51,830
我们将讨论的下一个函数将称为搜索。

95
00:05:51,870 --> 00:05:52,430
我们要去。

96
00:05:52,470 --> 00:05:56,310
这为您提供了一个协程，因此我们可以将其转化为任务。

97
00:05:56,470 --> 00:06:02,430
然后我们可以使用我告诉过你的关于异步收集的这种收集方法。

98
00:06:02,430 --> 00:06:09,950
如果您随后等待，它将并行运行所有这些任务，并且结果将进入结果。

99
00:06:10,750 --> 00:06:12,430
然后我们就完成了。

100
00:06:12,990 --> 00:06:14,790
所以希望我没有在那里失去你。

101
00:06:14,790 --> 00:06:19,900
基本上我想说的是我们从规划者那里得到结果，我们只是搜索所有这些

102
00:06:19,900 --> 00:06:23,860
使用搜索代理并行处理事情。

103
00:06:24,300 --> 00:06:26,860
这就是我们实际使用搜索代理的方式。

104
00:06:26,900 --> 00:06:28,340
我们给它一个输入。

105
00:06:28,580 --> 00:06:31,260
我们实际上所做的不仅仅是告诉它查询。

106
00:06:31,300 --> 00:06:33,740
我们还告诉它我们正在寻找的原因。

107
00:06:33,780 --> 00:06:37,580
请记住，我说过我们要求一个理由的原因不止一个。

108
00:06:37,620 --> 00:06:40,260
这也是我们可以在这里提供一些背景信息的原因。

109
00:06:40,500 --> 00:06:47,580
然后我们，呃，我们运行搜索代理，然后返回搜索的最终输出。

110
00:06:48,300 --> 00:06:49,020
好的。

111
00:06:49,540 --> 00:06:51,820
希望你遵循这三个。

112
00:06:51,860 --> 00:06:57,380
如果没有，请回来查看这些简短的函数，以便它应该有意义。

113
00:06:57,940 --> 00:07:00,940
最后是一些家政服务。

114
00:07:01,100 --> 00:07:02,260
两个功能。

115
00:07:02,380 --> 00:07:05,460
其中一名负责撰写报告，一名负责发送电子邮件。

116
00:07:05,740 --> 00:07:09,060
撰写报告将使用撰写代理。

117
00:07:09,100 --> 00:07:15,140
呃，它将运行那个以 HTML 形式重构输出的代理。

118
00:07:15,460 --> 00:07:20,570
最后我们将使用电子邮件代理编写一封电子邮件。

119
00:07:20,850 --> 00:07:23,890
然后这将完成该过程。

120
00:07:24,410 --> 00:07:29,050
所以我应该运行这两个来定义这两个函数。

121
00:07:29,090 --> 00:07:30,650
这两个这五个功能。

122
00:07:30,890 --> 00:07:34,330
现在我们应该为演出做好准备了。

123
00:07:35,050 --> 00:07:35,330
好的。

124
00:07:35,330 --> 00:07:40,210
如果你是不喜欢我只执行代码并与之对话的方式的人之一，

125
00:07:40,250 --> 00:07:43,250
这是一种懒惰，那么你就会快乐。

126
00:07:43,250 --> 00:07:48,050
这次我将输入代码，以便我们一起完成这部分。

127
00:07:48,050 --> 00:07:50,130
所以这是一个关键时刻。

128
00:07:50,130 --> 00:07:57,010
我们要说，就像痕迹研究一样，痕迹诅咒已经填补了它。

129
00:07:57,130 --> 00:07:58,090
我不是。

130
00:07:58,170 --> 00:07:59,130
不，我没有运气。

131
00:07:59,130 --> 00:08:01,530
好吧，我要忽略诅咒在这里所说的内容。

132
00:08:01,850 --> 00:08:03,410
我不看那个。

133
00:08:03,410 --> 00:08:06,570
所以我们要打印一条消息，比如开始研究。

134
00:08:06,930 --> 00:08:08,530
有时光标太好了。

135
00:08:09,090 --> 00:08:10,610
好吧，让我们摆脱光标。

136
00:08:10,650 --> 00:08:11,690
没有作弊。

137
00:08:14,810 --> 00:08:17,570
我没有看我没有看光标说搜索。

138
00:08:17,770 --> 00:08:19,290
如果我输入不同的内容怎么办？

139
00:08:19,330 --> 00:08:19,570
呃。

140
00:08:20,050 --> 00:08:22,010
混淆光标。

141
00:08:22,600 --> 00:08:23,080
好的。

142
00:08:23,120 --> 00:08:24,040
现在搜索。

143
00:08:24,600 --> 00:08:25,400
那是行不通的。

144
00:08:25,400 --> 00:08:25,760
仍然是。

145
00:08:25,760 --> 00:08:26,920
它仍然弄清楚了。

146
00:08:27,040 --> 00:08:27,560
好的。

147
00:08:27,600 --> 00:08:28,520
但我们就这样吧。

148
00:08:28,560 --> 00:08:29,200
它知道。

149
00:08:29,200 --> 00:08:34,160
所以我们要做的第一件事是有一个名为搜索计划的变量，它将等待

150
00:08:34,200 --> 00:08:35,520
规划搜索。

151
00:08:35,520 --> 00:08:38,040
因此，如果您来到这里，就会计划进行搜索。

152
00:08:38,040 --> 00:08:39,520
这是第一步。

153
00:08:39,520 --> 00:08:40,400
我们这样做。

154
00:08:40,560 --> 00:08:41,000
好的。

155
00:08:41,000 --> 00:08:43,880
下一步是搜索结果。

156
00:08:43,880 --> 00:08:46,000
我们将进行搜索。

157
00:08:46,000 --> 00:08:50,120
因此，我们来到这里执行搜索计划中传递的搜索。

158
00:08:50,160 --> 00:08:53,320
这就是我们也在等待的下一步。

159
00:08:53,320 --> 00:08:56,960
我们需要做的下一件事是实际运行该报告。

160
00:08:56,960 --> 00:09:02,560
因此，我们等待编写报告，传递查询和搜索结果。

161
00:09:03,040 --> 00:09:05,680
光标和你一样清楚。

162
00:09:05,720 --> 00:09:09,880
您已经说过我们下一步需要做的是发送电子邮件。

163
00:09:09,880 --> 00:09:12,040
确实如此。

164
00:09:12,200 --> 00:09:16,560
我可以取出然后我可以打印。

165
00:09:17,000 --> 00:09:17,560
好的。

166
00:09:17,600 --> 00:09:23,960
我们不会，我们会做一些与光标建议不同的事情，以表明我们在这里有一些自主权。

167
00:09:23,960 --> 00:09:25,870
我们不仅仅被机器统治。

168
00:09:25,910 --> 00:09:27,470
好的，我们开始吧。

169
00:09:27,510 --> 00:09:28,310
让我们开始吧。

170
00:09:28,310 --> 00:09:29,430
让我们运行一下。

171
00:09:29,870 --> 00:09:31,790
于是就开始了研究。

172
00:09:31,830 --> 00:09:33,270
它正在计划搜索。

173
00:09:33,270 --> 00:09:34,870
它将通过搜索来执行。

174
00:09:34,870 --> 00:09:35,990
原来如此。

175
00:09:36,030 --> 00:09:37,270
而且已经完成了。

176
00:09:37,270 --> 00:09:37,590
所以。

177
00:09:37,590 --> 00:09:41,910
因此，它使用了一个代理来确定要执行的三个搜索。

178
00:09:41,950 --> 00:09:49,950
然后，对于其中的每一个，它都使用 OpenAI 的远程托管工具来实际执行搜索。

179
00:09:49,990 --> 00:09:51,710
它返回了所有结果。

180
00:09:51,710 --> 00:09:58,270
我们现在使用代理来综合结果并将其转换为报告使用。

181
00:09:58,550 --> 00:10:05,110
它将生成一个 Markdown 格式的报告，然后将其转换为 HTML 电子邮件。

182
00:10:05,630 --> 00:10:08,750
所以，嗯，我们会让它发挥作用。

183
00:10:09,150 --> 00:10:10,190
我们回来吧。

184
00:10:10,190 --> 00:10:14,870
最终报告是采用这种格式，其中 Markdown 作为其中的一部分。

185
00:10:14,870 --> 00:10:18,070
这就是我们现在正在写电子邮件的部分。

186
00:10:18,070 --> 00:10:21,350
在撰写电子邮件时，双方都会提出主题行。

187
00:10:21,510 --> 00:10:25,830
它还会将其写入 HTML 电子邮件。

188
00:10:25,870 --> 00:10:28,270
希望我很快就能收到那封电子邮件。