qdrant-haystack 3.8.0__py3-none-any.whl → 4.0.0__py3-none-any.whl

haystack_integrations/components/retrievers/qdrant/retriever.py

@@ -37,7 +37,7 @@ class QdrantEmbeddingRetriever:
         document_store: QdrantDocumentStore,
         filters: Optional[Union[Dict[str, Any], models.Filter]] = None,
         top_k: int = 10,
-        scale_score: bool = True,
+        scale_score: bool = False,
         return_embedding: bool = False,
     ):
         """
@@ -159,7 +159,7 @@ class QdrantSparseEmbeddingRetriever:
         document_store: QdrantDocumentStore,
         filters: Optional[Union[Dict[str, Any], models.Filter]] = None,
         top_k: int = 10,
-        scale_score: bool = True,
+        scale_score: bool = False,
         return_embedding: bool = False,
     ):
         """

haystack_integrations/document_stores/qdrant/converters.py

@@ -17,7 +17,6 @@ UUID_NAMESPACE = uuid.UUID("3896d314-1e95-4a3a-b45a-945f9f0b541d")
 def convert_haystack_documents_to_qdrant_points(
     documents: List[Document],
     *,
-    embedding_field: str,
     use_sparse_embeddings: bool,
 ) -> List[rest.PointStruct]:
     points = []
