LangChain 核心概念学习（二）Components(组件)

原创已于 2024-10-26 19:21:42 修改 · 1.3k 阅读

21 ·

CC 4.0 BY-SA版权

文章标签：

#langchain #人工智能 #AI大模型 #大模型 #LLM #组件 #ai

于 2024-10-23 14:02:51 首次发布

二、Components(组件)

LangChain 提供了标准的、可扩展的接口和外部集成，这些接口和集成对于使用 LLM 构建应用非常有用。LangChain 自己实现了一些组件，对于其他组件我们依赖第三方集成，还有一些则是两者的结合。

1、Chat models(聊天模型)

使用消息序列作为输入并返回聊天消息作为输出的语言模型（与使用纯文本不同）。这些通常是较新的模型（较旧的模型通常是 LLM）。聊天模型支持为对话消息分配不同的角色，有助于区分来自 AI、用户以及系统消息等指令的消息。

尽管底层模型是以消息为输入和输出的，LangChain 的封装器也允许这些模型接受字符串作为输入。这意味着你可以轻松地将聊天模型用作 LLM。

当字符串作为输入传递时，它会被转换为 HumanMessage，然后传递给底层模型。

LangChain 不托管任何聊天模型，我们依赖第三方集成。

在构建聊天模型（ChatModels）时，我们有一些标准化的参数：

model: 模型名称
temperature: 采样温度
timeout: 请求超时时间
max_tokens: 生成的最大 token 数
stop: 默认停止序列
max_retries: 请求重试的最大次数
api_key: 模型提供商的 API 密钥
base_url: 发送请求的端点

重要注意事项：

标准参数仅适用于提供具有预期功能参数的模型提供商。例如，有些提供商不提供最大输出 token 的配置，因此 max_tokens 在这些情况下无法支持。
标准参数目前仅在具有独立集成包的集成（例如 langchain-openai, langchain-anthropic 等）中强制执行，不适用于 langchain-community 中的模型。
聊天模型还接受其他特定于该集成的参数。要查找聊天模型支持的所有参数，请访问该模型的 API 参考文档。

