qdrant_client/async_qdrant_fastembed.py (2)

232-244: Replace assert with explicit runtime check to avoid failures under -O and give actionable error.

Using assert for control flow is brittle (Python strips asserts with -O), and will lead to AttributeError when BuiltinEmbedder lacks get_or_init_model. Raise a clear ImportError instead.

Apply this diff:

-        assert isinstance(self._model_embedder.embedder, Embedder)
+        if not isinstance(self._model_embedder.embedder, Embedder):
+            raise ImportError(
+                "Client-side FastEmbed model initialization requires the 'fastembed' extra. "
+                "Install with `pip install qdrant-client[fastembed]` or use server-side/builtin inference paths."
+            )

---

252-264: Same here: avoid assert for the sparse model path.

Mirror the explicit check for the sparse initializer to prevent silent removal under -O and provide a clear message.

Apply this diff:

-        assert isinstance(self._model_embedder.embedder, Embedder)
+        if not isinstance(self._model_embedder.embedder, Embedder):
+            raise ImportError(
+                "Client-side FastEmbed sparse model initialization requires the 'fastembed' extra. "
+                "Install with `pip install qdrant-client[fastembed]` or use server-side/builtin sparse inference."
+            )

qdrant_client/qdrant_fastembed.py (2)

242-251: Avoid assert for control-flow; raise a clear error when FastEmbed isn’t available.

Asserts are stripped with python -O and will lead to obscure AttributeError on BuiltinEmbedder. Use an explicit guard.

Apply this diff:

-        assert isinstance(self._model_embedder.embedder, Embedder)
+        if not isinstance(self._model_embedder.embedder, Embedder):
+            raise ImportError(
+                "Client-side FastEmbed model initialization requires the 'fastembed' extra. "
+                "Install with `pip install qdrant-client[fastembed]` or use server/builtin inference."
+            )

---

262-270: Same fix for the sparse model initializer.

Mirror the explicit guard for the sparse model path.

Apply this diff:

-        assert isinstance(self._model_embedder.embedder, Embedder)
+        if not isinstance(self._model_embedder.embedder, Embedder):
+            raise ImportError(
+                "Client-side FastEmbed sparse model initialization requires the 'fastembed' extra. "
+                "Install with `pip install qdrant-client[fastembed]` or use server/builtin sparse inference."
+            )

qdrant_client/async_qdrant_client.py (1)

112-129: Clean local/remote split with is_local_mode propagation — looks solid.

• _is_local_mode is computed correctly and propagated to the mixin via super().init(parser=..., is_local_mode=_is_local_mode, ...).
• Local-path client creation (AsyncQdrantLocal) and the remote-path client creation (AsyncQdrantRemote) are mutually exclusive.

One nuance: kwargs are passed both to super() and later to AsyncQdrantRemote. If any user-provided kwargs are not expected by the HTTP client, httpx may error. If this has bitten us before, consider sanitizing or whitelisting kwargs before forwarding to AsyncQdrantRemote.

qdrant_client/qdrant_client.py (1)

116-139: Local/remote init path with is_local_mode propagation is coherent; minor nit on kwargs forwarding.

• The introduction of _is_local_mode and passing it to the mixin constructor aligns with the broader local-vs-remote flow.
• Inspector creation prior to super().init ensures the mixin has a parser for inference inspection.

Nit: kwargs are passed to both super() and QdrantRemote(). If any caller supplies unexpected keys intended only for high-level client construction, they may leak to the HTTP stack. Consider validating/whitelisting or documenting accepted kwargs for remote init to prevent httpx argument errors.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these settings in your CodeRabbit configuration.

qdrant_client/qdrant_fastembed.py (2)

246-254: Avoid bare asserts; raise actionable error when fastembed backend is required

Asserting the concrete Embedder type will raise an AssertionError with little guidance if the builtin embedder path is active. Prefer a clear exception guiding users to enable local inference or install fastembed.

Apply:

-        assert isinstance(self._model_embedder.embedder, Embedder)
+        if not isinstance(self._model_embedder.embedder, Embedder):
+            raise RuntimeError(
+                "This operation requires the fastembed backend. "
+                "Enable local inference or install the fastembed extras: "
+                "`pip install 'qdrant-client[fastembed]'`."
+            )

---

266-274: Mirror the clearer error for sparse-model init

Same rationale as above for _get_or_init_sparse_model.

-        assert isinstance(self._model_embedder.embedder, Embedder)
+        if not isinstance(self._model_embedder.embedder, Embedder):
+            raise RuntimeError(
+                "Sparse model initialization requires the fastembed backend. "
+                "Enable local inference or install the fastembed extras: "
+                "`pip install 'qdrant-client[fastembed]'`."
+            )

