Redis#

class langchain_community.vectorstores.redis.base.Redis(redis_url: str, index_name: str, embedding: Embeddings, index_schema: Dict[str, List[Dict[str, str]]] | str | PathLike | None = None, vector_schema: Dict[str, str | int] | None = None, relevance_score_fn: Callable[[float], float] | None = None, key_prefix: str | None = None, **kwargs: Any)[source]#

自版本0.3.13起已弃用：请改用:class:`~langchain_redis.RedisVectorStore`。在langchain-community==1.0之前不会移除。

Redis 向量数据库。

Deployment Options:

下面，我们将以本地部署为例。然而，Redis可以通过以下所有方式进行部署：

Setup:

安装 redis, redisvl, 和 langchain-community 并在本地运行 Redis。

pip install -qU redis redisvl langchain-community
docker run -d -p 6379:6379 -p 8001:8001 redis/redis-stack:latest
Key init args — indexing params:
index_name: str

索引的名称。

index_schema: Optional[Union[Dict[str, ListOfDict], str, os.PathLike]]

索引的模式和向量模式。可以是一个字典，或者是yaml文件的路径。

embedding: Embeddings

使用的嵌入函数。

Key init args — client params:
redis_url: str

Redis 连接 URL。

Instantiate:
from langchain_community.vectorstores.redis import Redis
from langchain_openai import OpenAIEmbeddings

vector_store = Redis(
    redis_url="redis://localhost:6379",
    embedding=OpenAIEmbeddings(),
    index_name="users",
)
Add Documents:
from langchain_core.documents import Document

document_1 = Document(page_content="foo", metadata={"baz": "bar"})
document_2 = Document(page_content="thud", metadata={"bar": "baz"})
document_3 = Document(page_content="i will be deleted :(")

documents = [document_1, document_2, document_3]
ids = ["1", "2", "3"]
vector_store.add_documents(documents=documents, ids=ids)
Delete Documents:
vector_store.delete(ids=["3"])
Search:
results = vector_store.similarity_search(query="thud",k=1)
for doc in results:
    print(f"* {doc.page_content} [{doc.metadata}]")

* thud [{'id': 'doc:users:2'}]
Search with filter:
from langchain_community.vectorstores.redis import RedisTag

results = vector_store.similarity_search(query="thud",k=1,filter=(RedisTag("baz") != "bar"))
for doc in results:
    print(f"* {doc.page_content} [{doc.metadata}]")

* thud [{'id': 'doc:users:2'}]
Search with score:
results = vector_store.similarity_search_with_score(query="qux",k=1)
for doc, score in results:
    print(f"* [SIM={score:3f}] {doc.page_content} [{doc.metadata}]")

* [SIM=0.167700] foo [{'id': 'doc:users:1'}]
Async:
# add documents
# await vector_store.aadd_documents(documents=documents, ids=ids)

# delete documents
# await vector_store.adelete(ids=["3"])

# search
# results = vector_store.asimilarity_search(query="thud",k=1)

# search with score
results = await vector_store.asimilarity_search_with_score(query="qux",k=1)
for doc,score in results:
    print(f"* [SIM={score:3f}] {doc.page_content} [{doc.metadata}]")

* [SIM=0.167700] foo [{'id': 'doc:users:1'}]
Use as Retriever:
retriever = vector_store.as_retriever(
    search_type="mmr",
    search_kwargs={"k": 1, "fetch_k": 2, "lambda_mult": 0.5},
)
retriever.invoke("thud")

[Document(metadata={'id': 'doc:users:2'}, page_content='thud')]

高级示例：

可以提供自定义向量模式来改变Redis创建底层向量模式的方式。这对于生产用例非常有用，您可以根据您的用例优化向量模式。例如，使用HNSW而不是默认的FLAT（knn）。

vector_schema = {
    "algorithm": "HNSW"
}

rds = Redis.from_texts(
    texts, # a list of strings
    metadata, # a list of metadata dicts
    embeddings, # an Embeddings object
    vector_schema=vector_schema,
    redis_url="redis://localhost:6379",
)

可以提供自定义索引模式来更改元数据的索引方式。这对于您希望使用Redis的混合查询（过滤）功能非常有用。

默认情况下，此实现将根据以下规则自动生成索引模式：

  • 所有字符串都被索引为文本字段

  • 所有数字都被索引为数字字段

  • 所有字符串列表都被索引为标签字段（由

    langchain_community.vectorstores.redis.constants.REDIS_TAG_SEPARATOR 连接）

  • 所有的None值都不会被索引，但仍然存储在Redis中

    无法通过这里的接口检索到，但可以使用原始的Redis客户端来检索它们。

  • 所有其他类型都不会被索引

