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

haystack_integrations/components/retrievers/qdrant/retriever.py

@@ -2,6 +2,8 @@ from typing import Any, Dict, List, Optional, Union
 
 from haystack import Document, component, default_from_dict, default_to_dict
 from haystack.dataclasses.sparse_embedding import SparseEmbedding
+from haystack.document_stores.types import FilterPolicy
+from haystack.document_stores.types.filter_policy import apply_filter_policy
 from haystack_integrations.document_stores.qdrant import QdrantDocumentStore
 from qdrant_client.http import models
 
@@ -39,6 +41,8 @@ class QdrantEmbeddingRetriever:
         top_k: int = 10,
         scale_score: bool = False,
         return_embedding: bool = False,
+        filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
+        score_threshold: Optional[float] = None,
     ):
         """
         Create a QdrantEmbeddingRetriever component.
@@ -48,6 +52,11 @@ class QdrantEmbeddingRetriever:
         :param top_k: The maximum number of documents to retrieve.
         :param scale_score: Whether to scale the scores of the retrieved documents or not.
         :param return_embedding: Whether to return the embedding of the retrieved Documents.
+        :param filter_policy: Policy to determine how filters are applied.
+        :param score_threshold: A minimal score threshold for the result.
+            Score of the returned result might be higher or smaller than the threshold
+             depending on the `similarity` function specified in the Document Store.
+            E.g. for cosine similarity only higher scores will be returned.
 
         :raises ValueError: If `document_store` is not an instance of `QdrantDocumentStore`.
         """
@@ -61,6 +70,10 @@ class QdrantEmbeddingRetriever:
         self._top_k = top_k
         self._scale_score = scale_score
         self._return_embedding = return_embedding
+        self._filter_policy = (
+            filter_policy if isinstance(filter_policy, FilterPolicy) else FilterPolicy.from_str(filter_policy)
+        )
+        self._score_threshold = score_threshold
 
     def to_dict(self) -> Dict[str, Any]:
         """
@@ -74,8 +87,10 @@ class QdrantEmbeddingRetriever:
             document_store=self._document_store,
             filters=self._filters,
             top_k=self._top_k,
+            filter_policy=self._filter_policy.value,
             scale_score=self._scale_score,
             return_embedding=self._return_embedding,
+            score_threshold=self._score_threshold,
         )
         d["init_parameters"]["document_store"] = self._document_store.to_dict()
 
@@ -93,6 +108,7 @@ class QdrantEmbeddingRetriever:
         """
         document_store = QdrantDocumentStore.from_dict(data["init_parameters"]["document_store"])
         data["init_parameters"]["document_store"] = document_store
+        data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(data["init_parameters"]["filter_policy"])
         return default_from_dict(cls, data)
 
     @component.output_types(documents=List[Document])
@@ -103,6 +119,7 @@ class QdrantEmbeddingRetriever:
         top_k: Optional[int] = None,
         scale_score: Optional[bool] = None,
         return_embedding: Optional[bool] = None,
+        score_threshold: Optional[float] = None,
     ):
         """
         Run the Embedding Retriever on the given input data.
@@ -112,16 +129,20 @@ class QdrantEmbeddingRetriever:
         :param top_k: The maximum number of documents to return.
         :param scale_score: Whether to scale the scores of the retrieved documents or not.
         :param return_embedding: Whether to return the embedding of the retrieved Documents.
+        :param score_threshold: A minimal score threshold for the result.
         :returns:
             The retrieved documents.
 
         """
+        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+
         docs = self._document_store._query_by_embedding(
             query_embedding=query_embedding,
-            filters=filters or self._filters,
+            filters=filters,
             top_k=top_k or self._top_k,
             scale_score=scale_score or self._scale_score,
             return_embedding=return_embedding or self._return_embedding,
+            score_threshold=score_threshold or self._score_threshold,
         )
 
         return {"documents": docs}
