qdrant-haystack 10.3.0__tar.gz → 10.4.0__tar.gz

{qdrant_haystack-10.3.0 → qdrant_haystack-10.4.0}/CHANGELOG.md

@@ -1,5 +1,48 @@
 # Changelog
 
+## [integrations/qdrant-v10.3.1] - 2026-07-06
+
+### 🐛 Bug Fixes
+
+- Replace in-place dataclass mutations in document stores (#3114)
+
+### 📚 Documentation
+
+- Replace old haystack core imports with haystack_integrations paths (#3545)
+
+### 🧪 Testing
+
+- Track test coverage for all integrations (#3065)
+- Mark some tests as integration in Faiss and Qdrant (#3076)
+- Qdrant - add unit tests (#3183)
+- Qdrant - add more unit tests (#3221)
+- *(qdrant)* Use async DocumentStore mixin tests (#3093)
+
+### 🧹 Chores
+
+- Enforce ruff docstring rules in integrations 31-40 (openrouter, opensearch, optimum, paddleocr, pgvector, pinecone, pyversity, qdrant, ragas, snowflake) (#3011)
+
+
+## [integrations/qdrant-v10.3.0] - 2026-03-23
+
+### 📚 Documentation
+
+- Simplify pydoc configs (#2855)
+
+### 🧪 Testing
+
+- Replacing each `DocumentStore` specific tests and used the generalised ones from `haystack.testing.document_store` (#2812)
+- Test compatible integrations with python 3.14; update pyproject (#3001)
+
+### 🧹 Chores
+
+- Standardize author mentions (#2897)
+- Add ANN ruff ruleset to optimum, paddleocr, pgvector, pinecone, pyversity, qdrant, ragas, snowflake (#2992)
+
+### 🌀 Miscellaneous
+
+- !test: `QdrantDocumentStore` use Mixin tests +  updated signature `get_metadata_fields_info(self) -> dict[str, dict[str, str]]`: (#3004)
+
 ## [integrations/qdrant-v10.2.1] - 2026-02-02
 
 ### 📚 Documentation

{qdrant_haystack-10.3.0 → qdrant_haystack-10.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qdrant-haystack
-Version: 10.3.0
+Version: 10.4.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
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.10
-Requires-Dist: haystack-ai>=2.26.1
+Requires-Dist: haystack-ai>=2.29.0
 Requires-Dist: qdrant-client>=1.12.0
 Description-Content-Type: text/markdown
 

{qdrant_haystack-10.3.0 → qdrant_haystack-10.4.0}/examples/embedding_retrieval.py

@@ -9,9 +9,12 @@ import glob
 
 from haystack import Pipeline
 from haystack.components.converters import MarkdownToDocument
-from haystack.components.embedders import SentenceTransformersDocumentEmbedder, SentenceTransformersTextEmbedder
 from haystack.components.preprocessors import DocumentSplitter
 from haystack.components.writers import DocumentWriter
+from haystack_integrations.components.embedders.sentence_transformers import (
+    SentenceTransformersDocumentEmbedder,
+    SentenceTransformersTextEmbedder,
+)
 
 from haystack_integrations.components.retrievers.qdrant import QdrantEmbeddingRetriever
 from haystack_integrations.document_stores.qdrant import QdrantDocumentStore

{qdrant_haystack-10.3.0 → qdrant_haystack-10.4.0}/pyproject.toml

@@ -28,7 +28,7 @@ classifiers = [
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
 dependencies = [
-  "haystack-ai>=2.26.1",
+  "haystack-ai>=2.29.0",
   "qdrant-client>=1.12.0"
 ]
 
@@ -71,7 +71,8 @@ dependencies = [
 unit = 'pytest -m "not integration" {args:tests}'
 integration = 'pytest -m "integration" {args:tests}'
 all = 'pytest {args:tests}'
-cov-retry = 'pytest --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x {args:tests}'
+unit-cov-retry = 'pytest --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x -m "not integration" {args:tests}'
+integration-cov-append-retry = 'pytest --cov=haystack_integrations --cov-append --reruns 3 --reruns-delay 30 -x -m "integration" {args:tests}'
 
 types = """mypy -p haystack_integrations.document_stores.qdrant \
 -p haystack_integrations.components.retrievers.qdrant {args}"""
@@ -93,6 +94,13 @@ select = [
   "ARG",
   "B",
   "C",
+  "D102",   # Missing docstring in public method
+  "D103",   # Missing docstring in public function
+  "D205",   # 1 blank line required between summary line and description
+  "D209",   # Closing triple quotes go to new line
+  "D213",   # summary lines must be positioned on the second physical line of the docstring
+  "D417",   # Missing argument descriptions in the docstring
+  "D419",   # Docstring is empty
   "DTZ",
   "E",
   "EM",
@@ -135,6 +143,7 @@ ignore = [
   "PLR0912",
   "PLR0913",
   "PLR0915",
+  "PLR0917",
   # Ignore assertions
   "S101",
 ]
@@ -144,14 +153,15 @@ ban-relative-imports = "parents"
 
 [tool.ruff.lint.per-file-ignores]
 # Tests can use magic values, assertions, and relative imports
-"tests/**/*" = ["PLR2004", "S101", "TID252", "ANN"]
+"tests/**/*" = ["D", "PLR2004", "S101", "TID252", "ANN"]
 # examples can contain "print" commands
-"examples/**/*" = ["T201"]
+"examples/**/*" = ["D", "T201"]
 
 
 [tool.coverage.run]
 source = ["haystack_integrations"]
 branch = true
+relative_files = true
 parallel = false
 
 
@@ -163,3 +173,10 @@ omit = [
 ]
 show_missing = true
 exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
+
+[tool.pytest.ini_options]
+addopts = "--strict-markers"
+markers = [
+  "integration: integration tests",
+]
+log_cli = true

{qdrant_haystack-10.3.0 → qdrant_haystack-10.4.0}/src/haystack_integrations/components/retrievers/qdrant/retriever.py

@@ -130,6 +130,18 @@ class QdrantEmbeddingRetriever:
             data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(filter_policy)
         return default_from_dict(cls, data)
 
+    def close(self) -> None:
+        """
+        Release the synchronous resources of the underlying Document Store.
+        """
+        self._document_store.close()
+
+    async def close_async(self) -> None:
+        """
+        Release the asynchronous resources of the underlying Document Store.
+        """
+        await self._document_store.close_async()
+
     @component.output_types(documents=list[Document])
     def run(
         self,
@@ -358,6 +370,18 @@ class QdrantSparseEmbeddingRetriever:
             data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(filter_policy)
         return default_from_dict(cls, data)
 
+    def close(self) -> None:
+        """
+        Release the synchronous resources of the underlying Document Store.
+        """
+        self._document_store.close()
+
+    async def close_async(self) -> None:
+        """
+        Release the asynchronous resources of the underlying Document Store.
+        """
+        await self._document_store.close_async()
+
     @component.output_types(documents=list[Document])
     def run(
         self,
@@ -482,8 +506,9 @@ class QdrantSparseEmbeddingRetriever:
 @component
 class QdrantHybridRetriever:
     """
-    A component for retrieving documents from an QdrantDocumentStore using both dense and sparse vectors
-    and fusing the results using Reciprocal Rank Fusion.
+    A component for retrieving documents from a QdrantDocumentStore using both dense and sparse vectors.
+
+    Fuses the results using Reciprocal Rank Fusion.
 
     Usage example:
     ```python
@@ -595,6 +620,18 @@ class QdrantHybridRetriever:
             data["init_parameters"]["filter_policy"] = FilterPolicy.from_str(filter_policy)
         return default_from_dict(cls, data)
 
+    def close(self) -> None:
+        """
+        Release the synchronous resources of the underlying Document Store.
+        """
+        self._document_store.close()
+
+    async def close_async(self) -> None:
+        """
+        Release the asynchronous resources of the underlying Document Store.
+        """
+        await self._document_store.close_async()
+
     @component.output_types(documents=list[Document])
     def run(
         self,

{qdrant_haystack-10.3.0 → qdrant_haystack-10.4.0}/src/haystack_integrations/document_stores/qdrant/converters.py

@@ -18,6 +18,7 @@ def convert_haystack_documents_to_qdrant_points(
     *,
     use_sparse_embeddings: bool,
 ) -> list[rest.PointStruct]:
+    """Convert a list of Haystack Document objects to Qdrant PointStruct objects."""
     points = []
     for document in documents:
         payload = document.to_dict(flatten=False)
@@ -61,6 +62,7 @@ QdrantPoint = rest.ScoredPoint | rest.Record
 
 
 def convert_qdrant_point_to_haystack_document(point: QdrantPoint, use_sparse_embeddings: bool) -> Document:
+    """Convert a Qdrant ScoredPoint or Record to a Haystack Document object."""
     payload = point.payload or {}
     payload["score"] = point.score if hasattr(point, "score") else None
 

{qdrant_haystack-10.3.0 → qdrant_haystack-10.4.0}/src/haystack_integrations/document_stores/qdrant/document_store.py

@@ -1,5 +1,7 @@
 import inspect
 from collections.abc import AsyncGenerator, Generator
+from contextlib import suppress
+from dataclasses import replace
 from itertools import islice
 from typing import Any, ClassVar, cast
 
@@ -54,8 +56,9 @@ def get_batches_from_generator(iterable: list, n: int) -> Generator:
 
 class QdrantDocumentStore:
     """
-    A QdrantDocumentStore implementation that you can use with any Qdrant instance: in-memory, disk-persisted,
-    Docker-based, and Qdrant Cloud Cluster deployments.
+    A QdrantDocumentStore implementation that you can use with any Qdrant instance.
+
+    Supports in-memory, disk-persisted, Docker-based, and Qdrant Cloud Cluster deployments.
 
     Usage example by creating an in-memory instance:
 
@@ -299,6 +302,24 @@ class QdrantDocumentStore:
                 self.payload_fields_to_index,
             )
 
+    def close(self) -> None:
+        """
+        Release the associated synchronous resources.
+        """
+        if self._client is not None:
+            with suppress(Exception):
+                self._client.close()
+            self._client = None
+
+    async def close_async(self) -> None:
+        """
+        Release the associated asynchronous resources.
+        """
+        if self._async_client is not None:
+            with suppress(Exception):
+                await self._async_client.close()
+            self._async_client = None
+
     def count_documents(self) -> int:
         """
         Returns the number of documents present in the Document Store.
@@ -376,6 +397,7 @@ class QdrantDocumentStore:
     ) -> int:
         """
         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.
@@ -429,6 +451,7 @@ class QdrantDocumentStore:
     ) -> int:
         """
         Asynchronously 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.
@@ -1223,8 +1246,9 @@ class QdrantDocumentStore:
         self, filters: dict[str, Any], metadata_fields: list[str]
     ) -> dict[str, int]:
         """
-        Asynchronously returns the number of unique values for each specified metadata field among documents that
-        match the filters.
+        Asynchronously returns the number of unique values for each specified metadata field among documents.
+
+        Only documents that match the filters are considered.
 
         :param filters: The filters to restrict the documents considered.
             For filter syntax, see [Haystack metadata filtering](https://docs.haystack.deepset.ai/docs/metadata-filtering)
@@ -1926,8 +1950,9 @@ class QdrantDocumentStore:
         group_size: int | None = None,
     ) -> list[Document]:
         """
-        Asynchronously retrieves documents based on dense and sparse embeddings and fuses
-        the results using Reciprocal Rank Fusion.
+        Asynchronously retrieves documents based on dense and sparse embeddings.
+
+        Fuses the results using Reciprocal Rank Fusion.
 
         This method is not part of the public interface of `QdrantDocumentStore` and shouldn't be used directly.
         Use the `QdrantHybridRetriever` instead.
@@ -2292,8 +2317,9 @@ class QdrantDocumentStore:
         policy: DuplicatePolicy | None = None,
     ) -> list[Document]:
         """
-        Checks whether any of the passed documents is already existing in the chosen index and returns a list of
-        documents that are not in the index yet.
+        Checks whether any of the passed documents is already existing in the chosen index.
+
+        Returns a list of documents that are not in the index yet.
 
         :param documents: A list of Haystack Document objects.
         :param policy: The duplicate policy to use when writing documents.
@@ -2319,9 +2345,9 @@ class QdrantDocumentStore:
         policy: DuplicatePolicy | None = None,
     ) -> list[Document]:
         """
-        Asynchronously checks whether any of the passed documents is already existing
-        in the chosen index and returns a list of
-        documents that are not in the index yet.
+        Asynchronously checks whether any of the passed documents is already existing in the chosen index.
+
+        Returns a list of documents that are not in the index yet.
 
         :param documents: A list of Haystack Document objects.
         :param policy: The duplicate policy to use when writing documents.
@@ -2468,15 +2494,17 @@ class QdrantDocumentStore:
         ]
 
         if scale_score:
-            for document in documents:
-                score = document.score
-                if score is None:
-                    continue
-                if self.similarity == "cosine":
-                    score = (score + 1) / 2
-                else:
-                    score = float(1 / (1 + exp(-score / 100)))
-                document.score = score
+            documents = [
+                replace(
+                    document,
+                    score=(document.score + 1) / 2
+                    if self.similarity == "cosine"
+                    else float(1 / (1 + exp(-document.score / 100))),
+                )
+                if document.score is not None
+                else document
+                for document in documents
+            ]
 
         return documents
 

{qdrant_haystack-10.3.0 → qdrant_haystack-10.4.0}/src/haystack_integrations/document_stores/qdrant/filters.py

@@ -9,7 +9,8 @@ from qdrant_client.http import models
 def convert_filters_to_qdrant(
     filter_term: list[dict[str, Any]] | dict[str, Any] | models.Filter | None = None,
 ) -> models.Filter | None:
-    """Converts Haystack filters to the format used by Qdrant.
+    """
+    Converts Haystack filters to the format used by Qdrant.
 
     :param filter_term: the haystack filter to be converted to qdrant.
     :returns: a single Qdrant Filter or None.
@@ -228,6 +229,7 @@ def _build_gte_condition(key: str, value: str | float | int) -> models.Condition
 
 
 def is_datetime_string(value: str) -> bool:
+    """Return True if the given string can be parsed as an ISO 8601 datetime, False otherwise."""
     try:
         datetime.fromisoformat(value)
         return True

qdrant_haystack-10.4.0/tests/test_converters.py

@@ -0,0 +1,144 @@
+from types import SimpleNamespace
+
+import numpy as np
+import pytest
+from haystack.dataclasses import Document, SparseEmbedding
+from qdrant_client.http import models as rest
+
+from haystack_integrations.document_stores.qdrant.converters import (
+    DENSE_VECTORS_NAME,
+    SPARSE_VECTORS_NAME,
+    convert_haystack_documents_to_qdrant_points,
+    convert_id,
+    convert_qdrant_point_to_haystack_document,
+)
+
+
+def test_convert_id_is_deterministic():
+    first_id = convert_id("test-id")
+    second_id = convert_id("test-id")
+    assert first_id == second_id
+
+
+def test_point_to_document_reverts_proper_structure_from_record_with_sparse():
+    point = rest.Record(
+        id="c7c62e8e-02b9-4ec6-9f88-46bd97b628b7",
+        payload={
+            "id": "my-id",
+            "id_hash_keys": ["content"],
+            "content": "Lorem ipsum",
+            "content_type": "text",
+            "meta": {
+                "test_field": 1,
+            },
+        },
+        vector={
+            "text-dense": [1.0, 0.0, 0.0, 0.0],
+            "text-sparse": {"indices": [7, 1024, 367], "values": [0.1, 0.98, 0.33]},
+        },
+    )
+    document = convert_qdrant_point_to_haystack_document(point, use_sparse_embeddings=True)
+    assert "my-id" == document.id
+    assert "Lorem ipsum" == document.content
+    assert "text" == document.content_type
+    assert {"indices": [7, 1024, 367], "values": [0.1, 0.98, 0.33]} == document.sparse_embedding.to_dict()
+    assert {"test_field": 1} == document.meta
+    assert 0.0 == np.sum(np.array([1.0, 0.0, 0.0, 0.0]) - document.embedding)
+
+
+def test_point_to_document_reverts_proper_structure_from_record_without_sparse():
+    point = rest.Record(
+        id="c7c62e8e-02b9-4ec6-9f88-46bd97b628b7",
+        payload={
+            "id": "my-id",
+            "id_hash_keys": ["content"],
+            "content": "Lorem ipsum",
+            "content_type": "text",
+            "meta": {
+                "test_field": 1,
+            },
+        },
+        vector=[1.0, 0.0, 0.0, 0.0],
+    )
+    document = convert_qdrant_point_to_haystack_document(point, use_sparse_embeddings=False)
+    assert "my-id" == document.id
+    assert "Lorem ipsum" == document.content
+    assert "text" == document.content_type
+    assert document.sparse_embedding is None
+    assert {"test_field": 1} == document.meta
+    assert 0.0 == np.sum(np.array([1.0, 0.0, 0.0, 0.0]) - document.embedding)
+
+
+def test_point_to_document_with_sparse_enabled_but_vector_none():
+    point = rest.Record(
+        id="c7c62e8e-02b9-4ec6-9f88-46bd97b628b7",
+        payload={"id": "my-id", "content": "Lorem"},
+        vector=None,
+    )
+    document = convert_qdrant_point_to_haystack_document(point, use_sparse_embeddings=True)
+    assert document.embedding is None
+    assert document.sparse_embedding is None
+
+
+def test_point_to_document_preserves_score_from_scored_point():
+    point = rest.ScoredPoint(
+        id="c7c62e8e-02b9-4ec6-9f88-46bd97b628b7",
+        payload={"id": "my-id", "content": "Lorem"},
+        vector=[0.1, 0.2],
+        score=0.75,
+        version=0,
+    )
+    document = convert_qdrant_point_to_haystack_document(point, use_sparse_embeddings=False)
+    assert document.score == 0.75
+
+
+def test_convert_haystack_documents_to_qdrant_points_without_sparse():
+    doc = Document(content="hello", embedding=[0.1, 0.2, 0.3])
+    points = convert_haystack_documents_to_qdrant_points([doc], use_sparse_embeddings=False)
+    assert len(points) == 1
+    assert points[0].vector == [0.1, 0.2, 0.3]
+    assert points[0].payload["content"] == "hello"
+    assert "embedding" not in points[0].payload
+
+
+def test_convert_haystack_documents_to_qdrant_points_without_sparse_without_embedding():
+    doc = Document(content="hello")
+    points = convert_haystack_documents_to_qdrant_points([doc], use_sparse_embeddings=False)
+    assert points[0].vector == {}
+
+
+def test_convert_haystack_documents_to_qdrant_points_with_sparse():
+    sparse = SparseEmbedding(indices=[0, 5], values=[0.1, 0.7])
+    doc = Document(content="hello", embedding=[0.1, 0.2], sparse_embedding=sparse)
+    points = convert_haystack_documents_to_qdrant_points([doc], use_sparse_embeddings=True)
+    assert points[0].vector[DENSE_VECTORS_NAME] == [0.1, 0.2]
+    assert isinstance(points[0].vector[SPARSE_VECTORS_NAME], rest.SparseVector)
+    assert points[0].vector[SPARSE_VECTORS_NAME].indices == [0, 5]
+    assert points[0].vector[SPARSE_VECTORS_NAME].values == [0.1, 0.7]
+
+
+def test_convert_haystack_documents_to_qdrant_points_with_sparse_only_dense():
+    doc = Document(content="hello", embedding=[0.1, 0.2])
+    points = convert_haystack_documents_to_qdrant_points([doc], use_sparse_embeddings=True)
+    assert points[0].vector == {DENSE_VECTORS_NAME: [0.1, 0.2]}
+
+
+def test_convert_haystack_documents_to_qdrant_points_with_sparse_no_vectors():
+    doc = Document(content="hello")
+    points = convert_haystack_documents_to_qdrant_points([doc], use_sparse_embeddings=True)
+    assert points[0].vector == {}
+
+
+@pytest.mark.parametrize(
+    "vector",
+    [
+        {DENSE_VECTORS_NAME: [0.1, 0.2]},
+        {DENSE_VECTORS_NAME: [0.1, 0.2], SPARSE_VECTORS_NAME: {"indices": [0], "values": [0.5]}},
+    ],
+    ids=["no_sparse_key", "sparse_value_not_sparse_vector_instance"],
+)
+def test_point_to_document_sparse_vector_edge_cases(vector):
+    point = SimpleNamespace(id="x", payload={"id": "x", "content": "x"}, vector=vector)
+    document = convert_qdrant_point_to_haystack_document(point, use_sparse_embeddings=True)
+    assert document.embedding == [0.1, 0.2]
+    assert document.sparse_embedding is None