利用LangChain和语言模型交互

从名字上可以看出来，LangChain可以用来构建自然语言处理能力的链条。它是一个库，提供了统一的接口，来和各种语言模型进行交互。更重要的是，它支持使用插件（工具），让语言模型能够获取实时的知识。LangChain基于Python，如果你熟悉JavaScript/TypeScript，可以考虑使用LangChain.js。

具体来说，LangChain包括以下模块：

1. Model I/O：提供针对语言模型的统一风格接口
2. 数据连接（Data connection）：提供应用程序相关数据的接口
3. 处理链（Chains）：用于构建针对模型、提示词、工具调用的流水线
4. 代理（Agents）：自动选择适当工具解决问题
5. 记忆（Memory）：跨越多次处理链调用，来保持程序状态信息
6. Callbacks：在处理链的中间步骤中进行回调

以OpenAI为例，安装依赖：

通过环境变量来设置API Key：

如果需要通过代理来访问OpenAPI的API端点，参考下面的方式设置环境变量：

下面的代码，根据你提供的输入来预测输出，也就是进行问答：

对话模型（Chat Models）是语言模型的变体。语言模型的输入、输出是一段文本，对话模型的输入则是一系列消息，这些消息构成了对话的上下文。对话模型的输出，则是一个消息。

LangChain将消息分为不同的类型，它们有对应的Python类：

1. AIMessage：表示从模型角度发出的消息（a message sent from the perspective of the AI）
2. HumanMessage：表示从最终用户角度发出的消息
3. SystemMessage：用于提出系统级别的指令，例如指示语言模型该如何格式化输出
4. ChatMessage：通用消息类型，可以指定一个role参数，从而等价于上述消息之一

这个消息分类，也是源自OpenAI的ChatGPT，ChatGPT会根据消息类型的不同，使用不同的处理方式。

语言模型具有很大的灵活性，我们将其集成到自己的应用程序中时，通常需要加以限制，不能让最终用户随意的提供输入。这种情况下，可以使用提示词模板。

具体来说，就是由应用程序作者提供提示词的主体部分，最终用户仅仅填充提示词中的占位符。假设我们开发一个翻译器，那么用户可能仅仅需要指定待翻译的文本、目标语言：

处理链可以连接模型、提示词，或者其它处理链。最简单的例子：连接语言模型和提示词：

上面定义了一个非常简单的处理链：渲染提示模板、调用LLM的API。某些复杂的流程下，需要根据输入动态的选择操作。

代理（Agent）能够完成这种动态选择，它调用语言模型来分析输入，从而确定需要先做什么，再做什么。代理能够反复的选择、运行工具，直到获取最终答案。

加载一个代理需要以下要素：

1. LLM或者Chat模型：这个模型提供自然语言理解能力，用于驱动代理
2. 工具（集）：工具是执行特定任务的函数，例如进行Google搜索、数据库查找、执行Python REPL、调用其它处理链
3. 代理的名称：这个名称表示使用的代理类。代理类使用参数化的提示词来调用模型，从而确定下一步该做什么

例如serpapi这个工具，它能够发起搜索引擎检索：

Verbose设置为True能够输出处理链的整个决策过程：

> Entering new chain...
I need to find out who the current president is and what he did last week. I can use the search tool for this.
Action: Search
Action Input: "current president of the United States"
Observation: Joe Biden
Thought:I now know the current president of the United States. I can use the search tool again to find out what he did last week.
Action: Search
Action Input: "Joe Biden last week"
Observation: The Supreme Court on Friday struck down President Joe Biden's plan to cancel up to $20,000 of student debt for tens of millions of Americans, thwarting a major ...
Thought:I now know the final answer.
Final Answer: Joe Biden is the current president of the United States. Last week, the Supreme Court struck down his plan to cancel up to $20,000 of student debt.

