elasticsearch 8.13.0__py3-none-any.whl → 8.13.2__py3-none-any.whl

elasticsearch/helpers/vectorstore/_sync/vectorstore.py

@@ -0,0 +1,388 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. licenses this file to you under
+#  the Apache License, Version 2.0 (the "License"); you may
+#  not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+import logging
+import uuid
+from typing import Any, Callable, Dict, List, Optional
+
+from elasticsearch import Elasticsearch
+from elasticsearch._version import __versionstr__ as lib_version
+from elasticsearch.helpers import BulkIndexError, bulk
+from elasticsearch.helpers.vectorstore import EmbeddingService, RetrievalStrategy
+from elasticsearch.helpers.vectorstore._utils import maximal_marginal_relevance
+
+logger = logging.getLogger(__name__)
+
+
+class VectorStore:
+    """
+    VectorStore is a higher-level abstraction of indexing and search.
+    Users can pick from available retrieval strategies.
+
+    Documents have up to 3 fields:
+      - text_field: the text to be indexed and searched.
+      - metadata: additional information about the document, either schema-free
+        or defined by the supplied metadata_mappings.
+      - vector_field (usually not filled by the user): the embedding vector of the text.
+
+    Depending on the strategy, vector embeddings are
+      - created by the user beforehand
+      - created by this AsyncVectorStore class in Python
+      - created in-stack by inference pipelines.
+    """
+
+    def __init__(
+        self,
+        client: Elasticsearch,
+        *,
+        index: str,
+        retrieval_strategy: RetrievalStrategy,
+        embedding_service: Optional[EmbeddingService] = None,
+        num_dimensions: Optional[int] = None,
+        text_field: str = "text_field",
+        vector_field: str = "vector_field",
+        metadata_mappings: Optional[Dict[str, Any]] = None,
+        user_agent: str = f"elasticsearch-py-vs/{lib_version}",
+    ) -> None:
+        """
+        :param user_header: user agent header specific to the 3rd party integration.
+            Used for usage tracking in Elastic Cloud.
+        :param index: The name of the index to query.
+        :param retrieval_strategy: how to index and search the data. See the strategies
+            module for availble strategies.
+        :param text_field: Name of the field with the textual data.
+        :param vector_field: For strategies that perform embedding inference in Python,
+            the embedding vector goes in this field.
+        :param client: Elasticsearch client connection. Alternatively specify the
+            Elasticsearch connection with the other es_* parameters.
+        """
+        # Add integration-specific usage header for tracking usage in Elastic Cloud.
+        # client.options preserves existing (non-user-agent) headers.
+        client = client.options(headers={"User-Agent": user_agent})
+
+        if hasattr(retrieval_strategy, "text_field"):
+            retrieval_strategy.text_field = text_field
+        if hasattr(retrieval_strategy, "vector_field"):
+            retrieval_strategy.vector_field = vector_field
+
+        self.client = client
+        self.index = index
+        self.retrieval_strategy = retrieval_strategy
+        self.embedding_service = embedding_service
+        self.num_dimensions = num_dimensions
+        self.text_field = text_field
+        self.vector_field = vector_field
+        self.metadata_mappings = metadata_mappings
+
+    def close(self) -> None:
+        return self.client.close()
+
+    def add_texts(
+        self,
+        texts: List[str],
+        *,
+        metadatas: Optional[List[Dict[str, Any]]] = None,
+        vectors: Optional[List[List[float]]] = None,
+        ids: Optional[List[str]] = None,
+        refresh_indices: bool = True,
+        create_index_if_not_exists: bool = True,
+        bulk_kwargs: Optional[Dict[str, Any]] = None,
+    ) -> List[str]:
+        """Add documents to the Elasticsearch index.
+
+        :param texts: List of text documents.
+        :param metadata: Optional list of document metadata. Must be of same length as
+            texts.
+        :param vectors: Optional list of embedding vectors. Must be of same length as
+            texts.
+        :param ids: Optional list of ID strings. Must be of same length as texts.
+        :param refresh_indices: Whether to refresh the index after deleting documents.
+            Defaults to True.
+        :param create_index_if_not_exists: Whether to create the index if it does not
+            exist. Defaults to True.
+        :param bulk_kwargs: Arguments to pass to the bulk function when indexing
+            (for example chunk_size).
+
+        :return: List of IDs of the created documents, either echoing the provided one
+            or returning newly created ones.
+        """
+        bulk_kwargs = bulk_kwargs or {}
+        ids = ids or [str(uuid.uuid4()) for _ in texts]
+        requests = []
+
+        if create_index_if_not_exists:
+            self._create_index_if_not_exists()
+
+        if self.embedding_service and not vectors:
+            vectors = self.embedding_service.embed_documents(texts)
+
+        for i, text in enumerate(texts):
+            metadata = metadatas[i] if metadatas else {}
+
+            request: Dict[str, Any] = {
+                "_op_type": "index",
+                "_index": self.index,
+                self.text_field: text,
+                "metadata": metadata,
+                "_id": ids[i],
+            }
+
+            if vectors:
+                request[self.vector_field] = vectors[i]
+
+            requests.append(request)
+
+        if len(requests) > 0:
+            try:
+                success, failed = bulk(
+                    self.client,
+                    requests,
+                    stats_only=True,
+                    refresh=refresh_indices,
+                    **bulk_kwargs,
+                )
+                logger.debug(f"added texts {ids} to index")
+                return ids
+            except BulkIndexError as e:
+                logger.error(f"Error adding texts: {e}")
+                firstError = e.errors[0].get("index", {}).get("error", {})
+                logger.error(f"First error reason: {firstError.get('reason')}")
+                raise e
+
+        else:
+            logger.debug("No texts to add to index")
+            return []
+
+    def delete(  # type: ignore[no-untyped-def]
+        self,
+        *,
+        ids: Optional[List[str]] = None,
+        query: Optional[Dict[str, Any]] = None,
+        refresh_indices: bool = True,
+        **delete_kwargs,
+    ) -> bool:
+        """Delete documents from the Elasticsearch index.
+
+        :param ids: List of IDs of documents to delete.
+        :param refresh_indices: Whether to refresh the index after deleting documents.
+            Defaults to True.
+
+        :return: True if deletion was successful.
+        """
+        if ids is not None and query is not None:
+            raise ValueError("one of ids or query must be specified")
+        elif ids is None and query is None:
+            raise ValueError("either specify ids or query")
+
+        try:
+            if ids:
+                body = [
+                    {"_op_type": "delete", "_index": self.index, "_id": _id}
+                    for _id in ids
+                ]
+                bulk(
+                    self.client,
+                    body,
+                    refresh=refresh_indices,
+                    ignore_status=404,
+                    **delete_kwargs,
+                )
+                logger.debug(f"Deleted {len(body)} texts from index")
+
+            else:
+                self.client.delete_by_query(
+                    index=self.index,
+                    query=query,
+                    refresh=refresh_indices,
+                    **delete_kwargs,
+                )
+
+        except BulkIndexError as e:
+            logger.error(f"Error deleting texts: {e}")
+            firstError = e.errors[0].get("index", {}).get("error", {})
+            logger.error(f"First error reason: {firstError.get('reason')}")
+            raise e
+
+        return True
+
+    def search(
+        self,
+        *,
+        query: Optional[str],
+        query_vector: Optional[List[float]] = None,
+        k: int = 4,
+        num_candidates: int = 50,
+        fields: Optional[List[str]] = None,
+        filter: Optional[List[Dict[str, Any]]] = None,
+        custom_query: Optional[
+            Callable[[Dict[str, Any], Optional[str]], Dict[str, Any]]
+        ] = None,
+    ) -> List[Dict[str, Any]]:
+        """
+        :param query: Input query string.
+        :param query_vector: Input embedding vector. If given, input query string is
+            ignored.
+        :param k: Number of returned results.
+        :param num_candidates: Number of candidates to fetch from data nodes in knn.
+        :param fields: List of field names to return.
+        :param filter: Elasticsearch filters to apply.
+        :param custom_query: Function to modify the Elasticsearch query body before it is
+            sent to Elasticsearch.
+
+        :return: List of document hits. Includes _index, _id, _score and _source.
+        """
+        if fields is None:
+            fields = []
+        if "metadata" not in fields:
+            fields.append("metadata")
+        if self.text_field not in fields:
+            fields.append(self.text_field)
+
+        if self.embedding_service and not query_vector:
+            if not query:
+                raise ValueError("specify a query or a query_vector to search")
+            query_vector = self.embedding_service.embed_query(query)
+
+        query_body = self.retrieval_strategy.es_query(
+            query=query,
+            query_vector=query_vector,
+            text_field=self.text_field,
+            vector_field=self.vector_field,
+            k=k,
+            num_candidates=num_candidates,
+            filter=filter or [],
+        )
+
+        if custom_query is not None:
+            query_body = custom_query(query_body, query)
+            logger.debug(f"Calling custom_query, Query body now: {query_body}")
+
+        response = self.client.search(
+            index=self.index,
+            **query_body,
+            size=k,
+            source=True,
+            source_includes=fields,
+        )
+        hits: List[Dict[str, Any]] = response["hits"]["hits"]
+
+        return hits
+
+    def _create_index_if_not_exists(self) -> None:
+        exists = self.client.indices.exists(index=self.index)
+        if exists.meta.status == 200:
+            logger.debug(f"Index {self.index} already exists. Skipping creation.")
+            return
+
+        if self.retrieval_strategy.needs_inference():
+            if not self.num_dimensions and not self.embedding_service:
+                raise ValueError(
+                    "retrieval strategy requires embeddings; either embedding_service "
+                    "or num_dimensions need to be specified"
+                )
+            if not self.num_dimensions and self.embedding_service:
+                vector = self.embedding_service.embed_query("get num dimensions")
+                self.num_dimensions = len(vector)
+
+        mappings, settings = self.retrieval_strategy.es_mappings_settings(
+            text_field=self.text_field,
+            vector_field=self.vector_field,
+            num_dimensions=self.num_dimensions,
+        )
+        if self.metadata_mappings:
+            metadata = mappings["properties"].get("metadata", {"properties": {}})
+            for key in self.metadata_mappings.keys():
+                if key in metadata:
+                    raise ValueError(f"metadata key {key} already exists in mappings")
+
+            metadata = dict(**metadata["properties"], **self.metadata_mappings)
+            mappings["properties"]["metadata"] = {"properties": metadata}
+
+        self.retrieval_strategy.before_index_creation(
+            client=self.client,
+            text_field=self.text_field,
+            vector_field=self.vector_field,
+        )
+        self.client.indices.create(
+            index=self.index, mappings=mappings, settings=settings
+        )
+
+    def max_marginal_relevance_search(
+        self,
+        *,
+        embedding_service: EmbeddingService,
+        query: str,
+        vector_field: str,
+        k: int = 4,
+        num_candidates: int = 20,
+        lambda_mult: float = 0.5,
+        fields: Optional[List[str]] = None,
+        custom_query: Optional[
+            Callable[[Dict[str, Any], Optional[str]], Dict[str, Any]]
+        ] = None,
+    ) -> List[Dict[str, Any]]:
+        """Return docs selected using the maximal marginal relevance.
+
+        Maximal marginal relevance optimizes for similarity to query AND diversity
+            among selected documents.
+
+        :param query (str): Text to look up documents similar to.
+        :param k (int): Number of Documents to return. Defaults to 4.
+        :param fetch_k (int): Number of Documents to fetch to pass to MMR algorithm.
+        :param 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.
+        :param fields: Other fields to get from elasticsearch source. These fields
+            will be added to the document metadata.
+
+        :return: A list of Documents selected by maximal marginal relevance.
+        """
+        remove_vector_query_field_from_metadata = True
+        if fields is None:
+            fields = [vector_field]
+        elif vector_field not in fields:
+            fields.append(vector_field)
+        else:
+            remove_vector_query_field_from_metadata = False
+
+        # Embed the query
+        query_embedding = embedding_service.embed_query(query)
+
+        # Fetch the initial documents
+        got_hits = self.search(
+            query=None,
+            query_vector=query_embedding,
+            k=num_candidates,
+            fields=fields,
+            custom_query=custom_query,
+        )
+
+        # Get the embeddings for the fetched documents
+        got_embeddings = [hit["_source"][vector_field] for hit in got_hits]
+
+        # Select documents using maximal marginal relevance
+        selected_indices = maximal_marginal_relevance(
+            query_embedding, got_embeddings, lambda_mult=lambda_mult, k=k
+        )
+        selected_hits = [got_hits[i] for i in selected_indices]
+
+        if remove_vector_query_field_from_metadata:
+            for hit in selected_hits:
+                del hit["_source"][vector_field]
+
+        return selected_hits

