qdrant-haystack 10.2.1__tar.gz → 10.3.1__tar.gz

{qdrant_haystack-10.2.1 → qdrant_haystack-10.3.1}/CHANGELOG.md

@@ -1,5 +1,32 @@
 # Changelog
 
+## [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
+
+- Fixing `QdrantDocumentStore` docstring parsing error (#2806)
+
+
 ## [integrations/qdrant-v10.2.0] - 2026-02-02
 
 ### 🌀 Miscellaneous

{qdrant_haystack-10.2.1 → qdrant_haystack-10.3.1}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: qdrant-haystack
-Version: 10.2.1
+Version: 10.3.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
 Project-URL: Issues, https://github.com/deepset-ai/haystack-core-integrations/issues
-Author-email: Kacper Łukawski <kacper.lukawski@qdrant.com>, Anush Shetty <anush.shetty@qdrant.com>
+Author-email: deepset GmbH <info@deepset.ai>, Kacper Łukawski <kacper.lukawski@qdrant.com>, Anush Shetty <anush.shetty@qdrant.com>
 License-Expression: Apache-2.0
 License-File: LICENSE.txt
 Classifier: Development Status :: 4 - Beta
@@ -15,10 +15,11 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+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.22.0
+Requires-Dist: haystack-ai>=2.29.0
 Requires-Dist: qdrant-client>=1.12.0
 Description-Content-Type: text/markdown
 

{qdrant_haystack-10.2.1 → qdrant_haystack-10.3.1}/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.1/pydoc/config_docusaurus.yml

@@ -0,0 +1,15 @@
+loaders:
+  - modules:
+      - haystack_integrations.components.retrievers.qdrant.retriever
+      - haystack_integrations.document_stores.qdrant.document_store
+      - haystack_integrations.document_stores.qdrant.migrate_to_sparse
+    search_path: [../src]
+processors:
+  - type: filter
+    documented_only: true
+    skip_empty_modules: true
+renderer:
+  description: Qdrant integration for Haystack
+  id: integrations-qdrant
+  filename: qdrant.md
+  title: Qdrant

{qdrant_haystack-10.2.1 → qdrant_haystack-10.3.1}/pyproject.toml

@@ -11,6 +11,7 @@ requires-python = ">=3.10"
 license = "Apache-2.0"
 keywords = []
 authors = [
+  { name = "deepset GmbH", email = "info@deepset.ai" },
   { name = "Kacper Łukawski", email = "kacper.lukawski@qdrant.com" },
   { name = "Anush Shetty", email = "anush.shetty@qdrant.com" },
 ]
@@ -22,10 +23,14 @@ classifiers = [
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Programming Language :: Python :: Implementation :: CPython",
   "Programming Language :: Python :: Implementation :: PyPy",
 ]
-dependencies = ["haystack-ai>=2.22.0", "qdrant-client>=1.12.0"]
+dependencies = [
+  "haystack-ai>=2.29.0",
+  "qdrant-client>=1.12.0"
+]
 
 [project.urls]
 Source = "https://github.com/deepset-ai/haystack-core-integrations"
@@ -48,7 +53,7 @@ installer = "uv"
 dependencies = ["haystack-pydoc-tools", "ruff"]
 
 [tool.hatch.envs.default.scripts]
-docs = ["pydoc-markdown pydoc/config_docusaurus.yml"]
+docs = ["haystack-pydoc pydoc/config_docusaurus.yml"]
 fmt = "ruff check --fix {args}; ruff format {args}"
 fmt-check = "ruff check {args} && ruff format --check {args}"
 
@@ -66,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}"""
@@ -84,9 +90,17 @@ line-length = 120
 [tool.ruff.lint]
 select = [
   "A",
+  "ANN",
   "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",
@@ -112,6 +126,8 @@ select = [
 ignore = [
   # Allow non-abstract empty methods in abstract base classes
   "B027",
+  # Allow Any in type annotations at dynamic boundaries
+  "ANN401",
   # Allow boolean positional values in function calls, like `dict.get(... True)`
   "FBT003",
   # Allow boolean arguments in function definition
@@ -136,14 +152,15 @@ ban-relative-imports = "parents"
 
 [tool.ruff.lint.per-file-ignores]
 # Tests can use magic values, assertions, and relative imports
-"tests/**/*" = ["PLR2004", "S101", "TID252"]
+"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
 
 
@@ -155,3 +172,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.2.1 → qdrant_haystack-10.3.1}/src/haystack_integrations/components/retrievers/qdrant/retriever.py

@@ -482,8 +482,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

{qdrant_haystack-10.2.1 → qdrant_haystack-10.3.1}/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.2.1 → qdrant_haystack-10.3.1}/src/haystack_integrations/document_stores/qdrant/document_store.py

@@ -1,5 +1,6 @@
 import inspect
 from collections.abc import AsyncGenerator, Generator
+from dataclasses import replace
 from itertools import islice
 from typing import Any, ClassVar, cast
 
@@ -10,6 +11,7 @@ from haystack.dataclasses.sparse_embedding import SparseEmbedding
 from haystack.document_stores.errors import DocumentStoreError, DuplicateDocumentError
 from haystack.document_stores.types import DuplicatePolicy
 from haystack.utils import Secret, deserialize_secrets_inplace
+from haystack.utils.misc import _normalize_metadata_field_name
 from numpy import exp
 from qdrant_client.http import models as rest
 from qdrant_client.http.exceptions import UnexpectedResponse
@@ -53,8 +55,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:
 
@@ -375,6 +378,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.
@@ -428,6 +432,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.
@@ -603,14 +608,59 @@ class QdrantDocumentStore:
         )
 
     @staticmethod
-    def _metadata_fields_info_from_schema(payload_schema: dict[str, Any]) -> dict[str, str]:
-        """Build field name -> type dict from Qdrant payload_schema. Used by get_metadata_fields_info (sync/async)."""
-        fields_info: dict[str, str] = {}
+    def _infer_type_from_value(value: Any) -> str:
+        """
+        Infers the type from a metadata value for get_metadata_fields_info.
+
+        Returns types matching OpenSearch format for consistency:
+        - 'keyword' for strings
+        - 'long' for integers
+        - 'float' for floats
+        - 'boolean' for booleans
+        """
+        if isinstance(value, bool):
+            return "boolean"
+        elif isinstance(value, int):
+            return "long"
+        elif isinstance(value, float):
+            return "float"
+        elif isinstance(value, str):
+            return "keyword"
+        else:
+            return "keyword"
+
+    @staticmethod
+    def _process_records_fields_info(records: list[Any], field_info: dict[str, dict[str, str]]) -> None:
+        """
+        Update field_info from a batch of Qdrant records.
+
+        Used by get_metadata_fields_info (sync/async). Extracts metadata from
+        payload["meta"] and infers types for each field.
+        """
+        for record in records:
+            if record.payload and "meta" in record.payload:
+                meta = record.payload["meta"]
+                for field_name, value in meta.items():
+                    if value is not None and field_name not in field_info:
+                        field_info[field_name] = {"type": QdrantDocumentStore._infer_type_from_value(value)}
+
+    @staticmethod
+    def _metadata_fields_info_from_schema(payload_schema: dict[str, Any]) -> dict[str, dict[str, str]]:
+        """
+        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.
+        """
+        fields_info: dict[str, dict[str, str]] = {}
         for field_name, field_config in payload_schema.items():
-            if hasattr(field_config, "data_type"):
-                fields_info[field_name] = str(field_config.data_type)
-            else:
-                fields_info[field_name] = "unknown"
+            if field_name.startswith("meta."):
+                meta_field = field_name[5:]
+                if hasattr(field_config, "data_type"):
+                    qdrant_type = str(field_config.data_type).lower()
+                    fields_info[meta_field] = {"type": qdrant_type}
+                else:
+                    fields_info[meta_field] = {"type": "unknown"}
         return fields_info
 
     @staticmethod
@@ -978,14 +1028,18 @@ class QdrantDocumentStore:
             logger.warning(f"Error {e} when calling QdrantDocumentStore.count_documents_by_filter_async()")
             return 0
 
-    def get_metadata_fields_info(self) -> dict[str, str]:
+    def get_metadata_fields_info(self) -> dict[str, dict[str, str]]:
         """