@@ -161,6 +182,8 @@ class QdrantSparseEmbeddingRetriever:
         top_k: int = 10,
         scale_score: bool = False,
         return_embedding: bool = False,
+        filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
+        score_threshold: Optional[float] = None,
     ):
         """
         Create a QdrantSparseEmbeddingRetriever component.
@@ -170,6 +193,11 @@ class QdrantSparseEmbeddingRetriever:
         :param top_k: The maximum number of documents to retrieve.
         :param scale_score: Whether to scale the scores of the retrieved documents or not.
         :param return_embedding: Whether to return the sparse embedding of the retrieved Documents.
+        :param filter_policy: Policy to determine how filters are applied. Defaults to "replace".
+        :param score_threshold: A minimal score threshold for the result.
+            Score of the returned result might be higher or smaller than the threshold
+             depending on the Distance function used.
+            E.g. for cosine similarity only higher scores will be returned.
 
         :raises ValueError: If `document_store` is not an instance of `QdrantDocumentStore`.
         """
@@ -183,6 +211,10 @@ class QdrantSparseEmbeddingRetriever:
         self._top_k = top_k
         self._scale_score = scale_score
         self._return_embedding = return_embedding
+        self._filter_policy = (
+            filter_policy if isinstance(filter_policy, FilterPolicy) else FilterPolicy.from_str(filter_policy)
+        )
+        self._score_threshold = score_threshold
 
     def to_dict(self) -> Dict[str, Any]:
         """
@@ -197,7 +229,9 @@ class QdrantSparseEmbeddingRetriever:
             filters=self._filters,
             top_k=self._top_k,
             scale_score=self._scale_score,
+            filter_policy=self._filter_policy.value,
             return_embedding=self._return_embedding,
+            score_threshold=self._score_threshold,
         )
         d["init_parameters"]["document_store"] = self._document_store.to_dict()
 
@@ -215,6 +249,7 @@ class QdrantSparseEmbeddingRetriever:
         """
         document_store = QdrantDocumentStore.from_dict(data["init_parameters"]["document_store"])
         data["init_parameters"]["document_store"] = document_store
+        data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(data["init_parameters"]["filter_policy"])
         return default_from_dict(cls, data)
 
     @component.output_types(documents=List[Document])
@@ -225,25 +260,35 @@ class QdrantSparseEmbeddingRetriever:
         top_k: Optional[int] = None,
         scale_score: Optional[bool] = None,
         return_embedding: Optional[bool] = None,
+        score_threshold: Optional[float] = None,
     ):
         """
         Run the Sparse Embedding Retriever on the given input data.
 
         :param query_sparse_embedding: Sparse Embedding of the query.
-        :param filters: A dictionary with filters to narrow down the search space.
+        :param filters: Filters applied to the retrieved Documents. The way runtime filters are applied depends on
+                        the `filter_policy` chosen at retriever initialization. See init method docstring for more
+                        details.
         :param top_k: The maximum number of documents to return.
         :param scale_score: Whether to scale the scores of the retrieved documents or not.
         :param return_embedding: Whether to return the embedding of the retrieved Documents.
+        :param score_threshold: A minimal score threshold for the result.
+            Score of the returned result might be higher or smaller than the threshold
+             depending on the Distance function used.
+            E.g. for cosine similarity only higher scores will be returned.
         :returns:
             The retrieved documents.
 
         """
+        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+
         docs = self._document_store._query_by_sparse(
             query_sparse_embedding=query_sparse_embedding,
-            filters=filters or self._filters,
+            filters=filters,
             top_k=top_k or self._top_k,
             scale_score=scale_score or self._scale_score,
             return_embedding=return_embedding or self._return_embedding,
+            score_threshold=score_threshold or self._score_threshold,
         )
 
         return {"documents": docs}
