`langchain_community.vectorstores.redis.base`.Redis¶

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

Redis 向量数据库。

要使用，您应该安装 redis Python 包，并运行 Redis Enterprise 或 Redis-Stack 服务器

对于生产用例，建议使用 Redis Enterprise，因为其扩展性、性能、稳定性和可用性远优于 Redis-Stack。

但是，对于测试和原型设计，这不是必需的。 Redis-Stack 可以作为 Docker 容器使用，并提供完整的向量搜索 API。

# to run redis stack in docker locally
docker run -d -p 6379:6379 -p 8001:8001 redis/redis-stack:latest

运行后，您可以使用以下 URL 模式连接到 Redis 服务器： - redis://<host>:<port> # 简单连接 - redis://<username>:<password>@<host>:<port> # 带身份验证的连接 - rediss://<host>:<port> # 使用 SSL 的连接 - rediss://<username>:<password>@<host>:<port> # 使用 SSL 和身份验证的连接

示例

以下示例展示了将 Redis VectorStore 与 LangChain 一起使用的各种方法。

对于以下所有示例，假设我们有以下导入

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

初始化、创建索引和加载文档

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

rds = Redis.from_documents(
    documents, # a list of Document objects from loaders or created
    embeddings, # an Embeddings object
    redis_url="redis://localhost:6379",
)

初始化、创建索引和加载带有元数据的文档

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

初始化、创建索引和加载带有元数据并返回键的文档

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

对于需要保持索引存活的用例，您可以使用索引名称进行初始化，以便稍后更容易引用

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

初始化并连接到现有索引（来自上面）

# must pass in schema and key_prefix from another index
existing_rds = Redis.from_existing_index(
    embeddings, # an Embeddings object
    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://localhost:6379",
)

高级示例

可以提供自定义向量模式来更改 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])	异步运行更多文本通过嵌入并添加到向量存储。
`add_documents`(documents, **kwargs)	在向量存储中添加或更新文档。
`add_texts`(texts[, metadatas, embeddings, ...])	向向量存储添加更多文本。
`adelete`([ids])	异步按向量 ID 或其他条件删除。
`afrom_documents`(documents, embedding, **kwargs)	异步从文档和嵌入初始化并返回 VectorStore。
`afrom_texts`(texts, embedding[, metadatas])	异步从文本和嵌入初始化并返回 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)	异步运行带距离的相似性搜索。
`astreaming_upsert`(items, /, batch_size, **kwargs)
`aupsert`(items, /, **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, ...])	Deprecated since version langchain-community==0.0.1: 使用 `similarity_search(distance_threshold=0.1)` 代替。
`similarity_search_with_relevance_scores`(query)	返回范围为 [0, 1] 的文档和相关性得分。
`similarity_search_with_score`(query[, k, ...])	运行带向量距离的相似性搜索。
`streaming_upsert`(items, /, batch_size, **kwargs)
`upsert`(items, /, **kwargs)
`write_schema`(path)	将模式写入 yaml 文件。

参数

redis_url (str) –
index_name (str) –
embedding (Embeddings) –
index_schema (Optional[Union[Dict[str, ListOfDict], str, os.PathLike]]) –
vector_schema (Optional[Dict[str, Union[str, int]]]) –
relevance_score_fn (Optional[Callable[[float], float]]) –
key_prefix (Optional[str]) –
kwargs (Any) –

__init__(redis_url: str, index_name: str, embedding: Embeddings, index_schema: Optional[Union[Dict[str, List[Dict[str, str]]], str, PathLike]] = None, vector_schema: Optional[Dict[str, Union[str, int]]] = None, relevance_score_fn: Optional[Callable[[float], float]] = None, key_prefix: Optional[str] = None, **kwargs: Any)[source]¶

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

参数

redis_url (str) –
index_name (str) –
embedding (Embeddings) –
index_schema (Optional[Union[Dict[str, List[Dict[str, str]]], str, PathLike]]) –
vector_schema (Optional[Dict[str, Union[str, int]]]) –
relevance_score_fn (Optional[Callable[[float], float]]) –
key_prefix (Optional[str]) –
kwargs (Any) –

async aadd_documents(documents: List[Document], **kwargs: Any) → List[str]¶

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

参数

documents (List[Document]) – 要添加到向量存储的文档。
kwargs (Any) – 额外的关键词参数。

返回

添加文本的 ID 列表。

Raises

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

Return type

List[str]

async aadd_texts(texts: Iterable[str], metadatas: Optional[List[dict]] = None, **kwargs: Any) → List[str]¶

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

