Tony20100/langchain_full huggingface dataset:
kwargs (Any) – 
Returns
List of Documents most similar to the query.
Return type
List[Document]
similarity_search_by_vector(embedding: List[float], k: int = 4, **kwargs: Any) → List[Document]¶
Return docs most similar to embedding vector.
Parameters
embedding (List[float]) – Embedding to look up documents similar to.
k (int) – Number of Documents to return. Defaults to 4.
kwargs (Any) – 
Returns
List of Documents most similar to the query vector.
Return type
List[Document]
similarity_search_with_relevance_scores(query: str, k: int = 4, **kwargs: Any) → List[Tuple[Document, float]]¶
Return docs and relevance scores in the range [0, 1].
0 is dissimilar, 1 is most similar.
Parameters
query (str) – Input text.
k (int) – Number of Documents to return. Defaults to 4.
**kwargs (Any) – kwargs to be passed to similarity search. Should include:
score_threshold: Optional, a floating point value between 0 to 1 to
filter the resulting set of retrieved docs
Returns
List of Tuples of (doc, similarity_score)
Return type
List[Tuple[Document, float]]
similarity_search_with_score(query: str, k: int = 4, **kwargs: Any) → List[Tuple[Document, float]]¶
Return docs most similar to query.
Parameters
query (str) – Text to look up documents similar to.
k (int) – Number of Documents to return. Defaults to 4.
kwargs (Any) – 
Returns
List of documents most similar to the query text and
cosine distance in float for each.
Lower score represents more similarity.
Return type
langchain_community.vectorstores.cassandra.Cassandra¶
class langchain_community.vectorstores.cassandra.Cassandra(embedding: Embeddings, session: Optional[Session] = None, keyspace: Optional[str] = None, table_name: str = '', ttl_seconds: Optional[int] = None, *, body_index_options: Optional[List[Tuple[str, Any]]] = None, setup_mode: SetupMode = SetupMode.SYNC, metadata_indexing: Union[Tuple[str, Iterable[str]], str] = 'all')[source]¶
Apache Cassandra(R) for vector-store workloads.
To use it, you need a recent installation of the cassio library
and a Cassandra cluster / Astra DB instance supporting vector capabilities.
Visit the cassio.org website for extensive quickstarts and code examples.
Example
from langchain_community.vectorstores import Cassandra
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
session = ...             # create your Cassandra session object
keyspace = 'my_keyspace'  # the keyspace should exist already
table_name = 'my_vector_store'
vectorstore = Cassandra(embeddings, session, keyspace, table_name)
Parameters
embedding (Embeddings) – Embedding function to use.
session (Optional[Session]) – Cassandra driver session. If not provided, it is resolved from
cassio.
keyspace (Optional[str]) – Cassandra keyspace. If not provided, it is resolved from cassio.
table_name (str) – Cassandra table (required).
ttl_seconds (Optional[int]) – Optional time-to-live for the added texts.
body_index_options (Optional[List[Tuple[str, Any]]]) – Optional options used to create the body index.
Eg. body_index_options = [cassio.table.cql.STANDARD_ANALYZER]
setup_mode (SetupMode) – mode used to create the Cassandra table (SYNC,
ASYNC or OFF).
metadata_indexing (Union[Tuple[str, Iterable[str]], str]) – Optional specification of a metadata indexing policy,
i.e. to fine-tune which of the metadata fields are indexed.
It can be a string (“all” or “none”), or a 2-tuple. The following
means that all fields except ‘f1’, ‘f2’ … are NOT indexed:
metadata_indexing=(“allowlist”, [“f1”, “f2”, …])
The following means all fields EXCEPT ‘g1’, ‘g2’, … are indexed:metadata_indexing(“denylist”, [“g1”, “g2”, …])
The default is to index every metadata field.
Note: if you plan to have massive unique text metadata entries,
consider not indexing them for performance
(and to overcome max-length limitations).
Attributes
embeddings
Access the query embedding object if available.
Methods
__init__(embedding[, session, keyspace, ...])
Apache Cassandra(R) for vector-store workloads.
aadd_documents(documents, **kwargs)
Run more documents through the embeddings and add to the vectorstore.
aadd_texts(texts[, metadatas, ids, ...])
Run more texts through the embeddings and add to the vectorstore.
aclear()
Empty the table.
add_documents(documents, **kwargs)
Run more documents through the embeddings and add to the vectorstore.
add_texts(texts[, metadatas, ids, ...])
Run more texts through the embeddings and add to the vectorstore.
adelete([ids])
Delete by vector IDs.
adelete_by_document_id(document_id)
Delete by document ID.
adelete_collection()
adelete_by_document_id(document_id)
Delete by document ID.
adelete_collection()
Just an alias for aclear (to better align with other VectorStore implementations).
afrom_documents(documents, embedding, *[, ...])
Create a Cassandra vectorstore from a document list.
afrom_texts(texts, embedding[, metadatas, ...])
Create a Cassandra vectorstore from raw texts.
amax_marginal_relevance_search(query[, k, ...])
Return docs selected using the maximal marginal relevance. Maximal marginal relevance optimizes for similarity to query AND diversity among selected documents. :param query: Text to look up documents similar to. :param k: Number of Documents to return. :param fetch_k: Number of Documents to fetch to pass to MMR algorithm. :param lambda_mult: Number between 0 and 1 that determines the degree                     of diversity among the results with 0 corresponding to maximum                     diversity and 1 to minimum diversity. Defaults to 0.5. :param filter: Filter on the metadata to apply. :param body_search: Document textual search terms to apply. Only supported by Astra DB at the moment.
amax_marginal_relevance_search_by_vector(...)
amax_marginal_relevance_search_by_vector(...)
Return docs selected using the maximal marginal relevance. Maximal marginal relevance optimizes for similarity to query AND diversity among selected documents. :param embedding: Embedding to look up documents similar to. :param k: Number of Documents to return. Defaults to 4. :param fetch_k: Number of Documents to fetch to pass to MMR algorithm. Defaults to 20. :param lambda_mult: Number between 0 and 1 that determines the degree                     of diversity among the results with 0 corresponding to maximum                     diversity and 1 to minimum diversity. Defaults to 0.5. :param filter: Filter on the metadata to apply. :param body_search: Document textual search terms to apply. Only supported by Astra DB at the moment.
as_retriever([search_type, search_kwargs, ...])
Return VectorStoreRetriever initialized from this VectorStore.
asearch(query, search_type, **kwargs)
Return docs most similar to query using specified search type.
asimilarity_search(query[, k, filter, ...])
Return docs most similar to query.
asimilarity_search_by_vector(embedding[, k, ...])
Return docs most similar to embedding vector.
asimilarity_search_with_relevance_scores(query)
Return docs and relevance scores in the range [0, 1].
asimilarity_search_with_score(query[, k, ...])
Return docs most similar to query.
asimilarity_search_with_score_by_vector(...)
Return docs most similar to embedding vector.
asimilarity_search_with_score_id(query[, k, ...])
Return docs most similar to query.
asimilarity_search_with_score_id_by_vector(...)
Return docs most similar to embedding vector.
clear()
Empty the table.
delete([ids])
Delete by vector IDs.
clear()
Empty the table.
delete([ids])
Delete by vector IDs.
delete_by_document_id(document_id)
Delete by document ID.
delete_collection()
Just an alias for clear (to better align with other VectorStore implementations).
from_documents(documents, embedding, *[, ...])
Create a Cassandra vectorstore from a document list.
from_texts(texts, embedding[, metadatas, ...])
Create a Cassandra vectorstore from raw texts.
max_marginal_relevance_search(query[, k, ...])
Return docs selected using the maximal marginal relevance. Maximal marginal relevance optimizes for similarity to query AND diversity among selected documents. :param query: Text to look up documents similar to. :param k: Number of Documents to return. Defaults to 4. :param fetch_k: Number of Documents to fetch to pass to MMR algorithm. Defaults to 20. :param lambda_mult: Number between 0 and 1 that determines the degree                     of diversity among the results with 0 corresponding to maximum                     diversity and 1 to minimum diversity. Defaults to 0.5. :param filter: Filter on the metadata to apply. :param body_search: Document textual search terms to apply. Only supported by Astra DB at the moment.
max_marginal_relevance_search_by_vector(...)
max_marginal_relevance_search_by_vector(...)
Return docs selected using the maximal marginal relevance. Maximal marginal relevance optimizes for similarity to query AND diversity among selected documents. :param embedding: Embedding to look up documents similar to. :param k: Number of Documents to return. Defaults to 4. :param fetch_k: Number of Documents to fetch to pass to MMR algorithm. Defaults to 20. :param lambda_mult: Number between 0 and 1 that determines the degree                     of diversity among the results with 0 corresponding to maximum                     diversity and 1 to minimum diversity. Defaults to 0.5. :param filter: Filter on the metadata to apply. :param body_search: Document textual search terms to apply. Only supported by Astra DB at the moment.
search(query, search_type, **kwargs)
Return docs most similar to query using specified search type.
similarity_search(query[, k, filter, ...])
Return docs most similar to query.
similarity_search_by_vector(embedding[, k, ...])
Return docs most similar to embedding vector.
similarity_search_with_relevance_scores(query)
Return docs and relevance scores in the range [0, 1].
similarity_search_with_score(query[, k, ...])
Return docs most similar to query.
similarity_search_with_score_by_vector(embedding)
Return docs most similar to embedding vector.
similarity_search_with_score_id(query[, k, ...])
Return docs most similar to query.
similarity_search_with_score_id_by_vector(...)
Return docs most similar to embedding vector.
similarity_search_with_score_id_by_vector(...)
Return docs most similar to embedding vector.
__init__(embedding: Embeddings, session: Optional[Session] = None, keyspace: Optional[str] = None, table_name: str = '', ttl_seconds: Optional[int] = None, *, body_index_options: Optional[List[Tuple[str, Any]]] = None, setup_mode: SetupMode = SetupMode.SYNC, metadata_indexing: Union[Tuple[str, Iterable[str]], str] = 'all') → None[source]¶
Apache Cassandra(R) for vector-store workloads.
To use it, you need a recent installation of the cassio library
and a Cassandra cluster / Astra DB instance supporting vector capabilities.
Visit the cassio.org website for extensive quickstarts and code examples.
Example
from langchain_community.vectorstores import Cassandra
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings()
session = ...             # create your Cassandra session object
keyspace = 'my_keyspace'  # the keyspace should exist already
table_name = 'my_vector_store'
vectorstore = Cassandra(embeddings, session, keyspace, table_name)
Parameters
embedding (Embeddings) – Embedding function to use.
session (Optional[Session]) – Cassandra driver session. If not provided, it is resolved from
cassio.
keyspace (Optional[str]) – Cassandra keyspace. If not provided, it is resolved from cassio.
table_name (str) – Cassandra table (required).
ttl_seconds (Optional[int]) – Optional time-to-live for the added texts.
body_index_options (Optional[List[Tuple[str, Any]]]) – Optional options used to create the body index.
Eg. body_index_options = [cassio.table.cql.STANDARD_ANALYZER]
setup_mode (SetupMode) – mode used to create the Cassandra table (SYNC,
ASYNC or OFF).
metadata_indexing (Union[Tuple[str, Iterable[str]], str]) – Optional specification of a metadata indexing policy,
i.e. to fine-tune which of the metadata fields are indexed.
It can be a string (“all” or “none”), or a 2-tuple. The following
means that all fields except ‘f1’, ‘f2’ … are NOT indexed:
metadata_indexing=(“allowlist”, [“f1”, “f2”, …])
The following means all fields EXCEPT ‘g1’, ‘g2’, … are indexed:metadata_indexing(“denylist”, [“g1”, “g2”, …])
The default is to index every metadata field.
Note: if you plan to have massive unique text metadata entries,
consider not indexing them for performance
(and to overcome max-length limitations).
Return type
None
async aadd_documents(documents: List[Document], **kwargs: Any) → List[str]¶
Run more documents through the embeddings and add to the vectorstore.
Parameters
documents (List[Document]) – Documents to add to the vectorstore.
kwargs (Any) – 
Returns
List of IDs of the added texts.
Return type
List[str]
async aadd_texts(texts: Iterable[str], metadatas: Optional[List[dict]] = None, ids: Optional[List[str]] = None, concurrency: int = 16, ttl_seconds: Optional[int] = None, **kwargs: Any) → List[str][source]¶
Run more texts through the embeddings and add to the vectorstore.
Parameters
texts (Iterable[str]) – Texts to add to the vectorstore.
metadatas (Optional[List[dict]]) – Optional list of metadatas.
metadatas (Optional[List[dict]]) – Optional list of metadatas.
ids (Optional[List[str]]) – Optional list of IDs.
concurrency (int) – Number of concurrent queries to the database.
Defaults to 16.
ttl_seconds (Optional[int]) – Optional time-to-live for the added texts.
kwargs (Any) – 
Returns
List of IDs of the added texts.
Return type
List[str]
async aclear() → None[source]¶
Empty the table.
Return type
None
add_documents(documents: List[Document], **kwargs: Any) → List[str]¶
Run more documents through the embeddings and add to the vectorstore.
Parameters
documents (List[Document]) – Documents to add to the vectorstore.
kwargs (Any) – 
Returns
List of IDs of the added texts.
Return type
List[str]
add_texts(texts: Iterable[str], metadatas: Optional[List[dict]] = None, ids: Optional[List[str]] = None, batch_size: int = 16, ttl_seconds: Optional[int] = None, **kwargs: Any) → List[str][source]¶
Run more texts through the embeddings and add to the vectorstore.
Parameters
texts (Iterable[str]) – Texts to add to the vectorstore.
metadatas (Optional[List[dict]]) – Optional list of metadatas.
ids (Optional[List[str]]) – Optional list of IDs.
batch_size (int) – Number of concurrent requests to send to the server.
ttl_seconds (Optional[int]) – Optional time-to-live for the added texts.
kwargs (Any) – 
Returns
List of IDs of the added texts.
Return type
List[str]
async adelete(ids: Optional[List[str]] = None, **kwargs: Any) → Optional[bool][source]¶
Delete by vector IDs.
Parameters
ids (Optional[List[str]]) – List of ids to delete.
kwargs (Any) – 
Returns
True if deletion is successful,
False otherwise, None if not implemented.
Return type
Optional[bool]
async adelete_by_document_id(document_id: str) → None[source]¶
Delete by document ID.
Parameters
document_id (str) – the document ID to delete.
Return type
None
async adelete_collection() → None[source]¶
Just an alias for aclear
(to better align with other VectorStore implementations).
Return type
None
async classmethod afrom_documents(documents: List[Document], embedding: Embeddings, *, session: Optional[Session] = None, keyspace: Optional[str] = None, table_name: str = '', ids: Optional[List[str]] = None, concurrency: int = 16, ttl_seconds: Optional[int] = None, body_index_options: Optional[List[Tuple[str, Any]]] = None, metadata_indexing: Union[Tuple[str, Iterable[str]], str] = 'all', **kwargs: Any) → CVST[source]¶
Create a Cassandra vectorstore from a document list.
Parameters
documents (List[Document]) – Documents to add to the vectorstore.
embedding (Embeddings) – Embedding function to use.
session (Optional[Session]) – Cassandra driver session.
If not provided, it is resolved from cassio.
keyspace (Optional[str]) – Cassandra key space.
If not provided, it is resolved from cassio.
table_name (str) – Cassandra table (required).
ids (Optional[List[str]]) – Optional list of IDs associated with the documents.
concurrency (int) – Number of concurrent queries to send to the database.
Defaults to 16.
Defaults to 16.
ttl_seconds (Optional[int]) – Optional time-to-live for the added documents.
body_index_options (Optional[List[Tuple[str, Any]]]) – Optional options used to create the body index.
Eg. body_index_options = [cassio.table.cql.STANDARD_ANALYZER]
metadata_indexing (Union[Tuple[str, Iterable[str]], str]) – 
kwargs (Any) – 
Returns
a Cassandra vectorstore.
Return type
CVST
async classmethod afrom_texts(texts: List[str], embedding: Embeddings, metadatas: Optional[List[dict]] = None, *, session: Optional[Session] = None, keyspace: Optional[str] = None, table_name: str = '', ids: Optional[List[str]] = None, concurrency: int = 16, ttl_seconds: Optional[int] = None, body_index_options: Optional[List[Tuple[str, Any]]] = None, metadata_indexing: Union[Tuple[str, Iterable[str]], str] = 'all', **kwargs: Any) → CVST[source]¶
Create a Cassandra vectorstore from raw texts.
Parameters
texts (List[str]) – Texts to add to the vectorstore.
embedding (Embeddings) – Embedding function to use.
metadatas (Optional[List[dict]]) – Optional list of metadatas associated with the texts.
session (Optional[Session]) – Cassandra driver session.
If not provided, it is resolved from cassio.
keyspace (Optional[str]) – Cassandra key space.
If not provided, it is resolved from cassio.
table_name (str) – Cassandra table (required).
ids (Optional[List[str]]) – Optional list of IDs associated with the texts.
concurrency (int) – Number of concurrent queries to send to the database.
Defaults to 16.
Defaults to 16.
ttl_seconds (Optional[int]) – Optional time-to-live for the added texts.
body_index_options (Optional[List[Tuple[str, Any]]]) – Optional options used to create the body index.
Eg. body_index_options = [cassio.table.cql.STANDARD_ANALYZER]
metadata_indexing (Union[Tuple[str, Iterable[str]], str]) – 
kwargs (Any) – 
Returns
a Cassandra vectorstore.
Return type
CVST
async amax_marginal_relevance_search(query: str, k: int = 4, fetch_k: int = 20, lambda_mult: float = 0.5, filter: Optional[Dict[str, str]] = None, body_search: Optional[Union[str, List[str]]] = None, **kwargs: Any) → List[Document][source]¶
Return docs selected using the maximal marginal relevance.
Maximal marginal relevance optimizes for similarity to query AND diversity
among selected documents.
:param query: Text to look up documents similar to.
:param k: Number of Documents to return.
:param fetch_k: Number of Documents to fetch to pass to MMR algorithm.
:param lambda_mult: Number between 0 and 1 that determines the degree
of diversity among the results with 0 corresponding to maximum
diversity and 1 to minimum diversity.
Defaults to 0.5.
Parameters
filter (Optional[Dict[str, str]]) – Filter on the metadata to apply.
body_search (Optional[Union[str, List[str]]]) – Document textual search terms to apply.
Only supported by Astra DB at the moment.
query (str) – 
k (int) – 
fetch_k (int) – 
lambda_mult (float) – 
kwargs (Any) – 
Returns
List of Documents selected by maximal marginal relevance.
kwargs (Any) – 
Returns
List of Documents selected by maximal marginal relevance.
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, filter: Optional[Dict[str, str]] = None, body_search: Optional[Union[str, List[str]]] = None, **kwargs: Any) → List[Document][source]¶
Return docs selected using the maximal marginal relevance.
Maximal marginal relevance optimizes for similarity to query AND diversity
among selected documents.
:param embedding: Embedding to look up documents similar to.
:param k: Number of Documents to return. Defaults to 4.
:param fetch_k: Number of Documents to fetch to pass to MMR algorithm.
Defaults to 20.
Parameters
lambda_mult (float) – Number between 0 and 1 that determines the degree
of diversity among the results with 0 corresponding to maximum
diversity and 1 to minimum diversity.
Defaults to 0.5.
filter (Optional[Dict[str, str]]) – Filter on the metadata to apply.
body_search (Optional[Union[str, List[str]]]) – Document textual search terms to apply.
Only supported by Astra DB at the moment.
embedding (List[float]) – 
k (int) – 
fetch_k (int) – 
kwargs (Any) – 
Returns
List of Documents selected by maximal marginal relevance.
Return type
List[Document]
Returns
List of Documents selected by maximal marginal relevance.
Return type
List[Document]
as_retriever(search_type: str = 'similarity', search_kwargs: Optional[Dict[str, Any]] = None, tags: Optional[List[str]] = None, metadata: Optional[Dict[str, Any]] = None, **kwargs: Any) → VectorStoreRetriever[source]¶
Return VectorStoreRetriever initialized from this VectorStore.
Parameters
search_type (str) – Defines the type of search that
the Retriever should perform.
Can be “similarity” (default), “mmr”, or
“similarity_score_threshold”.
search_kwargs (Optional[Dict[str, Any]]) – Keyword arguments to pass to the
search function. Can include things like:
k: Amount of documents to return (Default: 4)
score_threshold: Minimum relevance threshold
for similarity_score_threshold
fetch_k: Amount of documents to pass to MMR algorithm (Default: 20)
lambda_mult: Diversity of results returned by MMR;
1 for minimum diversity and 0 for maximum. (Default: 0.5)
filter: Filter by document metadata
tags (Optional[List[str]]) – List of tags associated with the retriever.
metadata (Optional[Dict[str, Any]]) – Metadata associated with the retriever.
kwargs (Any) – Other arguments passed to the VectorStoreRetriever init.
Returns
Retriever for VectorStore.
Return type
VectorStoreRetriever
Examples:
# 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
)
# 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]¶
Return docs most similar to query using specified search type.
Parameters
query (str) – Input text.
search_type (str) – Type of search to perform. Can be “similarity”,
“mmr”, or “similarity_score_threshold”.
**kwargs (Any) – Arguments to pass to the search method.
Return type
List[Document]
async asimilarity_search(query: str, k: int = 4, filter: Optional[Dict[str, str]] = None, body_search: Optional[Union[str, List[str]]] = None, **kwargs: Any) → List[Document][source]¶
Return docs most similar to query.
Parameters
query (str) – Text to look up documents similar to.
k (int) – Number of Documents to return. Defaults to 4.
filter (Optional[Dict[str, str]]) – Filter on the metadata to apply.