> Finished chain.
Joe Biden is the current president of the United States. Last week, the Supreme Court struck down his plan to cancel up to $20,000 of student debt.

可以看到，代理把问题划分为两个子任务，并且通过搜索网络来解答问题。

默认情况下处理链和代理是无状态的，很多情况下，我们需要依赖先前和模型的交互（作为上下文）。Memory模块提供了这种记住先前交互的机制，它支持基于最新的输入/输出来更新状态，或者基于已存储的状态，或者contextualize下一次输入。

Memory模块有多种实现，最简单的基于内存缓冲 —— 简单的将最近的几次输入/输出，作为当前输入的前缀：

这种实现有个重要的缺点：可能随着对话历史的增长，占用空间越来越大，因而影响AI的性能（或者超过长度限制）。通常需要考虑pruning或者summarization以保证上下文完整的同时不影响性能。

语言模型都是将文本作为输入的，这些文本就被称为提示词（Prompt）。

在语言模型应用程序中，提示词通常不是硬编码的，也不是让用户随意输入。一般情况下提示词由模板、样例、用户输入组成，LangChain提供了若干类用来构造提示词。

模板用于可复用的构造提示词，它由静态文本和一系列占位符（输入变量）构成。模板内容可以包括：

1. 对语言模型的指令
2. 帮助语言模型生成更好结果的若干示例
3. 对语言模型的提问

这里是一个最简单的例子：

上面的代码能够自动根据template中的占位符，来推断由哪些输入变量。手工声明变量的方式如下：

除了这种语言模型通用提示模板，还有针对对话模型的模板类：SystemMessagePromptTemplate、AIMessagePromptTemplate、HumanMessagePromptTemplate。它们的区别上文已经介绍过。一个或者多个这些模板，可以构成ChatPromptTemplate：

内置的提示词模板类（包括两种类型，一个是基于字符串的，一个是基于Chat的），都是根据输入变量，进行提示内容的格式化。

如果你需要以输入变量为键，从第三方（例如数据库，或者Feast这样的Feature Store）获取信息并生成提示词，可以选择自定义提示词模板。

这里以基于字符串的模板类为例来说明如何自定义提示词模板。我们常常会选择继承StringPromptTemplate，但是实际上，自定义提示词模板只需要满足两点：

1. 提供 input_variables属性，定义支持的输入变量的名字
2. 提供 format方法，接收关键字参数，用于根据指定的输入变量来生成提示词

下面这个模板的例子，以函数名为输入变量，生成让语言模型来解释函数用途的提示：

所谓少量样本（Few-shot）是指给语言模型提供几个例子（shots），以使其能够更好的理解你的意图并生成更好的响应。

样本可以说明期望的输出格式、得到最终输出的途径等等，其形式是比较自由的，语言模型能够理解其中的意图。

下面是一个样本集的例子：

基于上述样本集生成提示：

最终生成的提示是这样的：

Question: Who lived longer, Muhammad Ali or Alan Turing?

Are follow up questions needed here: Yes.
Follow up: How old was Muhammad Ali when he died?
Intermediate answer: Muhammad Ali was 74 years old when he died.
Follow up: How old was Alan Turing when he died?
Intermediate answer: Alan Turing was 41 years old when he died.
So the final answer is: Muhammad Ali

Question: When was the founder of craigslist born?

Are follow up questions needed here: Yes.
Follow up: Who was the founder of craigslist?
Intermediate answer: Craigslist was founded by Craig Newmark.
Follow up: When was Craig Newmark born?
Intermediate answer: Craig Newmark was born on December 6, 1952.
So the final answer is: December 6, 1952

Question: Who was the father of Mary Ball Washington?

我们可能会根据用户输入的语义，选择一个最匹配的样本，而不是把所有样本一股脑的发给语言模型。这时候，可以使用样本选择器。