参数

texts (Iterable[str]) – 要添加到向量存储的字符串的可迭代对象。
metadatas (Optional[List[dict]]) – 与文本关联的可选元数据列表。默认为 None。
**kwargs (Any) – 向量存储特定的参数。

返回

从将文本添加到向量存储中获取的 id 列表。

Raises

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

Return type

List[str]

add_documents(documents: List[Document], **kwargs: Any) → List[str]¶

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

参数

documents (List[Document]) – 要添加到向量存储的文档。
kwargs (Any) – 额外的关键词参数。如果 kwargs 包含 ids 且 documents 包含 ids，则 kwargs 中的 ids 将优先使用。

返回

添加文本的 ID 列表。

Raises

ValueError – 如果 ids 的数量与 documents 的数量不匹配。

Return type

List[str]

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

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

参数

texts (Iterable[str]) – 要添加到向量存储的可迭代字符串/文本。
metadatas (Optional[List[dict]], optional) – 可选的元数据列表。默认为 None。
embeddings (Optional[List[List[float]]], optional) – 可选的预生成嵌入向量。默认为 None。
keys (List[str]) or ids (List[str]) – 条目的标识符。默认为 None。
batch_size (int, optional) – 写入时使用的批处理大小。默认为 1000。
clean_metadata (bool) –
kwargs (Any) –

返回

添加到向量存储的 ids 列表

Return type

List[str]

async adelete(ids: Optional[List[str]] = None, **kwargs: Any) → Optional[bool]¶

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

参数

ids (Optional[List[str]]) – 要删除的 ids 列表。如果为 None，则删除所有。默认为 None。
**kwargs (Any) – 子类可能使用的其他关键词参数。

返回

如果删除成功，则为 True，否则为 False，如果未实现则为 None。

Return type

Optional[bool]

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

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

参数

documents (List[Document]) – 要添加到向量存储的 Document 列表。
embedding (Embeddings) – 要使用的嵌入函数。
kwargs (Any) – 额外的关键词参数。

返回

从 documents 和 embeddings 初始化 VectorStore。

Return type

VectorStore

async classmethod afrom_texts(texts: List[str], embedding: Embeddings, metadatas: Optional[List[dict]] = None, **kwargs: Any) → VST¶

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

参数

texts (List[str]) – 要添加到向量存储的文本列表。
embedding (Embeddings) – 要使用的嵌入函数。
metadatas (Optional[List[dict]]) – 与文本关联的可选元数据列表。默认为 None。
kwargs (Any) – 额外的关键词参数。

返回

从 texts 和 embeddings 初始化 VectorStore。

Return type

VectorStore

async aget_by_ids(ids: Sequence[str], /) → List[Document]¶

异步按 ID 获取文档。

返回的 documents 应该设置了 ID 字段，该字段是文档在向量存储中的 ID。

如果某些 IDs 未找到或存在重复的 IDs，则返回的 documents 可能会少于请求的数量。

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

如果某些 IDs 没有找到 documents，此方法**不应**引发异常。

参数: ids (Sequence[str]) – 要检索的 ids 列表。
返回: Document 列表。
Return type: List[Document]

0.2.11 版本新增。

async amax_marginal_relevance_search(query: str, k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, **kwargs: Any) → List[Document]¶

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

最大边际相关性优化了与查询的相似性以及所选 documents 之间的多样性。

参数

query (str) – 用于查找相似 documents 的文本。
k (int) – 要返回的 Documents 数量。默认为 4。
fetch_k (int) – 要获取并传递给 MMR 算法的 Documents 数量。默认为 20。
lambda_mult (float) – 介于 0 和 1 之间的数字，用于确定结果之间多样性的程度，其中 0 对应于最大多样性，1 对应于最小多样性。默认为 0.5。
kwargs (Any) –

返回

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

Return type

List[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]¶

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

最大边际相关性优化了与查询的相似性以及所选 documents 之间的多样性。

参数

embedding (List[float]) – 用于查找相似 documents 的嵌入向量。
k (int) – 要返回的 Documents 数量。默认为 4。
fetch_k (int) – 要获取并传递给 MMR 算法的 Documents 数量。默认为 20。
lambda_mult (float) – 介于 0 和 1 之间的数字，用于确定结果之间多样性的程度，其中 0 对应于最大多样性，1 对应于最小多样性。默认为 0.5。
**kwargs (Any) – 传递给搜索方法的参数。

返回

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

Return type