要覆盖这些规则，您可以传入一个自定义的索引模式，如下所示

tag:
    - name: credit_score
text:
    - name: user
    - name: job

通常，credit_score 字段会是一个文本字段，因为它是一个字符串， 但是，我们可以通过指定字段类型来覆盖这种行为，如上面的 yaml 配置（也可以是一个字典）和下面的代码所示。

rds = Redis.from_texts(
    texts, # a list of strings
    metadata, # a list of metadata dicts
    embeddings, # an Embeddings object
    index_schema="path/to/index_schema.yaml", # can also be a dictionary
    redis_url="redis://localhost:6379",
)

当连接到已应用自定义模式的现有索引时，重要的是将相同的模式传递给from_existing_index方法。否则，新添加样本的模式将不正确，并且不会返回元数据。

使用必要的组件初始化Redis向量存储。

属性

DEFAULT_VECTOR_SCHEMA

embeddings

如果可用，访问查询嵌入对象。

schema

返回索引的模式。

方法

__init__(redis_url, index_name, embedding[, ...])

使用必要的组件初始化Redis向量存储。

aadd_documents(documents, **kwargs)

异步运行更多文档通过嵌入并添加到向量存储中。

aadd_texts(texts[, metadatas, ids])

异步运行更多文本通过嵌入并添加到向量存储中。

add_documents(documents, **kwargs)

在向量存储中添加或更新文档。

add_texts(texts[, metadatas, embeddings, ...])

向向量存储中添加更多文本。

adelete([ids])

异步删除通过向量ID或其他条件。

afrom_documents(documents, embedding, **kwargs)

异步返回从文档和嵌入初始化的VectorStore。

afrom_texts(texts, embedding[, metadatas, ids])

异步返回从文本和嵌入初始化的VectorStore。

aget_by_ids(ids, /)

异步通过ID获取文档。

amax_marginal_relevance_search(query[, k, ...])

异步返回使用最大边际相关性选择的文档。

amax_marginal_relevance_search_by_vector(...)

异步返回使用最大边际相关性选择的文档。

as_retriever(**kwargs)

返回从此VectorStore初始化的VectorStoreRetriever。

asearch(query, search_type, **kwargs)

异步返回与查询最相似的文档，使用指定的搜索类型。

asimilarity_search(query[, k])

异步返回与查询最相似的文档。

asimilarity_search_by_vector(embedding[, k])

异步返回与嵌入向量最相似的文档。

asimilarity_search_with_relevance_scores(query)

异步返回文档和相关分数，范围在[0, 1]之间。

asimilarity_search_with_score(*args, **kwargs)

异步运行带距离的相似性搜索。

delete([ids])

删除一个Redis条目。

drop_index(index_name, delete_documents, ...)

删除一个Redis搜索索引。

from_documents(documents, embedding, **kwargs)

返回从文档和嵌入初始化的VectorStore。

from_existing_index(embedding, index_name, ...)

连接到现有的Redis索引。

from_texts(texts, embedding[, metadatas, ...])

从文本列表创建一个Redis向量存储。

from_texts_return_keys(texts, embedding[, ...])

从原始文档创建Redis向量存储。

get_by_ids(ids, /)

通过ID获取文档。

max_marginal_relevance_search(query[, k, ...])

返回使用最大边际相关性选择的文档。

max_marginal_relevance_search_by_vector(...)

返回使用最大边际相关性选择的文档。

search(query, search_type, **kwargs)

使用指定的搜索类型返回与查询最相似的文档。

similarity_search(query[, k, filter, ...])

运行相似性搜索

similarity_search_by_vector(embedding[, k, ...])

在查询向量和索引向量之间运行相似性搜索。

similarity_search_limit_score(query[, k, ...])

similarity_search_with_relevance_scores(query)

返回文档和相关分数，分数范围在[0, 1]之间。

similarity_search_with_score(query[, k, ...])

使用向量距离进行相似性搜索。

write_schema(path)

将模式写入一个yaml文件。
Parameters:

  • redis_url (str)

  • index_name (str)

  • embedding (Embeddings)

  • index_schema (可选[联合[字典[字符串, 字典列表], 字符串, os.PathLike]])

  • vector_schema (可选[字典[字符串, 联合[字符串, 整数]]])

  • relevance_score_fn (可选[Callable[[float], float]])

  • key_prefix (可选[str])

  • kwargs (Any)

