qdrant-haystack 13.0.0__tar.gz → 13.1.1__tar.gz

{qdrant_haystack-13.0.0 → qdrant_haystack-13.1.1}/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## [integrations/qdrant-v13.1.0] - 2026-10-22
+
+### 🚀 Features
+
+- Add ability to specify qdrant client kwargs (#4048)
+
+
+## [integrations/qdrant-v13.0.0] - 2026-10-16
+
+### 🧪 Testing
+
+- Test compatible integrations with Python 3.15; update pyproject (#4104)
+
+### 🧹 Chores
+
+- [**breaking**] Drop Python 3.10 support (#4105)
+
+
 ## [integrations/qdrant-v12.0.0] - 2026-10-09
 
 ### 🐛 Bug Fixes

{qdrant_haystack-13.0.0 → qdrant_haystack-13.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: qdrant-haystack
-Version: 13.0.0
+Version: 13.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

{qdrant_haystack-13.0.0 → qdrant_haystack-13.1.1}/src/haystack_integrations/document_stores/qdrant/document_store.py

@@ -150,6 +150,7 @@ class QdrantDocumentStore:
         write_batch_size: int = 100,
         scroll_size: int = 10_000,
         payload_fields_to_index: list[dict] | None = None,
+        client_kwargs: dict[str, Any] | None = None,
     ) -> None:
         """
         Initializes a QdrantDocumentStore.
@@ -236,6 +237,14 @@ class QdrantDocumentStore:
             The scroll size for reading documents.
         :param payload_fields_to_index:
             List of payload fields to index.
+        :param client_kwargs:
+            Additional keyword arguments passed to both `QdrantClient` and `AsyncQdrantClient`.
+            These arguments take precedence over named client parameters in case of overlap.
+            Serialized as-is by `to_dict()`: callbacks and `httpx.Limits` may not serialize, and
+            authentication headers will appear in plain text in pipeline YAML.
+            The same arguments are used for sync and async clients. For example, an async
+            `auth_token_provider` is also passed to `QdrantClient`, where it may not work with
+            synchronous requests.
         """
 
         self._client: qdrant_client.QdrantClient | None = None
@@ -255,6 +264,7 @@ class QdrantDocumentStore:
         self.path = path
         self.force_disable_check_same_thread = force_disable_check_same_thread
         self.metadata = metadata or {}
+        self.client_kwargs = dict(client_kwargs or {})
 
         # Store the Qdrant collection specific attributes
         self.shard_number = shard_number
@@ -457,7 +467,7 @@ class QdrantDocumentStore:
                     wait=self.wait_result_from_api,
                 )
 
-                progress_bar.update(self.write_batch_size)
+                progress_bar.update(len(document_batch))
         return len(document_objects)
 
     async def write_documents_async(
@@ -512,7 +522,7 @@ class QdrantDocumentStore:
                     wait=self.wait_result_from_api,
                 )
 
-                progress_bar.update(self.write_batch_size)
+                progress_bar.update(len(document_batch))
         return len(document_objects)
 
     def delete_documents(self, document_ids: list[str]) -> None:
@@ -684,8 +694,8 @@ class QdrantDocumentStore:
         """
         Build field name -> {type: ...} dict from Qdrant payload_schema.
 
-        Used when payload_schema has indexed metadata fields (e.g. meta.category).
-        Returns empty dict when schema has no metadata field info.
+        Covers only the indexed metadata fields (e.g. meta.category); unindexed fields
+        are added by scrolling. Returns empty dict when schema has no metadata field info.
         """
         fields_info: dict[str, dict[str, str]] = {}
         for field_name, field_config in payload_schema.items():
@@ -1072,9 +1082,9 @@ class QdrantDocumentStore:
         """
         Returns the information about the metadata fields in the collection.
 
-        Since Qdrant may not have a payload schema for unindexed metadata,
-        this method scrolls through documents to infer field types from
-        payload["meta"].
+        Indexed metadata fields take their type from the collection's payload schema.
+        Qdrant has no schema for unindexed metadata, so this method also scrolls
+        through documents to infer the type of every other field from payload["meta"].
 
         :returns:
             A dictionary mapping field names to their type information e.g.:
@@ -1091,20 +1101,21 @@ class QdrantDocumentStore:
             payload_schema = collection_info.payload_schema or {}
             fields_info = self._metadata_fields_info_from_schema(payload_schema)
 
-            if not fields_info:
-                next_offset = None
-                while True:
-                    records, next_offset = self._client.scroll(
-                        collection_name=self.index,
-                        scroll_filter=None,
-                        limit=self.scroll_size,
-                        offset=next_offset,
-                        with_payload=True,
-                        with_vectors=False,
-                    )
-                    self._process_records_fields_info(records, fields_info)
-                    if self._check_stop_scrolling(next_offset):
-                        break
+            # Indexed fields only cover part of the metadata, so scroll even when the schema
+            # has entries. Fields already typed by the schema keep their indexed type.
+            next_offset = None
+            while True:
+                records, next_offset = self._client.scroll(
+                    collection_name=self.index,
+                    scroll_filter=None,
+                    limit=self.scroll_size,
+                    offset=next_offset,
+                    with_payload=True,
+                    with_vectors=False,
+                )
+                self._process_records_fields_info(records, fields_info)
+                if self._check_stop_scrolling(next_offset):
+                    break
 
             return fields_info
         except Exception as e:
@@ -1115,9 +1126,9 @@ class QdrantDocumentStore:
         """
         Asynchronously returns the information about the metadata fields in the collection.
 
-        Since Qdrant may not have a payload schema for unindexed metadata,
-        this method scrolls through documents to infer field types from
-        payload["meta"].
+        Indexed metadata fields take their type from the collection's payload schema.
+        Qdrant has no schema for unindexed metadata, so this method also scrolls
+        through documents to infer the type of every other field from payload["meta"].
 
         :returns:
             A dictionary mapping field names to their type information e.g.:
@@ -1134,20 +1145,21 @@ class QdrantDocumentStore:
             payload_schema = collection_info.payload_schema or {}
             fields_info = self._metadata_fields_info_from_schema(payload_schema)
 
-            if not fields_info:
-                next_offset = None
-                while True:
-                    records, next_offset = await self._async_client.scroll(
-                        collection_name=self.index,
-                        scroll_filter=None,
-                        limit=self.scroll_size,
-                        offset=next_offset,
-                        with_payload=True,
-                        with_vectors=False,
-                    )
-                    self._process_records_fields_info(records, fields_info)
-                    if self._check_stop_scrolling(next_offset):
-                        break
+            # Indexed fields only cover part of the metadata, so scroll even when the schema
+            # has entries. Fields already typed by the schema keep their indexed type.
+            next_offset = None
+            while True:
+                records, next_offset = await self._async_client.scroll(
+                    collection_name=self.index,
+                    scroll_filter=None,
+                    limit=self.scroll_size,
+                    offset=next_offset,
+                    with_payload=True,
+                    with_vectors=False,
+                )
+                self._process_records_fields_info(records, fields_info)
+                if self._check_stop_scrolling(next_offset):
+                    break
 
             return fields_info
         except Exception as e:
@@ -1654,7 +1666,7 @@ class QdrantDocumentStore:
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             ).groups
-            return self._process_group_results(groups)
+            return self._process_group_results(groups, scale_score=scale_score)
         else:
             points = self._client.query_points(
                 collection_name=self.index,
@@ -1716,7 +1728,7 @@ class QdrantDocumentStore:
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             ).groups
-            return self._process_group_results(groups)
+            return self._process_group_results(groups, scale_score=scale_score)
 
         else:
             points = self._client.query_points(
@@ -1914,7 +1926,7 @@ class QdrantDocumentStore:
                 score_threshold=score_threshold,
             )
             groups = response.groups
-            return self._process_group_results(groups)
+            return self._process_group_results(groups, scale_score=scale_score)
         else:
             query_response = await self._async_client.query_points(
                 collection_name=self.index,
@@ -1978,7 +1990,7 @@ class QdrantDocumentStore:
                 score_threshold=score_threshold,
             )
             groups = response.groups
-            return self._process_group_results(groups)
+            return self._process_group_results(groups, scale_score=scale_score)
         else:
             query_response = await self._async_client.query_points(
                 collection_name=self.index,
@@ -2485,6 +2497,7 @@ class QdrantDocumentStore:
             # when using a hosted Qdrant service, which means running to_dict() exposes the api key.
             "metadata": {**self.metadata},
             "force_disable_check_same_thread": self.force_disable_check_same_thread,
+            **{key: {**value} if isinstance(value, dict) else value for key, value in self.client_kwargs.items()},
         }
 
     def _prepare_collection_config(
@@ -2568,7 +2581,7 @@ class QdrantDocumentStore:
 
         return documents
 
-    def _process_group_results(self, groups: list[rest.PointGroup]) -> list[Document]:
+    def _process_group_results(self, groups: list[rest.PointGroup], scale_score: bool = False) -> list[Document]:
         """
         Processes grouped query results from Qdrant.
 
@@ -2576,11 +2589,9 @@ class QdrantDocumentStore:
         if not groups:
             return []
 
-        return [
-            convert_qdrant_point_to_haystack_document(point, use_sparse_embeddings=self.use_sparse_embeddings)
-            for group in groups
-            for point in group.hits
-        ]
+        return self._process_query_point_results(
+            [point for group in groups for point in group.hits], scale_score=scale_score
+        )
 
     def _validate_collection_compatibility(
         self,

{qdrant_haystack-13.0.0 → qdrant_haystack-13.1.1}/src/haystack_integrations/document_stores/qdrant/filters.py

@@ -79,7 +79,9 @@ def _process_logical_operator(item: dict[str, Any]) -> models.Condition | None:
     elif operator == "OR":
         return models.Filter(should=nested_conditions)
     elif operator == "NOT":
-        return models.Filter(must_not=nested_conditions)
+        # Haystack's NOT negates the conjunction of its conditions. `must_not` on its own excludes points
+        # that match any condition, which would negate the disjunction instead.
+        return models.Filter(must_not=[models.Filter(must=nested_conditions)])
 
     return None
 
@@ -134,7 +136,19 @@ def _build_comparison_condition(operator: str, key: str, value: Any) -> models.C
     return builder(key, value)
 
 
+# Qdrant compares ranges as float64, so ints beyond 2**53 can't be matched exactly with a range.
+_MAX_EXACT_FLOAT_INT = 2**53
+
+
 def _build_eq_condition(key: str, value: models.ValueVariants) -> models.Condition:
+    # Qdrant ranges are compared as float64, so a huge int can't be matched exactly: keep MatchValue for it.
+    if (
+        isinstance(value, (int, float))
+        and not isinstance(value, bool)
+        and not (isinstance(value, int) and abs(value) > _MAX_EXACT_FLOAT_INT)
+    ):
+        # MatchValue rejects floats and doesn't match float payloads for int values; a closed range does both.
+        return models.FieldCondition(key=key, range=models.Range(gte=value, lte=value))
     return models.FieldCondition(key=key, match=models.MatchValue(value=value))
 
 

{qdrant_haystack-13.0.0 → qdrant_haystack-13.1.1}/tests/test_dict_converters.py

@@ -43,6 +43,7 @@ def test_to_dict():
             "write_batch_size": 100,
             "scroll_size": 10000,
             "payload_fields_to_index": None,
+            "client_kwargs": {},
         },
     }
 
@@ -73,6 +74,7 @@ def test_from_dict():
                 "write_batch_size": 1000,
                 "scroll_size": 10000,
                 "payload_fields_to_index": None,
+                "client_kwargs": {"check_compatibility": False},
             },
         }
     )
@@ -102,5 +104,6 @@ def test_from_dict():
             document_store.scroll_size == 10000,
             document_store.api_key == Secret.from_env_var("ENV_VAR", strict=False),
             document_store.payload_fields_to_index is None,
+            document_store.client_kwargs == {"check_compatibility": False},
         ]
     )

{qdrant_haystack-13.0.0 → qdrant_haystack-13.1.1}/tests/test_document_store.py

@@ -49,6 +49,7 @@ class TestQdrantDocumentStoreUnit:
             wait_result_from_api=True,
             use_sparse_embeddings=False,
             api_key=Secret.from_env_var("QDRANT_API_KEY"),
+            client_kwargs={"check_compatibility": False},
         )
         expected_dict = {
             "type": "haystack_integrations.document_stores.qdrant.document_store.QdrantDocumentStore",
@@ -91,6 +92,7 @@ class TestQdrantDocumentStoreUnit:
                 "write_batch_size": 100,
                 "scroll_size": 10000,
                 "payload_fields_to_index": None,
+                "client_kwargs": {"check_compatibility": False},
             },
         }
         assert doc_store.to_dict() == expected_dict
@@ -347,6 +349,30 @@ class TestQdrantDocumentStoreUnit:
         params["metadata"]["added"] = "x"
         assert metadata == {"key": "value"}
 
+    def test_prepare_client_params_does_not_mutate_client_kwargs(self):
+        client_kwargs = {"grpc_options": {"custom_option": "value"}}
+        document_store = QdrantDocumentStore(location=":memory:", client_kwargs=client_kwargs)
+        params = document_store._prepare_client_params()
+        params["grpc_options"]["grpc.primary_user_agent"] = "qdrant-client"
+
+        assert client_kwargs == {"grpc_options": {"custom_option": "value"}}
+        assert document_store.to_dict()["init_parameters"]["client_kwargs"] == client_kwargs
+
+    @pytest.mark.parametrize("port", [6333, 7333])
+    def test_client_kwargs_are_forwarded_with_client_kwargs_taking_precedence(self, port):
+        document_store = QdrantDocumentStore(
+            location=":memory:", port=port, client_kwargs={"check_compatibility": False, "port": 8333}
+        )
+
+        with (
+            patch("haystack_integrations.document_stores.qdrant.document_store.qdrant_client.QdrantClient") as client,
+            patch.object(document_store, "_set_up_collection"),
+        ):
+            document_store._initialize_client()
+
+        assert client.call_args.kwargs["check_compatibility"] is False
+        assert client.call_args.kwargs["port"] == 8333
+
     def test_get_batches_from_generator(self):
         batches = list(get_batches_from_generator([1, 2, 3, 4, 5], 2))
         assert batches == [(1, 2), (3, 4), (5,)]
@@ -403,6 +429,23 @@ class TestQdrantDocumentStoreUnit:
                 getattr(document_store, method_name)(*args)
             assert exc_info.value.__cause__ is err
 
+    def test_get_metadata_fields_info_includes_unindexed_fields_when_some_are_indexed(self):
+        document_store = QdrantDocumentStore(location=":memory:")
+        schema = {"meta.category": rest.PayloadIndexInfo(data_type=rest.PayloadSchemaType.TEXT, points=1)}
+        client = MagicMock()
+        client.get_collection.return_value = SimpleNamespace(payload_schema=schema)
+        client.scroll.return_value = (
+            [SimpleNamespace(payload={"meta": {"category": "news", "priority": 1}})],
+            None,
+        )
+        document_store._client = client
+
+        fields = document_store.get_metadata_fields_info()
+
+        # "news" would be inferred as "keyword", so "text" proves the indexed type wins.
+        assert fields == {"category": {"type": "text"}, "priority": {"type": "long"}}
+        client.scroll.assert_called_once()
+
     def test_close(self):
         document_store = QdrantDocumentStore(location=":memory:")
         mock_client = MagicMock()
@@ -426,6 +469,36 @@ class TestQdrantDocumentStoreUnit:
 
         assert document_store._client is None
 
+    @pytest.mark.parametrize(
+        "method_name, query_kwargs",
+        [
+            ("_query_by_embedding", {"query_embedding": [0.1] * 768}),
+            ("_query_by_sparse", {"query_sparse_embedding": SparseEmbedding(indices=[0], values=[0.1])}),
+        ],
+    )
+    @pytest.mark.parametrize("scale_score, expected_score", [(True, 0.75), (False, 0.5)])
+    def test_query_with_group_by_scale_score(self, method_name, query_kwargs, scale_score, expected_score):
+        document_store = QdrantDocumentStore(location=":memory:", similarity="cosine", use_sparse_embeddings=True)
+        mock_client = MagicMock()
+        point = rest.ScoredPoint(id=1, version=0, score=0.5, payload={"id": "1", "content": "doc"})
+        mock_client.query_points_groups.return_value.groups = [rest.PointGroup(id="a", hits=[point])]
+        document_store._client = mock_client
+
+        result = getattr(document_store, method_name)(**query_kwargs, group_by="meta.group", scale_score=scale_score)
+
+        assert [doc.score for doc in result] == [expected_score]
+
+    def test_write_documents_progress_bar_counts_documents(self):
+        document_store = QdrantDocumentStore(location=":memory:", write_batch_size=2)
+        document_store._client = MagicMock()
+        with patch("haystack_integrations.document_stores.qdrant.document_store.tqdm") as mock_tqdm:
+            document_store.write_documents(
+                [Document(content=str(i)) for i in range(3)], policy=DuplicatePolicy.OVERWRITE
+            )
+
+        progress_bar = mock_tqdm.return_value.__enter__.return_value
+        assert [c.args[0] for c in progress_bar.update.call_args_list] == [2, 1]
+
 
 @pytest.mark.integration
 class TestQdrantDocumentStore(

{qdrant_haystack-13.0.0 → qdrant_haystack-13.1.1}/tests/test_document_store_async.py

@@ -1,3 +1,4 @@
+from types import SimpleNamespace
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
@@ -35,6 +36,23 @@ from haystack_integrations.document_stores.qdrant.document_store import (
 
 @pytest.mark.asyncio
 class TestQdrantDocumentStoreAsyncUnit:
+    @pytest.mark.parametrize("port", [6333, 7333])
+    async def test_client_kwargs_are_forwarded_async(self, port):
+        document_store = QdrantDocumentStore(
+            location=":memory:", port=port, client_kwargs={"check_compatibility": False, "port": 8333}
+        )
+
+        with (
+            patch(
+                "haystack_integrations.document_stores.qdrant.document_store.qdrant_client.AsyncQdrantClient"
+            ) as client,
+            patch.object(document_store, "_set_up_collection_async", new_callable=AsyncMock),
+        ):
+            await document_store._initialize_async_client()
+
+        assert client.call_args.kwargs["check_compatibility"] is False
+        assert client.call_args.kwargs["port"] == 8333
+
     async def test_query_hybrid_search_batch_failure_async(self):
         document_store = QdrantDocumentStore(location=":memory:", use_sparse_embeddings=True)
         await document_store._initialize_async_client()
@@ -167,6 +185,22 @@ class TestQdrantDocumentStoreAsyncUnit:
                 await getattr(document_store, method_name)(*args)
             assert exc_info.value.__cause__ is err
 
+    async def test_get_metadata_fields_info_async_includes_unindexed_fields_when_some_are_indexed(self):
+        document_store = QdrantDocumentStore(location=":memory:")
+        schema = {"meta.category": rest.PayloadIndexInfo(data_type=rest.PayloadSchemaType.TEXT, points=1)}
+        client = AsyncMock()
+        client.get_collection.return_value = SimpleNamespace(payload_schema=schema)
+        client.scroll.return_value = (
+            [SimpleNamespace(payload={"meta": {"category": "news", "priority": 1}})],
+            None,
+        )
+        document_store._async_client = client
+
+        fields = await document_store.get_metadata_fields_info_async()
+
+        assert fields == {"category": {"type": "text"}, "priority": {"type": "long"}}
+        client.scroll.assert_awaited_once()
+
     async def test_close_async(self):
         document_store = QdrantDocumentStore(location=":memory:")
         mock_client = AsyncMock()
@@ -190,6 +224,38 @@ class TestQdrantDocumentStoreAsyncUnit:
 
         assert document_store._async_client is None
 
+    @pytest.mark.parametrize(
+        "method_name, query_kwargs",
+        [
+            ("_query_by_embedding_async", {"query_embedding": [0.1] * 768}),
+            ("_query_by_sparse_async", {"query_sparse_embedding": SparseEmbedding(indices=[0], values=[0.1])}),
+        ],
+    )
+    @pytest.mark.parametrize("scale_score, expected_score", [(True, 0.75), (False, 0.5)])
+    async def test_query_with_group_by_scale_score_async(self, method_name, query_kwargs, scale_score, expected_score):
+        document_store = QdrantDocumentStore(location=":memory:", similarity="cosine", use_sparse_embeddings=True)
+        mock_client = AsyncMock()
+        point = rest.ScoredPoint(id=1, version=0, score=0.5, payload={"id": "1", "content": "doc"})
+        mock_client.query_points_groups.return_value = rest.GroupsResult(groups=[rest.PointGroup(id="a", hits=[point])])
+        document_store._async_client = mock_client
+
+        result = await getattr(document_store, method_name)(
+            **query_kwargs, group_by="meta.group", scale_score=scale_score
+        )
+
+        assert [doc.score for doc in result] == [expected_score]
+
+    async def test_write_documents_async_progress_bar_counts_documents(self):
+        document_store = QdrantDocumentStore(location=":memory:", write_batch_size=2)
+        document_store._async_client = AsyncMock()
+        with patch("haystack_integrations.document_stores.qdrant.document_store.tqdm") as mock_tqdm:
+            await document_store.write_documents_async(
+                [Document(content=str(i)) for i in range(3)], policy=DuplicatePolicy.OVERWRITE
+            )
+
+        progress_bar = mock_tqdm.return_value.__enter__.return_value
+        assert [c.args[0] for c in progress_bar.update.call_args_list] == [2, 1]
+
 
 @pytest.mark.integration
 @pytest.mark.asyncio

{qdrant_haystack-13.0.0 → qdrant_haystack-13.1.1}/tests/test_embedding_retriever.py

@@ -83,6 +83,7 @@ class TestQdrantRetriever:
                         "write_batch_size": 100,
                         "scroll_size": 10000,
                         "payload_fields_to_index": None,
+                        "client_kwargs": {},
                     },
                 },
                 "filters": None,

{qdrant_haystack-13.0.0 → qdrant_haystack-13.1.1}/tests/test_filters.py

@@ -73,6 +73,46 @@ class TestConvertFiltersToQdrantUnit:
         assert isinstance(qdrant_filter, models.Filter)
         assert len(qdrant_filter.must) == 2
 
+    @pytest.mark.parametrize("value", [4, 4.5, -3, 2**53])
+    def test_eq_numeric_uses_closed_range(self, value):
+        qdrant_filter = convert_filters_to_qdrant({"operator": "==", "field": "meta.x", "value": value})
+        condition = qdrant_filter.must[0]
+        assert condition.match is None
+        assert condition.range == models.Range(gte=value, lte=value)
+
+    @pytest.mark.parametrize("value", [True, False, "a", 2**53 + 1, -(2**60)])
+    def test_eq_non_numeric_or_unsafe_int_keeps_match_value(self, value):
+        qdrant_filter = convert_filters_to_qdrant({"operator": "==", "field": "meta.x", "value": value})
+        condition = qdrant_filter.must[0]
+        assert condition.range is None
+        assert condition.match == models.MatchValue(value=value)
+        assert type(condition.match.value) is type(value)
+
+    def test_in_and_not_in_mixed_numerics(self):
+        values = [1, 2.5, "a", True]
+        in_filter = convert_filters_to_qdrant({"operator": "in", "field": "meta.x", "value": values})
+        nin_filter = convert_filters_to_qdrant({"operator": "not in", "field": "meta.x", "value": values})
+        for conditions in (in_filter.should, nin_filter.must_not):
+            assert [(c.range, c.match) for c in conditions] == [
+                (models.Range(gte=1, lte=1), None),
+                (models.Range(gte=2.5, lte=2.5), None),
+                (None, models.MatchValue(value="a")),
+                (None, models.MatchValue(value=True)),
+            ]
+
+    def test_ne_float(self):
+        qdrant_filter = convert_filters_to_qdrant({"operator": "!=", "field": "meta.x", "value": 4.5})
+        assert qdrant_filter.must_not[0].range == models.Range(gte=4.5, lte=4.5)
+
+    def test_not_negates_the_conjunction_of_its_conditions(self):
+        a = {"operator": "==", "field": "meta.a", "value": 1}
+        b = {"operator": "==", "field": "meta.b", "value": 2}
+        qdrant_filter = convert_filters_to_qdrant({"operator": "NOT", "conditions": [a, b]})
+        # `must_not` alone would exclude points matching either condition
+        assert qdrant_filter == models.Filter(
+            must_not=[models.Filter(must=[convert_filters_to_qdrant(a).must[0], convert_filters_to_qdrant(b).must[0]])]
+        )
+
 
 def test_is_datetime_string():
     assert is_datetime_string("2024-01-01T00:00:00") is True
@@ -165,22 +205,6 @@ class TestQdrantFilters(FilterDocumentsTest):
         # Check that the sets are equal, meaning the content and IDs match regardless of order
         assert {doc.id for doc in received} == {doc.id for doc in expected}
 
-    def test_not_operator(self, document_store, filterable_docs):
-        document_store.write_documents(filterable_docs)
-        result = document_store.filter_documents(
-            filters={
-                "operator": "NOT",
-                "conditions": [
-                    {"field": "meta.number", "operator": "==", "value": 100},
-                    {"field": "meta.name", "operator": "==", "value": "name_0"},
-                ],
-            }
-        )
-        self.assert_documents_are_equal(
-            result,
-            [d for d in filterable_docs if (d.meta.get("number") != 100 and d.meta.get("name") != "name_0")],
-        )
-
     def test_filter_criteria(self, document_store):
         documents = [
             Document(
@@ -329,3 +353,39 @@ class TestQdrantFilters(FilterDocumentsTest):
 
     @pytest.mark.skip(reason="Cannot distinguish errors yet")
     def test_missing_top_level_operator_key(self, document_store, filterable_docs): ...
+
+    @pytest.mark.parametrize(
+        ("operator", "value", "expected"),
+        [
+            ("==", 4, [4, 4.0]),
+            ("==", 4.5, [4.5]),
+            ("==", 4.0, [4, 4.0]),
+            ("!=", 4.5, [3, 4, 4.0]),
+            ("!=", 4, [3, 4.5]),
+            ("in", [3, 4.5], [3, 4.5]),
+            ("in", [4.0, 9], [4, 4.0]),
+            ("not in", [3, 4.5], [4, 4.0]),
+            ("not in", [4, 9.5], [3, 4.5]),
+        ],
+    )
+    def test_numeric_filters_match_int_and_float_payloads(self, document_store, operator, value, expected):
+        ratings = [3, 4, 4.0, 4.5]
+        document_store.write_documents(
+            [Document(content=str(r), meta={"rating": r}, embedding=[0.1] * 768) for r in ratings]
+        )
+
+        result = document_store.filter_documents({"field": "meta.rating", "operator": operator, "value": value})
+
+        assert sorted(d.meta["rating"] for d in result) == sorted(expected)
+
+    def test_eq_bool_does_not_match_numeric_payload(self, document_store):
+        document_store.write_documents(
+            [
+                Document(content="int", meta={"flag": 1}, embedding=[0.1] * 768),
+                Document(content="bool", meta={"flag": True}, embedding=[0.1] * 768),
+            ]
+        )
+
+        result = document_store.filter_documents({"field": "meta.flag", "operator": "==", "value": True})
+
+        assert [d.content for d in result] == ["bool"]

{qdrant_haystack-13.0.0 → qdrant_haystack-13.1.1}/tests/test_hybrid_retriever.py

@@ -81,6 +81,7 @@ class TestQdrantHybridRetriever:
                         "write_batch_size": 100,
                         "scroll_size": 10000,
                         "payload_fields_to_index": None,
+                        "client_kwargs": {},
                     },
                 },
                 "filters": None,

{qdrant_haystack-13.0.0 → qdrant_haystack-13.1.1}/tests/test_sparse_embedding_retriever.py

@@ -82,6 +82,7 @@ class TestQdrantSparseEmbeddingRetriever:
                         "write_batch_size": 100,
                         "scroll_size": 10000,
                         "payload_fields_to_index": None,
+                        "client_kwargs": {},
                     },
                 },
                 "filters": None,