List[Document]

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

返回从此 VectorStore 初始化的 VectorStoreRetriever。

参数

**kwargs (Any) –

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

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

search_kwargs (Optional[Dict]): 传递给搜索函数的关键词参数。可以包括诸如

search 函数的关键词参数。可以包括诸如

k: 要返回的 documents 数量 (默认: 4) score_threshold: 相似度分数阈值的最小相关性阈值

k: 要返回的 documents 数量 (默认: 4) score_threshold: 相似度分数阈值的最小相关性阈值

fetch_k: 要传递给 MMR 算法的 documents 数量 (默认: 20): (默认: 20)
lambda_mult: MMR 返回结果的多样性；1 表示最小多样性，0 表示最大多样性。(默认: 0.5): 1 表示最小多样性，0 表示最大多样性。(默认: 0.5)

filter: 按 document 元数据过滤

返回

VectorStore 的 Retriever 类。

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]¶

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

参数

query (str) – 输入文本。
search_type (str) – 要执行的搜索类型。可以是 “similarity”、“mmr” 或 “similarity_score_threshold”。
**kwargs (Any) – 传递给搜索方法的参数。

返回

与查询最相似的 Document 列表。

Raises

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

Return type

List[Document]

async asimilarity_search(query: str, k: int = 4, **kwargs: Any) → List[Document]¶

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

参数

query (str) – 输入文本。
k (int) – 要返回的 Documents 数量。默认为 4。
**kwargs (Any) – 传递给搜索方法的参数。

返回

与查询最相似的 Document 列表。

Return type

List[Document]

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

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

参数

embedding (List[float]) – 用于查找相似 documents 的嵌入向量。
k (int) – 要返回的 Documents 数量。默认为 4。
**kwargs (Any) – 传递给搜索方法的参数。

返回

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

Return type

List[Document]

async asimilarity_search_with_relevance_scores(query: str, k: int = 4, **kwargs: Any) → List[Tuple[Document, float]]¶

异步返回范围为 [0, 1] 的文档和相关性得分。

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

参数

query (str) – 输入文本。
k (int) – 要返回的 Documents 数量。默认为 4。
**kwargs (Any) –
要传递给相似性搜索的 kwargs。应包括： score_threshold: 可选，介于 0 到 1 之间的浮点值，用于

过滤检索到的文档结果集

返回

(doc, similarity_score) 元组列表

Return type

List[Tuple[Document, float]]

async asimilarity_search_with_score(*args: Any, **kwargs: Any) → List[Tuple[Document, float]]¶

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

参数

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

返回

(doc, similarity_score) 元组列表。

Return type

List[Tuple[Document, float]]

astreaming_upsert(items: AsyncIterable[Document], /, batch_size: int, **kwargs: Any) → AsyncIterator[UpsertResponse]¶

Beta

在 0.2.11 中添加。API 可能会更改。

以流式方式 Upsert documents。streaming_upsert 的异步版本。

参数

items (AsyncIterable[Document]) – 要添加到向量存储的 Document 的可迭代对象。
batch_size (int) – 每次 upsert 的批次大小。
kwargs (Any) – 额外的关键词参数。kwargs 应仅包含所有 documents 共有的参数。（例如，索引的超时时间、重试策略等）kwargs 不应包含 ids 以避免语义模糊。相反，ID 应作为 Document 对象的一部分提供。

Yields

UpsertResponse – 响应对象，其中包含已成功添加到向量存储或在向量存储中更新的 IDs 列表，以及未能添加或更新的 IDs 列表。

Return type

AsyncIterator[UpsertResponse]

0.2.11 版本新增。

async aupsert(items: Sequence[Document], /, **kwargs: Any) → UpsertResponse¶

Beta

在 0.2.11 中添加。API 可能会更改。

在向量存储中添加或更新 documents。upsert 的异步版本。

如果提供了 Document 对象的 ID 字段，则 upsert 功能应使用该字段。如果未提供 ID，则 upsert 方法可以自由地为 document 生成 ID。

当指定了 ID 且 document 已存在于向量存储中时，upsert 方法应使用新数据更新 document。如果 document 不存在，则 upsert 方法应将 document 添加到向量存储中。

参数

items (Sequence[Document]) – 要添加到向量存储的 Document 序列。
kwargs (Any) – 额外的关键词参数。

返回

响应对象，其中包含已成功添加到向量存储或在向量存储中更新的 IDs 列表，以及未能添加或更新的 IDs 列表。

Return type

UpsertResponse