@@ -288,6 +333,8 @@ class QdrantHybridRetriever:
         filters: Optional[Union[Dict[str, Any], models.Filter]] = None,
         top_k: int = 10,
         return_embedding: bool = False,
+        filter_policy: Union[str, FilterPolicy] = FilterPolicy.REPLACE,
+        score_threshold: Optional[float] = None,
     ):
         """
         Create a QdrantHybridRetriever component.
@@ -296,6 +343,11 @@ class QdrantHybridRetriever:
         :param filters: A dictionary with filters to narrow down the search space.
         :param top_k: The maximum number of documents to retrieve.
         :param return_embedding: Whether to return the embeddings of the retrieved Documents.
+        :param filter_policy: Policy to determine how filters are applied.
+        :param score_threshold: A minimal score threshold for the result.
+            Score of the returned result might be higher or smaller than the threshold
+             depending on the Distance function used.
+            E.g. for cosine similarity only higher scores will be returned.
 
         :raises ValueError: If 'document_store' is not an instance of QdrantDocumentStore.
         """
@@ -308,6 +360,10 @@ class QdrantHybridRetriever:
         self._filters = filters
         self._top_k = top_k
         self._return_embedding = return_embedding
+        self._filter_policy = (
+            filter_policy if isinstance(filter_policy, FilterPolicy) else FilterPolicy.from_str(filter_policy)
+        )
+        self._score_threshold = score_threshold
 
     def to_dict(self) -> Dict[str, Any]:
         """
@@ -321,7 +377,9 @@ class QdrantHybridRetriever:
             document_store=self._document_store.to_dict(),
             filters=self._filters,
             top_k=self._top_k,
+            filter_policy=self._filter_policy.value,
             return_embedding=self._return_embedding,
+            score_threshold=self._score_threshold,
         )
 
     @classmethod
@@ -336,6 +394,7 @@ class QdrantHybridRetriever:
         """
         document_store = QdrantDocumentStore.from_dict(data["init_parameters"]["document_store"])
         data["init_parameters"]["document_store"] = document_store
+        data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(data["init_parameters"]["filter_policy"])
         return default_from_dict(cls, data)
 
     @component.output_types(documents=List[Document])
@@ -346,25 +405,35 @@ class QdrantHybridRetriever:
         filters: Optional[Union[Dict[str, Any], models.Filter]] = None,
         top_k: Optional[int] = None,
         return_embedding: Optional[bool] = None,
+        score_threshold: Optional[float] = None,
     ):
         """
         Run the Sparse Embedding Retriever on the given input data.
 
         :param query_embedding: Dense embedding of the query.
         :param query_sparse_embedding: Sparse embedding of the query.
-        :param filters: A dictionary with filters to narrow down the search space.
+        :param filters: Filters applied to the retrieved Documents. The way runtime filters are applied depends on
+                        the `filter_policy` chosen at retriever initialization. See init method docstring for more
+                        details.
         :param top_k: The maximum number of documents to return.
         :param return_embedding: Whether to return the embedding of the retrieved Documents.
+        :param score_threshold: A minimal score threshold for the result.
+            Score of the returned result might be higher or smaller than the threshold
+             depending on the Distance function used.
+            E.g. for cosine similarity only higher scores will be returned.
         :returns:
             The retrieved documents.
 
         """
+        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+
         docs = self._document_store._query_hybrid(
             query_embedding=query_embedding,
             query_sparse_embedding=query_sparse_embedding,
-            filters=filters or self._filters,
+            filters=filters,
             top_k=top_k or self._top_k,
             return_embedding=return_embedding or self._return_embedding,
+            score_threshold=score_threshold or self._score_threshold,
         )
 
         return {"documents": docs}

haystack_integrations/document_stores/qdrant/document_store.py

@@ -111,6 +111,7 @@ class QdrantDocumentStore:
         embedding_dim: int = 768,
         on_disk: bool = False,
         use_sparse_embeddings: bool = False,