一些聊天模型经过专门微调以用于工具调用，并提供了专门的 API。通常，此类模型在工具调用方面表现优于未微调的模型，建议在需要工具调用的场景中使用。有关更多信息，请参阅工具调用部分(https://python.langchain.com/v0.2/docs/concepts/#functiontool-calling)。

有关如何使用聊天模型的具体信息，请参阅这里的相关操作指南(https://python.langchain.com/v0.2/docs/how_to/#chat-models)。

Multimodality(多模态)

一些聊天模型是多模态的，能够接受图像、音频甚至视频作为输入。目前，这些模型仍较为少见，因此模型提供商尚未对定义 API 的“最佳”方式达成标准。多模态输出更为少见。因此，我们的多模态抽象保持了相对轻量，并计划在领域成熟时进一步巩固多模态 API 和交互模式。

在 LangChain 中，大多数支持多模态输入的聊天模型也接受 OpenAI 的内容块格式的这些值。目前，这主要限制于图像输入。对于像 Gemini 这样的模型，支持视频和其他字节输入，API 也支持原生的、模型特定的表示方式。

有关如何使用多模态模型的具体信息，请参阅这里的相关操作指南(https://python.langchain.com/v0.2/docs/how_to/#multimodal)。

有关具有多模态模型的 LangChain 模型提供商的完整列表，请查看此表格(https://python.langchain.com/v0.2/docs/integrations/chat/#advanced-features)。

2、LLMs

警告: 纯文本输入/输出的 LLM 通常是较旧或较低级的模型。许多新的热门模型在用于聊天完成时表现最佳，即使在非聊天用例中也是如此。

语言模型接受字符串作为输入并返回字符串。这些通常是较旧的模型（较新的模型通常是Chat Models:https://python.langchain.com/v0.2/docs/concepts/#chat-models）。

尽管底层模型是字符串输入和输出，LangChain 的封装器也允许这些模型接受消息作为输入。这使得它们具有与聊天模型相同的接口。当消息作为输入传递时，它们会在底层被格式化为字符串，然后传递给底层模型。

LangChain 不托管任何 LLM，而是依赖于第三方集成。

有关如何使用 LLM 的具体信息，请参阅操作指南(https://python.langchain.com/v0.2/docs/how_to/#llms)。

3、Messages（消息）

一些语言模型接受消息列表作为输入并返回消息。有几种不同类型的消息。所有消息都有role(角色), content(内容), 和response_metadata(响应元数据)属性。

1、role(角色)描述了谁在说这条消息。标准角色包括“user(用户)”、“assistant(助手)”、“system(系统)”和“tool(工具)”。LangChain 为不同角色提供了不同的消息类。

2、content(内容)描述了消息的内容。这可以是几种不同的形式：

字符串（大多数模型处理这种类型的内容）
字典列表（用于多模态输入，其中字典包含有关输入类型和输入位置的信息）

此外，消息还可以有一个可选的 name 属性，用于区分具有相同角色的多个发言者。例如，如果聊天历史中有两个用户，区分他们可能会很有用。但并非所有模型都支持此功能。

HumanMessage
这表示一个角色为“用户”的消息。

AIMessage
这表示一个角色为“助手”的消息。除了 content 属性，这些消息还具有：

response_metadata

response_metadata 属性包含有关响应的额外元数据。这里的数据通常特定于每个模型提供者。这是存储诸如日志概率和令牌使用等信息的地方。
tool_calls

这些表示语言模型调用工具的决策。它们作为 AIMessage 输出的一部分包含在内。可以通过 .tool_calls 属性从中访问。

这个属性返回一个 ToolCalls 列表。ToolCall 是一个包含以下参数的字典：
name: 应调用的工具的名称。
args: 该工具的参数。
id: 工具调用的 id。

SystemMessage
这表示一个角色为“系统”的消息，告诉模型如何行为。并不是所有模型提供者都支持此功能。

ToolMessage
这表示一个角色为“工具”的消息，包含调用工具的结果。除了role(角色)和content(内容)外，这条消息还有：

tool_call_id 字段，传达调用工具的 id，以生成此结果。
artifact 字段，可用于传递工具执行的任意工件，这些工件对于跟踪很有用，但不应发送到模型。

（Legacy）FunctionMessage
这是一种旧版消息类型，对应于 OpenAI 的遗留函数调用 API。应使用 ToolMessage 来匹配更新后的工具调用 API。

它表示函数调用的结果。除role(角色)和content(内容)之外，这条消息还包含一个 name 参数，用于指示生成此结果的函数的名称。

4、Prompt templates(提示模板)

Prompt templates(提示模板)帮助将用户输入和参数转换为语言模型的指令。这可以用来引导模型的响应，帮助它理解上下文，并生成相关且连贯的语言输出。

提示模板接受一个字典作为输入，其中每个键代表要填充的提示模板中的变量。

提示模板输出一个 PromptValue。这个 PromptValue 可以传递给 LLM（语言模型）或 ChatModel（聊天模型），也可以转换为字符串或消息列表。之所以存在这个 PromptValue，是为了方便在字符串和消息之间切换。

有几种不同类型的提示模板：

1、字符串提示模板
字符串提示模板用于格式化单个字符串，通常用于较简单的输入。例如，构建和使用提示模板的一种常见方式如下：

from langchain_core.prompts import PromptTemplate
prompt_template = PromptTemplate.from_template("Tell me a joke about {topic}")
prompt_template.invoke({"topic": "cats"})

2、聊天提示模板
聊天提示模板用于格式化消息列表。这些“模板”由多个子模板组成。例如，构建和使用聊天提示模板的一种常见方式如下：

from langchain_core.prompts import ChatPromptTemplate

prompt_template = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant"),
    ("user", "Tell me a joke about {topic}")
])

prompt_template.invoke({"topic": "cats"})

在上述示例中，聊天提示模板（ChatPromptTemplate）在调用时将构建两个消息。第一个是系统消息，不需要格式化变量。第二个是用户消息（HumanMessage），将根据用户传入的 topic 变量进行格式化。

3、MessagesPlaceholder
MessagesPlaceholder提示模板负责在特定位置插入消息列表。在上述聊天提示模板（ChatPromptTemplate）中，我们看到如何格式化两个消息，每个消息都是一个字符串。但是，如果我们希望用户传递一个消息列表，然后将这些消息插入到特定位置，该怎么做呢？这时可以使用 MessagesPlaceholder。

from langchain_core.prompts import ChatPromptTemplate, MessagesPlaceholder
from langchain_core.messages import HumanMessage

prompt_template = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant"),
    MessagesPlaceholder("msgs")
])

prompt_template.invoke({"msgs": [HumanMessage(content="hi!")]})

这将生成一个包含两个消息的列表，第一个是系统消息，第二个是我们传入的用户消息。如果我们传入了 5 条消息，它将总共生成 6 条消息（系统消息加上 5 条传入的消息）。这对于将消息列表插入到特定位置非常有用。

另一种不显式使用 MessagesPlaceholder 类来完成相同任务的方法是：

prompt_template = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant"),
    ("placeholder", "{msgs}") # <-- This is the changed part
])

