Toggle Menu
Prev Up Next

# `langchain_community.vectorstores.vdms`.VDMS

class langchain_community.vectorstores.vdms.VDMS(client: vdms.vdms, *, embedding: Optional[Embeddings] = None, collection_name: str = 'langchain', distance_strategy: DISTANCE_METRICS = 'L2', engine: ENGINES = 'FaissFlat', relevance_score_fn: Optional[Callable[[float], float]] = None)

  Intel Lab’s VDMS for vector-store workloads.

  To use, you should have both: - the `vdms` python package installed - a host (str) and port (int) associated with a deployed VDMS Server

  Visit https://github.com/IntelLabs/vdms/wiki more information.

  IT IS HIGHLY SUGGESTED TO NORMALIZE YOUR DATA.

  Parameters

    - client (vdms.vdms) – VDMS Client used to connect to VDMS server

    - collection_name (str) – Name of data collection [Default: langchain]

    - distance_strategy (DISTANCE_METRICS) – Method used to calculate distances. VDMS supports “L2” (euclidean distance) or “IP” (inner product) [Default: L2]

    - engine (ENGINES) – Underlying implementation for indexing and computing distances. VDMS supports TileDBDense, TileDBSparse, FaissFlat, FaissIVFFlat, and Flinng [Default: FaissFlat]

    - embedding (Optional[Embeddings]) – Any embedding function implementing langchain_core.embeddings.Embeddings interface.

    - relevance_score_fn (Optional[Callable[[float], float]]) – Function for obtaining relevance score

  Example

      from langchain_community.embeddings import HuggingFaceEmbeddings
      from langchain_community.vectorstores.vdms import VDMS, VDMS_Client

      vectorstore = VDMS(
          client=VDMS_Client("localhost", 55555),
          embedding=HuggingFaceEmbeddings(),
          collection_name="langchain-demo",
          distance_strategy="L2",
          engine="FaissFlat",
      )

  Attributes

  `embeddings` | Access the query embedding object if available.

  Methods

  `__init__`(client, *[, embedding, ...]) |
  `aadd_documents`(documents, **kwargs) | Run more documents through the embeddings and add to the vectorstore.
  `aadd_texts`(texts[, metadatas]) | Run more texts through the embeddings and add to the vectorstore.
  `add_documents`(documents, **kwargs) | Run more documents through the embeddings and add to the vectorstore.
  `add_images`(uris[, metadatas, ids, ...]) | Run more images through the embeddings and add to the vectorstore.
  `add_texts`(texts[, metadatas, ids, batch_size]) | Run more texts through the embeddings and add to the vectorstore.
  `adelete`([ids]) | Delete by vector ID or other criteria.
  `afrom_documents`(documents, embedding, **kwargs) | Return VectorStore initialized from documents and embeddings.
  `afrom_texts`(texts, embedding[, metadatas]) | Return VectorStore initialized from texts and embeddings.
  `amax_marginal_relevance_search`(query[, k, ...]) | Return docs selected using the maximal marginal relevance.
  `amax_marginal_relevance_search_by_vector`(...) | Return docs selected using the maximal marginal relevance.
  `as_retriever`(**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]) | 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], asynchronously.
  `asimilarity_search_with_score`(*args, **kwargs) | Run similarity search with distance asynchronously.
  `count`(collection_name) |
  `decode_image`(base64_image) |
  `delete`([ids, collection_name, constraints]) | Delete by ID.
  `encode_image`(image_path) |
  `from_documents`(documents[, embedding, ids, ...]) | Create a VDMS vectorstore from a list of documents.
  `from_texts`(texts[, embedding, metadatas, ...]) | Create a VDMS vectorstore from a raw documents.
  `get`(collection_name[, constraints, limit, ...]) | Gets the collection.
  `get_descriptor_response`(command_str, setname) |
  `get_k_candidates`(setname, fetch_k[, ...]) |
  `max_marginal_relevance_search`(query[, k, ...]) | Return docs selected using the maximal marginal relevance.
  `max_marginal_relevance_search_by_vector`(...) | Return docs selected using the maximal marginal relevance.
  `max_marginal_relevance_search_with_score`(query) | Return docs selected using the maximal marginal relevance.
  `max_marginal_relevance_search_with_score_by_vector`(...) | Return docs selected using the maximal marginal relevance.
  `query_collection_embeddings`([...]) |
  `search`(query, search_type, **kwargs) | Return docs most similar to query using specified search type.
  `similarity_search`(query[, k, fetch_k, filter]) | Run similarity search with VDMS.
  `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, ...]) | Run similarity search with VDMS with distance.
  `similarity_search_with_score_by_vector`(embedding) | Return docs most similar to embedding vector and similarity score.
  `update_document`(collection_name, ...) | Update a document in the collection.
  `update_documents`(collection_name, ids, documents) | Update a document in the collection.

  __init__(client: vdms.vdms, *, embedding: Optional[Embeddings] = None, collection_name: str = 'langchain', distance_strategy: DISTANCE_METRICS = 'L2', engine: ENGINES = 'FaissFlat', relevance_score_fn: Optional[Callable[[float], float]] = None) → None
    Parameters

      - client (vdms.vdms) –

      - embedding (Optional[Embeddings]) –

      - collection_name (str) –

      - distance_strategy (DISTANCE_METRICS) –

      - engine (ENGINES) –

      - relevance_score_fn (Optional[Callable[[float], float]]) –

    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

      - (List[Document] (documents) – Documents to add to the vectorstore.

      - documents (List[Document]) –

      - 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, **kwargs: Any) → List[str]

    Run more texts through the embeddings and add to the vectorstore.

    Parameters

      - texts (Iterable[str]) –

      - metadatas (Optional[List[dict]]) –

      - kwargs (Any) –

    Return type

      List[str]

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

    Run more documents through the embeddings and add to the vectorstore.

    Parameters

      - (List[Document] (documents) – Documents to add to the vectorstore.

      - documents (List[Document]) –

      - kwargs (Any) –

    Returns

      List of IDs of the added texts.

    Return type

      List[str]

  add_images(uris: List[str], metadatas: Optional[List[dict]] = None, ids: Optional[List[str]] = None, batch_size: int = 32, add_path: Optional[bool] = True, **kwargs: Any) → List[str]

    Run more images through the embeddings and add to the vectorstore.

    Images are added as embeddings (AddDescriptor) instead of separate entity (AddImage) within VDMS to leverage similarity search capability

    Parameters

      - uris (List[str]) – List of paths to the images to add to the vectorstore.

      - metadatas (Optional[List[dict]]) – Optional list of metadatas associated with the texts.

      - ids (Optional[List[str]]) – Optional list of unique IDs.

      - batch_size (int) – Number of concurrent requests to send to the server.

      - add_path (Optional[bool]) – Bool to add image path as metadata

      - kwargs (Any) –

    Returns

      List of ids from adding images into the vectorstore.

    Return type

      List[str]

  add_texts(texts: Iterable[str], metadatas: Optional[List[dict]] = None, ids: Optional[List[str]] = None, batch_size: int = 32, **kwargs: Any) → List[str]

    Run more texts through the embeddings and add to the vectorstore.

    Parameters

      - texts (Iterable[str]) – List of strings to add to the vectorstore.

      - metadatas (Optional[List[dict]]) – Optional list of metadatas associated with the texts.

      - ids (Optional[List[str]]) – Optional list of unique IDs.

      - batch_size (int) – Number of concurrent requests to send to the server.

      - kwargs (Any) –

    Returns

      List of ids from adding the texts into the vectorstore.

    Return type

      List[str]

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

    Delete by vector ID or other criteria.

    Parameters

      - ids (Optional[List[str]]) – List of ids to delete.

      - **kwargs (Any) – Other keyword arguments that subclasses might use.

    Returns

      True if deletion is successful, False otherwise, None if not implemented.

    Return type

      Optional[bool]

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

    Return VectorStore initialized from documents and embeddings.

    Parameters

      - documents (List[Document]) –

      - embedding (Embeddings) –

      - kwargs (Any) –

    Return type

      VST

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

    Return VectorStore initialized from texts and embeddings.

    Parameters

      - texts (List[str]) –

      - embedding (Embeddings) –

      - metadatas (Optional[List[dict]]) –

      - kwargs (Any) –

    Return type

      VST

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

    Return docs selected using the maximal marginal relevance.

    Maximal marginal relevance optimizes for similarity to query AND diversity among selected documents.

    Parameters

      - query (str) – Text to look up documents similar to.

      - k (int) – Number of Documents to return. Defaults to 4.

      - fetch_k (int) – Number of Documents to fetch to pass to MMR algorithm.

      - 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.

      - 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, **kwargs: Any) → List[Document]

    Return docs selected using the maximal marginal relevance.

    Parameters

      - embedding (List[float]) –

      - k (int) –

      - fetch_k (int) –

      - lambda_mult (float) –

      - kwargs (Any) –

    Return type

      List[Document]

  as_retriever(**kwargs: Any) → VectorStoreRetriever

    Return VectorStoreRetriever initialized from this VectorStore.

    Parameters

      - search_type (Optional[str]) – Defines the type of search that the Retriever should perform. Can be “similarity” (default), “mmr”, or “similarity_score_threshold”.

      - search_kwargs (Optional[Dict]) –

        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

      - kwargs (Any) –

    Returns

      Retriever class 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
        # 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) –

      - search_type (str) –

      - kwargs (Any) –

    Return type

      List[Document]

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

    Return docs most similar to query.

    Parameters

      - query (str) –

      - k (int) –

      - kwargs (Any) –

    Return type

      List[Document]

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

    Return docs most similar to embedding vector.

    Parameters

      - embedding (List[float]) –

      - k (int) –

      - kwargs (Any) –

    Return type

      List[Document]

  async asimilarity_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], asynchronously.

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

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

    Run similarity search with distance asynchronously.

    Parameters

      - args (Any) –

      - kwargs (Any) –

    Return type

      List[Tuple[Document, float]]

  count(collection_name: str) → int
    Parameters

      collection_name (str) –

    Return type

      int

  decode_image(base64_image: str) → bytes
    Parameters

      base64_image (str) –

    Return type

      bytes

  delete(ids: Optional[List[str]] = None, collection_name: Optional[str] = None, constraints: Optional[Dict] = None, **kwargs: Any) → bool

    Delete by ID. These are the IDs in the vectorstore.

    Parameters

      - ids (Optional[List[str]]) – List of ids to delete.

      - collection_name (Optional[str]) –

      - constraints (Optional[Dict]) –

      - kwargs (Any) –

    Returns

      True if deletion is successful, False otherwise, None if not implemented.

    Return type

      Optional[bool]

  encode_image(image_path: str) → str
    Parameters

      image_path (str) –

    Return type

      str

  classmethod from_documents(documents: List[Document], embedding: Optional[Embeddings] = None, ids: Optional[List[str]] = None, batch_size: int = 32, collection_name: str = 'langchain', **kwargs: Any) → VDMS

    Create a VDMS vectorstore from a list of documents.

    Parameters

      - collection_name (str) – Name of the collection to create.

      - documents (List[Document]) – List of documents to add to vectorstore.

      - embedding (Embeddings) – Embedding function. Defaults to None.

      - ids (Optional[List[str]]) – List of document IDs. Defaults to None.

      - batch_size (int) – Number of concurrent requests to send to the server.

      - kwargs (Any) –

    Returns

      VDMS vectorstore.

    Return type

      VDMS

  classmethod from_texts(texts: List[str], embedding: Optional[Embeddings] = None, metadatas: Optional[List[dict]] = None, ids: Optional[List[str]] = None, batch_size: int = 32, collection_name: str = 'langchain', **kwargs: Any) → VDMS

    Create a VDMS vectorstore from a raw documents.

    Parameters

      - texts (List[str]) – List of texts to add to the collection.

      - embedding (Embeddings) – Embedding function. Defaults to None.

      - metadatas (Optional[List[dict]]) – List of metadatas. Defaults to None.

      - ids (Optional[List[str]]) – List of document IDs. Defaults to None.

      - batch_size (int) – Number of concurrent requests to send to the server.

      - collection_name (str) – Name of the collection to create.

      - kwargs (Any) –

    Returns

      VDMS vectorstore.

    Return type

      VDMS

  get(collection_name: str, constraints: Optional[Dict] = None, limit: Optional[int] = None, include: List[str] = ['metadata']) → Tuple[Any, Any]

    Gets the collection. Get embeddings and their associated data from the data store. If no constraints provided returns all embeddings up to limit.

    Parameters

      - constraints (Optional[Dict]) – A dict used to filter results by. E.g. {“color” : [“==”, “red”], “price”: [“>”, 4.00]}. Optional.

      - limit (Optional[int]) – The number of documents to return. Optional.

      - include (List[str]) – A list of what to include in the results. Can contain “embeddings”, “metadatas”, “documents”. Ids are always included. Defaults to [“metadatas”, “documents”]. Optional.

      - collection_name (str) –

    Return type

      Tuple[Any, Any]

  get_descriptor_response(command_str: str, setname: str, k_neighbors: int = 3, fetch_k: int = 15, constraints: Optional[dict] = None, results: Optional[Dict[str, Any]] = None, query_embedding: Optional[List[float]] = None, normalize_distance: bool = False) → Tuple[List[Dict[str, Any]], List]
    Parameters

      - command_str (str) –

      - setname (str) –

      - k_neighbors (int) –

      - fetch_k (int) –

      - constraints (Optional[dict]) –

      - results (Optional[Dict[str, Any]]) –

      - query_embedding (Optional[List[float]]) –

      - normalize_distance (bool) –

    Return type

      Tuple[List[Dict[str, Any]], List]

  get_k_candidates(setname: str, fetch_k: Optional[int], results: Optional[Dict[str, Any]] = None, all_blobs: Optional[List] = None, normalize: Optional[bool] = False) → Tuple[List[Dict[str, Any]], List, float]
    Parameters

      - setname (str) –

      - fetch_k (Optional[int]) –

      - results (Optional[Dict[str, Any]]) –

      - all_blobs (Optional[List]) –

      - normalize (Optional[bool]) –

    Return type

      Tuple[List[Dict[str, Any]], List, float]

  max_marginal_relevance_search(query: str, k: int = 3, fetch_k: int = 15, lambda_mult: float = 0.5, filter: Optional[Dict[str, List]] = None, **kwargs: Any) → List[Document]

    Return docs selected using the maximal marginal relevance. Maximal marginal relevance optimizes for similarity to query AND diversity among selected documents.

    Parameters

      - query (str) – Text to look up documents similar to.

      - k (int) – Number of Documents to return. Defaults to 4.

      - fetch_k (int) – Number of Documents to fetch to pass to MMR algorithm.

      - 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 by metadata. Defaults to None.

      - kwargs (Any) –

    Returns

      List of Documents selected by maximal marginal relevance.

    Return type

      List[Document]

  max_marginal_relevance_search_by_vector(embedding: List[float], k: int = 3, fetch_k: int = 15, lambda_mult: float = 0.5, filter: Optional[Dict[str, List]] = None, **kwargs: Any) → List[Document]

    Return docs selected using the maximal marginal relevance. Maximal marginal relevance optimizes for similarity to query AND diversity among selected documents.

    Parameters

      - embedding (List[float]) – Embedding to look up documents similar to.

      - k (int) – Number of Documents to return. Defaults to 4.

      - fetch_k (int) – Number of Documents to fetch to pass to MMR algorithm.

      - 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 by metadata. Defaults to None.

      - kwargs (Any) –

    Returns

      List of Documents selected by maximal marginal relevance.

    Return type

      List[Document]

  max_marginal_relevance_search_with_score(query: str, k: int = 3, fetch_k: int = 15, lambda_mult: float = 0.5, filter: Optional[Dict[str, List]] = None, **kwargs: Any) → List[Tuple[Document, float]]

    Return docs selected using the maximal marginal relevance. Maximal marginal relevance optimizes for similarity to query AND diversity among selected documents.

    Parameters

      - query (str) – Text to look up documents similar to.

      - k (int) – Number of Documents to return. Defaults to 4.

      - fetch_k (int) – Number of Documents to fetch to pass to MMR algorithm.

      - 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 by metadata. Defaults to None.

      - kwargs (Any) –

    Returns

      List of Documents selected by maximal marginal relevance.

    Return type

      List[Tuple[Document, float]]

  max_marginal_relevance_search_with_score_by_vector(embedding: List[float], k: int = 3, fetch_k: int = 15, lambda_mult: float = 0.5, filter: Optional[Dict[str, List]] = None, **kwargs: Any) → List[Tuple[Document, float]]

    Return docs selected using the maximal marginal relevance. Maximal marginal relevance optimizes for similarity to query AND diversity among selected documents.

    Parameters

      - embedding (List[float]) – Embedding to look up documents similar to.

      - k (int) – Number of Documents to return. Defaults to 4.

      - fetch_k (int) – Number of Documents to fetch to pass to MMR algorithm.

      - 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 by metadata. Defaults to None.

      - kwargs (Any) –

    Returns

      List of Documents selected by maximal marginal relevance.

    Return type

      List[Tuple[Document, float]]

  query_collection_embeddings(query_embeddings: Optional[List[List[float]]] = None, collection_name: Optional[str] = None, n_results: int = 3, fetch_k: int = 15, filter: Optional[Dict[str, Any]] = None, results: Optional[Dict[str, Any]] = None, normalize_distance: bool = False, **kwargs: Any) → List[Tuple[Dict[str, Any], List]]
    Parameters

      - query_embeddings (Optional[List[List[float]]]) –

      - collection_name (Optional[str]) –

      - n_results (int) –

      - fetch_k (int) –

      - filter (Optional[Dict[str, Any]]) –

      - results (Optional[Dict[str, Any]]) –

      - normalize_distance (bool) –

      - kwargs (Any) –

    Return type

      List[Tuple[Dict[str, Any], List]]

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

    Return docs most similar to query using specified search type.

    Parameters

      - query (str) –

      - search_type (str) –

      - kwargs (Any) –

    Return type

      List[Document]

  similarity_search(query: str, k: int = 3, fetch_k: int = 15, filter: Optional[Dict[str, List]] = None, **kwargs: Any) → List[Document]

    Run similarity search with VDMS.

    Parameters

      - query (str) – Query text to search for.

      - k (int) – Number of results to return. Defaults to 3.

      - fetch_k (int) – Number of candidates to fetch for knn (>= k).

      - filter (Optional[Dict[str, str]]) – Filter by metadata. Defaults to None.

      - kwargs (Any) –

    Returns

      List of documents most similar to the query text.

    Return type

      List[Document]

  similarity_search_by_vector(embedding: List[float], k: int = 3, fetch_k: int = 15, filter: Optional[Dict[str, List]] = None, **kwargs: Any) → List[Document]

    Return docs most similar to embedding vector. :param embedding: Embedding to look up documents similar to. :type embedding: List[float] :param k: Number of Documents to return. Defaults to 3. :type k: int :param fetch_k: Number of candidates to fetch for knn (>= k). :type fetch_k: int :param filter: Filter by metadata. Defaults to None. :type filter: Optional[Dict[str, str]]

    Returns

      List of Documents most similar to the query vector.

    Parameters

      - embedding (List[float]) –

      - k (int) –

      - fetch_k (int) –

      - filter (Optional[Dict[str, List]]) –

      - kwargs (Any) –

    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 = 3, fetch_k: int = 15, filter: Optional[Dict[str, List]] = None, **kwargs: Any) → List[Tuple[Document, float]]

    Run similarity search with VDMS with distance.

    Parameters

      - query (str) – Query text to search for.

      - k (int) – Number of results to return. Defaults to 3.

      - fetch_k (int) – Number of candidates to fetch for knn (>= k).

      - filter (Optional[Dict[str, str]]) – Filter by metadata. Defaults to None.

      - 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

      List[Tuple[Document, float]]

  similarity_search_with_score_by_vector(embedding: List[float], k: int = 3, fetch_k: int = 15, filter: Optional[Dict[str, List]] = None, **kwargs: Any) → List[Tuple[Document, float]]

    Return docs most similar to embedding vector and similarity score.

    Parameters

      - embedding (List[float]) – Embedding to look up documents similar to.

      - k (int) – Number of Documents to return. Defaults to 3.

      - fetch_k (int) – Number of candidates to fetch for knn (>= k).

      - filter (Optional[Dict[str, str]]) – Filter by metadata. Defaults to None.

      - 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

      List[Tuple[Document, float]]

  update_document(collection_name: str, document_id: str, document: Document) → None

    Update a document in the collection.

    Parameters

      - document_id (str) – ID of the document to update.

      - document (Document) – Document to update.

      - collection_name (str) –

    Return type

      None

  update_documents(collection_name: str, ids: List[str], documents: List[Document]) → None

    Update a document in the collection.

    Parameters

      - ids (List[str]) – List of ids of the document to update.

      - documents (List[Document]) – List of documents to update.

      - collection_name (str) –

    Return type

      None

# Examples using VDMS

- Pip install necessary package

- VDMS