+        sparse_idf: bool = False,
         similarity: str = "cosine",
         return_embedding: bool = False,
         progress_bar: bool = True,
@@ -168,6 +169,9 @@ class QdrantDocumentStore:
             Whether to store the collection on disk.
         :param use_sparse_embedding:
             If set to `True`, enables support for sparse embeddings.
+        :param sparse_idf:
+            If set to `True`, computes the Inverse Document Frequency (IDF) when using sparse embeddings.
+            It is required to use techniques like BM42. It is ignored if `use_sparse_embeddings` is `False`.
         :param similarity:
             The similarity metric to use.
         :param return_embedding:
@@ -246,6 +250,7 @@ class QdrantDocumentStore:
         self.recreate_index = recreate_index
         self.payload_fields_to_index = payload_fields_to_index
         self.use_sparse_embeddings = use_sparse_embeddings
+        self.sparse_idf = use_sparse_embeddings and sparse_idf
         self.embedding_dim = embedding_dim
         self.on_disk = on_disk
         self.similarity = similarity
@@ -280,6 +285,7 @@ class QdrantDocumentStore:
                 self.recreate_index,
                 self.similarity,
                 self.use_sparse_embeddings,
+                self.sparse_idf,
                 self.on_disk,
                 self.payload_fields_to_index,
             )
@@ -347,7 +353,9 @@ class QdrantDocumentStore:
             if not isinstance(doc, Document):
                 msg = f"DocumentStore.write_documents() expects a list of Documents but got an element of {type(doc)}."
                 raise ValueError(msg)
-        self._set_up_collection(self.index, self.embedding_dim, False, self.similarity, self.use_sparse_embeddings)
+        self._set_up_collection(
+            self.index, self.embedding_dim, False, self.similarity, self.use_sparse_embeddings, self.sparse_idf
+        )
 
         if len(documents) == 0:
             logger.warning("Calling QdrantDocumentStore.write_documents() with empty list")
@@ -498,6 +506,7 @@ class QdrantDocumentStore:
         top_k: int = 10,
         scale_score: bool = False,
         return_embedding: bool = False,
+        score_threshold: Optional[float] = None,
     ) -> List[Document]:
         """
         Queries Qdrant using a sparse embedding and returns the most relevant documents.
@@ -507,6 +516,10 @@ class QdrantDocumentStore:
         :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.
+        :param score_threshold: A minimal score threshold for the result.
+            Score of the returned result might be higher or smaller than the threshold
+             depending on the Distance function used.
+            E.g. for cosine similarity only higher scores will be returned.
 
         :returns: List of documents that are most similar to `query_sparse_embedding`.
 
@@ -536,6 +549,7 @@ class QdrantDocumentStore:
             query_filter=qdrant_filters,
             limit=top_k,
             with_vectors=return_embedding,
+            score_threshold=score_threshold,
         )
         results = [
             convert_qdrant_point_to_haystack_document(point, use_sparse_embeddings=self.use_sparse_embeddings)
@@ -555,6 +569,7 @@ class QdrantDocumentStore:
         top_k: int = 10,
         scale_score: bool = False,
         return_embedding: bool = False,
+        score_threshold: Optional[float] = None,
     ) -> List[Document]:
         """
         Queries Qdrant using a dense embedding and returns the most relevant documents.
@@ -564,6 +579,10 @@ class QdrantDocumentStore:
         :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.