qdrant_client/embed/model_embedder.py (1)

55-60: Embedder selection ignores is_local_mode/server_version — selects by fastembed presence only

As written, the chosen embedder depends solely on FastEmbedMisc.is_installed(). This breaks the intended behavior:

• Remote + server supports builtin (>= 1.15.3): should choose BuiltinEmbedder even if fastembed is installed.
• Local mode: must require fastembed and use Embedder.
• Remote + older server: fallback to fastembed if available, otherwise error.

Fix the decision tree to honor mode/server capability:

-        if is_local_mode or not self._builtin_embedder_supported(server_version):
-            FastEmbedMisc().is_installed()
-            FastEmbedMisc.import_fastembed()
-
-        self.embedder = Embedder() if FastEmbedMisc.is_installed() else BuiltinEmbedder()
+        if is_local_mode:
+            # Local mode requires fastembed
+            FastEmbedMisc.import_fastembed()
+            self.embedder = Embedder()
+        else:
+            if self._builtin_embedder_supported(server_version):
+                # Prefer builtin embedder on supported remote servers
+                self.embedder = BuiltinEmbedder()
+            else:
+                # Older remote servers: fall back to fastembed if available
+                FastEmbedMisc.import_fastembed()
+                self.embedder = Embedder()

Optional: track self._is_builtin_embedder: bool for downstream conditionals instead of isinstance(...).

qdrant_client/qdrant_remote.py (1)

209-231: Persisting server_version is good; add type annotation and avoid re-fetching client_version.

• Storing self.server_version is useful and aligns with the rest of the PR. Recommend adding a class-level type annotation for clarity and tooling.
• Minor nit: you already computed client_version earlier (Line 146). Re-fetching it on Line 212 is redundant.

Apply this diff to drop the duplicate client_version fetch:

-                client_version = importlib.metadata.version("qdrant-client")

Additionally, consider adding this class-level annotation (outside the selected range):

# directly under DEFAULT_GRPC_TIMEOUT
server_version: Optional[str]

qdrant_client/async_qdrant_remote.py (1)

174-197: Expose server_version: looks good; add type annotation and remove duplicate client_version lookup.

• Keeping self.server_version on the instance is a good improvement and consistent with the sync client.
• You already have client_version (Line 130). Re-fetching it on Line 177 is unnecessary.

Apply this diff to avoid redundant work:

-                client_version = importlib.metadata.version("qdrant-client")

Also consider a class-level type annotation (outside the selected range):

# directly under DEFAULT_GRPC_TIMEOUT
server_version: Optional[str]

qdrant_client/async_qdrant_fastembed.py (2)

246-254: Prefer explicit, informative guard over assert for runtime type check.

Asserts can be disabled with -O and yield a cryptic message. Raise a clear exception if the embedder is not FastEmbed-backed.

-        assert isinstance(self._model_embedder.embedder, Embedder)
+        if not isinstance(self._model_embedder.embedder, Embedder):
+            raise RuntimeError(
+                "FastEmbed path invoked but ModelEmbedder is not using Embedder. "
+                "This likely indicates builtin/server-side embedding is selected. "
+                "Avoid calling FastEmbed-specific APIs in this mode."
+            )

---

266-274: Same here: replace assert with explicit error for sparse model path.

-        assert isinstance(self._model_embedder.embedder, Embedder)
+        if not isinstance(self._model_embedder.embedder, Embedder):
+            raise RuntimeError(
+                "FastEmbed sparse path invoked but ModelEmbedder is not using Embedder. "
+                "This likely indicates builtin/server-side embedding is selected."
+            )

qdrant_client/qdrant_client.py (1)

116-161: Backend-first init and server_version propagation: LGTM

Selecting local/remote before base init, capturing server_version for the remote path, and wiring the inspector/parser into super().init keeps responsibilities well-scoped. The cloud_inference guard for local mode remains correct.

Minor: consider caching is_local = isinstance(self._client, QdrantLocal) once to reuse on Lines 149 and 160.

qdrant_client/embed/builtin_embedder.py (2)

13-35: Return type doesn’t match implementation; make it explicit Documents list

The method returns a list of models.Document, but it’s annotated as NumericVector. This misleads type checkers and readers.

-    ) -> NumericVector:
+    ) -> list[models.Document]:

If you prefer to keep compatibility with the external embedder interface, loosen to Iterable[Any] or define a shared alias encompassing both numeric vectors and Document outputs.

---

85-95: Case-insensitive membership can avoid per-call list construction