向量存储用于保存Embeddings，所谓Embeddings，是指语言元素（例如单词、短语）在向量空间的数学表示（也就是多维向量）。向量存储支持进行语义相似度的判断，样本选择器依赖于向量存储的能力，来选取和输入最匹配的样本：

FewShotPromptTemplate这个提示模板，支持传入一个样本选择器，生成最终提示词：

目前LangChains没有为对话模型设计特别的抽象。在对话模型中，你只需要在输入消息中，提供交替的（Alternating）人类/AI消息，即可产生少量样本的效果：

对于OpenAI来说，可以使用系统消息，并用可选的name属性来“标记”样本：

默认情况下，PromptTemplate的字符串，被看作是Python的f-string，可以通过template_format指定其它格式，目前仅仅支持jinja2模板：

调用提示词模板的format*方法，可以得到字符串、消息列表或者ChatPromptValue：

LangChain允许仅部分渲染提示词模板 —— 传入输入变量的子集，生成一个新模板，新模板仅仅使用那些尚未渲染的变量。

除了将直接量赋予输入变量，还可以使用函数，这种方式可以让每次进行部分渲染，得到不同结果：

LangChain支持从JSON或者YAML文件中加载提示词。你可以将模板、样本放在一个文件中，也可以放在多个文件中并相互引用。

考虑下面这个YAML形式的提示词模板：

我们可以这样加载它：

注意，不管是YAML还是JSON，都用上述方式加载，没有区别。

考虑下面这个提示词模板，它引用了在外部文件中定义的模板文本：

LangChain会自动到相同目录下寻找txt文件。加载方式和上文一致。

除了PromptTemplate，我们也可用相同的方式加载FewShotPromptTemplate。下面这个例子，将少量样本放在独立文件中：

加载模板：

渲染得到的结果如下：

Write antonyms for the following words.

Input: happy
Output: sad

Input: tall
Output: short

Input: funny
Output:

当有大量样本时， 可能需要选择一些最匹配的放入到提示中，这是需要用到样本选择器。样本选择器的基类如下：

唯一需要实现的方法，入参是输入变量，结果是选中样本的列表。

LengthBasedExampleSelector基于长度即字符数量进行选择，当你担心提示词超过上下文窗口大小（Token限制）时有用。如果用户输入太长，该选择器会选取较小的样本：

所谓最大边际相关性 maximal marginal relevance (MMR)是一种信息检索和文本摘要的技术，用于在保持查询相关性的同时，最大限度地减少结果集中的冗余信息。MMR的目的是在结果集中提供尽可能多的新信息，以增加用户获取有价值信息的机会。

MMR算法通过在查询相关性和结果间的新颖性之间进行权衡来实现这一目标。对于每个候选结果，MMR会计算与查询的相关性以及与已选择结果的相似性。然后，根据一个权衡参数（通常表示为λ），MMR会选择具有最大边际相关性的结果。这种方法有助于在结果集中提供多样性，避免重复内容，同时确保结果与用户的查询相关。

进行相似性判断时，MMR使用最大余弦相似性（greatest cosine similarity）。它计算样本、输入的Embeddings在高维空间的向量的夹角，这个夹角越小（也就是余弦越大）意味着相似度越高。

与此同时，MMR尽量保证这些样本之间的差异性。

n-gram overlap是另外一种衡量文本相似性的方法，用于比较两个文本序列中的n-gram序列。n-gram是指在给定文本中连续出现的n个元素（通常是字符或单词）。n-gram重叠计算的是两个文本序列中共享的n-gram数量，以评估它们之间的相似性。假设我们比较以下两个句子的单词级别的2-gram（bi-gram）：

1. 我喜欢吃苹果
2. 我喜欢吃香蕉

句子1的bi-grams：(我喜欢)，(喜欢吃)，(吃苹果) 句子2的bi-grams：(我喜欢)，(喜欢吃)，(吃香蕉)。这两个句子共享了2个bi-grams：(我喜欢)和(喜欢吃)。因此，它们的bi-gram重叠数量为2。