+        :param score_threshold: A minimal score threshold for the result.
+            Score of the returned result might be higher or smaller than the threshold
+             depending on the Distance function used.
+            E.g. for cosine similarity only higher scores will be returned.
 
         :returns: List of documents that are most similar to `query_embedding`.
         """
@@ -578,6 +597,7 @@ class QdrantDocumentStore:
             query_filter=qdrant_filters,
             limit=top_k,
             with_vectors=return_embedding,
+            score_threshold=score_threshold,
         )
         results = [
             convert_qdrant_point_to_haystack_document(point, use_sparse_embeddings=self.use_sparse_embeddings)
@@ -600,6 +620,7 @@ class QdrantDocumentStore:
         filters: Optional[Union[Dict[str, Any], rest.Filter]] = None,
         top_k: int = 10,
         return_embedding: bool = False,
+        score_threshold: Optional[float] = None,
     ) -> List[Document]:
         """
         Retrieves documents based on dense and sparse embeddings and fuses the results using Reciprocal Rank Fusion.
@@ -612,6 +633,10 @@ class QdrantDocumentStore:
         :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.
+        :param score_threshold: A minimal score threshold for the result.
+            Score of the returned result might be higher or smaller than the threshold
+             depending on the Distance function used.
+            E.g. for cosine similarity only higher scores will be returned.
 
         :returns: List of Document that are most similar to `query_embedding` and `query_sparse_embedding`.
 
@@ -642,6 +667,7 @@ class QdrantDocumentStore:
             limit=top_k,
             with_payload=True,
             with_vector=return_embedding,
+            score_threshold=score_threshold,
         )
 
         dense_request = rest.SearchRequest(
@@ -714,6 +740,7 @@ class QdrantDocumentStore:
         recreate_collection: bool,
         similarity: str,
         use_sparse_embeddings: bool,
+        sparse_idf: bool,
         on_disk: bool = False,
         payload_fields_to_index: Optional[List[dict]] = None,
     ):
@@ -729,6 +756,8 @@ class QdrantDocumentStore:
             The similarity measure to use.
         :param use_sparse_embeddings:
             Whether to use sparse embeddings.
+        :param sparse_idf:
+            Whether to compute the Inverse Document Frequency (IDF) when using sparse embeddings. Required for BM42.
         :param on_disk:
             Whether to store the collection on disk.
         :param payload_fields_to_index:
@@ -745,7 +774,9 @@ class QdrantDocumentStore:
         if recreate_collection or not self.client.collection_exists(collection_name):
             # There is no need to verify the current configuration of that
             # collection. It might be just recreated again or does not exist yet.
-            self.recreate_collection(collection_name, distance, embedding_dim, on_disk, use_sparse_embeddings)
+            self.recreate_collection(
+                collection_name, distance, embedding_dim, on_disk, use_sparse_embeddings, sparse_idf
+            )
             # Create Payload index if payload_fields_to_index is provided
             self._create_payload_index(collection_name, payload_fields_to_index)
             return
@@ -808,6 +839,7 @@ class QdrantDocumentStore:
         embedding_dim: int,
         on_disk: Optional[bool] = None,
         use_sparse_embeddings: Optional[bool] = None,
+        sparse_idf: bool = False,
     ):
         """
         Recreates the Qdrant collection with the specified parameters.
@@ -822,6 +854,8 @@ class QdrantDocumentStore:
             Whether to store the collection on disk.
         :param use_sparse_embeddings:
             Whether to use sparse embeddings.
+        :param sparse_idf:
+            Whether to compute the Inverse Document Frequency (IDF) when using sparse embeddings. Required for BM42.
         """
         if on_disk is None:
             on_disk = self.on_disk
@@ -840,7 +874,8 @@ class QdrantDocumentStore:
                 SPARSE_VECTORS_NAME: rest.SparseVectorParams(
                     index=rest.SparseIndexParams(
                         on_disk=on_disk,
-                    )
+                    ),
+                    modifier=rest.Modifier.IDF if sparse_idf else None,
                 ),
             }
 

haystack_integrations/document_stores/qdrant/filters.py

@@ -4,28 +4,55 @@ from typing import List, Optional, Union
 from haystack.utils.filters import COMPARISON_OPERATORS, LOGICAL_OPERATORS, FilterError
 from qdrant_client.http import models
 