Converting the supported models to lowercase on every call builds a new list each time. Precompute a frozenset for O(1) membership and no allocations.

-class BuiltinEmbedder:
-    _SUPPORTED_MODELS = ("Qdrant/Bm25",)
+class BuiltinEmbedder:
+    _SUPPORTED_MODELS = ("Qdrant/Bm25",)
+    _SUPPORTED_MODELS_CI = frozenset(m.lower() for m in _SUPPORTED_MODELS)
@@
-        return model_name.lower() in [model.lower() for model in cls._SUPPORTED_MODELS]
+        return model_name.lower() in cls._SUPPORTED_MODELS_CI

qdrant_client/embed/model_embedder.py (3)

55-58: Avoid instantiating FastEmbedMisc just to call class methods

Use the class methods directly.

-            FastEmbedMisc().is_installed()
-            FastEmbedMisc.import_fastembed()
+            FastEmbedMisc.is_installed()
+            FastEmbedMisc.import_fastembed()

---

61-78: Simplify version check logic

Minor readability improvement; return the comparison result directly.

-        try:
-            major, minor, patch = server_version.split(".")
-            patch = patch.split("-")[0]
-
-            if (int(major), int(minor), int(patch)) >= (1, 15, 3):
-                return True
-
-            return False
-        except Exception:
-            return True
+        try:
+            major, minor, patch = server_version.split(".")
+            patch = patch.split("-")[0]
+            return (int(major), int(minor), int(patch)) >= (1, 15, 3)
+        except Exception:
+            return True

---

129-134: Coupling on BuiltinEmbedder type check; consider a backend flag

This branch avoids multiprocess embedding for the builtin path by checking isinstance(self.embedder, BuiltinEmbedder). It’s workable, but an internal boolean (e.g., self._is_builtin_embedder) set at construction is more explicit and avoids type coupling.

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

qdrant_client/embed/model_embedder.py (4)

9-9: Missing module import breaks the build.

The BuiltinEmbedder module is not present in the repository, causing a ModuleNotFoundError at import time. This needs to be fixed before the PR can be merged.

Until the BuiltinEmbedder module is added, defer the import to runtime:

-from qdrant_client.embed.builtin_embedder import BuiltinEmbedder
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from qdrant_client.embed.builtin_embedder import BuiltinEmbedder

Then import it conditionally at runtime where needed (e.g., in __init__):

if not is_local_mode:
    from qdrant_client.embed.builtin_embedder import BuiltinEmbedder
    self.embedder = BuiltinEmbedder(**kwargs)

---

143-147: Use the _is_builtin_embedder_available flag instead of isinstance check.

The isinstance check will fail if BuiltinEmbedder cannot be imported. Use the flag computed during initialization.

         if (
-            isinstance(self.embedder, BuiltinEmbedder)
+            self._is_builtin_embedder_available and not FastEmbedMisc.is_installed()
             or parallel is None
             or parallel == 1
             or is_small
         ):

---

439-445: Use _is_builtin_embedder_available flag instead of isinstance check.

The isinstance check will fail if BuiltinEmbedder cannot be imported.

-                if isinstance(self.embedder, BuiltinEmbedder):
+                if self._is_builtin_embedder_available and not FastEmbedMisc.is_installed():
                     raise ValueError(
                         f"{model} is not among supported models. "
                         f"Have you forgotten to set `cloud_inference` or install `fastembed` for local inference?"
                     )
                 else:
                     raise ValueError(f"{model} is not among supported models")

---

56-61: Embedder selection logic doesn't properly use is_local_mode and builtin availability check.

The current implementation checks FastEmbedMisc.is_installed() instead of using the computed _is_builtin_embedder_available flag and is_local_mode parameter.

-        self._is_builtin_embedder_available = self._check_builtin_embedder_availability(
-            is_local_mode, server_version
-        )
-        self.embedder = (
-            Embedder(**kwargs) if FastEmbedMisc.is_installed() else BuiltinEmbedder(**kwargs)
-        )
+        self._is_builtin_embedder_available = self._check_builtin_embedder_availability(
+            is_local_mode, server_version
+        )
+        
+        if is_local_mode or not self._is_builtin_embedder_available:
+            # Local mode or old server version requires fastembed
+            if not FastEmbedMisc.is_installed():
+                raise ImportError(
+                    "Local mode or server version < 1.15.3 requires 'fastembed'. "
+                    "Install with `pip install qdrant-client[fastembed]`"
+                )
+            self.embedder = Embedder(**kwargs)
+        else:
+            # Remote mode with supported server version uses builtin embedder
+            from qdrant_client.embed.builtin_embedder import BuiltinEmbedder
+            self.embedder = BuiltinEmbedder(**kwargs)