0.2.11 版本新增。

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

删除 Redis 条目。

参数

ids (Optional[List[str]]) – 要删除的 ids 列表（redis 中的键）。
redis_url – Redis 连接 url。这应在 kwargs 中传递或设置为环境变量：REDIS_URL。
kwargs (Any) –

返回

删除是否成功。

Return type

bool

Raises

ValueError – 如果未安装 redis python 包。
ValueError – 如果未提供 ids （redis 中的键）

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

删除 Redis 搜索索引。

参数

index_name (str) – 要删除的索引的名称。
delete_documents (bool) – 是否删除关联的 documents。
kwargs (Any) –

返回

删除是否成功。

Return type

bool

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

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

参数

documents (List[Document]) – 要添加到向量存储的 Document 列表。
embedding (Embeddings) – 要使用的嵌入函数。
kwargs (Any) – 额外的关键词参数。

返回

从 documents 和 embeddings 初始化 VectorStore。

Return type

VectorStore

classmethod from_existing_index(embedding: Embeddings, index_name: str, schema: Union[Dict[str, List[Dict[str, str]]], str, PathLike], key_prefix: Optional[str] = None, **kwargs: Any) → Redis[source]¶

连接到现有的 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",
)

参数

embedding (Embeddings) – 用于嵌入查询的嵌入模型类（例如 OpenAIEmbeddings）。
index_name (str) – 要连接的索引的名称。
schema (Union[Dict[str, str], str, os.PathLike, Dict[str, ListOfDict]]) – 索引和向量模式的模式。可以是字典，也可以是 yaml 文件的路径。
key_prefix (Optional[str]) – 用于与此索引关联的 Redis 中所有键的前缀。
**kwargs (Any) – 要传递给 Redis 客户端的其他关键字参数。

返回

Redis 向量存储实例。

Return type

Redis

Raises

ValueError – 如果索引不存在。
ImportError – 如果未安装 redis python 包。

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

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

这是一个用户友好的接口，用于：

嵌入文档。
如果 Redis 索引尚不存在，则创建一个新的索引。
将文档添加到新创建的 Redis 索引中。

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

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

示例

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"
)

参数

texts (List[str]) – 要添加到向量存储的文本列表。
embedding (Embeddings) – 用于嵌入查询的嵌入模型类（例如 OpenAIEmbeddings）。
metadatas (Optional[List[dict]], 可选) – 要添加到向量存储的可选元数据字典列表。默认为 None。
index_name (Optional[str], 可选) – 要创建或添加到的索引的可选名称。默认为 None。
(Optional[Union[Dict[str (index_schema) – 可选): 元数据中要索引的可选字段。覆盖生成的模式。默认为 None。
ListOfDict] – 可选): 元数据中要索引的可选字段。覆盖生成的模式。默认为 None。
str – 可选): 元数据中要索引的可选字段。覆盖生成的模式。默认为 None。
os.PathLike]] – 可选): 元数据中要索引的可选字段。覆盖生成的模式。默认为 None。
index_schema (Optional[Union[Dict[str, List[Dict[str, str]]], str, PathLike]]) –
vector_schema (Optional[Dict[str, Union[str, int]]]) –
kwargs (Any) –

Return type

Redis

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

参数

vector_schema (Optional[Dict[str, Union[str, int]]], 可选) – 要使用的可选向量模式。默认为 None。
**kwargs (Any) – 要传递给 Redis 客户端的其他关键字参数。
texts (List[str]) –
embedding (Embeddings) –
metadatas (Optional[List[dict]]) –
index_name (Optional[str]) –
index_schema (Optional[Union[Dict[str, List[Dict[str, str]]], str, PathLike]]) –

返回

Redis 向量存储实例。

Return type

Redis

Raises

ValueError – 如果元数据的数量与文本的数量不匹配。
ImportError – 如果未安装 redis python 包。

classmethod from_texts_return_keys(texts: List[str], embedding: Embeddings, metadatas: Optional[List[dict]] = None, index_name: Optional[str] = None, index_schema: Optional[Union[Dict[str, List[Dict[str, str]]], str, PathLike]] = None, vector_schema: Optional[Dict[str, Union[str, int]]] **kwargs: Any) → Tuple[Redis, List[str]][source]¶

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

这是一个用户友好的接口，用于：

嵌入文档。
如果 Redis 索引尚不存在，则创建一个新的索引。
将文档添加到新创建的 Redis 索引中。
存储后返回新创建文档的键。

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

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

示例

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"
)

参数