-from .converters import convert_id
-
 COMPARISON_OPERATORS = COMPARISON_OPERATORS.keys()
 LOGICAL_OPERATORS = LOGICAL_OPERATORS.keys()
 
 
 def convert_filters_to_qdrant(
-    filter_term: Optional[Union[List[dict], dict, models.Filter]] = None,
-) -> Optional[models.Filter]:
-    """Converts Haystack filters to the format used by Qdrant."""
+    filter_term: Optional[Union[List[dict], dict, models.Filter]] = None, is_parent_call: bool = True
+) -> Optional[Union[models.Filter, List[models.Filter], List[models.Condition]]]:
+    """Converts Haystack filters to the format used by Qdrant.
+
+    :param filter_term: the haystack filter to be converted to qdrant.
+    :param is_parent_call: indicates if this is the top-level call to the function. If True, the function returns
+      a single models.Filter object; if False, it may return a list of filters or conditions for further processing.
+
+    :returns: a single Qdrant Filter in the parent call or a list of such Filters in recursive calls.
+
+    :raises FilterError: If the invalid filter criteria is provided or if an unknown operator is encountered.
+
+    """
+
     if isinstance(filter_term, models.Filter):
         return filter_term
     if not filter_term:
         return None
 
-    must_clauses, should_clauses, must_not_clauses = [], [], []
+    must_clauses: List[models.Filter] = []
+    should_clauses: List[models.Filter] = []
+    must_not_clauses: List[models.Filter] = []
+    # Indicates if there are multiple same LOGICAL OPERATORS on each level
+    # and prevents them from being combined
+    same_operator_flag = False
+    conditions, qdrant_filter, current_level_operators = (
+        [],
+        [],
+        [],
+    )
 
     if isinstance(filter_term, dict):
         filter_term = [filter_term]
 
+    # ======== IDENTIFY FILTER ITEMS ON EACH LEVEL ========
+
     for item in filter_term:
         operator = item.get("operator")
+
+        # Check for repeated similar operators on each level
+        same_operator_flag = operator in current_level_operators and operator in LOGICAL_OPERATORS
+        if not same_operator_flag:
+            current_level_operators.append(operator)
+
         if operator is None:
             msg = "Operator not found in filters"
             raise FilterError(msg)