__init__(redis_url: str, index_name: str, embedding: Embeddings, index_schema: Dict[str, List[Dict[str, str]]] | str | PathLike | None = None, vector_schema: Dict[str, str | int] | None = None, relevance_score_fn: Callable[[float], float] | None = None, key_prefix: str | None = None, **kwargs: Any)[来源]#

使用必要的组件初始化Redis向量存储。

Parameters:

  • redis_url (str)

  • index_name (str)

  • embedding (Embeddings)

  • index_schema (Dict[str, List[Dict[str, str]]] | str | PathLike | None)

  • vector_schema (Dict[str, str | int] | None)

  • relevance_score_fn (Callable[[float], float] | None)

  • key_prefix (str | None)

  • kwargs (Any)

async aadd_documents(documents: list[Document], **kwargs: Any) → list[str]#

通过嵌入异步运行更多文档并将其添加到向量存储中。

Parameters:

  • documents (list[Document]) – 要添加到向量存储中的文档。

  • kwargs (Any) – 额外的关键字参数。

Returns:

已添加文本的ID列表。

Raises:

ValueError – 如果ID的数量与文档的数量不匹配。

Return type:

列表[字符串]

async aadd_texts(texts: Iterable[str], metadatas: list[dict] | None = None, *, ids: list[str] | None = None, **kwargs: Any) → list[str]#

异步运行更多文本通过嵌入并添加到向量存储中。

Parameters:

  • texts (Iterable[str]) – 要添加到向量存储中的字符串的可迭代对象。

  • metadatas (list[dict] | None) – 可选的与文本关联的元数据列表。默认值为 None。

  • ids (list[str] | None) – 可选的列表

  • **kwargs (Any) – 向量存储特定参数。

Returns:

将文本添加到向量存储中后的ID列表。

Raises:

  • ValueError – 如果元数据的数量与文本的数量不匹配。

  • ValueError – 如果id的数量与文本的数量不匹配。

Return type:

列表[字符串]

add_documents(documents: list[Document], **kwargs: Any) → list[str]#

在向量存储中添加或更新文档。

Parameters:

  • documents (list[Document]) – 要添加到向量存储中的文档。

  • kwargs (Any) – 额外的关键字参数。 如果 kwargs 包含 ids 并且 documents 也包含 ids， kwargs 中的 ids 将优先。

Returns:

已添加文本的ID列表。

Raises:

ValueError – 如果id的数量与文档的数量不匹配。

Return type:

列表[字符串]

add_texts(texts: Iterable[str], metadatas: List[dict] | None = None, embeddings: List[List[float]] | None = None, batch_size: int = 1000, clean_metadata: bool = True, **kwargs: Any) → List[str][source]#

向向量存储中添加更多文本。

Parameters:

  • texts (Iterable[str]) – 要添加到向量存储中的字符串/文本的可迭代对象。

  • metadatas (Optional[List[dict]], optional) – 可选的元数据列表。 默认为 None。

  • embeddings (可选[列表[列表[浮点数]]], 可选) – 可选预生成的嵌入。默认为 None。

  • keys (List[str]) 或 ids (List[str]) – 条目标识符。 默认为 None。

  • batch_size (int, optional) – 用于写入的批量大小。默认为1000。

  • clean_metadata (bool)

  • kwargs (Any)

Returns:

添加到向量存储中的ID列表

Return type:

列表[str]

async adelete(ids: list[str] | None = None, **kwargs: Any) → bool | None#

通过向量ID或其他条件异步删除。

Parameters:

  • ids (list[str] | None) – 要删除的id列表。如果为None，则删除所有。默认值为None。

  • **kwargs (Any) – 子类可能使用的其他关键字参数。

Returns:

如果删除成功则为真， 否则为假，如果未实现则为无。

Return type:

可选[布尔]

async classmethod afrom_documents(documents: list[Document], embedding: Embeddings, **kwargs: Any) → VST#

异步返回从文档和嵌入初始化的VectorStore。

Parameters:

  • documents (list[Document]) – 要添加到向量存储中的文档列表。

  • embedding (Embeddings) – 使用的嵌入函数。

  • kwargs (Any) – 额外的关键字参数。

Returns:

从文档和嵌入初始化的VectorStore。

Return type:

VectorStore