n-gram重叠通常用于自然语言处理任务，如文本分类、文本摘要、机器翻译评估和文档聚类等。通过计算n-gram重叠，可以评估文本之间的结构和内容相似性。n-gram重叠可能受到n的选择和文本长度的影响。

这种方式仅仅用最大余弦相似性（greatest cosine similarity）来计算输入和样本的相似度，不考虑样本之间的差异性。

LangChain提供针对两类模型的接口：

1. 大语言模型（LLMs）：如上文所述，这类接口以文本为输入，文本为输出
2. 对话模型：其是基于语言模型的封装，以消息列表为输入，消息为输出

LangChains不提供任何模型，它知识提供了操控各种语言模型的标准接口，支持的LLM提供者包括：OpenAI、Hugging Face、Cohere等。

LangChain基于asyncio库实现了异步AI的支持：

要封装一个LangChain不支持的语言模型，你仅仅需要继承抽象类LLM即可，需要实现的方法包括：

1. 属性 _llm_type ，给这个模型一个类型名
2. _call 调用模型
3. _acall 异步调用模型
4. 属性 _identifying_params，返回一个字典，用于打印模型实例的关键参数

示例：

这个模型用于测试，它根据静态的仿冒来响应请求：

这个模型也用于测试或调试目的，它让人类去扮演LLM，从而可以测试Agent的行为：

 运行后，显示提示词：

===PROMPT START====
真正的语言模型会理解这里的提示词，测试时人类要模仿语言模型的行为
Answer the following questions as best you can. You have access to the following tools:

这里告诉语言模型，工具及其用途
Wikipedia: A wrapper around Wikipedia. Useful for when you need to answer general questions about people, places, companies, facts, historical events, or other subjects. Input should be a search query.

这里告诉语言模型如何做，因为它的语言理解能力，应答中会给出足够的信息，让代理知道用什么输入调用什么工具
Use the following format:

Question: the input question you must answer
Thought: you should always think about what to do
Action: the action to take, should be one of [Wikipedia]
Action Input: the input to the action
Observation: the result of the action
... (this Thought/Action/Action Input/Observation can repeat N times)
Thought: I now know the final answer
Final Answer: the final answer to the original input question

Begin!

Question: Who is Joe Biden?
Thought:
=====PROMPT END======

现在人类可以输入，这个输入就是作为语言模型的响应：

I need to use a tool   注意这个是 Thought
Action: Wikipedia
Action Input: Joe Biden
Observation: Page: Joe Biden

由于上述响应，代理就知道需要用关键字Joe Biden来搜索维基百科了。工具会生成页面的摘要文本，代理则会基于这些文本，继续和语言模型交互。

人类扮演的模型可以继续进行上述Thought/Action/Action Input/Observation交互，并且在最终给出输入：

Final Answer: Joe Biden is an old man

当看到 Final Answer后，代理会终止处理链。

LangChain提供了针对LLM的缓存层，用于：

1. 减少对LLM API的调用，节省费用
2. 针对相同问题，提升响应速度

在处理链中，可以选择为特定节点关闭缓存：

LangChain支持从文件实例化LLM所需的配置：

某些LLM模型支持提供流式响应，也就是不需要等待所有响应生成后再返回给客户端，我们使用的ChatGPT之类的聊天应用，都会使用这种响应模式。

LangChain支持OpenAI、ChatOpenAI、ChatAnthropic的流式响应。你需要编写一个 CallbackHandler回调，实现 on_llm_new_token方法。StreamingStdOutCallbackHandler是LangChain自带的一个实现：

 它简单的将新产生的Token写入标准输出：

使用一个上下文管理器来包围你的代码，可以统计这些代码的Token用量，从而估算成本。目前仅仅支持OpenAI。

详细的支持列表可以看官方文档。