tests/embed_tests/test_builtin_inference.py (4)

13-28: Consider adding error handling and return type annotation.

The prepare_collection function should handle potential errors and have a proper return type annotation for better code maintainability.

 def prepare_collection(
     client: QdrantClient,
     collection_name: str,
     vectors_config: Optional[dict[str, Any]] = None,
     sparse_vectors_config: Optional[dict[str, Any]] = None,
-) -> None:
+) -> None:
     if client.collection_exists(collection_name):
         client.delete_collection(collection_name)
     config = (
         {DEFAULT_VECTOR_NAME: models.SparseVectorParams(modifier=models.Modifier.IDF)}
         if sparse_vectors_config is None
         else sparse_vectors_config
     )
-    client.create_collection(
-        collection_name, vectors_config=vectors_config or {}, sparse_vectors_config=config
-    )
+    try:
+        client.create_collection(
+            collection_name, vectors_config=vectors_config or {}, sparse_vectors_config=config
+        )
+    except Exception as e:
+        raise RuntimeError(f"Failed to create collection '{collection_name}': {e}") from e

---

78-148: Consider extracting common test setup logic to reduce duplication.

The test function has repetitive patterns for creating clients and preparing collections. Consider extracting a helper method to reduce code duplication.

Add a helper method at the module level:

def create_and_prepare_client(monkeypatch=None, server_version=None, use_memory=False):
    """Helper to create and prepare a client with collection."""
    if monkeypatch and server_version is not None:
        monkeypatch.setattr(
            "qdrant_client.qdrant_remote.get_server_version", 
            lambda *args, **kwargs: server_version
        )
    
    client = QdrantClient(":memory:") if use_memory else QdrantClient()
    prepare_collection(client, COLLECTION_NAME)
    return client

Then simplify the test:

 def test_bm25_inference_server_version(monkeypatch):
     server_version = "1.11.0"
 
-    def patched_get_server_version(*args, **kwargs):
-        return server_version
-
-    monkeypatch.setattr(
-        "qdrant_client.qdrant_remote.get_server_version", patched_get_server_version
-    )
-    remote_client = QdrantClient()
-    prepare_collection(remote_client, COLLECTION_NAME)
+    remote_client = create_and_prepare_client(monkeypatch, server_version)

---

120-121: Inconsistent lambda function style.

For consistency, use the same style for lambda functions throughout the test.

-    monkeypatch.setattr("qdrant_client.qdrant_remote.get_server_version", lambda: server_version)
+    monkeypatch.setattr("qdrant_client.qdrant_remote.get_server_version", lambda *args, **kwargs: server_version)

---

136-137: Inconsistent lambda function style.

For consistency, use the same style for lambda functions throughout the test.

-    monkeypatch.setattr("qdrant_client.qdrant_remote.get_server_version", lambda: server_version)
+    monkeypatch.setattr("qdrant_client.qdrant_remote.get_server_version", lambda *args, **kwargs: server_version)

qdrant_client/embed/model_embedder.py (4)

70-74: Simplify conditional check and improve comment clarity.

The condition can be simplified and the comment can be more concise.

-        if (
-            server_version is None
-        ):  # failed to detect server version, it might happen due to security or network
-            # problems even on supported server versions, so we are not blocking usage of BuiltinEmbedder.
+        # If server version detection fails, assume builtin embedder is available
+        if server_version is None:
             return True

---

80-83: Simplify return statement.

As suggested by static analysis, directly return the condition.

-            if (int(major), int(minor), int(patch)) >= (1, 15, 3):
-                return True
-
-            return False
+            return (int(major), int(minor), int(patch)) >= (1, 15, 3)

---

138-140: Combine nested if statements for better readability.

As suggested by static analysis, combine the conditions.

-        if isinstance(raw_models, list):
-            if len(raw_models) < batch_size:
-                is_small = True
+        if isinstance(raw_models, list) and len(raw_models) < batch_size:
+            is_small = True

---

104-106: Consider consolidating repeated fastembed import checks.

The same check and import pattern is repeated in three methods. Consider extracting this to a helper method.

Add a helper method:

def _ensure_fastembed_if_needed(self) -> None:
    """Ensure fastembed is available when not using builtin embedder."""
    if not self._is_builtin_embedder_available:
        FastEmbedMisc.import_fastembed()  # fail fast if fastembed is required

Then use it in the three methods:

-        if not self._is_builtin_embedder_available:
-            FastEmbedMisc.import_fastembed()  # fail fast if fastembed is required
+        self._ensure_fastembed_if_needed()

Also applies to: 133-135, 188-190

Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.