async classmethod afrom_texts(texts: list[str], embedding: Embeddings, metadatas: list[dict] | None = None, *, ids: list[str] | None = None, **kwargs: Any) → VST#

异步返回从文本和嵌入初始化的VectorStore。

Parameters:

  • texts (list[str]) – 要添加到向量存储中的文本。

  • embedding (Embeddings) – 使用的嵌入函数。

  • metadatas (list[dict] | None) – 可选的与文本关联的元数据列表。默认值为 None。

  • ids (list[str] | None) – 可选的与文本关联的ID列表。

  • kwargs (Any) – 额外的关键字参数。

Returns:

VectorStore 从文本和嵌入初始化。

Return type:

VectorStore

async aget_by_ids(ids: Sequence[str], /) → list[Document]#

通过ID异步获取文档。

返回的文档预计将具有ID字段，该字段设置为向量存储中文档的ID。

如果某些ID未找到或存在重复的ID，返回的文档数量可能少于请求的数量。

用户不应假设返回文档的顺序与输入ID的顺序相匹配。相反，用户应依赖返回文档的ID字段。

如果没有找到某些ID的文档，此方法不应引发异常。

Parameters:

ids (Sequence[str]) – 要检索的ID列表。

Returns:

文档列表。

Return type:

列表[Document]

在版本0.2.11中添加。

异步返回使用最大边际相关性选择的文档。

最大边际相关性优化了与查询的相似性和所选文档之间的多样性。

Parameters:

  • query (str) – 用于查找相似文档的文本。

  • k (int) – 返回的文档数量。默认为4。

  • fetch_k (int) – 要传递给MMR算法的文档数量。 默认值为20。

  • lambda_mult (float) – 介于0和1之间的数字，决定了结果之间的多样性程度，0对应最大多样性，1对应最小多样性。默认值为0.5。

  • kwargs (Any)

Returns:

通过最大边际相关性选择的文档列表。

Return type:

列表[Document]

async amax_marginal_relevance_search_by_vector(embedding: list[float], k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, **kwargs: Any) → list[Document]#

异步返回使用最大边际相关性选择的文档。

最大边际相关性优化了与查询的相似性和所选文档之间的多样性。

Parameters:

  • embedding (list[float]) – 用于查找相似文档的嵌入。

  • k (int) – 返回的文档数量。默认为4。

  • fetch_k (int) – 要传递给MMR算法的文档数量。 默认值为20。

  • lambda_mult (float) – 介于0和1之间的数字，决定了结果之间的多样性程度，0对应最大多样性，1对应最小多样性。默认值为0.5。

  • **kwargs (Any) – 传递给搜索方法的参数。

Returns:

通过最大边际相关性选择的文档列表。

Return type:

列表[Document]

as_retriever(**kwargs: Any) → RedisVectorStoreRetriever[source]#

返回从此VectorStore初始化的VectorStoreRetriever。

Parameters:

**kwargs (Any) –

传递给搜索函数的关键字参数。 可以包括： search_type (Optional[str]): 定义检索器应执行的搜索类型。 可以是“similarity”（默认）、“mmr”或“similarity_score_threshold”。

检索器应执行的搜索类型。 可以是“similarity”（默认）、“mmr”或“similarity_score_threshold”。

search_kwargs (Optional[Dict]): 传递给搜索函数的关键字参数。
可以包括以下内容：

k: 返回的文档数量（默认：4） score_threshold: 最小相关性阈值

用于similarity_score_threshold

fetch_k: 传递给MMR算法的文档数量

（默认：20）

lambda_mult: MMR返回结果的多样性；

1表示最小多样性，0表示最大多样性。（默认：0.5）

filter: 按文档元数据过滤

Returns:

VectorStore的检索器类。

Return type:

VectorStoreRetriever

示例：

# Retrieve more documents with higher diversity
# Useful if your dataset has many similar documents
docsearch.as_retriever(
    search_type="mmr",
    search_kwargs={'k': 6, 'lambda_mult': 0.25}
)

# Fetch more documents for the MMR algorithm to consider
# But only return the top 5
docsearch.as_retriever(
    search_type="mmr",
    search_kwargs={'k': 5, 'fetch_k': 50}
)

# Only retrieve documents that have a relevance score
# Above a certain threshold
docsearch.as_retriever(
    search_type="similarity_score_threshold",
    search_kwargs={'score_threshold': 0.8}
)

# Only get the single most similar document from the dataset
docsearch.as_retriever(search_kwargs={'k': 1})