有关如何使用提示模板的具体信息，请参阅这里的相关操作指南：(https://python.langchain.com/v0.2/docs/how_to/#prompt-templates)。

5、Example selectors(示例选择器)

一种常见的提升性能的提示技术是将示例作为提示的一部分。这被称为少样本提示（few-shot prompting）。这种方法给语言模型提供了如何应对的具体示例。有时，这些示例是硬编码到提示中的，但对于更高级的情况，动态选择示例可能更为方便。示例选择器是负责选择并将示例格式化为提示的类。

有关如何使用示例选择器的具体信息，请参阅这里的相关操作指南：(https://python.langchain.com/v0.2/docs/how_to/#example-selectors)。

6、Output parsers输出解析器

注意
这里的信息指的是将模型的文本输出解析为更结构化表示的解析器。越来越多的模型支持函数（或工具）调用，这会自动处理这个过程。建议使用函数/工具调用，而不是输出解析。有关详细信息，请参阅：https://python.langchain.com/v0.2/docs/concepts/#function-tool-calling。

Output parser(输出解析器)负责将模型的输出转换为更适合下游任务的格式。它在使用语言模型生成结构化数据或标准化聊天模型和语言模型的输出时非常有用。

LangChain 支持多种不同类型的输出解析器。以下是 LangChain 支持的输出解析器列表。表格包含以下信息：

Name(名称): 输出解析器的名称
Supports Streaming(支持流式处理): 输出解析器是否支持流式处理
Has Format Instructions(具有格式说明): 输出解析器是否具有格式说明。一般情况下，输出解析器都会提供格式说明，除非（a）所需的模式在提示中没有指定，而是在其他参数中指定（如 OpenAI 函数调用），或（b）当 OutputParser 包装了另一个 OutputParser 时。
Calls LLM(调用 LLM): 这个输出解析器本身是否调用了 LLM。通常，只有那些尝试纠正格式错误的输出解析器才会这样做。
Input Type:(输入类型): 预期的输入类型。大多数输出解析器处理字符串和消息，但某些解析器（如 OpenAI Functions）需要带有特定参数的消息。
Output Type(输出类型): 解析器返回的对象的输出类型。
Description(描述): 我们对这个输出解析器的评论以及何时使用它。

名称	支持流式处理	具有格式说明	调用 LLM
JSON	✅	✅
str	Message	JSON 对象	返回指定的 JSON 对象。可以指定 Pydantic 模型，将返回该模型的 JSON 格式。可能是获取结构化数据的最可靠输出解析器，不使用函数调用。
XML	✅	✅
str	Message	dict	返回标签的字典。用于需要 XML 输出的情况。与擅长生成 XML 的模型（如 Anthropic 的）一起使用。
CSV	✅	✅
str	Message	List[str]	返回逗号分隔值的列表。
OutputFixing
✅
str	Message
包装另一个输出解析器。如果该解析器出错，则将错误信息和不良输出传递给 LLM，请求其修复输出。
RetryWithError
✅
str	Message
包装另一个输出解析器。如果该解析器出错，则将原始输入、不良输出和错误信息传递给 LLM，请求其修复。与 `OutputFixingParser` 相比，此解析器还发送原始指令。
Pydantic
✅
str	Message	pydantic.BaseModel	使用用户定义的 Pydantic 模型，并返回该格式的数据。
YAML
✅
str	Message	pydantic.BaseModel	使用用户定义的 Pydantic 模型，并返回该格式的数据。使用 YAML 编码。
PandasDataFrame
✅
str	Message	dict	适用于与 pandas DataFrame 进行操作。
Enum
✅
str	Message	Enum	将响应解析为提供的枚举值之一。
Datetime
✅
str	Message	datetime.datetime	将响应解析为 datetime 字符串。
Structured
✅
str	Message	Dict[str, str]	返回结构化信息的输出解析器。由于仅允许字段为字符串，因此其功能不如其他输出解析器强大。适用于处理较小的 LLM。

有关如何使用输出解析器的具体信息，请参阅这里的相关操作指南：（https://python.langchain.com/v0.2/docs/how_to/#output-parsers）。

7、Chat history（聊天记录）

大多数语言模型应用具有对话界面。对话的一个基本组件是能够引用对话中早期引入的信息。最基本的，对话系统应该能够直接访问一些历史消息。

ChatHistory 的概念指的是 LangChain 中的一个类，它可以用来包装任意chain(链)。这种 ChatHistory 将跟踪底层chain(链)的输入和输出，并将它们作为消息附加到消息数据库中。未来的交互将加载这些消息，并将其作为输入的一部分传递给chain(链)。

8、Documents(文档)

LangChain 中的 Document 对象包含有关某些数据的信息。它有两个属性：

page_content: str — 文档的内容。目前仅为字符串类型。
metadata: dict — 与此文档相关的任意元数据。可以跟踪文档 ID、文件名等。

9、Document loaders（文档加载器）

该类（DocumentLoader）用于加载 Document 对象。LangChain 提供了与各种数据源的集成来加载数据，例如 Slack、Notion、Google Drive 等。

每个 DocumentLoader 都有其特定的参数，但它们都可以通过 .load 方法以相同的方式调用。以下是一个示例用例：

from langchain_community.document_loaders.csv_loader import CSVLoader

loader = CSVLoader(
    ...  # <-- Integration specific parameters here
)
data = loader.load()

有关如何使用文档加载器的具体信息，请参阅这里的相关操作指南：(https://python.langchain.com/v0.2/docs/how_to/#document-loaders)。

10、Text splitters(文本分割器)

一旦加载了文档，你通常会希望对其进行转换，以更好地适应你的应用程序。最简单的例子是，你可能希望将长文档拆分为适合模型上下文窗口的小块。LangChain 提供了许多内置的文档转换器，使得split(拆分)、combine(合并)、filter(过滤)以及其他操作变得容易。

处理长文本时，必须将这些文本拆分成小块。尽管这听起来简单，但其中潜藏着许多复杂性。理想情况下，你希望将语义相关的文本片段保持在一起。“语义相关”可能取决于文本的类型。这里展示了几种实现方法。

从高层次来看，文本分割器的工作流程如下：

将文本拆分成小的、语义上有意义的块（通常是句子）。
开始将这些小块合并成更大的块，直到达到某个指定的大小（按某种函数测量）。
一旦达到该大小，将这个块作为独立的文本，然后开始创建一个新的文本块，并与前一个块有一些重叠（以保持块之间的上下文）。

这意味着你可以在两个不同的维度上自定义你的文本分割器：

如何拆分文本
如何测量块的大小

有关如何使用文本分割器的具体信息，请参阅这里的相关操作指南：(https://python.langchain.com/v0.2/docs/how_to/#text-splitters)。

11、Embedding models(嵌入模型)

嵌入模型创建文本的向量表示。你可以将向量视为一个数字数组，它捕捉了文本的语义意义。通过这种方式表示文本，你可以执行数学操作，从而实现诸如搜索语义最相似的其他文本等功能。这些自然语言搜索能力支撑了许多类型的上下文检索，在这些检索中，我们为语言模型提供了其有效响应查询所需的相关数据。

在这里插入图片描述

Embeddings 类是用于与文本嵌入模型交互的类。不同的嵌入模型提供商（如 OpenAI、Cohere、Hugging Face 等）以及本地模型都可以通过这个类来标准化接口。

LangChain 中的基础 Embeddings 类提供了两个方法：

一个用于嵌入文档
另一个用于嵌入查询

前者接受多个文本作为输入，而后者接受单个文本。之所以将这两个方法分开，是因为某些嵌入提供商对文档（用于检索）和查询（搜索查询本身）的嵌入方法有所不同。

有关如何使用嵌入模型的具体信息，请参阅这里的相关操作指南：(https://python.langchain.com/v0.2/docs/how_to/#embedding-models)。

12、Vector stores(向量存储)

存储和搜索非结构化数据的一种常见方式是将数据嵌入并存储生成的嵌入向量，然后在查询时对非结构化查询进行嵌入，并检索与嵌入查询“最相似”的嵌入向量。向量存储负责为你存储嵌入的数据并执行向量搜索。

大多数向量存储还可以存储有关嵌入向量的元数据，并支持在相似度搜索之前对这些元数据进行过滤，这让你可以更好地控制返回的文档。

向量存储可以通过以下方式转换为检索器接口：

vectorstore = MyVectorStore()
retriever = vectorstore.as_retriever()

有关如何使用向量存储的具体信息，请参阅这里的相关操作指南：(https://python.langchain.com/v0.2/docs/how_to/#vector-stores)。

13、Retrievers检索器

检索器是一个接口，用于根据非结构化查询返回文档。它比向量存储更为通用。检索器不需要具备存储文档的能力，只需返回（或检索）文档。检索器可以从向量存储创建，但也足够广泛，涵盖了像Wikipedia search(维基百科搜索)和 Amazon Kendra 这样的工具。

检索器接受一个字符串查询作为输入，并返回一个 Document 列表作为输出。

有关如何使用检索器的具体信息，请参阅这里的相关操作指南：（https://python.langchain.com/v0.2/docs/how_to/#retrievers）。

14、Key-value stores(键值存储)

对于一些技术，如使用多个向量进行索引和检索或缓存嵌入，拥有一种键值（KV）存储形式是有帮助的。

LangChain 包含一个 BaseStore 接口，允许存储任意数据。然而，LangChain 组件中需要 KV 存储的部分接受更具体的 BaseStore[str, bytes] 实例，用于存储二进制数据（称为 ByteStore），并在内部处理数据的编码和解码，以满足其特定需求。

这意味着作为用户，你只需要考虑一种存储类型，而不是针对不同类型数据使用不同的存储。

Interface(接口)

所有 BaseStore 都支持以下接口。请注意，该接口允许一次修改多个键值对：

mget(key: Sequence[str]) -> List[Optional[bytes]]: 获取多个键的内容，如果键不存在则返回 None。
mset(key_value_pairs: Sequence[Tuple[str, bytes]]) -> None: 设置多个键的内容。
mdelete(key: Sequence[str]) -> None: 删除多个键。
yield_keys(prefix: Optional[str] = None) -> Iterator[str]: 生成存储中的所有键， optionally 使用前缀进行过滤。

有关键值存储实现的更多信息，请参阅该部分：(https://python.langchain.com/v0.2/docs/integrations/stores/)。

15、Tools(工具)

Tools(工具)是设计用来由模型调用的实用程序：它们的输入设计为由模型生成，输出则设计为传递回模型。当你希望模型控制代码的部分或调用外部 API 时，就需要使用工具。

一个工具包括：

name:工具的名称
description:工具的功能描述
JSON schema:定义工具输入的 JSON 模式
a function:一个函数（以及可选的异步版本）

当一个工具绑定到模型时，工具的名称、描述和 JSON 模式作为上下文提供给模型。给定一组工具和指令，模型可以请求调用一个或多个工具，并提供特定的输入。

典型的使用方式可能如下所示：

tools = [...] # Define a list of tools
llm_with_tools = llm.bind_tools(tools)
ai_msg = llm_with_tools.invoke("do xyz...")
# -> AIMessage(tool_calls=[ToolCall(...), ...], ...)

从模型返回的 AIMessage 可能会包含与之相关的 tool_calls。有关响应类型的更多信息，请阅读此指南：(https://python.langchain.com/v0.2/docs/concepts/#aimessage)。

一旦选择的工具被调用，结果可以传递回模型，以便模型完成其正在执行的任务。通常有两种不同的方式来调用工具并传递响应：

1、Invoke with just the arguments（仅使用参数进行调用）

当你仅使用参数调用工具时，你会得到工具的原始输出（通常是一个字符串）。这通常看起来像这样：

# You will want to previously check that the LLM returned tool calls
tool_call = ai_msg.tool_calls[0]
# ToolCall(args={...}, id=..., ...)
tool_output = tool.invoke(tool_call["args"])
tool_message = ToolMessage(
    content=tool_output,
    tool_call_id=tool_call["id"],
    name=tool_call["name"]
)

请注意，content 字段通常会传递回模型。如果你不希望将原始工具响应传递给模型，但仍希望保留它，你可以转换工具输出，并将其作为附加信息（了解更多关于 ToolMessage.artifact 的内容:（https://python.langchain.com/v0.2/docs/concepts/#toolmessage））传递。

... # Same code as above
response_for_llm = transform(response)
tool_message = ToolMessage(
    content=response_for_llm,
    tool_call_id=tool_call["id"],
    name=tool_call["name"],
    artifact=tool_output
)

2、Invoke with ToolCall(使用 ToolCall 调用)

另一种调用工具的方式是使用模型生成的完整 ToolCall。当你这样做时，工具将返回一个 ToolMessage。这样做的好处是你不需要自己编写逻辑来将工具输出转换为 ToolMessage。这通常看起来像这样：

tool_call = ai_msg.tool_calls[0]
# -> ToolCall(args={...}, id=..., ...)
tool_message = tool.invoke(tool_call)
# -> ToolMessage(
    content="tool result foobar...",
    tool_call_id=...,
    name="tool_name"
)

如果你以这种方式调用工具并希望为 ToolMessage 包含一个附加信息，你需要让工具返回两个东西。有关定义返回附加信息的工具的更多信息，请参阅这里：（https://python.langchain.com/v0.2/docs/how_to/tool_artifacts/）。

16、Toolkits(工具包)

工具包是设计为一起使用的工具集合，用于特定任务。它们具有便捷的加载方法。

所有工具包都暴露了一个 get_tools 方法，该方法返回一个工具列表。因此，你可以这样做：

# Initialize a toolkit
toolkit = ExampleTookit(...)

# Get list of tools
tools = toolkit.get_tools()

17、Agents（代理）

单独的语言模型不能采取行动——它们只能输出文本。LangChain 的一个重要用例是创建代理。代理是系统，利用 LLM 作为推理引擎来确定应该采取哪些行动以及这些行动的输入是什么。这些行动的结果可以反馈到代理中，代理再决定是否需要更多的行动，或者是否可以结束。

LangGraph 是 LangChain 的一个扩展，专门用于创建高度可控和可定制的代理。

LangChain 中有一个过时的代理概念，我们正计划逐步弃用：AgentExecutor。AgentExecutor 实质上是代理的运行时环境。它是一个很好的起点，但随着你开始创建更定制的代理，它的灵活性不足。为了解决这个问题，我们构建了 LangGraph 作为一个灵活且高度可控的运行时环境。

如果你仍在使用 AgentExecutor，请不要担心：我们仍然提供有关如何使用 AgentExecutor 的指南。然而，建议你开始过渡到 LangGraph。为此，我们准备了一个过渡指南。

ReAct agents

构建代理的一个流行架构是 ReAct。ReAct 结合了推理和行动的迭代过程——实际上，“ReAct” 的名称代表了 “Reason” 和 “Act”。

一般流程如下：

模型会“思考”在响应输入和任何先前观察结果时采取的步骤。
模型将从可用工具中选择一个行动（或选择回应用户）。
模型会生成对该工具的参数。
代理运行时（执行器）会解析选择的工具，并用生成的参数调用它。
执行器将工具调用的结果作为观察结果返回给模型。

这个过程会重复，直到代理选择回应。

有一些基于提示的通用实现不需要模型特定的功能，但最可靠的实现使用工具调用等功能来可靠地格式化输出并减少变异。

有关更多信息，请参见 LangGraph 文档的操作指南：（https://langchain-ai.github.io/langgraph/）。

18、Callbacks(回调)

LangChain 提供了一个回调系统，允许你在 LLM 应用程序的各个阶段进行钩取。这对日志记录、监控、流式处理和其他任务非常有用。

你可以通过使用 API 中可用的 callbacks 参数来订阅这些事件。这个参数是一个处理程序对象的列表，这些对象应实现以下方法中的一个或多个，具体如下：

on_start: 在操作开始时调用。
on_step: 在操作的每一步调用。
on_end: 在操作结束时调用。
on_error: 在操作出错时调用。

这些回调方法可以用来实现不同的功能，如记录模型的操作、监控模型的性能、流式传输模型的输出等。通过回调系统，你可以更好地控制和观察模型的行为及其输出。

回调事件（Callback Events）

事件	事件触发	关联方法
Chat model start	当聊天模型开始时	`on_chat_model_start`
LLM start	当语言模型（LLM）开始时	`on_llm_start`
LLM new token	当语言模型或聊天模型发出新 token 时	`on_llm_new_token`
LLM ends	当语言模型或聊天模型结束时	`on_llm_end`
LLM errors	当语言模型或聊天模型出错时	`on_llm_error`
Chain start	当链开始运行时	`on_chain_start`
Chain end	当链结束时	`on_chain_end`
Chain error	当链出错时	`on_chain_error`
Tool start	当工具开始运行时	`on_tool_start`
Tool end	当工具结束时	`on_tool_end`
Tool error	当工具出错时	`on_tool_error`
Agent action	当代理执行动作时	`on_agent_action`
Agent finish	当代理结束时	`on_agent_finish`
Retriever start	当检索器开始时	`on_retriever_start`
Retriever end	当检索器结束时	`on_retriever_end`
Retriever error	当检索器出错时	`on_retriever_error`
Text	当任意文本运行时	`on_text`
Retry	当重试事件运行时	`on_retry`