1
00:00:00,160 --> 00:00:02,400
所以下一部分是最重要的部分。

2
00:00:02,440 --> 00:00:04,400
它也可能是最复杂的。

3
00:00:04,920 --> 00:00:11,960
现在您对我们将把这个 JSON 发送给 LLM 并给予

4
00:00:11,960 --> 00:00:15,760
它可以选择在生成响应时进行回复。

5
00:00:15,920 --> 00:00:20,640
它可以选择说它想要运行这些工具之一。

6
00:00:20,640 --> 00:00:25,760
它想要运行这个工具或者它想要运行这个工具。

7
00:00:26,480 --> 00:00:33,120
所以我们接下来要做的就是编写一个函数来处理当

8
00:00:33,120 --> 00:00:36,480
法学硕士回复说，是的，我确实想运行这个工具。

9
00:00:36,520 --> 00:00:39,840
请运行它并向我提供输出。

10
00:00:40,320 --> 00:00:45,960
这就是我在这里编写的称为“处理工具调用”的函数的目的。

11
00:00:46,400 --> 00:00:50,120
它是一个接受工具调用列表的函数。

12
00:00:50,400 --> 00:00:51,520
它会运行它们。

13
00:00:52,080 --> 00:00:56,560
它会将响应添加到返回的结果中。

14
00:00:57,160 --> 00:00:58,320
所以它有一个循环。

15
00:00:58,320 --> 00:01:00,040
它循环执行这些工具调用。

16
00:01:00,080 --> 00:01:03,040
通常，模型一次只会调用一个工具。

17
00:01:03,040 --> 00:01:06,880
但实际上该构造支持运行多个工具。

18
00:01:06,880 --> 00:01:08,680
所以我们想在这里支持这一点。

19
00:01:08,680 --> 00:01:09,840
所以我们就这么做。

20
00:01:10,280 --> 00:01:12,600
所以我们循环所有的工具调用。

21
00:01:12,800 --> 00:01:13,920
我们看看这个。

22
00:01:13,960 --> 00:01:15,680
这个工具调用返回了什么。

23
00:01:15,680 --> 00:01:19,360
我应该说这实际上是一个结构化的输出。

24
00:01:19,400 --> 00:01:24,200
它是从 LM 返回的 JSON，已放入对象中。

25
00:01:24,200 --> 00:01:28,040
这就是我说它与结构化输出非常相似的原因之一。

26
00:01:28,040 --> 00:01:32,240
这个 JSON 对象以对象工具调用的形式回来了。

27
00:01:32,280 --> 00:01:37,640
我们将查看它在该响应中提供的函数名称。

28
00:01:38,120 --> 00:01:40,320
我们将称之为工具名称。

29
00:01:40,320 --> 00:01:43,000
这就是它要调用的函数的名称。

30
00:01:43,200 --> 00:01:48,000
它还为我们提供了参数，即应该放入该函数中的参数。

31
00:01:48,000 --> 00:01:50,160
我们可以像这样把它们去掉。

32
00:01:50,560 --> 00:01:53,120
然后我将打印我们称之为这个工具的内容。

33
00:01:53,840 --> 00:01:56,880
接下来是 if 语句。

34
00:01:56,880 --> 00:01:58,240
就像我向你承诺的那样。

35
00:01:58,600 --> 00:02:02,880
我们说工具名称是否是记录用户详细信息。

36
00:02:02,880 --> 00:02:09,880
如果它想调用这个工具，那么我们调用名为记录用户详细信息的函数。

37
00:02:09,880 --> 00:02:11,520
我们传递论据。

38
00:02:12,000 --> 00:02:18,840
但相反，如果该工具是该工具，则将未知问题记录在 JSON 中。

39
00:02:19,200 --> 00:02:21,400
然后我们调用名为 record 的函数。

40
00:02:21,440 --> 00:02:22,120
未知的问题。

41
00:02:22,120 --> 00:02:23,600
我们传入参数。

42
00:02:24,000 --> 00:02:31,160
然后我们将从该函数调用返回的任何内容添加到消息列表中。

43
00:02:31,160 --> 00:02:32,440
这就是我们返回的。

44
00:02:33,240 --> 00:02:38,560
这就是句柄工具调用函数的范围。

45
00:02:38,560 --> 00:02:41,600
正如我告诉你的，它有这个 if 语句。

46
00:02:42,480 --> 00:02:45,200
希望这对您来说更具体。

47
00:02:45,200 --> 00:02:46,280
你看到了这一点。

48
00:02:46,280 --> 00:02:49,720
如果没有，请过来看看并接受它。

49
00:02:50,160 --> 00:02:50,600
好的。

50
00:02:50,640 --> 00:02:54,440
接下来我要做的事情有点偷偷摸摸。

51
00:02:54,680 --> 00:02:58,240
当你看到这个时，你可能会想，这有点愚蠢。

52
00:02:58,440 --> 00:03:03,320
我们有这个东西，它查找字符串，然后调用具有相同名称的函数并查找

53
00:03:03,320 --> 00:03:05,840
对于不同的字符串，并调用具有相同名称的函数。