@@ -34,12 +61,23 @@ def convert_filters_to_qdrant(
             msg = f"'conditions' not found for '{operator}'"
             raise FilterError(msg)
 
-        if operator == "AND":
-            must_clauses.append(convert_filters_to_qdrant(item.get("conditions", [])))
-        elif operator == "OR":
-            should_clauses.append(convert_filters_to_qdrant(item.get("conditions", [])))
-        elif operator == "NOT":
-            must_not_clauses.append(convert_filters_to_qdrant(item.get("conditions", [])))
+        if operator in LOGICAL_OPERATORS:
+            # Recursively process nested conditions
+            current_filter = convert_filters_to_qdrant(item.get("conditions", []), is_parent_call=False) or []
+
+            # When same_operator_flag is set to True,
+            # ensure each clause is appended as an independent list to avoid merging distinct clauses.
+            if operator == "AND":
+                must_clauses = [must_clauses, current_filter] if same_operator_flag else must_clauses + current_filter
+            elif operator == "OR":
+                should_clauses = (
+                    [should_clauses, current_filter] if same_operator_flag else should_clauses + current_filter
+                )
+            elif operator == "NOT":
+                must_not_clauses = (
+                    [must_not_clauses, current_filter] if same_operator_flag else must_not_clauses + current_filter
+                )
+
         elif operator in COMPARISON_OPERATORS:
             field = item.get("field")
             value = item.get("value")
@@ -47,20 +85,106 @@ def convert_filters_to_qdrant(
                 msg = f"'field' or 'value' not found for '{operator}'"
                 raise FilterError(msg)
 
-            must_clauses.extend(_parse_comparison_operation(comparison_operation=operator, key=field, value=value))
+            parsed_conditions = _parse_comparison_operation(comparison_operation=operator, key=field, value=value)
+
+            # check if the parsed_conditions are models.Filter or models.Condition
+            for condition in parsed_conditions:
+                if isinstance(condition, models.Filter):
+                    qdrant_filter.append(condition)
+                else:
+                    conditions.append(condition)
+
         else:
             msg = f"Unknown operator {operator} used in filters"
             raise FilterError(msg)
 
-    payload_filter = models.Filter(
-        must=must_clauses or None,
-        should=should_clauses or None,
-        must_not=must_not_clauses or None,
-    )
+    # ======== PROCESS FILTER ITEMS ON EACH LEVEL ========
+
+    # If same logical operators have separate clauses, create separate filters
+    if same_operator_flag:
+        qdrant_filter = build_filters_for_repeated_operators(
+            must_clauses, should_clauses, must_not_clauses, qdrant_filter
+        )
+
+    # else append a single Filter for existing clauses
+    elif must_clauses or should_clauses or must_not_clauses:
+        qdrant_filter.append(
+            models.Filter(
+                must=must_clauses or None,
+                should=should_clauses or None,
+                must_not=must_not_clauses or None,
+            )
+        )
+
+    # In case of parent call, a single Filter is returned
+    if is_parent_call:
+        # If qdrant_filter has just a single Filter in parent call,
+        # then it might be returned instead.
+        if len(qdrant_filter) == 1 and isinstance(qdrant_filter[0], models.Filter):
+            return qdrant_filter[0]
+        else:
+            must_clauses.extend(conditions)
+            return models.Filter(
+                must=must_clauses or None,
+                should=should_clauses or None,
+                must_not=must_not_clauses or None,
+            )
+
+    # Store conditions of each level in output of the loop
+    elif conditions:
+        qdrant_filter.extend(conditions)
+
+    return qdrant_filter
+
+
+def build_filters_for_repeated_operators(
+    must_clauses,
+    should_clauses,
+    must_not_clauses,
+    qdrant_filter,
+) -> List[models.Filter]:
+    """
+    Flattens the nested lists of clauses by creating separate Filters for each clause of a logical operator.
+
+    :param must_clauses: a nested list of must clauses or an empty list.
+    :param should_clauses: a nested list of should clauses or an empty list.
+    :param must_not_clauses: a nested list of must_not clauses or an empty list.
+    :param qdrant_filter: a list where the generated Filter objects will be appended.
+      This list will be modified in-place.
 
-    filter_result = _squeeze_filter(payload_filter)
 
-    return filter_result
+    :returns: the modified `qdrant_filter` list with appended generated Filter objects.
+    """
+
+    if any(isinstance(i, list) for i in must_clauses):
+        for i in must_clauses:
+            qdrant_filter.append(
+                models.Filter(
+                    must=i or None,
+                    should=should_clauses or None,
+                    must_not=must_not_clauses or None,
+                )
+            )
+    if any(isinstance(i, list) for i in should_clauses):
+        for i in should_clauses:
+            qdrant_filter.append(
+                models.Filter(
+                    must=must_clauses or None,
+                    should=i or None,
+                    must_not=must_not_clauses or None,
+                )
+            )
+    if any(isinstance(i, list) for i in must_not_clauses):
+        for i in must_clauses:
+            qdrant_filter.append(
+                models.Filter(
+                    must=must_clauses or None,
+                    should=should_clauses or None,
+                    must_not=i or None,
+                )
+            )
+
+    return qdrant_filter
 
 
 def _parse_comparison_operation(
@@ -92,7 +216,7 @@ def _parse_comparison_operation(
 
 def _build_eq_condition(key: str, value: models.ValueVariants) -> models.Condition:
     if isinstance(value, str) and " " in value:
-        models.FieldCondition(key=key, match=models.MatchText(text=value))
+        return models.FieldCondition(key=key, match=models.MatchText(text=value))
     return models.FieldCondition(key=key, match=models.MatchValue(value=value))
 
 
@@ -184,52 +308,6 @@ def _build_gte_condition(key: str, value: Union[str, float, int]) -> models.Cond
     raise FilterError(msg)
 
 
-def _build_has_id_condition(id_values: List[models.ExtendedPointId]) -> models.HasIdCondition:
-    return models.HasIdCondition(
-        has_id=[
-            # Ids are converted into their internal representation
-            convert_id(item)
-            for item in id_values
-        ]
-    )
-
-
-def _squeeze_filter(payload_filter: models.Filter) -> models.Filter:
-    """
-    Simplify given payload filter, if the nested structure might be unnested.
-    That happens if there is a single clause in that filter.
-    :param payload_filter:
-    :returns:
-    """
-    filter_parts = {
-        "must": payload_filter.must,
-        "should": payload_filter.should,
-        "must_not": payload_filter.must_not,
-    }
-
-    total_clauses = sum(len(x) for x in filter_parts.values() if x is not None)
-    if total_clauses == 0 or total_clauses > 1:
-        return payload_filter
-
-    # Payload filter has just a single clause provided (either must, should
-    # or must_not). If that single clause is also of a models.Filter type,
-    # then it might be returned instead.
-    for part_name, filter_part in filter_parts.items():
-        if not filter_part:
-            continue
-
-        subfilter = filter_part[0]
-        if not isinstance(subfilter, models.Filter):
-            # The inner statement is a simple condition like models.FieldCondition
-            # so it cannot be simplified.
-            continue
-
-        if subfilter.must:
-            return models.Filter(**{part_name: subfilter.must})
-
-    return payload_filter
-
-
 def is_datetime_string(value: str) -> bool:
     try:
         datetime.fromisoformat(value)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: qdrant-haystack
-Version: 4.0.0
+Version: 4.1.1
 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
@@ -18,8 +18,8 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.8
-Requires-Dist: haystack-ai>=2.0.1
-Requires-Dist: qdrant-client
+Requires-Dist: haystack-ai
+Requires-Dist: qdrant-client>=1.10.0
 Description-Content-Type: text/markdown
 
 # qdrant-haystack

{qdrant_haystack-4.0.0.dist-info → qdrant_haystack-4.1.1.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=_6noYJ0M71shgoTOywIgSuGQtB-CBhwRW_zUFiYIOTw,13465
+haystack_integrations/components/retrievers/qdrant/retriever.py,sha256=55IY5bmNvFe62abNBfDOhuo1I38-ue713c8gMNgkfuY,17947
 haystack_integrations/document_stores/qdrant/__init__.py,sha256=kUGc5uewqArhmVR-JqB_NmJ4kNkTIQIvYDNSoO2ELn0,302
 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/document_store.py,sha256=eLw4P1h8GCj40R-BIlQOvJG9MpDzvtmQ7Hpb3AZhMSo,38117
+haystack_integrations/document_stores/qdrant/filters.py,sha256=Nv_eKIYKwUWvldJfa0omfFQ0kgqi6L3DUFeMuIWziOY,11751
 haystack_integrations/document_stores/qdrant/migrate_to_sparse.py,sha256=i6wBC_9_JVzYZtqKm3dhHKTxhwNdcAdpgki8GABDp1c,4909
-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-4.1.1.dist-info/METADATA,sha256=BQcRpx4WyYIvccTCEowd4jnc43zoApKx-Ql_BnUqZwM,1863
+qdrant_haystack-4.1.1.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+qdrant_haystack-4.1.1.dist-info/licenses/LICENSE.txt,sha256=B05uMshqTA74s-0ltyHKI6yoPfJ3zYgQbvcXfDVGFf8,10280
+qdrant_haystack-4.1.1.dist-info/RECORD,,