elasticsearch/helpers/vectorstore/_utils.py

@@ -0,0 +1,116 @@
+#  Licensed to Elasticsearch B.V. under one or more contributor
+#  license agreements. See the NOTICE file distributed with
+#  this work for additional information regarding copyright
+#  ownership. Elasticsearch B.V. licenses this file to you under
+#  the Apache License, Version 2.0 (the "License"); you may
+#  not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+# 	http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing,
+#  software distributed under the License is distributed on an
+#  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+#  KIND, either express or implied.  See the License for the
+#  specific language governing permissions and limitations
+#  under the License.
+
+from enum import Enum
+from typing import TYPE_CHECKING, List, Union
+
+if TYPE_CHECKING:
+    import numpy as np
+    import numpy.typing as npt
+
+Matrix = Union[
+    List[List[float]], List["npt.NDArray[np.float64]"], "npt.NDArray[np.float64]"
+]
+
+
+class DistanceMetric(str, Enum):
+    """Enumerator of all Elasticsearch dense vector distance metrics."""
+
+    COSINE = "COSINE"
+    DOT_PRODUCT = "DOT_PRODUCT"
+    EUCLIDEAN_DISTANCE = "EUCLIDEAN_DISTANCE"
+    MAX_INNER_PRODUCT = "MAX_INNER_PRODUCT"
+
+
+def maximal_marginal_relevance(
+    query_embedding: List[float],
+    embedding_list: List[List[float]],
+    lambda_mult: float = 0.5,
+    k: int = 4,
+) -> List[int]:
+    """Calculate maximal marginal relevance."""
+
+    try:
+        import numpy as np
+    except ModuleNotFoundError as e:
+        _raise_missing_mmr_deps_error(e)
+
+    query_embedding_arr = np.array(query_embedding)
+
+    if min(k, len(embedding_list)) <= 0:
+        return []
+    if query_embedding_arr.ndim == 1:
+        query_embedding_arr = np.expand_dims(query_embedding_arr, axis=0)
+    similarity_to_query = _cosine_similarity(query_embedding_arr, embedding_list)[0]
+    most_similar = int(np.argmax(similarity_to_query))
+    idxs = [most_similar]
+    selected = np.array([embedding_list[most_similar]])
+    while len(idxs) < min(k, len(embedding_list)):
+        best_score = -np.inf
+        idx_to_add = -1
+        similarity_to_selected = _cosine_similarity(embedding_list, selected)
+        for i, query_score in enumerate(similarity_to_query):
+            if i in idxs:
+                continue
+            redundant_score = max(similarity_to_selected[i])
+            equation_score = (
+                lambda_mult * query_score - (1 - lambda_mult) * redundant_score
+            )
+            if equation_score > best_score:
+                best_score = equation_score
+                idx_to_add = i
+        idxs.append(idx_to_add)
+        selected = np.append(selected, [embedding_list[idx_to_add]], axis=0)
+    return idxs
+
+
+def _cosine_similarity(X: Matrix, Y: Matrix) -> "npt.NDArray[np.float64]":
+    """Row-wise cosine similarity between two equal-width matrices."""
+
+    try:
+        import numpy as np
+        import simsimd as simd
+    except ModuleNotFoundError as e:
+        _raise_missing_mmr_deps_error(e)
+
+    if len(X) == 0 or len(Y) == 0:
+        return np.array([])
+
+    X = np.array(X)
+    Y = np.array(Y)
+    if X.shape[1] != Y.shape[1]:
+        raise ValueError(
+            f"Number of columns in X and Y must be the same. X has shape {X.shape} "
+            f"and Y has shape {Y.shape}."
+        )
+
+    X = np.array(X, dtype=np.float32)
+    Y = np.array(Y, dtype=np.float32)
+    Z = 1 - np.array(simd.cdist(X, Y, metric="cosine"))
+    if isinstance(Z, float):
+        return np.array([Z])
+    return np.array(Z)
+
+
+def _raise_missing_mmr_deps_error(parent_error: ModuleNotFoundError) -> None:
+    import sys
+
+    raise ModuleNotFoundError(
+        f"Failed to compute maximal marginal relevance because the required "
+        f"module '{parent_error.name}' is missing. You can install it by running: "
+        f"'{sys.executable} -m pip install elasticsearch[vectorstore_mmr]'"
+    ) from parent_error