# Use a filter to only retrieve documents from a specific paper
docsearch.as_retriever(
    search_kwargs={'filter': {'paper_title':'GPT-4 Technical Report'}}
)
async asearch(query: str, search_type: str, **kwargs: Any) → list[Document]#

异步返回与查询最相似的文档，使用指定的搜索类型。

Parameters:

  • query (str) – 输入文本。

  • search_type (str) – 要执行的搜索类型。可以是“similarity”、“mmr”或“similarity_score_threshold”。

  • **kwargs (Any) – 传递给搜索方法的参数。

Returns:

与查询最相似的文档列表。

Raises:

ValueError – 如果 search_type 不是 “similarity”、“mmr” 或 “similarity_score_threshold” 之一。

Return type:

列表[Document]

异步返回与查询最相似的文档。

Parameters:

  • query (str) – 输入文本。

  • k (int) – 返回的文档数量。默认为4。

  • **kwargs (Any) – 传递给搜索方法的参数。

Returns:

与查询最相似的文档列表。

Return type:

列表[Document]

async asimilarity_search_by_vector(embedding: list[float], k: int = 4, **kwargs: Any) → list[Document]#

异步返回与嵌入向量最相似的文档。

Parameters:

  • embedding (list[float]) – 用于查找相似文档的嵌入。

  • k (int) – 返回的文档数量。默认为4。

  • **kwargs (Any) – 传递给搜索方法的参数。

Returns:

与查询向量最相似的文档列表。

Return type:

列表[Document]

async asimilarity_search_with_relevance_scores(query: str, k: int = 4, **kwargs: Any) → list[tuple[Document, float]]#

异步返回文档和相关度分数，范围在[0, 1]之间。

0 表示不相似，1 表示最相似。

Parameters:

  • query (str) – 输入文本。

  • k (int) – 返回的文档数量。默认为4。

  • **kwargs (Any) –

    传递给相似性搜索的kwargs。应包括： score_threshold: 可选，一个介于0到1之间的浮点值

    过滤检索到的文档集

Returns:

（文档，相似度分数）的元组列表

Return type:

列表[元组[Document, 浮点数]]

async asimilarity_search_with_score(*args: Any, **kwargs: Any) → list[tuple[Document, float]]#

异步运行带有距离的相似性搜索。

Parameters:

  • *args (Any) – 传递给搜索方法的参数。

  • **kwargs (Any) – 传递给搜索方法的参数。

Returns:

(文档, 相似度分数) 的元组列表。

Return type:

列表[元组[Document, 浮点数]]

delete(ids: List[str] | None = None, **kwargs: Any) → bool[source]#

删除一个Redis条目。

Parameters:

  • ids (List[str] | None) – 要删除的id列表（redis中的键）。

  • redis_url – Redis 连接 URL。这应该通过 kwargs 传递或设置为环境变量：REDIS_URL。

  • kwargs (Any)

Returns:

删除是否成功。

Return type:

布尔

Raises:

  • ValueError – 如果未安装redis python包。

  • ValueError – 如果未提供ids（redis中的键）

static drop_index(index_name: str, delete_documents: bool, **kwargs: Any) → bool[source]#

删除一个Redis搜索索引。

Parameters:

  • index_name (str) – 要删除的索引的名称。

  • delete_documents (bool) – 是否删除关联的文档。

  • kwargs (Any)

Returns:

删除是否成功。

Return type:

布尔

classmethod from_documents(documents: list[Document], embedding: Embeddings, **kwargs: Any) → VST#

返回从文档和嵌入初始化的VectorStore。

Parameters:

  • documents (list[Document]) – 要添加到向量存储中的文档列表。

  • embedding (Embeddings) – 使用的嵌入函数。

  • kwargs (Any) – 额外的关键字参数。

Returns:

从文档和嵌入初始化的VectorStore。

Return type:

VectorStore

classmethod from_existing_index(embedding: Embeddings, index_name: str, schema: Dict[str, List[Dict[str, str]]] | str | PathLike, key_prefix: str | None = None, **kwargs: Any) → Redis[来源]#

连接到现有的Redis索引。

示例

from langchain_community.vectorstores import Redis
from langchain_community.embeddings import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()