54
00:03:05,880 --> 00:03:08,760
现在我们知道 Python 充满了神奇的东西。

55
00:03:09,080 --> 00:03:14,480
Python 中是否有一种方法可以进行某种反射，然后使用

56
00:03:14,480 --> 00:03:16,560
与该字符串同名吗？

57
00:03:16,600 --> 00:03:18,280
答案是肯定的，当然有。

58
00:03:18,440 --> 00:03:23,120
这是在这种特殊情况下有效的一种方法。

59
00:03:23,120 --> 00:03:29,610
有一个叫做全局的东西，它给你一个字典，你可以用它来查找任何函数

60
00:03:29,610 --> 00:03:31,570
这是在全球范围内。

61
00:03:31,570 --> 00:03:35,610
所以我可以用它来查找一个名为 record 的函数。

62
00:03:35,650 --> 00:03:37,090
未知的问题。

63
00:03:37,290 --> 00:03:40,690
这将为我提供实际的功能记录。

64
00:03:40,730 --> 00:03:41,410
未知的问题。

65
00:03:41,410 --> 00:03:43,810
然后我就可以这样称呼它。

66
00:03:43,810 --> 00:03:45,210
这是一个非常难的问题。

67
00:03:45,250 --> 00:03:49,050
因此，如果我运行它，它应该向我的手机发送推送通知。

68
00:03:49,050 --> 00:03:49,690
让我们来看看。

69
00:03:51,490 --> 00:03:52,810
是的，这似乎有效。

70
00:03:53,010 --> 00:03:55,170
我发现记录这是一个非常困难的问题。

71
00:03:55,170 --> 00:03:55,890
这样就可以了。

72
00:03:55,890 --> 00:03:56,770
让我们再做一次。

73
00:03:57,610 --> 00:03:59,010
啊，这值得。

74
00:03:59,050 --> 00:04:00,370
当我收到电子邮件时进行 ping 操作。

75
00:04:00,370 --> 00:04:01,370
所以，呃。

76
00:04:01,370 --> 00:04:01,690
是的。

77
00:04:01,730 --> 00:04:04,210
在那里你会看到这个诡计是有效的。

78
00:04:04,210 --> 00:04:11,330
当然，这意味着我可以重写句柄工具调用函数并这样做，以便

79
00:04:11,330 --> 00:04:14,250
现在基本上不再有 if 语句了。

80
00:04:14,250 --> 00:04:21,490
我在那里有一个狡猾的逻辑，可以提取出正确的函数，然后动态地

81
00:04:21,490 --> 00:04:23,970
像这样调用该函数。

82
00:04:24,690 --> 00:04:29,570
我认为这样做肯定会更好。

83
00:04:30,250 --> 00:04:37,530
所以，嗯，是的，这显然为我们提供了一种解决方法，可以让我们拥有 if 语句

84
00:04:37,530 --> 00:04:38,050
前。

85
00:04:38,050 --> 00:04:43,250
但我不想让你想一分钟这意味着这不仅仅是一个美化的 if 语句，

86
00:04:43,250 --> 00:04:44,570
因为仅此而已。

87
00:04:44,610 --> 00:04:50,170
当然，我们有一些技巧可以使用字典来查找，从而不必列出一些东西

88
00:04:50,170 --> 00:04:50,570
出去。

89
00:04:50,770 --> 00:04:52,490
但归根结底，事情还是一样。

90
00:04:52,490 --> 00:04:57,410
我们只是获取一些文本，然后使用它来映射到函数名称，然后我们调用它

91
00:04:57,410 --> 00:04:58,130
功能。

92
00:04:58,130 --> 00:05:01,010
这是一个美化的 if 语句，仅此而已。

93
00:05:01,250 --> 00:05:03,690
这就是它的工作原理。

94
00:05:03,690 --> 00:05:07,650
我希望现在这能让您对正在发生的事情有一些了解。

95
00:05:07,690 --> 00:05:12,730
好消息是，第一周之后你就再也不用这样做了，因为所有其他的

96
00:05:12,730 --> 00:05:14,970
框架会为你处理这类事情。

97
00:05:15,010 --> 00:05:19,690
您无需费力地取出 JSON 并将其转换为函数调用。

98
00:05:19,690 --> 00:05:21,850
这正是这些框架所做的。

99
00:05:21,850 --> 00:05:24,610
人们写了这样的东西，然后想，你知道吗？

100
00:05:24,610 --> 00:05:28,650
只需将其放入一个漂亮的小框架中就很容易，这样人们就不必担心

101
00:05:28,650 --> 00:05:29,330
不再这样了。

102
00:05:29,450 --> 00:05:32,370
所以以后你就不用再担心这个问题了。

103
00:05:32,370 --> 00:05:38,250
但我希望这能让你真正了解它是如何运作的，发生了什么，这样你就可以

104
00:05:38,250 --> 00:05:43,450
这个基础，当你真正开始使用这些框架时，你就知道它实际上是什么

105
00:05:43,450 --> 00:05:43,850
正在做。