@@ -26,7 +25,7 @@ def convert_haystack_documents_to_qdrant_points(
         if use_sparse_embeddings:
             vector = {}
 
-            dense_vector = payload.pop(embedding_field, None)
+            dense_vector = payload.pop("embedding", None)
             if dense_vector is not None:
                 vector[DENSE_VECTORS_NAME] = dense_vector
 
@@ -36,7 +35,7 @@ def convert_haystack_documents_to_qdrant_points(
                 vector[SPARSE_VECTORS_NAME] = sparse_vector_instance
 
         else:
-            vector = payload.pop(embedding_field) or {}
+            vector = payload.pop("embedding") or {}
         _id = convert_id(payload.get("id"))
 
         point = rest.PointStruct(

haystack_integrations/document_stores/qdrant/document_store.py

@@ -49,6 +49,44 @@ def get_batches_from_generator(iterable, n):
 
 
 class QdrantDocumentStore:
+    """
+    QdrantDocumentStore is a Document Store for Qdrant.
+    It can be used with any Qdrant instance: in-memory, disk-persisted, Docker-based,
+    and Qdrant Cloud Cluster deployments.
+
+    Usage example by creating an in-memory instance:
+
+    ```python
+    from haystack.dataclasses.document import Document
+    from haystack_integrations.document_stores.qdrant import QdrantDocumentStore
+
+    document_store = QdrantDocumentStore(
+        ":memory:",
+        recreate_index=True
+    )
+    document_store.write_documents([
+        Document(content="This is first", embedding=[0.0]*5),
+        Document(content="This is second", embedding=[0.1, 0.2, 0.3, 0.4, 0.5])
+    ])
+    ```
+
+    Usage example with Qdrant Cloud:
+
+    ```python
+    from haystack.dataclasses.document import Document
+    from haystack_integrations.document_stores.qdrant import QdrantDocumentStore
+
+    document_store = QdrantDocumentStore(
+            url="https://xxxxxx-xxxxx-xxxxx-xxxx-xxxxxxxxx.us-east.aws.cloud.qdrant.io:6333",
+        api_key="<your-api-key>",
+    )
+    document_store.write_documents([
+        Document(content="This is first", embedding=[0.0]*5),
+        Document(content="This is second", embedding=[0.1, 0.2, 0.3, 0.4, 0.5])
+    ])
+    ```
+    """
+
     SIMILARITY: ClassVar[Dict[str, str]] = {
         "cosine": rest.Distance.COSINE,
         "dot_product": rest.Distance.DOT,
@@ -72,14 +110,10 @@ class QdrantDocumentStore:
         index: str = "Document",
         embedding_dim: int = 768,
         on_disk: bool = False,
-        content_field: str = "content",
-        name_field: str = "name",
-        embedding_field: str = "embedding",
         use_sparse_embeddings: bool = False,
         similarity: str = "cosine",
         return_embedding: bool = False,
         progress_bar: bool = True,
-        duplicate_documents: str = "overwrite",
         recreate_index: bool = False,
         shard_number: Optional[int] = None,
         replication_factor: Optional[int] = None,
@@ -96,6 +130,90 @@ class QdrantDocumentStore:
         scroll_size: int = 10_000,
         payload_fields_to_index: Optional[List[dict]] = None,
     ):
+        """
+        :param location:
+            If `memory` - use in-memory Qdrant instance.
+            If `str` - use it as a URL parameter.
+            If `None` - use default values for host and port.
+        :param url:
+            Either host or str of `Optional[scheme], host, Optional[port], Optional[prefix]`.
+        :param port:
+            Port of the REST API interface.
+        :param grpc_port:
+            Port of the gRPC interface.
+        :param prefer_grpc:
+            If `True` - use gRPC interface whenever possible in custom methods.
+        :param https:
+            If `True` - use HTTPS(SSL) protocol.
+        :param api_key:
+            API key for authentication in Qdrant Cloud.
+        :param prefix:
+            If not `None` - add prefix to the REST URL path.
+            Example: service/v1 will result in http://localhost:6333/service/v1/{qdrant-endpoint}
+            for REST API.
+        :param timeout:
+            Timeout for REST and gRPC API requests.
+        :param host:
+            Host name of Qdrant service. If ùrl` and `host` are `None`, set to `localhost`.
+        :param path:
+            Persistence path for QdrantLocal.
+        :param force_disable_check_same_thread:
+            For QdrantLocal, force disable check_same_thread.
+            Only use this if you can guarantee that you can resolve the thread safety outside QdrantClient.
+        :param index:
+            Name of the index.
+        :param embedding_dim:
+            Dimension of the embeddings.
+        :param on_disk:
+            Whether to store the collection on disk.
+        :param use_sparse_embedding:
+            If set to `True`, enables support for sparse embeddings.
+        :param similarity:
+            The similarity metric to use.
+        :param return_embedding:
+            Whether to return embeddings in the search results.
+        :param progress_bar:
+            Whether to show a progress bar or not.
+        :param recreate_index:
+            Whether to recreate the index.
+        :param shard_number:
+            Number of shards in the collection.
+        :param replication_factor:
+            Replication factor for the collection.
+            Defines how many copies of each shard will be created. Effective only in distributed mode.
+        :param write_consistency_factor:
+            Write consistency factor for the collection. Minimum value is 1.
+            Defines how many replicas should apply to the operation for it to be considered successful.
+            Increasing this number makes the collection more resilient to inconsistencies
+            but will cause failures if not enough replicas are available.
+            Effective only in distributed mode.
+        :param on_disk_payload:
+            If `True`, the point's payload will not be stored in memory and
+            will be read from the disk every time it is requested.
+            This setting saves RAM by slightly increasing response time.
+            Note: indexed payload values remain in RAM.
+        :param hnsw_config:
+            Params for HNSW index.
+        :param optimizers_config:
+            Params for optimizer.
+        :param wal_config:
+            Params for Write-Ahead-Log.
+        :param quantization_config:
+            Params for quantization. If `None`, quantization will be disabled.
+        :param init_from:
+            Use data stored in another collection to initialize this collection.
+        :param wait_result_from_api:
+            Whether to wait for the result from the API after each request.
+        :param metadata:
+            Additional metadata to include with the documents.
+        :param write_batch_size:
+            The batch size for writing documents.
+        :param scroll_size:
+            The scroll size for reading documents.
+        :param payload_fields_to_index:
+            List of payload fields to index.
+        """
+
         self._client = None
 
         # Store the Qdrant client specific attributes
@@ -130,14 +248,10 @@ class QdrantDocumentStore:
         self.use_sparse_embeddings = use_sparse_embeddings
         self.embedding_dim = embedding_dim
         self.on_disk = on_disk
-        self.content_field = content_field
-        self.name_field = name_field
-        self.embedding_field = embedding_field
         self.similarity = similarity
         self.index = index
         self.return_embedding = return_embedding
         self.progress_bar = progress_bar
-        self.duplicate_documents = duplicate_documents
         self.write_batch_size = write_batch_size
         self.scroll_size = scroll_size
 
@@ -172,6 +286,9 @@ class QdrantDocumentStore:
         return self._client
 
     def count_documents(self) -> int:
+        """
+        Returns the number of documents present in the Document Store.
+        """
         try:
             response = self.client.count(
                 collection_name=self.index,
@@ -187,6 +304,15 @@ class QdrantDocumentStore:
         self,
         filters: Optional[Union[Dict[str, Any], rest.Filter]] = None,
     ) -> List[Document]:
+        """
+        Returns the documents that match the provided filters.
+
+        For a detailed specification of the filters, refer to the
+        [documentation](https://docs.haystack.deepset.ai/docs/metadata-filtering)
+
+        :param filters: The filters to apply to the document list.
+        :returns: A list of documents that match the given filters.
+        """
         if filters and not isinstance(filters, dict) and not isinstance(filters, rest.Filter):
             msg = "Filter must be a dictionary or an instance of `qdrant_client.http.models.Filter`"
             raise ValueError(msg)
@@ -204,6 +330,19 @@ class QdrantDocumentStore:
         documents: List[Document],
         policy: DuplicatePolicy = DuplicatePolicy.FAIL,
     ):
+        """
+        Writes documents to Qdrant using the specified policy.
+        The QdrantDocumentStore can handle duplicate documents based on the given policy.
+        The available policies are:
+        - `FAIL`: The operation will raise an error if any document already exists.
+        - `OVERWRITE`: Existing documents will be overwritten with the new ones.
+        - `SKIP`: Existing documents will be skipped, and only new documents will be added.
+
+        :param documents: A list of Document objects to write to Qdrant.
+        :param policy: The policy for handling duplicate documents.
+
+        :returns: The number of documents written to the document store.
+        """
         for doc in documents:
             if not isinstance(doc, Document):
                 msg = f"DocumentStore.write_documents() expects a list of Documents but got an element of {type(doc)}."
@@ -225,7 +364,6 @@ class QdrantDocumentStore:
             for document_batch in batched_documents:
                 batch = convert_haystack_documents_to_qdrant_points(
                     document_batch,
-                    embedding_field=self.embedding_field,
                     use_sparse_embeddings=self.use_sparse_embeddings,
                 )
 
@@ -239,6 +377,11 @@ class QdrantDocumentStore:
         return len(document_objects)
 
     def delete_documents(self, ids: List[str]):
+        """
+        Deletes documents that match the provided `document_ids` from the document store.
+
+        :param document_ids: the document ids to delete
+        """
         ids = [convert_id(_id) for _id in ids]
         try:
             self.client.delete(
@@ -253,10 +396,24 @@ class QdrantDocumentStore:
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> "QdrantDocumentStore":
+        """
+        Deserializes the component from a dictionary.
+
+        :param data:
+            The dictionary to deserialize from.
+        :returns:
+            The deserialized component.
+        """
         deserialize_secrets_inplace(data["init_parameters"], keys=["api_key"])
         return default_from_dict(cls, data)
 
     def to_dict(self) -> Dict[str, Any]:
+        """
+        Serializes the component to a dictionary.
+
+        :returns:
+            Dictionary with serialized data.
+        """
         params = inspect.signature(self.__init__).parameters  # type: ignore
         # All the __init__ params must be set as attributes
         # Set as init_parms without default values
@@ -271,6 +428,13 @@ class QdrantDocumentStore:
         self,
         filters: Optional[Union[Dict[str, Any], rest.Filter]] = None,
     ) -> Generator[Document, None, None]:
+        """
+        Returns a generator that yields documents from Qdrant based on the provided filters.
+
+        :param filters: Filters applied to the retrieved documents.
+        :returns: A generator that yields documents retrieved from Qdrant.
+        """
+
         index = self.index
         qdrant_filters = convert_filters_to_qdrant(filters)
 
@@ -299,6 +463,16 @@ class QdrantDocumentStore:
         ids: List[str],
         index: Optional[str] = None,
     ) -> List[Document]:
+        """
+        Retrieves documents from Qdrant by their IDs.
+
+        :param ids:
+            A list of document IDs to retrieve.
+        :param index:
+            The name of the index to retrieve documents from.
+        :returns:
+            A list of documents.
+        """
         index = index or self.index
 
         documents: List[Document] = []
@@ -322,9 +496,24 @@ class QdrantDocumentStore:
         query_sparse_embedding: SparseEmbedding,
         filters: Optional[Union[Dict[str, Any], rest.Filter]] = None,
         top_k: int = 10,
-        scale_score: bool = True,
+        scale_score: bool = False,
         return_embedding: bool = False,
     ) -> List[Document]:
+        """
+        Queries Qdrant using a sparse embedding and returns the most relevant documents.
+
+        :param query_sparse_embedding: Sparse embedding of the query.
+        :param filters: Filters applied to the retrieved documents.
+        :param top_k: Maximum number of documents to return.
+        :param scale_score: Whether to scale the scores of the retrieved documents.
+        :param return_embedding: Whether to return the embeddings of the retrieved documents.
+
+        :returns: List of documents that are most similar to `query_sparse_embedding`.
+
+        :raises QdrantStoreError:
+            If the Document Store was initialized with `use_sparse_embeddings=False`.
+        """
+
         if not self.use_sparse_embeddings:
             message = (
                 "You are trying to query using sparse embeddings, but the Document Store "
@@ -364,9 +553,20 @@ class QdrantDocumentStore:
         query_embedding: List[float],
         filters: Optional[Union[Dict[str, Any], rest.Filter]] = None,
         top_k: int = 10,
-        scale_score: bool = True,
+        scale_score: bool = False,
         return_embedding: bool = False,
     ) -> List[Document]:
+        """
+        Queries Qdrant using a dense embedding and returns the most relevant documents.
+
+        :param query_embedding: Dense embedding of the query.
+        :param filters: Filters applied to the retrieved documents.
+        :param top_k: Maximum number of documents to return.
+        :param scale_score: Whether to scale the scores of the retrieved documents.
+        :param return_embedding: Whether to return the embeddings of the retrieved documents.
+
+        :returns: List of documents that are most similar to `query_embedding`.
+        """
         qdrant_filters = convert_filters_to_qdrant(filters)
 
         points = self.client.search(
@@ -409,8 +609,8 @@ class QdrantDocumentStore:
 
         :param query_embedding: Dense embedding of the query.
         :param query_sparse_embedding: Sparse embedding of the query.
-        :param filters: Filters applied to the retrieved Documents.
-        :param top_k: Maximum number of Documents to return.
+        :param filters: Filters applied to the retrieved documents.
+        :param top_k: Maximum number of documents to return.
         :param return_embedding: Whether to return the embeddings of the retrieved documents.
 
         :returns: List of Document that are most similar to `query_embedding` and `query_sparse_embedding`.
@@ -474,6 +674,16 @@ class QdrantDocumentStore:
         return results
 
     def get_distance(self, similarity: str) -> rest.Distance:
+        """
+        Retrieves the distance metric for the specified similarity measure.
+
+        :param similarity:
+            The similarity measure to retrieve the distance.
+        :returns:
+            The corresponding rest.Distance object.
+        :raises QdrantStoreError:
+            If the provided similarity measure is not supported.
+        """
         try:
             return self.SIMILARITY[similarity]
         except KeyError as ke:
@@ -507,6 +717,29 @@ class QdrantDocumentStore:
         on_disk: bool = False,
         payload_fields_to_index: Optional[List[dict]] = None,
     ):
