Redis向量存储#

class langchain_redis.vectorstores.RedisVectorStore(embeddings: Embeddings, config: RedisConfig | None = None, **kwargs: Any)[source]#

Redis 向量存储集成。

Setup:

安装 langchain-redis 并运行 Redis docker 容器。

pip install -qU langchain-redis
docker run -p 6379:6379 redis/redis-stack-server:latest

Key init args — indexing params:

index_name: str: 要创建的索引的名称。
embedding: Embeddings: 使用的嵌入函数。
distance_metric: str: 用于相似性搜索的距离度量。默认是“COSINE”。
indexing_algorithm: str: 使用的索引算法。默认为“FLAT”。
vector_datatype: str: 向量的数据类型。默认是“FLOAT32”。

Key init args — client params:

redis_url: Optional[str]: 要连接的Redis实例的URL。
redis_client: Optional[Redis]: 预先存在的Redis连接。

Instantiate:

from langchain_redis import RedisVectorStore
from langchain_openai import OpenAIEmbeddings

vector_store = RedisVectorStore(
    index_name="langchain-demo",
    embedding=OpenAIEmbeddings(),
    redis_url="redis://localhost:6379",
)

您还可以通过redis_client参数传入一个预先存在的Redis连接来连接到现有的Redis实例。

Instantiate from existing connection:

from langchain_redis import RedisVectorStore
from langchain_openai import OpenAIEmbeddings
from redis import Redis

redis_client = Redis.from_url("redis://localhost:6379")

store = RedisVectorStore(
    embedding=OpenAIEmbeddings(),
    index_name="langchain-demo",
    redis_client=redis_client
)

Add Documents:

from langchain_core.documents import Document

document_1 = Document(page_content="foo", metadata={"baz": "bar"})
document_2 = Document(page_content="bar", metadata={"foo": "baz"})
document_3 = Document(page_content="to 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="foo", k=1)
for doc in results:
    print(f"* {doc.page_content} [{doc.metadata}]")

* foo [{'baz': 'bar'}]

Search with filter:

from redisvl.query.filter import Tag

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

* foo [{'baz': 'bar'}]

Search with score:

results = vector_store.similarity_search_with_score(query="foo", k=1)
for doc, score in results:
    print(f"* [SIM={score:.3f}] {doc.page_content} [{doc.metadata}]")

* [SIM=0.916] foo [{'baz': 'bar'}]

Use as Retriever:

retriever = vector_store.as_retriever(
    search_type="mmr",
    search_kwargs={"k": 1, "fetch_k": 2, "lambda_mult": 0.5},
)
retriever.get_relevant_documents("foo")

[Document(page_content='foo', metadata={'baz': 'bar'})]

属性

`embeddings`	如果可用，访问查询嵌入对象。
`index`
`key_prefix`

方法

`__init__`(embeddings[, config])
`aadd_documents`(documents, **kwargs)	异步运行更多文档通过嵌入并添加到向量存储中。
`aadd_texts`(texts[, metadatas, ids])	异步运行更多文本通过嵌入并添加到向量存储中。
`add_documents`(documents, **kwargs)	在向量存储中添加或更新文档。
`add_texts`(texts[, metadatas, keys])	将文本文档添加到向量存储中。
`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])	从向量存储中删除 ids。
`from_documents`(documents, embedding[, ...])	从文档列表创建一个RedisVectorStore。
`from_existing_index`(index_name, embedding, ...)	从现有的 Redis 搜索索引创建一个 RedisVectorStore。
`from_texts`(texts, embedding[, metadatas, ...])	从文本列表创建一个RedisVectorStore。
`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, sort_by])	返回与查询最相似的文档。
`similarity_search_by_vector`(embedding[, k, ...])	返回与嵌入向量最相似的文档。
`similarity_search_with_relevance_scores`(query)	返回文档和相关度分数，分数范围在[0, 1]之间。
`similarity_search_with_score`(query[, k, ...])	返回与查询字符串最相似的文档及其分数。
`similarity_search_with_score_by_vector`(embedding)	返回与嵌入向量最相似的文档。

Parameters:

embeddings (Embeddings)
config (可选[RedisConfig])
kwargs (Any)

__init__(embeddings: Embeddings, config: RedisConfig | None = None, **kwargs: Any)[source]#

Parameters:

embeddings (Embeddings)
config (RedisConfig | 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, keys: List[dict] | None = None, **kwargs: Any) → List[str][来源]#

将文本文档添加到向量存储中。

Parameters:

texts (Iterable[str]) – 要添加到向量存储中的字符串的可迭代对象。
metadatas (List[dict] | None) – 可选的与文本关联的元数据字典列表。
keys (List[dict] | None) – 可选的与文档关联的键列表。
**kwargs (Any) – 额外的关键字参数： - ids: 可选的ID列表，用于与文档关联。 - refresh_indices: 是否在添加文本后刷新Redis索引。默认为True。 - create_index_if_not_exists: 如果Redis索引不存在，是否创建它。默认为True。 - batch_size: 可选的。每次添加到索引的文本数量。默认为1000。

Returns:

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

Return type:

列表[str]

示例

from langchain_redis import RedisVectorStore
from langchain_openai import OpenAIEmbeddings

vector_store = RedisVectorStore(
    index_name="langchain-demo",
    embedding=OpenAIEmbeddings(),
    redis_url="redis://localhost:6379",
)

texts = [
    "The quick brown fox jumps over the lazy dog",
    "Hello world",
    "Machine learning is fascinating"
]
metadatas = [
    {"source": "book", "page": 1},
    {"source": "greeting", "language": "english"},
    {"source": "article", "topic": "AI"}
]

ids = vector_store.add_texts(
    texts=texts,
    metadatas=metadatas,
    batch_size=2
)

print(f"Added documents with ids: {ids}")

注意

如果提供了 metadatas，它必须与 texts 的长度相同。
如果提供了keys，它必须与texts的长度相同。
batch_size 参数可用于控制数量

每批添加的文档数量，这对于在添加大量文档时管理内存使用非常有用。

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中添加。

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

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

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

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) → VectorStoreRetriever#

返回从此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]