# must pass in schema and key_prefix from another index
existing_rds = Redis.from_existing_index(
    embeddings,
    index_name="my-index",
    schema=rds.schema, # schema dumped from another index
    key_prefix=rds.key_prefix, # key prefix from another index
    redis_url="redis://username:password@localhost:6379",
)
Parameters:

  • embedding (Embeddings) – 用于嵌入查询的嵌入模型类（例如 OpenAIEmbeddings）。

  • index_name (str) – 要连接的索引的名称。

  • schema (Union[Dict[str, str], str, os.PathLike, Dict[str, ListOfDict]]) – 索引和向量模式的模式。可以是一个字典，或者是yaml文件的路径。

  • key_prefix (可选[str]) – 用于与此索引关联的所有Redis键的前缀。

  • **kwargs (Any) – 传递给Redis客户端的额外关键字参数。

Returns:

Redis 向量存储实例。

Return type:

Redis

Raises:

  • ValueError – 如果索引不存在。

  • ImportError – 如果未安装redis python包。

classmethod from_texts(texts: List[str], embedding: Embeddings, metadatas: List[dict] | None = None, index_name: str | None = None, index_schema: Dict[str, List[Dict[str, str]]] | str | PathLike | None = None, vector_schema: Dict[str, str | int] | None = None, **kwargs: Any) → Redis[source]#

从文本列表创建一个Redis向量存储。

This is a user-friendly interface that:

  1. 嵌入文档。

  2. 如果Redis索引尚不存在，则创建一个新的Redis索引

  3. 将文档添加到新创建的Redis索引中。

如果未定义index_schema，此方法将根据传入的元数据生成模式。如果定义了index_schema，它将与生成的模式进行比较，并在存在差异时发出警告。如果您有意为元数据定义模式，则可以忽略该警告。

要检查模式选项，请初始化此类的实例并使用Redis.schema`属性打印出模式。这将包括始终存在于langchain模式中的content和content_vector类。

示例

from langchain_community.vectorstores import Redis
from langchain_community.embeddings import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
redisearch = RediSearch.from_texts(
    texts,
    embeddings,
    redis_url="redis://username:password@localhost:6379"
)
Parameters:

  • texts (List[str]) – 要添加到向量存储中的文本列表。

  • embedding (Embeddings) – 用于嵌入查询的嵌入模型类（例如 OpenAIEmbeddings）。

  • metadatas (Optional[List[dict]], optional) – 可选的元数据字典列表，用于添加到向量存储中。默认为 None。

  • index_name (可选[str], 可选) – 要创建或添加到的索引的可选名称。默认为 None。

  • (Optional[Union[Dict[str (index_schema) – 可选): 在元数据中索引的可选字段。覆盖生成的模式。默认为 None。

  • ListOfDict] – 可选): 可选的元数据字段索引。覆盖生成的模式。默认为 None。

  • str – 可选): 元数据中要索引的可选字段。覆盖生成的模式。默认为 None。

  • os.PathLike]] – 可选): 在元数据中可选的字段进行索引。覆盖生成的模式。默认为 None。

  • index_schema (Dict[str, List[Dict[str, str]]] | str | PathLike | None)

  • vector_schema (Dict[str, str | int] | None)

  • kwargs (Any)

Return type:

Redis

:paramoptional):

元数据中要索引的可选字段。覆盖生成的模式。默认为None。

Parameters:

  • vector_schema (可选[字典[字符串, 联合[字符串, 整数]]], 可选) – 可选的 要使用的向量模式。默认为 None。

  • **kwargs (Any) – 传递给Redis客户端的额外关键字参数。

  • 文本 (列表[字符串])

  • embedding (Embeddings)

  • metadatas (列表[字典] | 无)

  • index_name (str | None)

  • index_schema (Dict[str, List[Dict[str, str]]] | str | PathLike | None)

Returns:

Redis 向量存储实例。

Return type:

Redis

Raises:

  • ValueError – 如果元数据的数量与文本的数量不匹配。

  • ImportError – 如果未安装redis python包。

classmethod from_texts_return_keys(texts: List[str], embedding: Embeddings, metadatas: List[dict] | None = None, index_name: str | None = None, index_schema: Dict[str, List[Dict[str, str]]] | str | PathLike | None = None, vector_schema: Dict[str, str | int] | None = None, **kwargs: Any) → Tuple[Redis, List[str]][来源]#

从原始文档创建一个Redis向量存储。

This is a user-friendly interface that:

  1. 嵌入文档。

  2. 如果尚不存在，则创建一个新的Redis索引

  3. 将文档添加到新创建的Redis索引中。

  4. 返回新创建文档的键，一旦存储。

如果未定义index_schema，此方法将根据传入的元数据生成模式。如果定义了index_schema，它将与生成的模式进行比较，并在存在差异时发出警告。如果您有意为元数据定义模式，则可以忽略该警告。

要检查模式选项，请初始化此类的实例，并使用Redis.schema`属性打印出模式。这将包括始终存在于langchain模式中的content和content_vector类。

