qdrant-haystack 9.1.3__tar.gz → 9.2.0__tar.gz

{qdrant_haystack-9.1.3 → qdrant_haystack-9.2.0}/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [integrations/qdrant-v9.1.3] - 2025-05-28
+
+### 🌀 Miscellaneous
+
+- Add pins for Qdrant (#1853)
+
 ## [integrations/qdrant-v9.1.2] - 2025-05-27
 
 ### 🐛 Bug Fixes

{qdrant_haystack-9.1.3 → qdrant_haystack-9.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: qdrant-haystack
-Version: 9.1.3
+Version: 9.2.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
@@ -45,7 +45,7 @@ pip install qdrant-haystack
 The test suites use Qdrant's in-memory instance. No additional steps required.
 
 ```console
-hatch run test
+hatch run test:all
 ```
 
 ## License

{qdrant_haystack-9.1.3 → qdrant_haystack-9.2.0}/README.md

@@ -20,7 +20,7 @@ pip install qdrant-haystack
 The test suites use Qdrant's in-memory instance. No additional steps required.
 
 ```console
-hatch run test
+hatch run test:all
 ```
 
 ## License

{qdrant_haystack-9.1.3 → qdrant_haystack-9.2.0}/pyproject.toml

@@ -46,25 +46,37 @@ git_describe_command = 'git describe --tags --match="integrations/qdrant-v[0-9]*
 
 [tool.hatch.envs.default]
 installer = "uv"
-dependencies = ["coverage[toml]>=6.5", "pytest", "pytest-rerunfailures", "haystack-pydoc-tools", "pytest-asyncio"]
+dependencies = ["haystack-pydoc-tools", "ruff"]
+
 [tool.hatch.envs.default.scripts]
-test = "pytest {args:tests}"
-test-cov = "coverage run -m pytest {args:tests}"
-test-cov-retry = "test-cov --reruns 3 --reruns-delay 30 -x"
-cov-report = ["- coverage combine", "coverage report"]
-cov = ["test-cov", "cov-report"]
-cov-retry = ["test-cov-retry", "cov-report"]
 docs = ["pydoc-markdown pydoc/config.yml"]
+fmt = "ruff check --fix {args} && ruff format {args}"
+fmt-check = "ruff check {args} && ruff format --check {args}"
+
+[tool.hatch.envs.test]
+dependencies = [
+    "pytest",
+    "pytest-asyncio",
+    "pytest-cov",
+    "pytest-rerunfailures",
+    "mypy",
+    "pip"
+]
 
-[tool.hatch.envs.lint]
-installer = "uv"
-detached = true
-dependencies = ["pip", "black>=23.1.0", "mypy>=1.0.0", "ruff>=0.0.243"]
-[tool.hatch.envs.lint.scripts]
-typing = "mypy --install-types --non-interactive --explicit-package-bases {args:src/ tests}"
-style = ["ruff check {args:.}", "black --check --diff {args:.}"]
-fmt = ["black {args:.}", "ruff check --fix {args:.}", "style"]
-all = ["style", "typing"]
+[tool.hatch.envs.test.scripts]
+unit = 'pytest -m "not integration" {args:tests}'
+integration = 'pytest -m "integration" {args:tests}'
+all = 'pytest {args:tests}'
+cov-retry = 'all --cov=haystack_integrations --reruns 3 --reruns-delay 30 -x'
+
+types = """mypy -p haystack_integrations.document_stores.qdrant \
+-p haystack_integrations.components.retrievers.qdrant {args}"""
+
+[tool.mypy]
+install_types = true
+non_interactive = true
+check_untyped_defs = true
+disallow_incomplete_defs = true
 
 [tool.black]
 target-version = ["py38"]
@@ -146,18 +158,10 @@ parallel = false
 
 
 [tool.coverage.report]
-omit = ["*/tests/*", "*/__init__.py"]
+omit = [
+  "*/tests/*",
+  "*/__init__.py",
+  "src/haystack_integrations/document_stores/qdrant/migrate_to_sparse.py",
+]
 show_missing = true
 exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]
-
-
-[[tool.mypy.overrides]]
-module = [
-  "haystack.*",
-  "haystack_integrations.*",
-  "pytest.*",
-  "qdrant_client.*",
-  "numpy",
-  "grpc",
-]
-ignore_missing_imports = true

{qdrant_haystack-9.1.3 → qdrant_haystack-9.2.0}/src/haystack_integrations/components/retrievers/qdrant/retriever.py

@@ -8,6 +8,11 @@ from qdrant_client.http import models
 
 from haystack_integrations.document_stores.qdrant import QdrantDocumentStore
 
+FILTER_POLICY_MERGE_ERROR_MESSAGE = (
+    "Native Qdrant filters cannot be used with filter_policy set to MERGE. "
+    "Set filter_policy to REPLACE or use Haystack filters instead."
+)
+
 
 @component
 class QdrantEmbeddingRetriever:
@@ -153,8 +158,19 @@ class QdrantEmbeddingRetriever:
         :returns:
             The retrieved documents.
 
+        :raises ValueError: If 'filter_policy' is set to 'MERGE' and 'filters' is a native Qdrant filter.
         """
-        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+        if self._filter_policy == FilterPolicy.MERGE and (
+            isinstance(self._filters, models.Filter) or isinstance(filters, models.Filter)
+        ):
+            raise ValueError(FILTER_POLICY_MERGE_ERROR_MESSAGE)
+
+        # Replacing filters works with native Qdrant filters even if the type is wrong
+        filters = apply_filter_policy(
+            filter_policy=self._filter_policy,
+            init_filters=self._filters,  # type: ignore[arg-type]
+            runtime_filters=filters,  # type: ignore[arg-type]
+        )
 
         docs = self._document_store._query_by_embedding(
             query_embedding=query_embedding,
@@ -197,8 +213,19 @@ class QdrantEmbeddingRetriever:
         :returns:
             The retrieved documents.
 
+        :raises ValueError: If 'filter_policy' is set to 'MERGE' and 'filters' is a native Qdrant filter.
         """
-        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+        if self._filter_policy == FilterPolicy.MERGE and (
+            isinstance(self._filters, models.Filter) or isinstance(filters, models.Filter)
+        ):
+            raise ValueError(FILTER_POLICY_MERGE_ERROR_MESSAGE)
+
+        # Replacing filters works with native Qdrant filters even if the type is wrong
+        filters = apply_filter_policy(
+            filter_policy=self._filter_policy,
+            init_filters=self._filters,  # type: ignore[arg-type]
+            runtime_filters=filters,  # type: ignore[arg-type]
+        )
 
         docs = await self._document_store._query_by_embedding_async(
             query_embedding=query_embedding,
@@ -364,8 +391,19 @@ class QdrantSparseEmbeddingRetriever:
         :returns:
             The retrieved documents.
 
+        :raises ValueError: If 'filter_policy' is set to 'MERGE' and 'filters' is a native Qdrant filter.
         """
-        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+        if self._filter_policy == FilterPolicy.MERGE and (
+            isinstance(self._filters, models.Filter) or isinstance(filters, models.Filter)
+        ):
+            raise ValueError(FILTER_POLICY_MERGE_ERROR_MESSAGE)
+
+        # Replacing filters works with native Qdrant filters even if the type is wrong
+        filters = apply_filter_policy(
+            filter_policy=self._filter_policy,
+            init_filters=self._filters,  # type: ignore[arg-type]
+            runtime_filters=filters,  # type: ignore[arg-type]
+        )
 
         docs = self._document_store._query_by_sparse(
             query_sparse_embedding=query_sparse_embedding,
@@ -413,8 +451,19 @@ class QdrantSparseEmbeddingRetriever:
         :returns:
             The retrieved documents.
 
+        :raises ValueError: If 'filter_policy' is set to 'MERGE' and 'filters' is a native Qdrant filter.
         """
-        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+        if self._filter_policy == FilterPolicy.MERGE and (
+            isinstance(self._filters, models.Filter) or isinstance(filters, models.Filter)
+        ):
+            raise ValueError(FILTER_POLICY_MERGE_ERROR_MESSAGE)
+
+        # Replacing filters works with native Qdrant filters even if the type is wrong
+        filters = apply_filter_policy(
+            filter_policy=self._filter_policy,
+            init_filters=self._filters,  # type: ignore[arg-type]
+            runtime_filters=filters,  # type: ignore[arg-type]
+        )
 
         docs = await self._document_store._query_by_sparse_async(
             query_sparse_embedding=query_sparse_embedding,
@@ -579,8 +628,19 @@ class QdrantHybridRetriever:
         :returns:
             The retrieved documents.
 
+        :raises ValueError: If 'filter_policy' is set to 'MERGE' and 'filters' is a native Qdrant filter.
         """
-        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+        if self._filter_policy == FilterPolicy.MERGE and (
+            isinstance(self._filters, models.Filter) or isinstance(filters, models.Filter)
+        ):
+            raise ValueError(FILTER_POLICY_MERGE_ERROR_MESSAGE)
+
+        # Replacing filters works with native Qdrant filters even if the type is wrong
+        filters = apply_filter_policy(
+            filter_policy=self._filter_policy,
+            init_filters=self._filters,  # type: ignore[arg-type]
+            runtime_filters=filters,  # type: ignore[arg-type]
+        )
 
         docs = self._document_store._query_hybrid(
             query_embedding=query_embedding,
@@ -628,8 +688,19 @@ class QdrantHybridRetriever:
         :returns:
             The retrieved documents.
 
+        :raises ValueError: If 'filter_policy' is set to 'MERGE' and 'filters' is a native Qdrant filter.
         """
-        filters = apply_filter_policy(self._filter_policy, self._filters, filters)
+        if self._filter_policy == FilterPolicy.MERGE and (
+            isinstance(self._filters, models.Filter) or isinstance(filters, models.Filter)
+        ):
+            raise ValueError(FILTER_POLICY_MERGE_ERROR_MESSAGE)
+
+        # Replacing filters works with native Qdrant filters even if the type is wrong
+        filters = apply_filter_policy(
+            filter_policy=self._filter_policy,
+            init_filters=self._filters,  # type: ignore[arg-type]
+            runtime_filters=filters,  # type: ignore[arg-type]
+        )
 
         docs = await self._document_store._query_hybrid_async(
             query_embedding=query_embedding,

{qdrant_haystack-9.1.3 → qdrant_haystack-9.2.0}/src/haystack_integrations/document_stores/qdrant/converters.py

@@ -37,7 +37,7 @@ def convert_haystack_documents_to_qdrant_points(
 
         else:
             vector = payload.pop("embedding") or {}
-        _id = convert_id(payload.get("id"))
+        _id = convert_id(document.id)
 
         point = rest.PointStruct(
             payload=payload,
@@ -62,19 +62,21 @@ QdrantPoint = Union[rest.ScoredPoint, rest.Record]
 
 
 def convert_qdrant_point_to_haystack_document(point: QdrantPoint, use_sparse_embeddings: bool) -> Document:
-    payload = {**point.payload}
+    payload = point.payload or {}
     payload["score"] = point.score if hasattr(point, "score") else None
 
     if not use_sparse_embeddings:
         payload["embedding"] = point.vector if hasattr(point, "vector") else None
-    elif hasattr(point, "vector") and point.vector is not None:
+    elif hasattr(point, "vector") and point.vector is not None and isinstance(point.vector, dict):
         payload["embedding"] = point.vector.get(DENSE_VECTORS_NAME)
 
         if SPARSE_VECTORS_NAME in point.vector:
-            parse_vector_dict = {
-                "indices": point.vector[SPARSE_VECTORS_NAME].indices,
-                "values": point.vector[SPARSE_VECTORS_NAME].values,
-            }
-            payload["sparse_embedding"] = parse_vector_dict
+            sparse_vector = point.vector[SPARSE_VECTORS_NAME]
+            if isinstance(sparse_vector, rest.SparseVector):
+                sparse_vector_dict = {
+                    "indices": sparse_vector.indices,
+                    "values": sparse_vector.values,
+                }
+                payload["sparse_embedding"] = sparse_vector_dict
 
     return Document.from_dict(payload)

{qdrant_haystack-9.1.3 → qdrant_haystack-9.2.0}/src/haystack_integrations/document_stores/qdrant/document_store.py

@@ -2,7 +2,6 @@ import inspect
 from itertools import islice
 from typing import Any, AsyncGenerator, ClassVar, Dict, Generator, List, Optional, Set, Tuple, Union
 
-import numpy as np
 import qdrant_client
 from haystack import default_from_dict, default_to_dict, logging
 from haystack.dataclasses import Document
@@ -10,6 +9,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 numpy import exp
 from qdrant_client import grpc
 from qdrant_client.http import models as rest
 from qdrant_client.http.exceptions import UnexpectedResponse
@@ -18,7 +18,6 @@ from tqdm import tqdm
 from .converters import (
     DENSE_VECTORS_NAME,
     SPARSE_VECTORS_NAME,
-    QdrantPoint,
     convert_haystack_documents_to_qdrant_points,
     convert_id,
     convert_qdrant_point_to_haystack_document,
@@ -27,6 +26,12 @@ from .filters import convert_filters_to_qdrant
 
 logger = logging.getLogger(__name__)
 
+# Default group size to apply when using group_by
+# - Our methods use None as the default for optional group_size parameter.
+# - Qdrant expects an integer and internally defaults to 3 when performing grouped queries.
+# - When group_by is specified but group_size is None, we use this value instead of passing None.
+DEFAULT_GROUP_SIZE = 3
+
 
 class QdrantStoreError(DocumentStoreError):
     pass
@@ -85,7 +90,7 @@ class QdrantDocumentStore:
     ```
     """
 
-    SIMILARITY: ClassVar[Dict[str, str]] = {
+    SIMILARITY: ClassVar[Dict[str, rest.Distance]] = {
         "cosine": rest.Distance.COSINE,
         "dot_product": rest.Distance.DOT,
         "l2": rest.Distance.EUCLID,
@@ -216,8 +221,8 @@ class QdrantDocumentStore:
             List of payload fields to index.
         """
 
-        self._client = None
-        self._async_client = None
+        self._client: Optional[qdrant_client.QdrantClient] = None
+        self._async_client: Optional[qdrant_client.AsyncQdrantClient] = None
 
         # Store the Qdrant client specific attributes
         self.location = location
@@ -575,8 +580,8 @@ class QdrantDocumentStore:
                 with_vectors=True,
             )
             stop_scrolling = next_offset is None or (
-                isinstance(next_offset, grpc.PointId) and next_offset.num == 0 and next_offset.uuid == ""
-            )
+                isinstance(next_offset, grpc.PointId) and next_offset.num == 0 and next_offset.uuid == ""  # type: ignore[union-attr]
+            )  # grpc.PointId always has num and uuid
 
             for record in records:
                 yield convert_qdrant_point_to_haystack_document(
@@ -612,8 +617,8 @@ class QdrantDocumentStore:
                 with_vectors=True,
             )
             stop_scrolling = next_offset is None or (
-                isinstance(next_offset, grpc.PointId) and next_offset.num == 0 and next_offset.uuid == ""
-            )
+                isinstance(next_offset, grpc.PointId) and next_offset.num == 0 and next_offset.uuid == ""  # type: ignore[union-attr]
+            )  # grpc.PointId always has num and uuid
 
             for record in records:
                 yield convert_qdrant_point_to_haystack_document(
@@ -739,7 +744,7 @@ class QdrantDocumentStore:
                 query_filter=qdrant_filters,
                 limit=top_k,
                 group_by=group_by,
-                group_size=group_size,
+                group_size=group_size or DEFAULT_GROUP_SIZE,
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             ).groups
@@ -801,7 +806,7 @@ class QdrantDocumentStore:
                 query_filter=qdrant_filters,
                 limit=top_k,
                 group_by=group_by,
-                group_size=group_size,
+                group_size=group_size or DEFAULT_GROUP_SIZE,
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             ).groups
@@ -893,7 +898,7 @@ class QdrantDocumentStore:
                     query=rest.FusionQuery(fusion=rest.Fusion.RRF),
                     limit=top_k,
                     group_by=group_by,
-                    group_size=group_size,
+                    group_size=group_size or DEFAULT_GROUP_SIZE,
                     score_threshold=score_threshold,
                     with_payload=True,
                     with_vectors=return_embedding,
@@ -990,14 +995,14 @@ class QdrantDocumentStore:
                 query_filter=qdrant_filters,
                 limit=top_k,
                 group_by=group_by,
-                group_size=group_size,
+                group_size=group_size or DEFAULT_GROUP_SIZE,
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             )
             groups = response.groups
             return self._process_group_results(groups)
         else:
-            response = await self._async_client.query_points(
+            query_response = await self._async_client.query_points(
                 collection_name=self.index,
                 query=rest.SparseVector(
                     indices=query_indices,
@@ -1009,7 +1014,7 @@ class QdrantDocumentStore:
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             )
-            points = response.points
+            points = query_response.points
             return self._process_query_point_results(points, scale_score=scale_score)
 
     async def _query_by_embedding_async(
@@ -1054,14 +1059,14 @@ class QdrantDocumentStore:
                 query_filter=qdrant_filters,
                 limit=top_k,
                 group_by=group_by,
-                group_size=group_size,
+                group_size=group_size or DEFAULT_GROUP_SIZE,
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             )
             groups = response.groups
             return self._process_group_results(groups)
         else:
-            response = await self._async_client.query_points(
+            query_response = await self._async_client.query_points(
                 collection_name=self.index,
                 query=query_embedding,
                 using=DENSE_VECTORS_NAME if self.use_sparse_embeddings else None,
@@ -1070,7 +1075,7 @@ class QdrantDocumentStore:
                 with_vectors=return_embedding,
                 score_threshold=score_threshold,
             )
-            points = response.points
+            points = query_response.points
             return self._process_query_point_results(points, scale_score=scale_score)
 
     async def _query_hybrid_async(
@@ -1145,14 +1150,14 @@ class QdrantDocumentStore:
                     query=rest.FusionQuery(fusion=rest.Fusion.RRF),
                     limit=top_k,
                     group_by=group_by,
-                    group_size=group_size,
+                    group_size=group_size or DEFAULT_GROUP_SIZE,
                     score_threshold=score_threshold,
                     with_payload=True,
                     with_vectors=return_embedding,
                 )
                 groups = response.groups
             else:
-                response = await self._async_client.query_points(
+                query_response = await self._async_client.query_points(
                     collection_name=self.index,
                     prefetch=[
                         rest.Prefetch(
@@ -1175,7 +1180,7 @@ class QdrantDocumentStore:
                     with_payload=True,
                     with_vectors=return_embedding,
                 )
-                points = response.points
+                points = query_response.points
 
         except Exception as e:
             msg = "Error during hybrid search"
@@ -1233,7 +1238,6 @@ class QdrantDocumentStore:
         """
         if payload_fields_to_index is not None:
             for payload_index in payload_fields_to_index:
-
                 # self._async_client is initialized at this point
                 # since _initialize_async_client() is called before this method is executed
                 assert self._async_client is not None
@@ -1359,7 +1363,7 @@ class QdrantDocumentStore:
     def recreate_collection(
         self,
         collection_name: str,
-        distance,
+        distance: rest.Distance,
         embedding_dim: int,
         on_disk: Optional[bool] = None,
         use_sparse_embeddings: Optional[bool] = None,
@@ -1402,7 +1406,7 @@ class QdrantDocumentStore:
     async def recreate_collection_async(
         self,
         collection_name: str,
-        distance,
+        distance: rest.Distance,
         embedding_dim: int,
         on_disk: Optional[bool] = None,
         use_sparse_embeddings: Optional[bool] = None,
@@ -1445,7 +1449,7 @@ class QdrantDocumentStore:
     def _handle_duplicate_documents(
         self,
         documents: List[Document],
-        policy: DuplicatePolicy = None,
+        policy: Optional[DuplicatePolicy] = None,
     ) -> List[Document]:
         """
         Checks whether any of the passed documents is already existing in the chosen index and returns a list of
@@ -1472,7 +1476,7 @@ class QdrantDocumentStore:
     async def _handle_duplicate_documents_async(
         self,
         documents: List[Document],
-        policy: DuplicatePolicy = None,
+        policy: Optional[DuplicatePolicy] = None,
     ) -> List[Document]:
         """
         Asynchronously checks whether any of the passed documents is already existing
@@ -1561,11 +1565,11 @@ class QdrantDocumentStore:
     def _prepare_collection_config(
         self,
         embedding_dim: int,
-        distance,
+        distance: rest.Distance,
         on_disk: Optional[bool] = None,
         use_sparse_embeddings: Optional[bool] = None,
         sparse_idf: bool = False,
-    ) -> Tuple[Dict[str, rest.VectorParams], Optional[Dict[str, rest.SparseVectorParams]]]:
+    ) -> Tuple[Union[Dict[str, rest.VectorParams], rest.VectorParams], Optional[Dict[str, rest.SparseVectorParams]]]:
         """
         Prepares the configuration for creating or recreating a Qdrant collection.
 
@@ -1577,12 +1581,14 @@ class QdrantDocumentStore:
             use_sparse_embeddings = self.use_sparse_embeddings
 
         # dense vectors configuration
-        vectors_config = rest.VectorParams(size=embedding_dim, on_disk=on_disk, distance=distance)
-        sparse_vectors_config = None
+        base_vectors_config = rest.VectorParams(size=embedding_dim, on_disk=on_disk, distance=distance)
+        vectors_config: Union[rest.VectorParams, Dict[str, rest.VectorParams]] = base_vectors_config
+
+        sparse_vectors_config: Optional[Dict[str, rest.SparseVectorParams]] = None
 
         if use_sparse_embeddings:
             # in this case, we need to define named vectors
-            vectors_config = {DENSE_VECTORS_NAME: vectors_config}
+            vectors_config = {DENSE_VECTORS_NAME: base_vectors_config}
 
             sparse_vectors_config = {
                 SPARSE_VECTORS_NAME: rest.SparseVectorParams(
@@ -1610,7 +1616,9 @@ class QdrantDocumentStore:
             msg = "Invalid filter syntax. See https://docs.haystack.deepset.ai/docs/metadata-filtering for details."
             raise ValueError(msg)
 
-    def _process_query_point_results(self, results: List[QdrantPoint], scale_score: bool = False) -> List[Document]:
+    def _process_query_point_results(
+        self, results: List[rest.ScoredPoint], scale_score: bool = False
+    ) -> List[Document]:
         """
         Processes query results from Qdrant.
         """
@@ -1622,10 +1630,12 @@ 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 + np.exp(-score / 100)))
+                    score = float(1 / (1 + exp(-score / 100)))
                 document.score = score
 
         return documents
@@ -1647,16 +1657,22 @@ class QdrantDocumentStore:
     def _validate_collection_compatibility(
         self,
         collection_name: str,
-        collection_info,
-        distance,
+        collection_info: rest.CollectionInfo,
+        distance: rest.Distance,
         embedding_dim: int,
     ) -> None:
         """
         Validates that an existing collection is compatible with the current configuration.
         """
-        has_named_vectors = isinstance(collection_info.config.params.vectors, dict)
+        vectors_config = collection_info.config.params.vectors
 
-        if has_named_vectors and DENSE_VECTORS_NAME not in collection_info.config.params.vectors:
+        if vectors_config is None:
+            msg = f"Collection '{collection_name}' has no vector configuration."
+            raise QdrantStoreError(msg)
+
+        has_named_vectors = isinstance(vectors_config, dict)
+
+        if has_named_vectors and DENSE_VECTORS_NAME not in vectors_config:
             msg = (
                 f"Collection '{collection_name}' already exists in Qdrant, "
                 f"but it has been originally created outside of Haystack and is not supported. "
@@ -1688,11 +1704,20 @@ class QdrantDocumentStore:
 
         # Get current distance and vector size based on collection configuration
         if self.use_sparse_embeddings:
-            current_distance = collection_info.config.params.vectors[DENSE_VECTORS_NAME].distance
-            current_vector_size = collection_info.config.params.vectors[DENSE_VECTORS_NAME].size
+            if not isinstance(vectors_config, dict):
+                msg = f"Collection '{collection_name}' has invalid vector configuration for sparse embeddings."
+                raise QdrantStoreError(msg)
+
+            dense_vector_config = vectors_config[DENSE_VECTORS_NAME]
+            current_distance = dense_vector_config.distance
+            current_vector_size = dense_vector_config.size
         else:
-            current_distance = collection_info.config.params.vectors.distance
-            current_vector_size = collection_info.config.params.vectors.size
+            if isinstance(vectors_config, dict):
+                msg = f"Collection '{collection_name}' has invalid vector configuration for dense embeddings only."
+                raise QdrantStoreError(msg)
+
+            current_distance = vectors_config.distance
+            current_vector_size = vectors_config.size
 
         # Validate distance metric
         if current_distance != distance: