首页手记无限可能Langchain——...

无限可能Langchain——向量存储和检索

标签：

Python 人工智能

欢迎关注微信公众号【千练极客】，尽享更多干货文章！

本教程将使您熟悉LangChain的向量存储和检索器抽象。这些抽象旨在支持从（向量）数据库和其他来源检索数据，以便与LLM工作流集成。它们对于获取数据作为模型推理的一部分进行推理的应用程序很重要，例如检索增强生成或RAG（请参阅我们的RAG教程这里）。

概念

这个指南专注于文本数据的检索。我们将涵盖以下概念：

文档；
向量存储；
检索器。

安装

参考前面文档：
《无限可能LangChain——开启大模型世界》
《无限可能LangChain——构建一个简单的LLM应用程序》

本教程还需要 langchain-chroma 包

pip install langchain langchain-chroma langchain-openai

请参阅官网的安装指南以获取更多详细信息。

Documents

LangChain 实现了一个 Document 抽象，旨在表示一个文本单元和相关的元数据。它有两个属性：

page_content：表示内容的字符串；
metadata：包含任意的元数据。

metadata 属性可以捕获有关文档源、与其他文档的关系以及其他信息的信息。请注意，单个 Document 对象通常代表较大文档的一大块。

让我们生成一些示例文档：

from langchain_core.documents import Document

documents = [
    Document(
        page_content="狗是很好的伴侣，以忠诚和友善而闻名。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="猫是独立的宠物，经常享受自己的空间。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="金鱼是深受初学者欢迎的宠物，需要相对简单的护理。",
        metadata={"source": "fish-pets-doc"},
    ),
    Document(
        page_content="鹦鹉是一种聪明的鸟类，能够模仿人类的语言。",
        metadata={"source": "bird-pets-doc"},
    ),
    Document(
        page_content="兔子是群居动物，需要足够的空间来跳跃。",
        metadata={"source": "mammal-pets-doc"},
    ),
]

API Reference:Document

在这里，我们生成了五个文档，其中包含指示三个不同“来源”的元数据（mammal-pets-doc、fish-pets-doc、bird-pets-doc）。

VectorStore

向量搜索是存储和搜索非结构化数据（例如非结构化文本）的常用方法。这个想法是存储与文本关联的数字向量。给定一个查询，我们可以将嵌入为相同维度的向量，并使用向量相似度度量来识别存储中的相关数据。

LangChain VectorStore 对象包含用于添加文本和 Document对象记录到存储中，并使用各种相似度指标查询它们。它们通常用嵌入模型，它确定如何将文本数据转换为数字向量。

LangChain 包括一套与不同矢量存储技术的集成。一些矢量存储由提供商（例如，各种云提供商）托管，需要特定的凭据才能使用；一些（例如 Postgres）在单独的基础架构中运行，可以在本地或通过第三方运行；其他人可以在内存中运行以实现轻量级工作负载。

在这里，我们将使用 Chroma，Chroma 是一个AI原生开源矢量数据库，专注于开发人员的生产力和幸福感。其中包括一个内存实现。

OpenAI 嵌入

要实例化向量存储，我们通常需要提供一个嵌入模型以指定如何将文本转换为数字向量。这里我们将使用 OpenAI嵌入。

from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings

vectorstore = Chroma.from_documents(
    documents,
    embedding=OpenAIEmbeddings(),
)

**API Reference: **OpenAIEmbeddings

DashScope 嵌入（灵积模型）

from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings

vectorstore = Chroma.from_documents(
    documents,
    embedding=DashScopeEmbeddings(),
)

调用 .from_documents 将文档添加到矢量存储中。VectorStore 实现了添加文档的方法，这些文档也可以在对象实例化后调用。大多数实现将允许您连接到现有的向量存储——例如，通过提供客户端、索引名称或其他信息。有关特定的集成了解更多细节。

一旦我们实例化了一个 VectorStore包含文档，我们可以查询它。 VectorStore包括查询方法：

同步和异步；
通过字符串查询和向量；
有和没有返回相似度分数；
通过相似性和最大边际相关性（平衡相似性与查询到检索结果的多样性）。

这些方法通常会在其输出中包含 Document 对象的列表。

搜索实例

根据与字符串查询的相似性返回文档：

from langchain_core.documents import Document

# 构造文档
documents = [
    Document(
        page_content="狗是很好的伴侣，以忠诚和友善而闻名。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="猫是独立的宠物，经常享受自己的空间。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="金鱼是深受初学者欢迎的宠物，需要相对简单的护理。",
        metadata={"source": "fish-pets-doc"},
    ),
    Document(
        page_content="鹦鹉是一种聪明的鸟类，能够模仿人类的语言。",
        metadata={"source": "bird-pets-doc"},
    ),
    Document(
        page_content="兔子是群居动物，需要足够的空间来跳跃。",
        metadata={"source": "mammal-pets-doc"},
    ),
]