+        """
+        Sets up the Qdrant collection with the specified parameters.
+        :param collection_name:
+            The name of the collection to set up.
+        :param embedding_dim:
+            The dimension of the embeddings.
+        :param recreate_collection:
+            Whether to recreate the collection if it already exists.
+        :param similarity:
+            The similarity measure to use.
+        :param use_sparse_embeddings:
+            Whether to use sparse embeddings.
+        :param on_disk:
+            Whether to store the collection on disk.
+        :param payload_fields_to_index:
+            List of payload fields to index.
+
+        :raises QdrantStoreError:
+            If the collection exists with incompatible settings.
+        :raises ValueError:
+            If the collection exists with a different similarity measure or embedding dimension.
+
+        """
         distance = self.get_distance(similarity)
 
         if recreate_collection or not self.client.collection_exists(collection_name):
@@ -576,6 +809,20 @@ class QdrantDocumentStore:
         on_disk: Optional[bool] = None,
         use_sparse_embeddings: Optional[bool] = None,
     ):
+        """
+        Recreates the Qdrant collection with the specified parameters.
+
+        :param collection_name:
+            The name of the collection to recreate.
+        :param distance:
+            The distance metric to use for the collection.
+        :param embedding_dim:
+            The dimension of the embeddings.
+        :param on_disk:
+            Whether to store the collection on disk.
+        :param use_sparse_embeddings:
+            Whether to use sparse embeddings.
+        """
         if on_disk is None:
             on_disk = self.on_disk
 