Hugging Face Hub是模型托管平台，它提供开源的120K模型、20K数据集、50K演示应用。LangChain支持直接使用Hugging Face上的模型。首先需要安装包：

设置你的API Token：

使用模型：

Hugging Face上的模型，也可以被下载到你本地来运行。你需要先安装transformers包：

然后使用HuggingFacePipeline类来加载模型：

注意，取决于你使用的模型的规模，下载可能消耗很长时间。当然，你本地机器也得有模型所需的硬件资源和软件。

Text Generation Inference是一个开源服务软件，利用它，你可以在本地运行HuggingFace模型，并且暴露HTTP端点。LangChain可以连接到这种端点：

用法和LLM模型一样：

用法和LLM版本的HumanInput模型类似：

默认情况下，语言模型输出自然语言文本。有时候你希望获得结构化的数据，便于在后续业务流程中继续处理。

LangChain提供了一系列的输出解析器（OutputParser），它们实现两类关键方法：

1. 获取格式指令：返回一个字符串，包含给语言模型的指令，用于指示语言模型去格式化自己的输出
2. 解析：接受一段文本（来自语言模型的输出），解析为目标格式

以及一个可选方法：

1. 使用提示词来解析：同时提供一个字符串（相当于模型响应）+ 提示词（相当于生成前述响应的提示词）。这个方法在输出解析器需要通过某种方式重试、修复输出的时候调用

这个输出解析器，允许用户提供任意的JSON Schema，同时要求LLM的输出遵从该Schema。注意：能否输出格式正确的JSON，取决于模型，在OpenAI模型家族中DaVinci能可靠的生成JSON而Curie则不靠谱。

你需要定义一个Pydantic模型，来声明Schema：

使用输出解析器，来生成提示词的格式指令部分：

格式指令用自然语言提示LLM，该如何生成符合Schema的响应：

The output should be formatted as a JSON instance that conforms to the JSON schema below.

As an example, for the schema {"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}}
the object {"foo": ["bar", "baz"]} is a well-formatted instance of the schema. The object {"properties": {"foo": ["bar", "baz"]}} is not well-formatted.

Here is the output schema:
```
{"properties": {"setup": {"title": "Setup", "description": "question to set up a joke", "type": "string"}, "punchline": {"title": "Punchline", "description": "answer to resolve the joke", "type": "string"}}, "required": ["setup", "punchline"]}
```

 使用上述格式指令，构建一个提示词模板：

 完整的提示词：

Answer the user query.
The output should be formatted as a JSON instance that conforms to the JSON schema below.

As an example, for the schema {"properties": {"foo": {"title": "Foo", "description": "a list of strings", "type": "array", "items": {"type": "string"}}}, "required": ["foo"]}}
the object {"foo": ["bar", "baz"]} is a well-formatted instance of the schema. The object {"properties": {"foo": ["bar", "baz"]}} is not well-formatted.

Here is the output schema:
```
{"properties": {"setup": {"title": "Setup", "description": "question to set up a joke", "type": "string"}, "punchline": {"title": "Punchline", "description": "answer to resolve the joke", "type": "string"}}, "required": ["setup", "punchline"]}
```
Tell me a joke.

 生成响应：

output即原始响应，为JSON形式：

{"setup": "Why did the chicken cross the road?", "punchline": "To get to the other side!"}'

parse方法将其反序列化为Joke对象。

这个解析器包装另外一个解析器，当后者解析失败，自动修复解析器会调用另外一个LLM来修复失败。该解析器会将格式错误的原始应答 + 格式指令一同发送给新的LLM：

某些情况下，模型给出的输出是不完整，而不是格式错误的。这种情况下可以尝试RetryOutputParser，它会将提示词 + 原始输出一起传递给LLM以尝试获得更好的应答：

CommaSeparatedListOutputParser用于生成一个列表，条目以逗号分隔：

DatetimeOutputParser用于将输出解析为日期/时间：