texts (List[str]) – 要添加到向量存储的文本列表。
embedding (Embeddings) – 用于向量存储的嵌入。
metadatas (Optional[List[dict]], 可选) – 要添加到向量存储的可选元数据字典列表。默认为 None。
index_name (Optional[str], 可选) – 要创建或添加到的索引的可选名称。默认为 None。
(Optional[Union[Dict[str (index_schema) – 可选): 元数据中要索引的可选字段。覆盖生成的模式。默认为 None。
ListOfDict] – 可选): 元数据中要索引的可选字段。覆盖生成的模式。默认为 None。
str – 可选): 元数据中要索引的可选字段。覆盖生成的模式。默认为 None。
os.PathLike]] – 可选): 元数据中要索引的可选字段。覆盖生成的模式。默认为 None。
index_schema (Optional[Union[Dict[str, List[Dict[str, str]]], str, PathLike]]) –
vector_schema (Optional[Dict[str, Union[str, int]]]) –
kwargs (Any) –

Return type

Tuple[Redis, List[str]]

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

参数

vector_schema (Optional[Dict[str, Union[str, int]]], 可选) – 要使用的可选向量模式。默认为 None。
**kwargs (Any) – 要传递给 Redis 客户端的其他关键字参数。
texts (List[str]) –
embedding (Embeddings) –
metadatas (Optional[List[dict]]) –
index_name (Optional[str]) –
index_schema (Optional[Union[Dict[str, List[Dict[str, str]]], str, PathLike]]) –

返回

Redis 实例和以下键的元组: 新创建的文档。

Return type

Tuple[Redis, List[str]]

Raises

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

get_by_ids(ids: Sequence[str], /) → List[Document]¶

按 ID 获取文档。

返回的 documents 应该设置了 ID 字段，该字段是文档在向量存储中的 ID。

如果某些 IDs 未找到或存在重复的 IDs，则返回的 documents 可能会少于请求的数量。

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

如果某些 IDs 没有找到 documents，此方法**不应**引发异常。

参数: ids (Sequence[str]) – 要检索的 ids 列表。
返回: Document 列表。
Return type: List[Document]

0.2.11 版本新增。

max_marginal_relevance_search(query: str, k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, filter: Optional[RedisFilterExpression] = None, return_metadata: bool = True, distance_threshold: Optional[float] = None, **kwargs: Any) → List[Document][source]¶

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

最大边际相关性（MMR）优化查询的相似性和: 所选文档之间的多样性。

参数

query (str) – 用于查找相似 documents 的文本。
k (int) – 要返回的 Documents 数量。默认为 4。
fetch_k (int) – 要获取并传递给 MMR 算法的文档数量。
lambda_mult (float) – 介于 0 和 1 之间的数字，用于确定结果之间多样性的程度，其中 0 对应于最大多样性，1 对应于最小多样性。默认为 0.5。
filter (RedisFilterExpression, 可选) – 可选的元数据过滤器。默认为 None。
return_metadata (bool, 可选) – 是否返回元数据。默认为 True。
distance_threshold (Optional[float], 可选) – 所选文档和查询向量之间的最大向量距离。默认为 None。
kwargs (Any) –

返回

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

Return type

List[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]¶

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

最大边际相关性优化了与查询的相似性以及所选 documents 之间的多样性。

参数

embedding (List[float]) – 用于查找相似 documents 的嵌入向量。
k (int) – 要返回的 Documents 数量。默认为 4。
fetch_k (int) – 要获取并传递给 MMR 算法的 Documents 数量。默认为 20。
lambda_mult (float) – 介于 0 和 1 之间的数字，用于确定结果之间多样性的程度，其中 0 对应于最大多样性，1 对应于最小多样性。默认为 0.5。
**kwargs (Any) – 传递给搜索方法的参数。

返回

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

Return type

List[Document]

search(query: str, search_type: str, **kwargs: Any) → List[Document]¶

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

参数

query (str) – 输入文本
search_type (str) – 要执行的搜索类型。可以是 “similarity”、“mmr” 或 “similarity_score_threshold”。
**kwargs (Any) – 传递给搜索方法的参数。

返回

与查询最相似的 Document 列表。

Raises

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

Return type

List[Document]

similarity_search(query: str, k: int = 4, filter: Optional[RedisFilterExpression] = None, return_metadata: bool = True, distance_threshold: Optional[float] = None, **kwargs: Any) → List[Document][source]¶

运行相似性搜索

参数