-        Returns the information about the fields from the collection.
+        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"].
 
         :returns:
-            A dictionary mapping field names to their types e.g.:
+            A dictionary mapping field names to their type information e.g.:
             ```python
-            {"field_name": "integer"}
+            {"category": {"type": "keyword"}, "priority": {"type": "long"}}
             ```
         """
         self._initialize_client()
@@ -994,19 +1048,40 @@ class QdrantDocumentStore:
         try:
             collection_info = self._client.get_collection(self.index)
             payload_schema = collection_info.payload_schema or {}
-            return self._metadata_fields_info_from_schema(payload_schema)
+            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
+
+            return fields_info
         except (UnexpectedResponse, ValueError) as e:
             logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_fields_info()")
             return {}
 
-    async def get_metadata_fields_info_async(self) -> dict[str, str]:
+    async def get_metadata_fields_info_async(self) -> dict[str, dict[str, str]]:
         """
-        Asynchronously returns the information about the fields from the collection.
+        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"].
 
         :returns:
-            A dictionary mapping field names to their types e.g.:
+            A dictionary mapping field names to their type information e.g.:
             ```python
-            {"field_name": "integer"}
+            {"category": {"type": "keyword"}, "priority": {"type": "long"}}
             ```
         """
         await self._initialize_async_client()
@@ -1015,7 +1090,24 @@ class QdrantDocumentStore:
         try:
             collection_info = await self._async_client.get_collection(self.index)
             payload_schema = collection_info.payload_schema or {}
-            return self._metadata_fields_info_from_schema(payload_schema)
+            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
+
+            return fields_info
         except (UnexpectedResponse, ValueError) as e:
             logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_fields_info_async()")
             return {}
@@ -1027,11 +1119,13 @@ class QdrantDocumentStore:
         :param metadata_field: The metadata field key (inside ``meta``) to get the minimum and maximum values for.
 
         :returns: A dictionary with the keys "min" and "max", where each value is the minimum or maximum value of the
-                  metadata field across all documents. Returns an empty dict if no documents have the field.
+                  metadata field across all documents. Returns ``{"min": None, "max": None}`` if no documents have
+                  the field.
         """
         self._initialize_client()
         assert self._client is not None
 