示例

from langchain_community.vectorstores import Redis
from langchain_community.embeddings import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
redis, keys = Redis.from_texts_return_keys(
    texts,
    embeddings,
    redis_url="redis://localhost:6379"
)
Parameters:

  • texts (List[str]) – 要添加到向量存储中的文本列表。

  • embedding (Embeddings) – 用于向量存储的嵌入。

  • metadatas (Optional[List[dict]], optional) – 可选的元数据字典列表，用于添加到向量存储中。默认为 None。

  • index_name (可选[str], 可选) – 要创建或添加到的索引的可选名称。默认为 None。

  • (Optional[Union[Dict[str (index_schema) – 可选): 在元数据中索引的可选字段。覆盖生成的模式。默认为 None。

  • ListOfDict] – 可选): 可选的元数据字段索引。覆盖生成的模式。默认为 None。

  • str – 可选): 元数据中要索引的可选字段。覆盖生成的模式。默认为 None。

  • os.PathLike]] – 可选): 在元数据中可选的字段进行索引。覆盖生成的模式。默认为 None。

  • index_schema (Dict[str, List[Dict[str, str]]] | str | PathLike | None)

  • vector_schema (Dict[str, str | int] | None)

  • kwargs (Any)

Return type:

元组[Redis, 列表[str]]

:paramoptional):

元数据中要索引的可选字段。覆盖生成的模式。默认为None。

Parameters:

  • vector_schema (可选[字典[字符串, 联合[字符串, 整数]]], 可选) – 可选的 要使用的向量模式。默认为 None。

  • **kwargs (Any) – 传递给Redis客户端的额外关键字参数。

  • 文本 (列表[字符串])

  • embedding (Embeddings)

  • metadatas (列表[字典] | 无)

  • index_name (str | None)

  • index_schema (Dict[str, List[Dict[str, str]]] | str | PathLike | None)

Returns:

Redis实例和键的元组

新创建的文档。

Return type:

元组[Redis, 列表[str]]

Raises:

ValueError – 如果元数据的数量与文本的数量不匹配。

get_by_ids(ids: Sequence[str], /) → list[Document]#

通过ID获取文档。

返回的文档预计将具有ID字段，该字段设置为向量存储中文档的ID。

如果某些ID未找到或存在重复的ID，返回的文档数量可能少于请求的数量。

用户不应假设返回文档的顺序与输入ID的顺序相匹配。相反，用户应依赖返回文档的ID字段。

如果没有找到某些ID的文档，此方法不应引发异常。

Parameters:

ids (Sequence[str]) – 要检索的ID列表。

Returns:

文档列表。

Return type:

列表[Document]

在版本0.2.11中添加。

返回使用最大边际相关性选择的文档。

Maximal marginal relevance optimizes for similarity to query AND diversity

在选定的文档中。

Parameters:

  • query (str) – 用于查找相似文档的文本。

  • k (int) – 返回的文档数量。默认为4。

  • fetch_k (int) – 要获取并传递给MMR算法的文档数量。

  • lambda_mult (float) – 介于0和1之间的数字，决定了结果之间的多样性程度，0对应最大多样性，1对应最小多样性。默认值为0.5。

  • filter (RedisFilterExpression, optional) – 可选的元数据过滤器。 默认为 None。

  • return_metadata (bool, optional) – 是否返回元数据。 默认为 True。

  • distance_threshold (Optional[float], optional) – 所选文档与查询向量之间的最大向量距离。默认为 None。

  • kwargs (Any)

Returns:

通过最大边际相关性选择的文档列表。

Return type:

列表[Document]

max_marginal_relevance_search_by_vector(embedding: list[float], k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, **kwargs: Any) → list[Document]#

返回使用最大边际相关性选择的文档。

最大边际相关性优化了与查询的相似性和所选文档之间的多样性。

Parameters:

  • embedding (list[float]) – 用于查找相似文档的嵌入。

  • k (int) – 返回的文档数量。默认为4。

  • fetch_k (int) – 要传递给MMR算法的文档数量。 默认值为20。

  • lambda_mult (float) – 介于0和1之间的数字，决定了结果之间的多样性程度，0对应最大多样性，1对应最小多样性。默认值为0.5。

  • **kwargs (Any) – 传递给搜索方法的参数。