from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings

# 创建 Chroma 向量存储
vectorstore = Chroma.from_documents(
    documents,
    embedding=DashScopeEmbeddings(),
)

# 查询向量存储
result = vectorstore.similarity_search("猫")
print(result)

运行结果：

[Document(page_content='猫是独立的宠物，经常享受自己的空间。', metadata={'source': 'mammal-pets-doc'
    }), Document(page_content='狗是很好的伴侣，以忠诚和友善而闻名。', metadata={'source': 'mammal-pets-doc'
    }), Document(page_content='兔子是群居动物，需要足够的空间来跳跃。', metadata={'source': 'mammal-pets-doc'
    }), Document(page_content='鹦鹉是一种聪明的鸟类，能够模仿人类的语言。', metadata={'source': 'bird-pets-doc'
    })
]

异步查询

from langchain_core.documents import Document

# 构造文档
documents = [
    Document(
        page_content="狗是很好的伴侣，以忠诚和友善而闻名。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="猫是独立的宠物，经常享受自己的空间。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="金鱼是深受初学者欢迎的宠物，需要相对简单的护理。",
        metadata={"source": "fish-pets-doc"},
    ),
    Document(
        page_content="鹦鹉是一种聪明的鸟类，能够模仿人类的语言。",
        metadata={"source": "bird-pets-doc"},
    ),
    Document(
        page_content="兔子是群居动物，需要足够的空间来跳跃。",
        metadata={"source": "mammal-pets-doc"},
    ),
]



from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings

# 创建 Chroma 向量存储
vectorstore = Chroma.from_documents(
    documents,
    embedding=DashScopeEmbeddings(),
)

# 查询向量存储
# result = vectorstore.similarity_search("猫")

async def asnc_search():
    result = await vectorstore.asimilarity_search("猫")
    print(result)

if __name__ == "__main__":
    import asyncio
    asyncio.run(asnc_search())

[Document(page_content='猫是独立的宠物，经常享受自己的空间。', metadata={'source': 'mammal-pets-doc'
    }), Document(page_content='狗是很好的伴侣，以忠诚和友善而闻名。', metadata={'source': 'mammal-pets-doc'
    }), Document(page_content='兔子是群居动物，需要足够的空间来跳跃。', metadata={'source': 'mammal-pets-doc'
    }), Document(page_content='鹦鹉是一种聪明的鸟类，能够模仿人类的语言。', metadata={'source': 'bird-pets-doc'
    })
]

返回分数

from langchain_core.documents import Document

# 构造文档
documents = [
    Document(
        page_content="狗是很好的伴侣，以忠诚和友善而闻名。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="猫是独立的宠物，经常享受自己的空间。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="金鱼是深受初学者欢迎的宠物，需要相对简单的护理。",
        metadata={"source": "fish-pets-doc"},
    ),
    Document(
        page_content="鹦鹉是一种聪明的鸟类，能够模仿人类的语言。",
        metadata={"source": "bird-pets-doc"},
    ),
    Document(
        page_content="兔子是群居动物，需要足够的空间来跳跃。",
        metadata={"source": "mammal-pets-doc"},
    ),
]



from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings

# 创建 Chroma 向量存储
vectorstore = Chroma.from_documents(
    documents,
    embedding=DashScopeEmbeddings(),
)

# 查询向量存储
result = vectorstore.similarity_search_with_score("猫")
print(result)

[
    (Document(page_content='猫是独立的宠物，经常享受自己的空间。', metadata={'source': 'mammal-pets-doc'}),6132.1220703125), 
    (Document(page_content='狗是很好的伴侣，以忠诚和友善而闻名。', metadata={'source': 'mammal-pets-doc'}),9821.0986328125), 
    (Document(page_content='兔子是群居动物，需要足够的空间来跳跃。', metadata={'source': 'mammal-pets-doc'}),12847.712890625), 
    (Document(page_content='鹦鹉是一种聪明的鸟类，能够模仿人类的语言。', metadata={'source': 'bird-pets-doc'}),13557.1650390625)
]

根据与嵌入式查询的相似性返回文档：

from langchain_core.documents import Document

# 构造文档
documents = [
    Document(
        page_content="狗是很好的伴侣，以忠诚和友善而闻名。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="猫是独立的宠物，经常享受自己的空间。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="金鱼是深受初学者欢迎的宠物，需要相对简单的护理。",
        metadata={"source": "fish-pets-doc"},
    ),
    Document(
        page_content="鹦鹉是一种聪明的鸟类，能够模仿人类的语言。",
        metadata={"source": "bird-pets-doc"},
    ),
    Document(
        page_content="兔子是群居动物，需要足够的空间来跳跃。",
        metadata={"source": "mammal-pets-doc"},
    ),
]