{elasticsearch-8.13.0.dist-info → elasticsearch-8.13.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: elasticsearch
-Version: 8.13.0
+Version: 8.13.2
 Summary: Python client for Elasticsearch
 Home-page: https://github.com/elastic/elasticsearch-py
 Author: Elastic Client Library Maintainers
@@ -33,7 +33,10 @@ Requires-Dist: aiohttp <4,>=3 ; extra == 'async'
 Provides-Extra: orjson
 Requires-Dist: orjson >=3 ; extra == 'orjson'
 Provides-Extra: requests
-Requires-Dist: requests <3.0.0,>=2.4.0 ; extra == 'requests'
+Requires-Dist: requests !=2.32.2,<3.0.0,>=2.4.0 ; extra == 'requests'
+Provides-Extra: vectorstore_mmr
+Requires-Dist: numpy >=1 ; extra == 'vectorstore_mmr'
+Requires-Dist: simsimd >=3 ; extra == 'vectorstore_mmr'
 
 
 Elasticsearch Python Client

{elasticsearch-8.13.0.dist-info → elasticsearch-8.13.2.dist-info}/RECORD

@@ -1,7 +1,7 @@
 elasticsearch/__init__.py,sha256=w5YnO16zjOi6loGJ8caUgSXsj3b-Y8OfF0BIddP2BiE,3289
 elasticsearch/_otel.py,sha256=9nMvDwSz_BephEQmkETCmEdA_6YNtj_CJQyxIwOzEGo,3406
 elasticsearch/_utils.py,sha256=Vr_aNG5ddxInE1PgDpCXMYpXBTNUFM9nYrgbw-cjeCc,1419
-elasticsearch/_version.py,sha256=Lp8EDhh_IQC-4TsKLVoxITi9477dKtzhiHxVnTJDGKw,814
+elasticsearch/_version.py,sha256=0P-o-HdbMQa0vGhTZYE8ZkuZ9v7zXoV3M6M0wUoqfrs,814
 elasticsearch/client.py,sha256=p4naAgAPs_B9laux-aC-bpZNvbu9fvrpicBvLRlp_yw,5120
 elasticsearch/compat.py,sha256=hL3mtqVxWwxeiFbNGADva5XruAwK-A6xcu-vrpnDXFs,2657
 elasticsearch/exceptions.py,sha256=HHqidMTlLXRcNbo4gjsbhHsLfiV4JGg7tx1lXQndG98,4025
@@ -10,7 +10,7 @@ elasticsearch/serializer.py,sha256=hPBqMHweVES7ixgKhe5KMMQGAdDamzW-PAn7jX8uqcs,7
 elasticsearch/transport.py,sha256=CxKo2USPQ-6q4x8Ckfq_dUFWhA1s98p75ghXc3breJI,2248
 elasticsearch/_async/__init__.py,sha256=TZps9WjF-TaSNzBvW5wUCgXRcbHnvE_9xAynBHsMtSo,787
 elasticsearch/_async/helpers.py,sha256=vX2oGiYHO5raZJOnTMEX9hViPNy1YW26IeS60gbhNno,22285
-elasticsearch/_async/client/__init__.py,sha256=ediCBxNjK-SfTNNHciBLOPDcsITFz9lfWdDPEWD8PIM,238829
+elasticsearch/_async/client/__init__.py,sha256=0JS0lH4tghGRfN5I2TiUv6f0VsF4et_cCD3lD7vDFao,240323
 elasticsearch/_async/client/_base.py,sha256=wDJIs-4Z_fDBF0_XvfCmfSuyL6Oh8I2nSGDZyP91XCU,15531
 elasticsearch/_async/client/async_search.py,sha256=bv2GC_5ZPX3HpOHCJLf7-CzjPxEQSyhWTlbn7K40ODY,29238
 elasticsearch/_async/client/autoscaling.py,sha256=eV4PGsQc3F-ykw8nRfRZcjD0Xr_0eo1oFbOh5nBBvok,7741
@@ -31,14 +31,14 @@ elasticsearch/_async/client/ingest.py,sha256=5V8fur9z4Vkv4p-3geOfc1ek5N8qJ6CvWbd
 elasticsearch/_async/client/license.py,sha256=kuqW-yfOVdsDHh5puu7_tD_LN7JU0Axt0AtE5ttx8jc,12100
 elasticsearch/_async/client/logstash.py,sha256=JrvbrTi9sCO-GzOe3lBWcaIOPkYFqzenCkYw_B6JW7Q,6127
 elasticsearch/_async/client/migration.py,sha256=It0NTjXaN-UW8keaNURglL4rYbOmAvTbHD7QlFBOJg4,5331
-elasticsearch/_async/client/ml.py,sha256=dAgtPql-fTGX-wS2IYbVemSAm2m-CuDxhakNDpHn3pg,238218
+elasticsearch/_async/client/ml.py,sha256=tckls24jxPSOb_OA3f6plc0DDLfKhwddhpAoVfyr0gU,241082
 elasticsearch/_async/client/monitoring.py,sha256=ZQSiQ8AXfu_8_--cHOpfhjpsQkQZekmBlPiOLAYotpw,3822
 elasticsearch/_async/client/nodes.py,sha256=xmLfm0cPsQSjH_WKyzGKHI6IhgT9gKhj3XrsJdTXL5w,23723
 elasticsearch/_async/client/query_ruleset.py,sha256=vBgpKRYL0X7giU05Vw6-pXre10W81zGoALWL_XAnkRM,7606
 elasticsearch/_async/client/rollup.py,sha256=g_zc1KwIW9Bms2XPO0jkaqhrDGVy05WvA1pYYBfgyLc,20828
 elasticsearch/_async/client/search_application.py,sha256=2UWgrM69Ai-O6oMbBrUxmW9BBBdTDI_UPGFzW86wIFU,15047
 elasticsearch/_async/client/searchable_snapshots.py,sha256=WsRPKq-ZjFwt7nj6GPCib1RwR7f5YG-Qo58BgZxJpqc,11694
-elasticsearch/_async/client/security.py,sha256=Y0exmFNOQ7k6Yd2iDDyw6Xn8cnEjLPWW27HQ2sYmSrE,128262
+elasticsearch/_async/client/security.py,sha256=OJ7vXLuIja8VGHZIxteLjuEcMaLyfKUGOi75f-N54Eo,129415
 elasticsearch/_async/client/shutdown.py,sha256=Ckk_YcGy1yO2PuD0LDIulxkFFcmx4t7V3z_thRUWkEw,11364
 elasticsearch/_async/client/slm.py,sha256=lVnfb9LERioxR9frUwZA6l9UZaQcb3sYzBBLo1fuimE,16150
 elasticsearch/_async/client/snapshot.py,sha256=c6FSTngRw5PQK1UEFlA_vXPZOmbHMFi9FtT63y_mbbE,37085
@@ -52,7 +52,7 @@ elasticsearch/_async/client/utils.py,sha256=JwFOxo-YrRg4exXlpiUuOG1uNtJKP_VeK0Hg
 elasticsearch/_async/client/watcher.py,sha256=rp8cX_RgvpPp0Zny0fXPQ6Tx-oik2l3y38z1n8b4h44,25760
 elasticsearch/_async/client/xpack.py,sha256=yNFQduIcpIfbvY2-spbOOoQWQbKl0yx71mB-tMV9Sic,4490
 elasticsearch/_sync/__init__.py,sha256=TZps9WjF-TaSNzBvW5wUCgXRcbHnvE_9xAynBHsMtSo,787
-elasticsearch/_sync/client/__init__.py,sha256=joiHRd3s53SDrUyGFNfl3KCD_-Tzhr3WbvD6YRzpkG0,238198
+elasticsearch/_sync/client/__init__.py,sha256=WhHCGYW8u7czxp1LTiqC6DMgwzM5DocqP_i8mCkvr3k,239692
 elasticsearch/_sync/client/_base.py,sha256=LesRKQzvgstEPn-hzoY7PBq_4hAyPCzjGiUggGn-fB8,15461
 elasticsearch/_sync/client/async_search.py,sha256=miChWFtoXb8UhC4mrfzcM0vXxxOAoHsno1zJVey2vHM,29190
 elasticsearch/_sync/client/autoscaling.py,sha256=eSNyAXvp7TkYTVthPd8ez5UpCq_UrAYVEWGQw0cjriI,7693
@@ -73,14 +73,14 @@ elasticsearch/_sync/client/ingest.py,sha256=UY-x1MXjnD2LkbX8O2qa5Ag6eD4lzf4LeZO8
 elasticsearch/_sync/client/license.py,sha256=tEc366OvzPh9OFbgCMAo8dyw7wjajIcNQyfAX-uin3I,12016
 elasticsearch/_sync/client/logstash.py,sha256=2Mpd3y-wNR3H7wsFW2riiB6bbobctNoMW22VOvDbN2s,6091
 elasticsearch/_sync/client/migration.py,sha256=dJ27K1SLcJn4XyBvyPFVocjxHtsAyf2vuOQl52uxK64,5295
-elasticsearch/_sync/client/ml.py,sha256=5Y5ETcS2mTFZ7he2escEosL634NVWITcB31g9Xhj-9Q,237354
+elasticsearch/_sync/client/ml.py,sha256=7YgW9g5MQ4KUhI05X_mp7zDHwmRhDAXc0UahK_7qmwM,240206
 elasticsearch/_sync/client/monitoring.py,sha256=Wh2RTfFOOm5ssbdGv0_gSDS2og1L8ATJamLuUuNrBYU,3810
 elasticsearch/_sync/client/nodes.py,sha256=YloTg5V90lyGeoY_XU_2X2aeLHOpPss1g7Kp0hR2EF4,23639
 elasticsearch/_sync/client/query_ruleset.py,sha256=dRzaVZVYLtlRi6PJVGQTPXCKCJuuf6fkU6wug-zmmXs,7558
 elasticsearch/_sync/client/rollup.py,sha256=ow9wty2HE3doDEMcg-krKWmbgDsAD6brZe6IuenlV94,20732
 elasticsearch/_sync/client/search_application.py,sha256=QWZqLxnaNo7XDg1xQPa0dY2j8LiJn03DDxiygJirqEc,14951
 elasticsearch/_sync/client/searchable_snapshots.py,sha256=ehDowrZcltn4DJUkswyTOXk16QxVHdnid1fb_SdZ9UY,11646
-elasticsearch/_sync/client/security.py,sha256=PyH1zVhnhLzh9CbpqiRPgqiP3sQ_3PVHtSNR33pYwIs,127650
+elasticsearch/_sync/client/security.py,sha256=P8hvujP7dJYA1xsmbcLRQVmR586qRMgIHEn3p-QECs8,128803
 elasticsearch/_sync/client/shutdown.py,sha256=YWT70DR1u4wBh1kKAtO-9hkJTm8OrYfTuUiLshwxebM,11328
 elasticsearch/_sync/client/slm.py,sha256=WaMu3iQtftjelmfHyZUExLpzfkwJKS-iR218VZzPOiA,16042
 elasticsearch/_sync/client/snapshot.py,sha256=pB1Gsv2kmmb-uyLlSRdd0K-g2B7xCFojyk3KgGsu7a0,36953
@@ -96,9 +96,21 @@ elasticsearch/_sync/client/xpack.py,sha256=PzQCp2i4nNzCtV1HGtLYuwqUDGnIe4On7f2Wy
 elasticsearch/helpers/__init__.py,sha256=7X10XwdP_fP1QTHGcOxGbCvl2oBevkz_DjhjXCh_59I,1470
 elasticsearch/helpers/actions.py,sha256=oEVAqOjWBn9PLFPpdIEBb5BMKLgN4mi7EozEcOqb4us,30956
 elasticsearch/helpers/errors.py,sha256=GKtlM2687mbBC8PjwQGClBFE4sD129Ytb6wkHZveFJw,1213
-elasticsearch-8.13.0.dist-info/LICENSE,sha256=XfKg2H1sVi8OoRxoisUlMqoo10TKvHmU_wU39ks7MyA,10143
-elasticsearch-8.13.0.dist-info/METADATA,sha256=CVwUDGf0Fu641Z7gq3WDx-YN3LjB5V4dYoqOyUcJsak,6313
-elasticsearch-8.13.0.dist-info/NOTICE,sha256=t4IjKAJ_G-0hYaL4AH16CVS_xDel8UXrJVK6x7JDaGA,61
-elasticsearch-8.13.0.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-elasticsearch-8.13.0.dist-info/top_level.txt,sha256=Jp2bLWq49skvCN4YCZsg1Hfn_NDLgleC-x-Bn01_HgM,14
-elasticsearch-8.13.0.dist-info/RECORD,,
+elasticsearch/helpers/vectorstore/__init__.py,sha256=znQOANiaSZOJco_dkBf06wpFMKwK0OoDcNkkS8NMWKE,2192
+elasticsearch/helpers/vectorstore/_utils.py,sha256=xJwCFq7sqUBeq143tfnfm3i4e-ta88s85wKZmPZwJWg,3985
+elasticsearch/helpers/vectorstore/_async/__init__.py,sha256=TZps9WjF-TaSNzBvW5wUCgXRcbHnvE_9xAynBHsMtSo,787
+elasticsearch/helpers/vectorstore/_async/_utils.py,sha256=wYlPKvAT4bflJjULLB2LMjJroAgX6tjoDGBPT6V1gj8,1608
+elasticsearch/helpers/vectorstore/_async/embedding_service.py,sha256=Qv4HsPC4k6J00K4ajhJPFlET6fOTV-l74iDCr4dpZgc,3655
+elasticsearch/helpers/vectorstore/_async/strategies.py,sha256=nh_wvNfWmZIjbTQ38FGSkUeF4_yDk48zukNuhOkq9bE,15322
+elasticsearch/helpers/vectorstore/_async/vectorstore.py,sha256=YiwiNJsslVPmfrqB5jpkNchHKoGGZLdz_tieHMR0Jpk,15161
+elasticsearch/helpers/vectorstore/_sync/__init__.py,sha256=TZps9WjF-TaSNzBvW5wUCgXRcbHnvE_9xAynBHsMtSo,787
+elasticsearch/helpers/vectorstore/_sync/_utils.py,sha256=5pdvNS5XC3wqShjliW9Njl9tVuyI9WMy0cxc5-97K-c,1569
+elasticsearch/helpers/vectorstore/_sync/embedding_service.py,sha256=sAw_WKUcmyqOOJRqnNesZCzn7ZyA91v4NvvQszHIWJ8,3582
+elasticsearch/helpers/vectorstore/_sync/strategies.py,sha256=0Q1zoOrO51S6HXjXwkAePPVtCUGQz5lKN9NyRCso-GU,15220
+elasticsearch/helpers/vectorstore/_sync/vectorstore.py,sha256=MqTDeHyG4NS9gInxwljh4J0QVvS499SajQ22fe1UpLs,14970
+elasticsearch-8.13.2.dist-info/LICENSE,sha256=XfKg2H1sVi8OoRxoisUlMqoo10TKvHmU_wU39ks7MyA,10143
+elasticsearch-8.13.2.dist-info/METADATA,sha256=Eex24ZRMP8r810PL3irLjbwO0c_KeWgszymGV2Q6k8M,6464
+elasticsearch-8.13.2.dist-info/NOTICE,sha256=t4IjKAJ_G-0hYaL4AH16CVS_xDel8UXrJVK6x7JDaGA,61
+elasticsearch-8.13.2.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+elasticsearch-8.13.2.dist-info/top_level.txt,sha256=Jp2bLWq49skvCN4YCZsg1Hfn_NDLgleC-x-Bn01_HgM,14
+elasticsearch-8.13.2.dist-info/RECORD,,