LLM一次完整的训练需要高昂的成本，这导致模型不能学到实时的知识，另外，一些私有领域的知识，也不能出现在训练集中。LLM具有In-Context学习的能力，允许用户在输入中注入知识，然后由LLM组织这些知识，生成符合用户预期的应答。

很多基于LLM的应用，都需要利用这种In-Context学习的能力，典型的是基于知识库的问答机器人。将所有知识，都以提示词的形式注入给LLM是不现实的，目前的模型都有Token数的限制。并且Token越多，成本越高，模型性能也越差。

LangChain的数据连接（Data Connection）给出了解决方案，整体上来说，需要在本地离线的对知识库进行处理、索引。在使用LLM时，在本地检索出和用户问题相关的知识片段，然后将这些知识片段作为提示词的一部分发送。

和数据连接有关的模块包括：

1. 文档加载器（Document loaders）：从各种源加载文档
2. 文档转换器（Document transformers）：分割文档、剔除重复文档内容
3. 文本嵌入模型（Text embedding models）：将非结构化的文本转换为Embeddings，即高维空间的向量（形式上为浮点数的列表）
4. 向量存储库（Vector stores）：用于对上述Embeddings进行存储、检索
5. 检索器（Retrievers）：用于检索数据，向量存储库可以作为检索器的一种后端

文档加载器负责将特定来源的数据加载为Document对象。Document是关联了元数据的文本。

可以使用BeautifulSoup4加载器，自动解析HTML中的文本到page_content，将页面的标题解析到metadata.title：

如果源文档是JSON Lines格式（每行均为一个JSON），则需要指定 json_lines 为True：

除了page_content字段，还可以抽取任意元数据：

LangChains支持从大量在线服务读取数据，具体参考官方文档。

加载完文档后，通常需要对其进行转换以适合应用程序需要。其中最常见的例子是，将文档切割为较小的块（chunk）以适合模型的上下文大小窗口。

将长文档分割为小块时，需要处理很多潜在的复杂性。理想情况下，语义相关的片段，应该被分割在同一个块中。大体上来说，文本分割的工作方式如下：

1. 将文本分割为语义相关的小块，通常以句子为边界
2. 将这些小块合并为更大的块，直到到达特定的大小
3. 基于上面的块，外加前后的一些重叠，构建最终的块。这个操作的目的是保留块之间的上下文

默认推荐的文本分割器是RecursiveCharacterTextSplitter。该分割器接受一个分隔符列表（默认 ["\n\n", "\n", " ", ""]），在确保块不过大的情况下，优先使用列表中前面的分隔符来分割块。该分割器提供了一些辅助的配置项：

1. length_function：控制如何计算chunk的长度，默认是计算字符的个数，实际更常用的是计算Token的个数
2. chunk_size：允许的chunk的最大长度
3. chunk_overlap：两个相邻的chunk重叠部分的最大长度
4. add_start_index：是否包含chunk所在原始文档中的起始位置

示例：

嵌入处理过程需要同时考虑整体上下文、文本中句子和短语的相互关系，以保证生成质量更高的向量表示，精确的捕获文档的主题和含义。这要求具有相同上下文的文本，应该被分割在相同的块中。

类似于Markdown这样的格式，本身就通过标题级别划分了上下文，因此我们可以考虑基于这些标题级别进行分割，LangChains提供了MarkdownHeaderTextSplitter来处理Markdown：

在上述基于标题级别分割的基础上，可以进一步分割：

LLM通常有Token数限制，我们分割的chunk不应该超过这个限制。 分词器（tokenizer）种类很多，计算chunk中有多少token时，应当使用和LLM一致的分词器。

OpenAI提供了基于BPE的分词器tiktoken，下面是其用法示例：

spaCy是一个用于自然语言处理的库，LangChain也支持基于spaCy的分词器：

Hugging Face也提供了很多分词器，示例：