+        field_name = _normalize_metadata_field_name(metadata_field)
         try:
             min_value: Any = None
             max_value: Any = None
@@ -1046,13 +1140,11 @@ class QdrantDocumentStore:
                     with_payload=True,
                     with_vectors=False,
                 )
-                min_value, max_value = self._process_records_min_max(records, metadata_field, min_value, max_value)
+                min_value, max_value = self._process_records_min_max(records, field_name, min_value, max_value)
                 if self._check_stop_scrolling(next_offset):
                     break
 
-            if min_value is not None and max_value is not None:
-                return {"min": min_value, "max": max_value}
-            return {}
+            return {"min": min_value, "max": max_value}
         except Exception as e:
             logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_field_min_max()")
             return {}
@@ -1064,11 +1156,13 @@ class QdrantDocumentStore:
         :param metadata_field: The metadata field key (inside ``meta``) to get the minimum and maximum values for.
 
         :returns: A dictionary with the keys "min" and "max", where each value is the minimum or maximum value of the
-                  metadata field across all documents. Returns an empty dict if no documents have the field.
+                  metadata field across all documents. Returns ``{"min": None, "max": None}`` if no documents have
+                  the field.
         """
         await self._initialize_async_client()
         assert self._async_client is not None
 
+        field_name = _normalize_metadata_field_name(metadata_field)
         try:
             min_value: Any = None
             max_value: Any = None
@@ -1083,13 +1177,11 @@ class QdrantDocumentStore:
                     with_payload=True,
                     with_vectors=False,
                 )
-                min_value, max_value = self._process_records_min_max(records, metadata_field, min_value, max_value)
+                min_value, max_value = self._process_records_min_max(records, field_name, min_value, max_value)
                 if self._check_stop_scrolling(next_offset):
                     break
 
-            if min_value is not None and max_value is not None:
-                return {"min": min_value, "max": max_value}
-            return {}
+            return {"min": min_value, "max": max_value}
         except Exception as e:
             logger.warning(f"Error {e} when calling QdrantDocumentStore.get_metadata_field_min_max_async()")
             return {}
@@ -1135,8 +1227,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)
@@ -1838,8 +1931,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.
@@ -2204,8 +2298,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.
@@ -2231,9 +2326,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.
@@ -2380,15 +2475,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.2.1 → qdrant_haystack-10.3.1}/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