@@ -627,12 +874,7 @@ class QdrantDocumentStore:
 
         :param documents: A list of Haystack Document objects.
         :param index: name of the index
-        :param duplicate_documents: Handle duplicates document based on parameter options.
-                                    Parameter options : ( 'skip','overwrite','fail')
-                                    skip (default option): Ignore the duplicates documents
-                                    overwrite: Update any existing documents with the same ID when adding documents.
-                                    fail: an error is raised if the document ID of the document being added already
-                                    exists.
+        :param policy: The duplicate policy to use when writing documents.
         :returns: A list of Haystack Document objects.
         """
 
@@ -652,10 +894,10 @@ class QdrantDocumentStore:
 
     def _drop_duplicate_documents(self, documents: List[Document], index: Optional[str] = None) -> List[Document]:
         """
-        Drop duplicates documents based on same hash ID
+        Drop duplicate documents based on same hash ID.
 
         :param documents: A list of Haystack Document objects.
-        :param index: name of the index
+        :param index: Name of the index.
         :returns: A list of Haystack Document objects.
         """
         _hash_ids: Set = set()

{qdrant_haystack-3.8.0.dist-info → qdrant_haystack-4.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qdrant-haystack
-Version: 3.8.0
+Version: 4.0.0
 Summary: An integration of Qdrant ANN vector database backend with Haystack
 Project-URL: Source, https://github.com/deepset-ai/haystack-core-integrations
 Project-URL: Documentation, https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/qdrant/README.md

{qdrant_haystack-3.8.0.dist-info → qdrant_haystack-4.0.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
 haystack_integrations/components/retrievers/qdrant/__init__.py,sha256=IRjcM4f8b5eKFEMn8tn6h6RrfslEGP3WafU7mrzNzQM,313
-haystack_integrations/components/retrievers/qdrant/retriever.py,sha256=r416_a7_6l7ehfPLdFtyHncsPrHj3mFCyROeJJF9rwM,13463
+haystack_integrations/components/retrievers/qdrant/retriever.py,sha256=_6noYJ0M71shgoTOywIgSuGQtB-CBhwRW_zUFiYIOTw,13465
 haystack_integrations/document_stores/qdrant/__init__.py,sha256=kUGc5uewqArhmVR-JqB_NmJ4kNkTIQIvYDNSoO2ELn0,302
-haystack_integrations/document_stores/qdrant/converters.py,sha256=oSO2YlsWEQbcw9CPlWfSg_HoTZlnkAhZw_6VlYWzKKs,2525
-haystack_integrations/document_stores/qdrant/document_store.py,sha256=B8oR4621IrnXKKvYycP7CLUmo8T5xK48Lmk3bDErzIs,26567
+haystack_integrations/document_stores/qdrant/converters.py,sha256=2hcuI3kty1dVHzX1WGXxEtlrnZ9E8TAG56XATCFa6Pw,2491
+haystack_integrations/document_stores/qdrant/document_store.py,sha256=mjzv6Z3iE9oFRil_PVLjmEq-vX7a7ULpT5afGsU7iSU,36088
 haystack_integrations/document_stores/qdrant/filters.py,sha256=0w70Wa3Za1fNdbJ5O95sZDIpXfblJG_sBBUv0JTQ0-o,8337
 haystack_integrations/document_stores/qdrant/migrate_to_sparse.py,sha256=i6wBC_9_JVzYZtqKm3dhHKTxhwNdcAdpgki8GABDp1c,4909
-qdrant_haystack-3.8.0.dist-info/METADATA,sha256=FsZssukO3zv1nkdEhOHiz-sLBrk41Ta9u64mWuZC_Ec,1862
-qdrant_haystack-3.8.0.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
-qdrant_haystack-3.8.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
-qdrant_haystack-3.8.0.dist-info/RECORD,,
+qdrant_haystack-4.0.0.dist-info/METADATA,sha256=wHvVJIDCQDPFLX8fL_d11zNMZul4U6r02bVhhCdmitk,1862
+qdrant_haystack-4.0.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+qdrant_haystack-4.0.0.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+qdrant_haystack-4.0.0.dist-info/RECORD,,

{qdrant_haystack-3.8.0.dist-info → qdrant_haystack-4.0.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.24.2
+Generator: hatchling 1.25.0
 Root-Is-Purelib: true
 Tag: py3-none-any