Reviewing files that changed from the base of the PR and between 808b0ab and 570a2c2.

• qdrant_client/async_qdrant_client.py (6 hunks)
• qdrant_client/qdrant_client.py (6 hunks)

• GitHub Check: Redirect rules - poetic-froyo-8baba7
• GitHub Check: Header rules - poetic-froyo-8baba7
• GitHub Check: Pages changed - poetic-froyo-8baba7
• GitHub Check: Python 3.11.x on ubuntu-latest test
• GitHub Check: Python 3.12.x on ubuntu-latest test
• GitHub Check: Python 3.10.x on ubuntu-latest test
• GitHub Check: Python 3.13.x on ubuntu-latest test
• GitHub Check: Python 3.9.x on ubuntu-latest test

qdrant_client/qdrant_client.py (4)

421-428: Condition now correctly skips local inference on cloud-inference runs

Swapping the two‐step requires_inference logic for

if not self.cloud_inference and self._inference_inspector.inspect(requests):

makes the intent explicit and prevents the (expensive) inspection+embedding when cloud_inference is enabled.
Looks good.

---

1617-1632: LGTM – early exit when cloud inference is enabled

The new guard prevents the local embedder from doing unnecessary work. No further issues spotted.

---

1682-1687: Same concise guard pattern correctly applied to update_vectors

---

2135-2140: Consistent fix in batch_update_points – mirrors the other write paths.

qdrant_client/async_qdrant_client.py (6)

398-403: Avoid re-allocating the generator just to wrap it in list()

_embed_models() already yields an iterable whose length matches the input.
If the upstream _client.query_batch_points can consume any iterable (it eventually converts to Protobuf / JSON anyway) there is no need to materialise the whole thing:

-        if not self.cloud_inference and self._inference_inspector.inspect(requests):
-            requests = list(
-                self._embed_models(
-                    requests, is_query=True, batch_size=self.local_inference_batch_size
-                )
-            )
+        if not self.cloud_inference and self._inference_inspector.inspect(requests):
+            # Pass a lazy generator straight through; saves memory for big batches
+            requests = self._embed_models(
+                requests, is_query=True, batch_size=self.local_inference_batch_size
+            )

This keeps memory usage constant and avoids one extra traversal.
[ suggest_optional_refactor ]

---

528-562: Combine the two if levels to satisfy Ruff SIM102 and skip pointless embeddings

You run _embed_models on prefetch even when only query required inference, which can double the work on large lists.
Merging the conditions lets you decide per-argument which one really needs embedding:

-        if not self.cloud_inference:
-            if self._inference_inspector.inspect(query) or self._inference_inspector.inspect(
-                prefetch
-            ):
+        if (
+            not self.cloud_inference
+            and (
+                self._inference_inspector.inspect(query)
+                or self._inference_inspector.inspect(prefetch)
+            )
+        ):

Then, before embedding, re-check each object:

if query is not None and self._inference_inspector.inspect(query):
    query = next(
        self._embed_models(
            query, is_query=True, batch_size=self.local_inference_batch_size
        )
    )

if isinstance(prefetch, list) and any(self._inference_inspector.inspect(p) for p in prefetch):
    prefetch = list(
        self._embed_models(
            prefetch, is_query=True, batch_size=self.local_inference_batch_size
        )
    )
elif prefetch is not None and self._inference_inspector.inspect(prefetch):
    prefetch = next(
        self._embed_models(
            prefetch, is_query=True, batch_size=self.local_inference_batch_size
        )
    )

This removes the nested if, fulfils the static-analysis hint, and avoids unnecessary work.
[ suggest_essential_refactor ]

🧰 Tools

🪛 Ruff (0.11.9)

528-531: Use a single if statement instead of nested if statements

(SIM102)

---

696-724: Same SIM102 / redundant-embedding issue as in query_points

The logic duplicates the pattern fixed above. Applying the same consolidation keeps the two public APIs in sync and prevents divergent behaviour in the future.
[ duplicate_comment ]

🧰 Tools

🪛 Ruff (0.11.9)

696-699: Use a single if statement instead of nested if statements

(SIM102)

---

1564-1579: Minor readability – inline condition is 👍

Nice simplification compared to the previous requires_inference variable.
No functional concerns here.
[ approve_code_changes ]

---

1627-1633: Consider early-returning when inspect is False to save one allocation

-        if not self.cloud_inference and self._inference_inspector.inspect(points):
-            points = list(
-                self._embed_models(
-                    points, is_query=False, batch_size=self.local_inference_batch_size
-                )
-            )
+        if self.cloud_inference or not self._inference_inspector.inspect(points):
+            return await self._client.update_vectors(
+                collection_name=collection_name,
+                points=points,
+                wait=wait,
+                ordering=ordering,
+                shard_key_selector=shard_key_selector,
+            )
+
+        points = list(
+            self._embed_models(
+                points, is_query=False, batch_size=self.local_inference_batch_size
+            )
+        )

This fast-path avoids the second pass over points when inference is not needed.
[ suggest_optional_refactor ]

---

2070-2075: Generator vs. list again

Same remark as for query_batch_points: if the lower layer accepts any Iterable, do not eagerly list() the result.
[ duplicate_comment ]