query (str) – 用于查找相似文档的查询文本。
k (int) – 要返回的文档数量。默认为 4。
filter (RedisFilterExpression, 可选) – 可选的元数据过滤器。默认为 None。
return_metadata (bool, 可选) – 是否返回元数据。默认为 True。
distance_threshold (Optional[float], 可选) – 所选文档和查询向量之间的最大向量距离。默认为 None。
kwargs (Any) –

返回

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

Return type

List[Document]

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

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

参数

embedding (List[float]) – 用于查找相似文档的查询向量。
k (int) – 要返回的文档数量。默认为 4。
filter (RedisFilterExpression, 可选) – 可选的元数据过滤器。默认为 None。
return_metadata (bool, 可选) – 是否返回元数据。默认为 True。
distance_threshold (Optional[float], 可选) – 所选文档和查询向量之间的最大向量距离。默认为 None。
kwargs (Any) –

返回

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

Return type

List[Document]

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

Deprecated since version langchain-community==0.0.1: 使用 similarity_search(distance_threshold=0.1) 代替。

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

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

参数

query (str) – 用于查找相似文档的查询文本。
k (int) – 要返回的文档数量。默认为 4。
score_threshold (float) – 文档被视为匹配项所需的最小匹配距离。默认为 0.2。
kwargs (Any) –

返回

与查询文本最相似的文档列表，: 包括每个文档的匹配得分。

Return type

List[Document]

注意

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

similarity_search_with_relevance_scores(query: str, k: int = 4, **kwargs: Any) → List[Tuple[Document, float]]¶

返回范围为 [0, 1] 的文档和相关性得分。

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

参数

query (str) – 输入文本。
k (int) – 要返回的 Documents 数量。默认为 4。
**kwargs (Any) –
要传递给相似性搜索的 kwargs。应包括： score_threshold: 可选，介于 0 到 1 之间的浮点值，用于

过滤检索到的文档结果集。

返回

(doc, similarity_score) 元组列表。

Return type

List[Tuple[Document, float]]

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

运行带向量距离的相似性搜索。

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

参数

query (str) – 用于查找相似文档的查询文本。
k (int) – 要返回的文档数量。默认为 4。
filter (RedisFilterExpression, 可选) – 可选的元数据过滤器。默认为 None。
return_metadata (bool, 可选) – 是否返回元数据。默认为 True。
kwargs (Any) –

返回

与查询最相似的文档列表，: 并包含每个文档的距离。

Return type

List[Tuple[Document, float]]

streaming_upsert(items: Iterable[Document], /, batch_size: int, **kwargs: Any) → Iterator[UpsertResponse]¶

Beta

在 0.2.11 中添加。API 可能会更改。

以流式方式更新文档。

参数

items (Iterable[Document]) – 要添加到向量存储的文档的可迭代对象。
batch_size (int) – 每次 upsert 的批次大小。
kwargs (Any) – 附加关键字参数。 kwargs 应仅包括所有文档通用的参数。（例如，索引超时、重试策略等）kwargs 不应包含 ids 以避免语义模糊。相反，ID 应作为 Document 对象的一部分提供。

Yields

UpsertResponse – 响应对象，其中包含已成功添加到向量存储或在向量存储中更新的 IDs 列表，以及未能添加或更新的 IDs 列表。

Return type

Iterator[UpsertResponse]

0.2.11 版本新增。

upsert(items: Sequence[Document], /, **kwargs: Any) → UpsertResponse¶

Beta

在 0.2.11 中添加。API 可能会更改。

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

如果提供了 Document 对象的 ID 字段，则 upsert 功能应使用该字段。如果未提供 ID，则 upsert 方法可以自由地为 document 生成 ID。

当指定了 ID 且 document 已存在于向量存储中时，upsert 方法应使用新数据更新 document。如果 document 不存在，则 upsert 方法应将 document 添加到向量存储中。

参数

items (Sequence[Document]) – 要添加到向量存储的 Document 序列。
kwargs (Any) – 额外的关键词参数。

返回

响应对象，其中包含已成功添加到向量存储或在向量存储中更新的 IDs 列表，以及未能添加或更新的 IDs 列表。

Return type

UpsertResponse

0.2.11 版本新增。

write_schema(path: Union[str, PathLike]) → None[source]¶

将模式写入 yaml 文件。

参数: path (Union[str, PathLike]) –
Return type: None

Redis 使用示例¶

Redis

langchain_community.vectorstores.redis.base.Redis¶

Redis 使用示例¶

`langchain_community.vectorstores.redis.base`.Redis¶