Returns:

通过最大边际相关性选择的文档列表。

Return type:

列表[Document]

search(query: str, search_type: str, **kwargs: Any) → list[Document]#

使用指定的搜索类型返回与查询最相似的文档。

Parameters:

  • query (str) – 输入文本

  • search_type (str) – 要执行的搜索类型。可以是“similarity”、“mmr”或“similarity_score_threshold”。

  • **kwargs (Any) – 传递给搜索方法的参数。

Returns:

与查询最相似的文档列表。

Raises:

ValueError – 如果 search_type 不是 “similarity”、“mmr” 或 “similarity_score_threshold” 之一。

Return type:

列表[Document]

运行相似性搜索

Parameters:

  • query (str) – 用于查找相似文档的查询文本。

  • k (int) – 返回的文档数量。默认值为4。

  • filter (RedisFilterExpression, optional) – 可选的元数据过滤器。 默认为 None。

  • return_metadata (bool, optional) – 是否返回元数据。 默认为 True。

  • distance_threshold (Optional[float], optional) – 所选文档与查询向量之间的最大向量距离。默认为 None。

  • kwargs (Any)

Returns:

与查询最相似的文档列表

文本。

Return type:

列表[Document]

similarity_search_by_vector(embedding: List[float], k: int = 4, filter: RedisFilterExpression | None = None, return_metadata: bool = True, distance_threshold: float | None = None, **kwargs: Any) → List[Document][source]#

在查询向量和索引向量之间运行相似性搜索。

Parameters:

  • embedding (List[float]) – 用于查找相似文档的查询向量。

  • k (int) – 返回的文档数量。默认值为4。

  • filter (RedisFilterExpression, optional) – 可选的元数据过滤器。 默认为 None。

  • return_metadata (bool, optional) – 是否返回元数据。 默认为 True。

  • distance_threshold (Optional[float], optional) – 所选文档与查询向量之间的最大向量距离。默认为 None。

  • kwargs (Any)

Returns:

与查询最相似的文档列表

文本。

Return type:

列表[Document]

similarity_search_limit_score(query: str, k: int = 4, score_threshold: float = 0.2, **kwargs: Any) → List[Document][来源]#

自版本0.0.1起已弃用：请改用1)()。

返回与查询文本在score_threshold范围内最相似的索引文档。

已弃用：请改用带有 distance_threshold 的 similarity_search。

Parameters:

  • query (str) – 用于查找相似文档的查询文本。

  • k (int) – 返回的文档数量。默认值为4。

  • score_threshold (float) – 文档被视为匹配所需的最小匹配距离。默认为0.2。

  • kwargs (Any)

Returns:

与查询文本最相似的文档列表

包括每个文档的匹配分数。

Return type:

列表[Document]

注意

如果没有满足score_threshold值的文档，则返回一个空列表。

similarity_search_with_relevance_scores(query: str, k: int = 4, **kwargs: Any) → list[tuple[Document, float]]#

返回文档和相关度分数，范围在[0, 1]之间。

0 表示不相似，1 表示最相似。

Parameters:

  • query (str) – 输入文本。

  • k (int) – 返回的文档数量。默认为4。

  • **kwargs (Any) –

    传递给相似性搜索的kwargs。应包括： score_threshold: 可选，一个介于0到1之间的浮点值

    用于过滤检索到的文档集。

Returns:

(文档, 相似度分数) 的元组列表。

Return type:

列表[元组[Document, 浮点数]]

similarity_search_with_score(query: str, k: int = 4, filter: RedisFilterExpression | None = None, return_metadata: bool = True, **kwargs: Any) → List[Tuple[Document, float]][source]#

使用向量距离运行相似性搜索。

此函数返回的“scores”是查询向量的原始向量距离。对于相似度分数，请使用similarity_search_with_relevance_scores。

Parameters:

  • query (str) – 用于查找相似文档的查询文本。

  • k (int) – 返回的文档数量。默认值为4。

  • filter (RedisFilterExpression, optional) – 可选的元数据过滤器。 默认为 None。

  • return_metadata (bool, optional) – 是否返回元数据。 默认为 True。

  • kwargs (Any)

Returns:

与查询最相似的文档列表

每个文档的距离。

Return type:

列表[元组[Document, 浮点数]]

write_schema(path: str | PathLike) → None[source]#

将模式写入一个yaml文件。

Parameters:

路径 (字符串 | 路径类型)

Return type:

无

使用 Redis 的示例