async asimilarity_search(query: str, k: int = 4, **kwargs: Any) → list[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 | None[source]#

从向量存储中删除ID。

Parameters:

ids (List[str] | None) – 可选的文档ID列表，用于删除。
**kwargs (Any) – 额外的关键字参数（在当前实现中未使用）。

Returns:

如果删除一个或多个键则为True，否则为False

Return type:

可选[布尔]

示例

from langchain_redis import RedisVectorStore
from langchain_openai import OpenAIEmbeddings

vector_store = RedisVectorStore(
    index_name="langchain-demo",
    embedding=OpenAIEmbeddings(),
    redis_url="redis://localhost:6379",
)

# Assuming documents with these ids exist in the store
ids_to_delete = ["doc1", "doc2", "doc3"]

result = vector_store.delete(ids=ids_to_delete)
if result:
  print("Documents were succesfully deleted")
else:
  print("No Documents were deleted")

注意

如果 ids 为 None 或空列表，则该方法返回 False。
如果实际删除的键的数量与提交删除的键的数量不同，则该方法返回 False
该方法使用 RedisVL 中的 drop_keys 功能从 Redis 中删除键。
键是通过在配置中指定的key_prefix前缀每个id来构建的。

classmethod from_documents(documents: List[Document], embedding: Embeddings, config: RedisConfig | None = None, return_keys: bool = False, **kwargs: Any) → RedisVectorStore[source]#

从文档列表创建一个RedisVectorStore。

Parameters:

documents (List[Document]) – 要添加到向量存储中的Document对象列表。
embedding (Embeddings) – 用于编码文档的嵌入对象。
config (RedisConfig | None) – 可选的RedisConfig对象。如果未提供，将从kwargs创建一个。
return_keys (bool) – 是否返回添加文档的键。
**kwargs (Any) –

如果没有提供配置，传递给RedisConfig的额外关键字参数
。

常见的kwargs包括： - index_name: 要创建的Redis索引的名称。 - redis_url: 要连接的Redis实例的URL。 - distance_metric: 用于相似性搜索的距离度量。

默认是“COSINE”。
- indexing_algorithm: 使用的索引算法。默认是“FLAT”。

Returns:

一个新的RedisVectorStore实例，文档已添加。

Return type:

RedisVectorStore

示例

from langchain_redis import RedisVectorStore
from langchain_openai import OpenAIEmbeddings
from langchain_core.documents import Document

documents = [
    Document(
      page_content="The quick brown fox",
      metadata={"animal": "fox"}
    ),
    Document(
      page_content="jumps over the lazy dog",
      metadata={"animal": "dog"}
    )
]

embeddings = OpenAIEmbeddings()

vector_store = RedisVectorStore.from_documents(
    documents=documents,
    embedding=embeddings,
    index_name="animal-docs",
    redis_url="redis://localhost:6379"
)

# Now you can use the vector_store for similarity search
results = vector_store.similarity_search("quick animal", k=1)
print(results[0].page_content)

注意

此方法创建一个新的 RedisVectorStore 实例，并将提供的文档添加到其中。
该方法从每个Document对象中提取文本内容和元数据。
如果没有提供 RedisConfig 对象，将使用传递给此方法的额外 kwargs 创建一个。
嵌入函数用于将文档文本转换为向量表示，以便进行高效的相似性搜索。

classmethod from_existing_index(index_name: str, embedding: Embeddings, **kwargs: Any) → RedisVectorStore[source]#

从现有的Redis搜索索引创建一个RedisVectorStore。

此方法允许您连接到Redis中已存在的索引，这对于继续使用先前创建的索引或连接到在此客户端之外创建的索引非常有用。

Parameters:

index_name (str) – 要使用的现有索引的名称。
embedding (Embeddings) – 用于编码查询的嵌入函数。
**kwargs (Any) –
传递给 RedisConfig 的额外关键字参数。常见的 kwargs 包括： - redis_url: 要连接的 Redis 实例的 URL。 - redis_client: 要使用的预先存在的 Redis 客户端。 - vector_query_field: 包含向量的字段名称

表示。
- content_field: 包含文档内容的字段名称。

Returns:

一个新的RedisVectorStore实例连接到: 现有索引。

Return type:

RedisVectorStore

示例

from langchain_redis import RedisVectorStore
from langchain_openai import OpenAIEmbeddings
from redis import Redis

embeddings = OpenAIEmbeddings()

# Connect to an existing index
vector_store = RedisVectorStore.from_existing_index(
    index_name="my-existing-index",
    embedding=embeddings,
    redis_url="redis://localhost:6379",
    vector_query_field="embedding",
    content_field="text"
)

# Now you can use the vector_store for similarity search
results = vector_store.similarity_search("AI and machine learning", k=1)
print(results[0].page_content)

注意

该方法假设索引已经存在于Redis中。
提供的嵌入函数应与嵌入兼容

存储在现有索引中。 - 如果您在自定义字段名称中使用向量或内容

现有索引，请确保分别使用vector_query_field和content_field来指定它们。

此方法适用于您希望重用现有索引的场景，
例如当索引由另一个进程创建时，或者当您希望在不同会话或应用程序中使用相同索引时。

classmethod from_texts(texts: List[str], embedding: Embeddings, metadatas: List[dict] | None = None, config: RedisConfig | None = None, keys: List[str] | None = None, return_keys: bool = False, **kwargs: Any) → RedisVectorStore[来源]#

从文本列表创建一个RedisVectorStore。

Parameters:

texts (List[str]) – 要添加到向量存储中的文本列表。
embedding (Embeddings) – 用于编码文本的嵌入函数。
metadatas (List[dict] | None) – 可选的与文本关联的元数据字典列表。
config (RedisConfig | None) – 可选的RedisConfig对象。如果未提供，将从kwargs创建一个。
keys (List[str] | None) – 可选的键列表，用于与文档关联。
return_keys (bool) – 是否返回添加文档的键。
**kwargs (Any) –
如果未提供配置，则传递给RedisConfig的额外关键字参数。常用的kwargs包括： - index_name: 要创建的Redis索引的名称。 - redis_url: 要连接的Redis实例的URL。 - distance_metric: 用于相似性搜索的距离度量。

默认值为“COSINE”。
- indexing_algorithm: 使用的索引算法。默认值为“FLAT”。

Returns:

一个新的RedisVectorStore实例，其中已添加文本。

Return type:

RedisVectorStore

示例

from langchain_redis import RedisVectorStore
from langchain_openai import OpenAIEmbeddings

texts = [
    "The quick brown fox jumps over the lazy dog",
    "Hello world",
    "Machine learning is fascinating"
]
metadatas = [
    {"source": "book", "page": 1},
    {"source": "greeting", "language": "english"},
    {"source": "article", "topic": "AI"}
]

embeddings = OpenAIEmbeddings()

vector_store = RedisVectorStore.from_texts(
    texts=texts,
    embedding=embeddings,
    metadatas=metadatas,
    index_name="langchain-demo",
    redis_url="redis://localhost:6379",
    distance_metric="COSINE"
)

# Now you can use the vector_store for similarity search
results = vector_store.similarity_search("AI and machine learning", k=1)
print(results[0].page_content)

注意

此方法创建一个新的RedisVectorStore实例，并将
提供的文本添加到其中。
如果提供了 metadatas，它必须与 texts 的长度相同。
如果提供了keys，它必须与texts的长度相同。
return_keys 参数决定方法是否仅返回

RedisVectorStore 实例或一个元组 (RedisVectorStore, List[str])，其中第二个元素是添加文档的键列表。

get_by_ids(ids: Sequence[str]) → List[Document][source]#

通过ID获取文档。

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

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

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

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

Parameters:: ids (Sequence[str]) – 要检索的ID列表。
Returns:: 文档列表。
Return type:: 列表[文档]

在版本0.1.2中添加。

max_marginal_relevance_search(query: str, k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, **kwargs: Any) → List[Document][source]#

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

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

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:

列表[文档]

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][source]#

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

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

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:

列表[文档]

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]

similarity_search(query: str, k: int = 4, filter: FilterExpression | None = None, sort_by: str | None = None, **kwargs: Any) → List[Document][source]#

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

Parameters:

query (str) – 用于查找相似文档的文本。
k (int) – 返回的文档数量。默认为4。
filter (FilterExpression | None) – 可选的过滤表达式。
sort_by (str | None) – 可选的sort_by表达式。
**kwargs (Any) – 传递给搜索函数的其他关键字参数。

Returns:

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

Return type:

列表[文档]

similarity_search_by_vector(embedding: List[float], k: int = 4, filter: FilterExpression | None = None, sort_by: str | None = None, **kwargs: Any) → List[Document][source]#

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

Parameters:

embedding (List[float]) – 用于查找相似文档的嵌入。
k (int) – 返回的文档数量。默认为4。
filter (FilterExpression | None) – 可选的过滤表达式。
sort_by (str | None) – 可选的sort_by表达式。
**kwargs (Any) –
其他关键字参数： - return_metadata: 是否返回元数据。默认为 True。 - distance_threshold: 用于过滤结果的可选距离阈值。 - return_all: 是否返回 Hash/JSON 中的所有数据，包括

非索引字段

Returns:

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

Return type:

列表[文档]

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: FilterExpression | None = None, sort_by: str | None = None, **kwargs: Any) → List[Tuple[Document, float]] | List[Tuple[Document, float, ndarray]][source]#

返回与查询字符串最相似的文档，以及分数。

Args:
查询：要查找相似文档的文本。 k：要返回的文档数量。默认为4。 filter：可选的过滤表达式，应用于查询。 sort_by：可选的排序表达式，应用于查询。 **kwargs：传递给搜索函数的其他关键字参数：

custom_query: 可选的可调用函数，可用于
自定义查询。

doc_builder: 可选的 callable 用于自定义 Document 的创建。

return_metadata: 是否返回元数据。默认为 True。

distance_threshold: 用于过滤结果的可选距离阈值。

return_all: 是否返回Hash/JSON中的所有数据

非索引字段。默认为 False。

Returns:
与查询最相似的（文档，分数）元组列表。

Example:
from langchain_redis import RedisVectorStore
from langchain_openai import OpenAIEmbeddings

vector_store = RedisVectorStore(
    index_name="langchain-demo",
    embedding=OpenAIEmbeddings(),
    redis_url="redis://localhost:6379",
)

results = vector_store.similarity_search_with_score(
    "What is machine learning?",
    k=2,
    filter=None
)

for doc, score in results:
    print(f"Score: {score}")
    print(f"Content: {doc.page_content}")
    print(f"Metadata: {doc.metadata}

“)

Note:

该方法返回分数以及文档。较低的分数表示

更高的相似度。 - 实际搜索是使用向量表示进行的

查询，这就是为什么在初始化期间必须提供一个嵌入函数。

filter 参数允许基于元数据对结果进行额外的过滤。

如果 return_all 设置为 True，将返回存储在 Redis 中的所有字段，这可能包括非索引字段。

Parameters:

query (str)
k (整数)
filter (FilterExpression | None)
sort_by (str | None)
kwargs (Any)

Return type:

列表[元组[文档, 浮点数]] | 列表[元组[文档, 浮点数, ndarray]]

similarity_search_with_score_by_vector(embedding: List[float], k: int = 4, filter: FilterExpression | None = None, sort_by: str | None = None, **kwargs: Any) → List[Tuple[Document, float]] | List[Tuple[Document, float, ndarray]][source]#

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

Parameters:

embedding (List[float]) – 用于查找相似文档的嵌入。
k (int) – 返回的文档数量。默认为4。
filter (FilterExpression | None) – 可选的过滤表达式。
sort_by (str | None) – 可选的sort_by表达式。
**kwargs (Any) – 其他关键字参数： with_vectors: 是否返回文档向量。默认为 False。 return_metadata: 是否返回元数据。默认为 True。 distance_threshold: 用于过滤结果的可选距离阈值。

Returns:

与查询向量最相似的文档元组列表，包括分数，以及可选的文档向量。

Return type:

列表[元组[文档, 浮点数]] | 列表[元组[文档, 浮点数, ndarray]]