from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings

# 创建 Chroma 向量存储
vectorstore = Chroma.from_documents(
    documents,
    embedding=DashScopeEmbeddings(),
)

# 查询向量存储
embedding = DashScopeEmbeddings().embed_query("猫")
result = vectorstore.similarity_search_by_vector(embedding)
print(result)

[Document(page_content='猫是独立的宠物，经常享受自己的空间。', metadata={'source': 'mammal-pets-doc'
    }), Document(page_content='狗是很好的伴侣，以忠诚和友善而闻名。', metadata={'source': 'mammal-pets-doc'
    }), Document(page_content='兔子是群居动物，需要足够的空间来跳跃。', metadata={'source': 'mammal-pets-doc'
    }), Document(page_content='鹦鹉是一种聪明的鸟类，能够模仿人类的语言。', metadata={'source': 'bird-pets-doc'
    })
]

了解更多：

Retrievers

LangChain VectorStore 对象不是子类可运行，因此不能立即集成到 LangChain 表达式语言中链。

朗链检索器是Runnables，因此它们实现了一组标准方法（例如，同步和异步 invoke 和 batch 操作）并被设计为合并到LCEL链中。

我们可以自己创建一个简单的版本，无需子类化 Retriever。如果我们选择希望使用什么方法来检索文档，我们可以轻松创建一个可运行的。下面我们将围绕 similarity_search 方法：

from langchain_core.documents import Document

# 构造文档
documents = [
    Document(
        page_content="狗是很好的伴侣，以忠诚和友善而闻名。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="猫是独立的宠物，经常享受自己的空间。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="金鱼是深受初学者欢迎的宠物，需要相对简单的护理。",
        metadata={"source": "fish-pets-doc"},
    ),
    Document(
        page_content="鹦鹉是一种聪明的鸟类，能够模仿人类的语言。",
        metadata={"source": "bird-pets-doc"},
    ),
    Document(
        page_content="兔子是群居动物，需要足够的空间来跳跃。",
        metadata={"source": "mammal-pets-doc"},
    ),
]

from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings

# 创建 Chroma 向量存储
vectorstore = Chroma.from_documents(
    documents,
    embedding=DashScopeEmbeddings(),
)

# 查询向量存储
from langchain_core.runnables import RunnableLambda
retriever = RunnableLambda(vectorstore.similarity_search).bind(k=1)  # 选择顶部结果

result = retriever.batch(["猫", "鲨鱼"])
print(result)

API Reference:Document | RunnableLambda

运行结果：

[
    [Document(page_content='猫是独立的宠物，经常享受自己的空间。', metadata={'source': 'mammal-pets-doc'
        })
    ],
    [Document(page_content='金鱼是深受初学者欢迎的宠物，需要相对简单的护理。', metadata={'source': 'fish-pets-doc'
        })
    ]
]

Vectorstore 实现了一个 as_retriever 将生成 Retriever 的方法，特别是 VectorStoreRetriever。这些检索器包括特定的 search_type 和 search_kwargs 属性，用于标识要调用的底层向量存储的哪些方法，以及如何参数化它们。例如，我们可以使用以下内容复制上述内容：

from langchain_core.documents import Document

# 构造文档
documents = [
    Document(
        page_content="狗是很好的伴侣，以忠诚和友善而闻名。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="猫是独立的宠物，经常享受自己的空间。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="金鱼是深受初学者欢迎的宠物，需要相对简单的护理。",
        metadata={"source": "fish-pets-doc"},
    ),
    Document(
        page_content="鹦鹉是一种聪明的鸟类，能够模仿人类的语言。",
        metadata={"source": "bird-pets-doc"},
    ),
    Document(
        page_content="兔子是群居动物，需要足够的空间来跳跃。",
        metadata={"source": "mammal-pets-doc"},
    ),
]



from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings

# 创建 Chroma 向量存储
vectorstore = Chroma.from_documents(
    documents,
    embedding=DashScopeEmbeddings(),
)

# 查询向量存储
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 1},
)

result = retriever.batch(["猫", "鲨鱼"])
print(result)

运行结果：

[
    [Document(page_content='猫是独立的宠物，经常享受自己的空间。', metadata={'source': 'mammal-pets-doc'
        })
    ],
    [Document(page_content='金鱼是深受初学者欢迎的宠物，需要相对简单的护理。', metadata={'source': 'fish-pets-doc'
        })
    ]
]

VectorStoreRetriever 支持搜索类型 “similarity”（默认）， “mmr”（最大边际相关性，如上所述），以及
"similarity_score_threshold"。我们可以使用后者根据相似度分数对检索器输出的文档进行阈值。