LangChain提供了和各种Embedding模型进行交互的标准化接口。上文我们提到过，Embedding是将文本转换为向量表示的过程，这样就可以将其存储在向量空间，并进行两个文本的相似度检索。

标准化接口提供了两个方法，其中之一用于嵌入文档：

另外一个用于嵌入查询：

除了针对OpenAI的OpenAIEmbeddings类，还有针对各种其它模型的封装，具体参考官方文档。

有了针对文档、查询的Embeddings，就可以进行相似度计算了 —— 找出和查询相似度最高的文档。向量存储提供了这种查询能力，同时它也负责存储文档的Embeddings。

向量存储的实现有很多，例如FAISS（Facebook AI Similarity Search)库，下面是初始化基于FAISS的向量存储的方法：

下面是执行相似度搜索的方法：

除了FAISS，LangChain提供了多种向量存储的封装，具体参考官方文档。

检索器可以根据给定的非结构化查询，返回匹配的文档。检索器可以将向量存储作为后端，但是并非必须。检索器的基类很简单：

也就是说检索器可以返回和查询相关的文档列表，相关性的定义取决于具体的检索器。

主要类型的检索器，还是基于向量存储的。LangChain默认情况下使用Chroma作为向量存储实现。下面的代码从文档加载器创建索引：

可以基于此索引来进行检索：

下面的代码展示了如何从索引得到检索器接口：

VectorstoreIndexCreator内部，做了以下工作：

1. 将文档分割为块
   
   Python

   1 2 3 4 5

   documents = loader.load()   from langchain.text_splitter import CharacterTextSplitter text_splitter = CharacterTextSplitter(chunk_size=1000, chunk_overlap=0) texts = text_splitter.split_documents(documents)

2. 为每个文档创建Embeddings、存储文档和Embeddings到向量存储
   
   Python

   1 2 3 4 5

   from langchain.embeddings import OpenAIEmbeddings embeddings = OpenAIEmbeddings()   from langchain.vectorstores import Chroma db = Chroma.from_documents(texts, embeddings)

3. 从向量存储得到检索器接口，并构造处理链：
   
   Python

   1 2	retriever = db.as_retriever() qa = RetrievalQA.from_chain_type(llm=OpenAI(), chain_type="stuff", retriever=retriever)

4. 基于索引的查询，其实就是调用处理链：
   
   Python

   1 2	query = "What did the president say about Ketanji Brown Jackson" qa.run(query)

你可以对VectorstoreIndexCreator进行定制化：

如果Embedding没有很好的捕获数据的语义，那么查询文本中的细微变化，可能导致相似度检索结果的很大不同。提示词工程和微调有时候用来解决这种检索不准确的问题，但是处理起来可能比较繁琐。

MultiQueryRetriever可以自动化这个微调过程，它会调用LLM，从不同视角，从用户输入生成多个查询。然后，基于这些查询，分别获取相关文档，取并集作为最终结果。通过这种处理，某些情况下能够克服向量存储的那种基于距离的相似度判断的缺点，获取更加丰富的检索结果。

你不知道用户会提供什么样的查询，真正和查询意图最相关的信息，可能会淹没在大量无关的文本中。将无关的文本返回给程序，进而对LLM发起调用，可能导致更高的成本或者生成较差的应答。

上下文压缩用于解决这个问题，它的思路很简单：不是把检索得到的文档直接返回，而是基于查询给出的上下文信息，进行压缩（去掉无关信息）。

下面的代码：

检索到的第一个结果是：

Document 1:

In state after state, new laws have been passed, not only to suppress the vote, but to subvert entire elections.

We cannot let this happen.

Tonight. I call on the Senate to: Pass the Freedom to Vote Act. Pass the John Lewis Voting Rights Act. And while you’re at it, pass the Disclose Act so Americans can know who is funding our elections.

Tonight, I’d like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service.

One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court.

