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

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

@@ -1,5 +1,12 @@
 # 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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: qdrant-haystack
-Version: 13.1.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.1.0 → qdrant_haystack-13.1.1}/src/haystack_integrations/document_stores/qdrant/document_store.py

@@ -467,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(
@@ -522,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:
@@ -694,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():
@@ -1082,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.:
@@ -1101,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:
@@ -1125,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.:
@@ -1144,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:
@@ -1664,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,
@@ -1726,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(
@@ -1924,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,
@@ -1988,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,
@@ -2579,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.
 
@@ -2587,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.1.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.1.0 → qdrant_haystack-13.1.1}/tests/test_document_store.py

@@ -429,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()
@@ -452,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.1.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
@@ -184,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()
@@ -207,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.1.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"]