检索器可以很容易地合并到更复杂的应用程序中，例如检索增强生成（RAG）应用程序，它将给定问题与检索到的上下文组合成LLM的提示。下面我们展示一个最小的例子。

from langchain_core.documents import Document

# 构造文档
documents = [
    Document(
        page_content="狗是很好的伴侣，以忠诚和友善而闻名。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="猫是独立的宠物，经常享受自己的空间。",
        metadata={"source": "mammal-pets-doc"},
    ),
    Document(
        page_content="金鱼是深受初学者欢迎的宠物，需要相对简单的护理。",
        metadata={"source": "fish-pets-doc"},
    ),
    Document(
        page_content="鹦鹉是一种聪明的鸟类，能够模仿人类的语言。",
        metadata={"source": "bird-pets-doc"},
    ),
    Document(
        page_content="兔子是群居动物，需要足够的空间来跳跃。",
        metadata={"source": "mammal-pets-doc"},
    ),
]

# 构造 prompt
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnablePassthrough

message = """
仅使用提供的上下文回答此问题。
{question}

上下文:
{context}
"""
prompt = ChatPromptTemplate.from_messages([("human", message)])


from langchain_chroma import Chroma
from langchain_community.embeddings import DashScopeEmbeddings
# 创建 Chroma 向量存储
vectorstore = Chroma.from_documents(
    documents,
    embedding=DashScopeEmbeddings(),
)

# 查询向量存储
retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 1},
)

# 使用 Tongyi LLM，并设置温度为 1，代表模型会更加随机，但也会更加不确定
from langchain_community.llms import Tongyi
llm = Tongyi(temperature=1)

# 构建 RAG 链
rag_chain = {"context": retriever, "question": RunnablePassthrough()} | prompt | llm

# 使用 RAG 链并打印结果
response = rag_chain.invoke("告诉我关于猫的事")
print(response)

API Reference:ChatPromptTemplate | RunnablePassthrough

运行结果：

langsmith 日志：搜索日志

小结

本文我们了解了 Documents、VectorStore 、Retrievers 的简单用法，作为目前最火的 RAG 应用方向，值得我们深入去了解学习。

如果想继续深入，我们可以了解以下内容，比如检索策略可能丰富而复杂。

我们可以从查询中推断出硬规则和过滤器（例如，“使用2020年之后发布的文档”）；
我们可以以某种方式（例如，通过某些文档分类）返回链接到检索到的上下文的文档；
我们可以为每个上下文单元生成多个嵌入；
我们可以从多个检索器集成结果；
我们可以为文档分配权重，例如，将最近的文档的权重提高。

操作指南的检索器部分涵盖了这些和其他内置检索策略。扩展BaseRetriever类以实现自定义检索器也很简单。请参阅我们的操作指南此处。

本文由博客一文多发平台 OpenWrite 发布！

点击查看更多内容

为 TA 点赞

若觉得本文不错，就分享一下吧！

评论

评论

共同学习，写下你的评论

评论加载中...

展开查看更多评论

作者其他优质文章

正在加载中

千练极客

架构师

手记
篇

粉丝

1

获赞与收藏

12

关注作者，订阅最新文章

相关文章推荐

基于LangChain的LLM应用开发3——记忆

Javascript版Langchain入门

基于LangChain的LLM应用开发1——介绍

使用提示模板使用 LangChain 和 OpenAI 构建摘要应用程序

TiKV + SPDK，探索存储的性能极限

阅读免费教程

Python 办公自动化教程

17个小节 25449 857

Python 算法入门教程

15个小节 27084 1058

Python 进阶应用教程

38个小节 64818 1015

推荐

评论

收藏

共同学习，写下你的评论



感谢您的支持，我会继续努力的～

扫码打赏，你说多少就多少

赞赏金额会直接到老师账户

支付方式

打开微信扫一扫，即可进行扫码打赏哦

今天注册有机会得

100积分直接送

付费专栏免费学

大额优惠券免费领

立即参与放弃机会

点击
抽奖

慕课手记新用户专享福利

恭喜你，你的运气太好了，居然抽中了 100个积分！

恭喜你，抽中了价值元的专栏！

太棒了，直接落到你账户里！

积分商城里的罗技鼠标、机械键盘、
Kindle 阅读器、小米平衡车
Apple iPad （10.2英寸）、大额优惠券
在等着你去兑换了噢

作者：

免费赠送

兑换码：1111222211 复制

优惠券可用于购买实战课、体系课
无门槛使用

先去看看，有什么好东西马上兑换我爱学习，选课去


热搜

最近搜索清空

无限可能Langchain——向量存储和检索

概念

安装

Documents

VectorStore

OpenAI 嵌入

DashScope 嵌入（灵积模型）

搜索实例

异步查询

返回分数

Retrievers

小结

相关文章推荐

阅读免费教程