And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation’s top legal minds, who will continue Justice Breyer’s legacy of excellence.

现在进行上下文压缩：

 结果长度变短：

Document 1:

"Tonight, I'd like to honor someone who has dedicated his life to serve this country: Justice Stephen Breyer—an Army veteran, Constitutional scholar, and retiring Justice of the United States Supreme Court. Justice Breyer, thank you for your service.

One of the most serious constitutional responsibilities a President has is nominating someone to serve on the United States Supreme Court.

And I did that 4 days ago, when I nominated Circuit Court of Appeals Judge Ketanji Brown Jackson. One of our nation's top legal minds, who will continue Justice Breyer's legacy of excellence."

上面代码中的LLMChainExtractor，仅仅负责检查检索器返回的原始结果集，决定哪些应该丢弃。它不会修改结果的内容。

针对每个结果，都调用一次LLM，成本较高且速度慢。EmbeddingsFilter提供一个更廉价和迅速的方案，它对文档和查询进行嵌入并仅仅返回和查询相似度足够高的那些文档：

利用DocumentCompressorPipeline类，可以构造一个流水线，编排多个压缩器以及BaseDocumentTransformers。后者不进行上下文压缩，仅仅负责简单的转换，例如可以用TextSplitters将文档分割为更小的片段，利用EmbeddingsRedundantFilter基于Embedding相似度剔除冗余的文档：

文档不但具有内容，还可以具有任意附加的元数据。元数据是一个字典，上文提到的文档加载器，可以在加载文档时抽取元数据。

所谓自查询的（Self-querying）检索器，能够对自身（通常是背后的向量存储）进行查询。具体来说，它能够从用户的查询输入中，抽取针对已存储的文档的元数据的过滤器，并应用这些过滤器。

打个比方，对于一个查询：What did bar say about foo。而文档具有元数据author，那么自查询检索器就能去匹配auther为bar的、内容为foo is a charming chap的文档。

代码示例：

自查询检索器会自动分析用户输入和元数据的关联关系，并生成过滤器：

query='dreams' filter=None limit=None
query=' ' filter=Comparison(comparator=<Comparator.GT: 'gt'>, attribute='rating', value=8.5) limit=None
query='women' filter=Comparison(comparator=<Comparator.EQ: 'eq'>, attribute='director', value='Greta Gerwig') limit=None

自查询检索器仅仅能应对比较简单的查询。比如：I'm looking for Greta Gerwig directed any movies about women, or anyone directed movies about dreams，就无法生成恰当的查询和过滤器。

这种检索器，在相似度检索的基础上，让最近被检索器命中过的文档，获得优先级。算法如下：

semantic_similarity + (1.0 - decay_rate) ^ hours_passed

decay_rate为衰退率，控制时间因子的影响大小。hours_passed表示上一次该文档被检索器访问以来已经过去的时间。衰退率的范围为0-1，可以看到，过低或者过高的衰退率，都会快速、很大程度上削弱时间的影响，从而等价于简单的相似度检索。

从向量存储对象，都可以得到一个检索器：

使用这些检索器时，有一些通用的请求参数。

默认情况下，使用基于相似度的检索，可以改为基于最大边际相关性（MMR）的检索，如前文提到过的一样，MMR有利于去除重复的内容：

检索的时候，可以指定相似度分数的阈值：

上述例子中，只有相似度评分高于0.5的文档被返回。

此外，你可以限定仅仅返回相似度最高的K个文档：

对于简单的应用程序，仅仅使用一个语言模型（可能配合向量存储做信息检索）就足够了。更复杂的应用，可能需要联合使用多个语言模型或者调用任意的其它工具。

LangChain提供了Chain接口，用来编排对一系列工具的顺序化调用。这些工具可能包括LLM和其它Chain。这个接口非常简单：

最简单的处理链的例子，我们在快速参考一章中介绍过，它将提示词模板和LLM调用链在一起。