qdrant_client/async_qdrant_remote.py (1)

278-281: About “race” on _grpc_client_next_index (context).

In asyncio, this method runs to completion between awaits, so intra-loop races are unlikely. Cross-thread use would be unsafe, though. If multi-threaded access is a goal, guard the rotation with a lock or constrain the class to single-threaded use in docs.

Would you like a minimal lock-based variant that keeps _next_grpc_client synchronous (no await in call-sites) but safe under threads?

qdrant_client/async_qdrant_remote.py (1)

205-226: Close: make idempotent, GC-friendly, and resilient to cancellation.

• Catch asyncio.CancelledError during shutdown.
• Drop references and reset index so repeated close() calls are harmless and memory is freed promptly.

Apply:

@@
-        if len(self._grpc_channel_pool) > 0:
+        if len(self._grpc_channel_pool) > 0:
             for channel in self._grpc_channel_pool:
                 try:
                     await channel.close(grace=grpc_grace)
-                except AttributeError:
+                except AttributeError:
                     show_warning(
                         message="Unable to close grpc_channel. Connection was interrupted on the server side",
                         category=UserWarning,
                         stacklevel=4,
                     )
-                except RuntimeError:
+                except (RuntimeError, asyncio.CancelledError):
                     pass
@@
-        self._closed = True
+        # Drop references for GC and idempotency
+        self._grpc_points_client_pool = None
+        self._grpc_collections_client_pool = None
+        self._grpc_snapshots_client_pool = None
+        self._grpc_root_client_pool = None
+        self._grpc_channel_pool.clear()
+        self._grpc_client_next_index = 0
+        self._closed = True

Add import:

import asyncio

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

qdrant_client/async_qdrant_remote.py (1)

283-286: About the previously raised “race” on _next_grpc_client()

In a single asyncio event loop, this method has no await points and executes atomically; practical risk is low. If cross-thread access is expected, consider an asyncio.Lock.

Do you plan to use AsyncQdrantRemote across threads? If yes, I can provide a lock-based variant.

qdrant_client/qdrant_remote.py (1)

328-331: Thread-safety: protect round‑robin index with a lock

Sync client may be used from multiple threads; unsynchronized read/modify leads to skewed rotation. Add a lock and base modulo on actual pool length.

Apply:

+import threading
@@ class QdrantRemote(QdrantBase):
-        self._grpc_client_next_index: int = 0  # The next index to use
+        self._grpc_client_next_index: int = 0  # The next index to use
+        self._grpc_client_lock = threading.Lock()
@@
-    def _next_grpc_client(self) -> int:
-        current_index = self._grpc_client_next_index
-        self._grpc_client_next_index = (self._grpc_client_next_index + 1) % self._pool_size
-        return current_index
+    def _next_grpc_client(self) -> int:
+        length = len(self._grpc_channel_pool)
+        if length <= 0:
+            return 0
+        with self._grpc_client_lock:
+            current_index = self._grpc_client_next_index % length
+            self._grpc_client_next_index = (current_index + 1) % length
+            return current_index

tools/async_client_generator/transformers/remote/function_def_transformer.py (1)

41-41: Nit: truthiness check is cleaner

Prefer if self._grpc_channel_pool: over len(self._grpc_channel_pool) > 0.

qdrant_client/async_qdrant_remote.py (2)

283-286: Round‑robin should use actual pool length, not configured pool_size

This avoids indexing errors if the pool is rebuilt to a different size in the future and keeps rotation correct.

Apply:

-    def _next_grpc_client(self) -> int:
-        current_index = self._grpc_client_next_index
-        self._grpc_client_next_index = (self._grpc_client_next_index + 1) % self._pool_size
-        return current_index
+    def _next_grpc_client(self) -> int:
+        length = len(self._grpc_channel_pool)
+        if length <= 0:
+            return 0
+        current_index = self._grpc_client_next_index % length
+        self._grpc_client_next_index = (current_index + 1) % length
+        return current_index

---

241-257: Chain the original exception when wrapping initialization errors

Improves debuggability and satisfies linters.

Apply:

-        except Exception as e:
-            raise RuntimeError(f"Error initializing the grpc connection(s): {e}")
+        except Exception as e:
+            raise RuntimeError("Error initializing the grpc connection(s)") from e

qdrant_client/qdrant_remote.py (1)

301-302: Chain original exception in _init_grpc_channel()

Use exception chaining for context and to appease linters.

Apply:

-        except Exception as e:
-            raise RuntimeError(f"Error initializing the grpc connection(s): {e}")
+        except Exception as e:
+            raise RuntimeError("Error initializing the grpc connection(s)") from e

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

qdrant_client/async_qdrant_remote.py (2)

285-288: Make round‑robin use actual pool length.

Avoid modulo by configured size; use the real pool length to prevent future mismatches.

-    def _next_grpc_client(self) -> int:
-        current_index = self._grpc_client_next_index
-        self._grpc_client_next_index = (self._grpc_client_next_index + 1) % self._pool_size
-        return current_index
+    def _next_grpc_client(self, pool_len: Optional[int] = None) -> int:
+        length = pool_len or len(self._grpc_channel_pool)
+        if length <= 0:
+            return 0  # defensive; pools are initialized before use
+        current_index = self._grpc_client_next_index % length
+        self._grpc_client_next_index = (current_index + 1) % length
+        return current_index

---

297-301: Use local pool var and pass its length to the rotator (also keeps mypy happy).

@@
-        assert self._grpc_collections_client_pool is not None
-        return self._grpc_collections_client_pool[self._next_grpc_client()]
+        assert self._grpc_collections_client_pool is not None
+        pool = self._grpc_collections_client_pool
+        return pool[self._next_grpc_client(len(pool))]
@@
-        assert self._grpc_points_client_pool is not None
-        return self._grpc_points_client_pool[self._next_grpc_client()]
+        assert self._grpc_points_client_pool is not None
+        pool = self._grpc_points_client_pool
+        return pool[self._next_grpc_client(len(pool))]
@@
-        assert self._grpc_snapshots_client_pool is not None
-        return self._grpc_snapshots_client_pool[self._next_grpc_client()]
+        assert self._grpc_snapshots_client_pool is not None
+        pool = self._grpc_snapshots_client_pool
+        return pool[self._next_grpc_client(len(pool))]
@@
-        assert self._grpc_root_client_pool is not None
-        return self._grpc_root_client_pool[self._next_grpc_client()]
+        assert self._grpc_root_client_pool is not None
+        pool = self._grpc_root_client_pool
+        return pool[self._next_grpc_client(len(pool))]

Also applies to: 309-313, 321-325, 333-337

qdrant_client/qdrant_remote.py (1)

331-335: Thread-safety: protect round‑robin index and use actual pool length.

Concurrent callers can race on _grpc_client_next_index. Add a lock and compute modulo by the real pool length.

Apply (plus import/init below):

-    def _next_grpc_client(self) -> int:
-        current_index = self._grpc_client_next_index
-        self._grpc_client_next_index = (self._grpc_client_next_index + 1) % self._pool_size
-        return current_index
+    def _next_grpc_client(self, pool_len: Optional[int] = None) -> int:
+        length = pool_len or len(self._grpc_channel_pool)
+        if length <= 0:
+            return 0
+        with self._grpc_client_lock:
+            current_index = self._grpc_client_next_index % length
+            self._grpc_client_next_index = (current_index + 1) % length
+            return current_index

Add at top and in init:

@@
-from typing import (
+from typing import (
@@
 )
+import threading
@@
-        self._grpc_client_next_index: int = 0  # The next index to use
+        self._grpc_client_next_index: int = 0  # The next index to use
+        self._grpc_client_lock = threading.Lock()

qdrant_client/async_qdrant_remote.py (2)

243-259: Harden channel init: top-up to target size and preserve exception cause.

• Initialize until the pool reaches the target size (defensive if pool becomes undersized later).
• Chain the original exception for debuggability and to satisfy linters (BLE001/B904/TRY003).

-        try:
-            channel_pool = []
-            if len(self._grpc_channel_pool) == 0:
-                for _ in range(self._pool_size):
+        try:
+            channel_pool = []
+            if len(self._grpc_channel_pool) < self._pool_size:
+                missing = self._pool_size - len(self._grpc_channel_pool)
+                for _ in range(missing):
                     channel = get_channel(
                         host=self._host,
                         port=self._grpc_port,
                         ssl=self._https,
                         metadata=self._grpc_headers,
                         options=self._grpc_options,
                         compression=self._grpc_compression,
                         auth_token_provider=self._auth_token_provider,
                     )
                     channel_pool.append(channel)
-                self._grpc_channel_pool = channel_pool
-        except Exception as e:
-            raise RuntimeError(f"Error initializing the grpc connection(s): {e}")
+                # Apply atomically to avoid half-initialized state
+                self._grpc_channel_pool.extend(channel_pool)
+        except Exception as e:
+            raise RuntimeError("Error initializing the grpc connection(s)") from e

---

206-219: Nit: align warning category with sync variant or downgrade duplicate except.

Sync uses RuntimeWarning; async uses UserWarning and also swallows RuntimeError. Consider aligning categories and add a brief comment on why RuntimeError is suppressed.

qdrant_client/qdrant_remote.py (2)

343-347: Use local pool var and pass its length to the rotator.

Prevents mismatches and improves readability/type narrowing.

@@
-        assert self._grpc_collections_client_pool is not None
-        return self._grpc_collections_client_pool[self._next_grpc_client()]
+        assert self._grpc_collections_client_pool is not None
+        pool = self._grpc_collections_client_pool
+        return pool[self._next_grpc_client(len(pool))]
@@
-        assert self._grpc_points_client_pool is not None
-        return self._grpc_points_client_pool[self._next_grpc_client()]
+        assert self._grpc_points_client_pool is not None
+        pool = self._grpc_points_client_pool
+        return pool[self._next_grpc_client(len(pool))]
@@
-        assert self._grpc_snapshots_client_pool is not None
-        return self._grpc_snapshots_client_pool[self._next_grpc_client()]
+        assert self._grpc_snapshots_client_pool is not None
+        pool = self._grpc_snapshots_client_pool
+        return pool[self._next_grpc_client(len(pool))]
@@
-        assert self._grpc_root_client_pool is not None
-        return self._grpc_root_client_pool[self._next_grpc_client()]
+        assert self._grpc_root_client_pool is not None
+        pool = self._grpc_root_client_pool
+        return pool[self._next_grpc_client(len(pool))]

Also applies to: 355-359, 367-371, 379-383

---

284-305: Preserve exception cause; optional: top‑up pool defensively.

• Re-raise with from e to keep the original traceback (ruff BLE001/B904/TRY003).
• Optionally, initialize until the pool reaches _pool_size (defensive against undersized pool).

-        try:
-            channel_pool = []
-
-            if len(self._grpc_channel_pool) == 0:
-                for _ in range(self._pool_size):
+        try:
+            channel_pool = []
+            if len(self._grpc_channel_pool) < self._pool_size:
+                missing = self._pool_size - len(self._grpc_channel_pool)
+                for _ in range(missing):
                     channel = get_channel(
                         host=self._host,
                         port=self._grpc_port,
                         ssl=self._https,
                         metadata=self._grpc_headers,
                         options=self._grpc_options,
                         compression=self._grpc_compression,
                         # sync get_channel does not accept coroutine functions,
                         # but we can't check type here, since it'll get into async client as well
                         auth_token_provider=self._auth_token_provider,  # type: ignore
                     )
-                    channel_pool.append(channel)
-
-                # Apply the clients late to prevent half-initialized pools if a channel creation fails.
-                self._grpc_channel_pool = channel_pool
-        except Exception as e:
-            raise RuntimeError(f"Error initializing the grpc connection(s): {e}")
+                    channel_pool.append(channel)
+                # Apply atomically to avoid half-initialized state.
+                self._grpc_channel_pool.extend(channel_pool)
+        except Exception as e:
+            raise RuntimeError("Error initializing the grpc connection(s)") from e

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

qdrant_client/async_qdrant_remote.py (3)

121-123: Good: use sanitized self._pool_size for httpx limits

Fixes prior bug where raw pool_size could be 0/negative.

---

286-289: Use actual pool length (and optionally a lock) in round‑robin

Defensive against any future divergence between configured size and realized pool.

-    def _next_grpc_client(self) -> int:
-        current_index = self._grpc_client_next_index
-        self._grpc_client_next_index = (self._grpc_client_next_index + 1) % self._pool_size
-        return current_index
+    def _next_grpc_client(self, pool_len: Optional[int] = None) -> int:
+        length = pool_len or len(self._grpc_channel_pool)
+        if length <= 0:
+            return 0
+        # Optional if you introduced asyncio.Lock in __init__:
+        # async with self._grpc_client_lock:
+        current_index = self._grpc_client_next_index % length
+        self._grpc_client_next_index = (current_index + 1) % length
+        return current_index

---

298-302: Index using realized pool length; keep mypy happy with local var

Prevents theoretical IndexError if pool length diverges; local var preserves narrowing.

@@ def grpc_collections(self) -> grpc.CollectionsStub:
-        assert self._grpc_collections_client_pool is not None
-        return self._grpc_collections_client_pool[self._next_grpc_client()]
+        assert self._grpc_collections_client_pool is not None
+        pool = self._grpc_collections_client_pool
+        return pool[self._next_grpc_client(len(pool))]
@@ def grpc_points(self) -> grpc.PointsStub:
-        assert self._grpc_points_client_pool is not None
-        return self._grpc_points_client_pool[self._next_grpc_client()]
+        assert self._grpc_points_client_pool is not None
+        pool = self._grpc_points_client_pool
+        return pool[self._next_grpc_client(len(pool))]
@@ def grpc_snapshots(self) -> grpc.SnapshotsStub:
-        assert self._grpc_snapshots_client_pool is not None
-        return self._grpc_snapshots_client_pool[self._next_grpc_client()]
+        assert self._grpc_snapshots_client_pool is not None
+        pool = self._grpc_snapshots_client_pool
+        return pool[self._next_grpc_client(len(pool))]
@@ def grpc_root(self) -> grpc.QdrantStub:
-        assert self._grpc_root_client_pool is not None
-        return self._grpc_root_client_pool[self._next_grpc_client()]
+        assert self._grpc_root_client_pool is not None
+        pool = self._grpc_root_client_pool
+        return pool[self._next_grpc_client(len(pool))]

Also applies to: 310-314, 322-326, 334-337

qdrant_client/qdrant_remote.py (4)

133-136: Good: use sanitized self._pool_size for httpx limits

Fixes the earlier bug with raw pool_size.

---

345-349: Index using realized pool length; local var helps mypy

Keeps rotation correct even if the pool is rebuilt/top‑upped.

@@ def grpc_collections(self) -> grpc.CollectionsStub:
-        assert self._grpc_collections_client_pool is not None
-        return self._grpc_collections_client_pool[self._next_grpc_client()]
+        assert self._grpc_collections_client_pool is not None
+        pool = self._grpc_collections_client_pool
+        return pool[self._next_grpc_client(len(pool))]
@@ def grpc_points(self) -> grpc.PointsStub:
-        assert self._grpc_points_client_pool is not None
-        return self._grpc_points_client_pool[self._next_grpc_client()]
+        assert self._grpc_points_client_pool is not None
+        pool = self._grpc_points_client_pool
+        return pool[self._next_grpc_client(len(pool))]
@@ def grpc_snapshots(self) -> grpc.SnapshotsStub:
-        assert self._grpc_snapshots_client_pool is not None
-        return self._grpc_snapshots_client_pool[self._next_grpc_client()]
+        assert self._grpc_snapshots_client_pool is not None
+        pool = self._grpc_snapshots_client_pool
+        return pool[self._next_grpc_client(len(pool))]
@@ def grpc_root(self) -> grpc.QdrantStub:
-        assert self._grpc_root_client_pool is not None
-        return self._grpc_root_client_pool[self._next_grpc_client()]
+        assert self._grpc_root_client_pool is not None
+        pool = self._grpc_root_client_pool
+        return pool[self._next_grpc_client(len(pool))]

Also applies to: 357-361, 369-373, 381-385

---

333-336: Make round‑robin thread‑safe and length‑aware

Use the lock and actual pool length to avoid races and theoretical OOB.

-    def _next_grpc_client(self) -> int:
-        current_index = self._grpc_client_next_index
-        self._grpc_client_next_index = (self._grpc_client_next_index + 1) % self._pool_size
-        return current_index
+    def _next_grpc_client(self, pool_len: Optional[int] = None) -> int:
+        length = pool_len or len(self._grpc_channel_pool)
+        if length <= 0:
+            return 0
+        with self._grpc_client_lock:
+            current_index = self._grpc_client_next_index % length
+            self._grpc_client_next_index = (current_index + 1) % length
+            return current_index

---

203-209: Add a lock for thread‑safe round‑robin

Multiple threads can read/update the index concurrently; protect it.

@@
-        self._grpc_client_next_index: int = 0  # The next index to use
+        self._grpc_client_next_index: int = 0  # The next index to use
+        self._grpc_client_lock = threading.Lock()

Additional import needed near other imports:

+import threading

qdrant_client/async_qdrant_remote.py (2)

173-179: Consider guarding round‑robin index in async (low risk)

Async properties are synchronous (no awaits), so task interleaving is unlikely to corrupt the index. If you still want belt-and-suspenders safety for cross‑thread use, add a lock field now and use it in the rotator.

@@
-        self._grpc_client_next_index: int = 0
+        self._grpc_client_next_index: int = 0
+        # Optional: protect index if instance is shared across threads/loops
+        # import asyncio at top if you choose this path:
+        # import asyncio
+        # self._grpc_client_lock = asyncio.Lock()

---

244-260: Tighten exception handling; close partially created channels on failure

Avoid leaking channels if creation fails mid-loop and preserve tracebacks.

-    def _init_grpc_channel(self) -> None:
+    def _init_grpc_channel(self) -> None:
         if self._closed:
             raise RuntimeError("Client was closed. Please create a new QdrantClient instance.")
-        try:
-            channel_pool = []
+        channel_pool: list[grpc.Channel] = []
+        try:
             if len(self._grpc_channel_pool) == 0:
                 for _ in range(self._pool_size):
@@
                     )
                     channel_pool.append(channel)
                 self._grpc_channel_pool = channel_pool
-        except Exception as e:
-            raise RuntimeError(f"Error initializing the grpc connection(s): {e}")
+        except Exception as e:
+            # best‑effort cleanup for channels created before the failure
+            for ch in channel_pool:
+                try:
+                    await ch.close()
+                except Exception:
+                    pass
+            raise RuntimeError("Error initializing the grpc connection(s)") from e

qdrant_client/qdrant_remote.py (2)

286-307: Tighten exception handling; close partially created channels on failure

Avoid leaks on mid‑loop failure and preserve traceback chain.

-        try:
-            channel_pool = []
+        channel_pool: list[grpc.Channel] = []
+        try:
@@
-                self._grpc_channel_pool = channel_pool
-        except Exception as e:
-            raise RuntimeError(f"Error initializing the grpc connection(s): {e}")
+                self._grpc_channel_pool = channel_pool
+        except Exception as e:
+            for ch in channel_pool:
+                try:
+                    ch.close()
+                except Exception:
+                    pass
+            raise RuntimeError("Error initializing the grpc connection(s)") from e

---

210-214: Remove unused aio gRPC stub fields

rg shows only their declarations in qdrant_client/qdrant_remote.py (lines 210–213): self._aio_grpc_points_client, self._aio_grpc_collections_client, self._aio_grpc_snapshots_client, self._aio_grpc_root_client — delete them.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

qdrant_client/qdrant_remote.py (1)

139-141: Bug fix confirmed: REST now uses sanitized pool size.

Switching httpx.Limits to self._pool_size prevents 0/negative usage. LGTM.

qdrant_client/async_qdrant_remote.py (1)

124-126: Bug fix confirmed: REST uses sanitized value.

Using self._pool_size is correct and consistent with sync.

qdrant_client/qdrant_remote.py (6)

76-82: Good: input sanitization for pool_size.

Clamping to ≥1 avoids invalid pools. Consider also validating type (non‑int inputs) earlier if these can arrive from env/config.

---

209-215: Make round‑robin index thread‑safe.

Concurrent use of a single client instance can interleave the increment. Guard the index with a lock.

Apply:

@@
-import logging
+import logging
+import threading
@@ class QdrantRemote(QdrantBase):
-        self._grpc_client_next_index: int = 0  # The next index to use
+        self._grpc_client_next_index: int = 0  # The next index to use
+        self._grpc_rr_lock = threading.Lock()

---

351-356: Round‑robin should use actual pool length and lock.

Using configured size risks mismatch if the pool is rebuilt; also not thread‑safe. Use the lock and current pool length.

Apply:

-    def _next_grpc_client(self) -> int:
-        current_index = self._grpc_client_next_index
-        self._grpc_client_next_index = (
-            self._grpc_client_next_index + 1
-        ) % self._get_grpc_pool_size()
-        return current_index
+    def _next_grpc_client(self) -> int:
+        with self._grpc_rr_lock:
+            length = len(self._grpc_channel_pool) or self._get_grpc_pool_size()
+            idx = self._grpc_client_next_index % length
+            self._grpc_client_next_index = (idx + 1) % length
+            return idx

---

304-326: Tighten exception handling and release partially created channels.

Catching bare Exception and not closing locally created channels can leak resources on failures. Raise from the original error and close any channels created before the failure.

Apply:

-        try:
+        try:
             channel_pool = []
@@
-                self._grpc_channel_pool = channel_pool
-        except Exception as e:
-            raise RuntimeError(f"Error initializing the grpc connection(s): {e}")
+                self._grpc_channel_pool = channel_pool
+        except Exception as err:
+            # Best effort: close any channels created before the failure.
+            for ch in channel_pool:
+                try:
+                    ch.close()
+                except Exception:
+                    pass
+            raise RuntimeError("Error initializing the gRPC connection pool") from err

Notes:

• Addresses BLE001/B904/TRY003 from static analysis.

---

48-48: Performance/behavior note: default REST vs gRPC pool sizes differ.

Given real‑world benchmarks showing pool_size=100 improves throughput ~1.5x vs 3, consider:

• Keeping REST default (httpx) untouched unless user sets pool_size (current behavior).
• Bumping DEFAULT_GRPC_POOL_SIZE based on benchmarks or making it None to mean “auto”.
  At minimum, document the asymmetry and recommend tuning in high‑concurrency workloads.

If you want, I can provide a quick aio/sync benchmark harness similar to the one shared in the PR to compare 3 vs 100 on your CI hardware.

Also applies to: 132-142, 288-299

---

48-48: Clarify DEFAULT_GRPC_POOL_SIZE=3 and REST pool_size behavior

DEFAULT_GRPC_POOL_SIZE is set to 3 in qdrant_client/qdrant_remote.py and async_qdrant_remote.py and is returned by _get_grpc_pool_size() when pool_size is unset. The REST client only applies httpx.Limits when pool_size is explicitly provided (localhost is a special-case that disables limits), so REST falls back to httpx's defaults otherwise. Add a short constructor docstring or docs note stating this; optionally align REST and gRPC defaults if consistency is desired.

qdrant_client/async_qdrant_remote.py (4)

57-57: Default gRPC pool size: clarify consistency stance.

Async sets DEFAULT_GRPC_POOL_SIZE=3. As with sync, document that REST keeps httpx defaults unless pool_size is provided.

---

258-274: Tighten exception handling and release partial channels.

Mirror the sync fix: don’t catch bare Exception without chaining, and close any created aio channels on failure.

Apply:

-        try:
+        try:
             channel_pool = []
@@
-                self._grpc_channel_pool = channel_pool
-        except Exception as e:
-            raise RuntimeError(f"Error initializing the grpc connection(s): {e}")
+                self._grpc_channel_pool = channel_pool
+        except Exception as err:
+            for ch in channel_pool:
+                try:
+                    await ch.close(grace=None)
+                except Exception:
+                    pass
+            raise RuntimeError("Error initializing the gRPC connection pool") from err

Notes:

• Addresses BLE001/B904/TRY003 hints.
• Since this method is sync, you can’t await; alternatively, drop the await and close best‑effort in finally later. If you prefer to keep it sync, do not await and just ignore close; or refactor _init_grpc_channel to async in the generator and adapt call sites.

Would you prefer we keep this method sync and skip best‑effort closes, or make it async in the generator?

---

300-305: Async RR: use actual pool length; lock likely unnecessary.

In asyncio (single thread), this method runs to completion without await, so race risk is minimal. Still, prefer modulo actual length for resilience.

Apply:

-    def _next_grpc_client(self) -> int:
-        current_index = self._grpc_client_next_index
-        self._grpc_client_next_index = (
-            self._grpc_client_next_index + 1
-        ) % self._get_grpc_pool_size()
-        return current_index
+    def _next_grpc_client(self) -> int:
+        length = len(self._grpc_channel_pool) or self._get_grpc_pool_size()
+        idx = self._grpc_client_next_index % length
+        self._grpc_client_next_index = (idx + 1) % length
+        return idx

---

57-57: Operational guidance: document tuning advice.

Recommend pool_size tuning in README/API docs (e.g., start at 32–128 for heavy parallel ingestion; keep httpx default unless constrained).

Also applies to: 84-88, 121-126

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

qdrant_client/qdrant_remote.py (2)

355-360: Make RR index thread‑safe and use actual pool length.
Avoids races and mis-modulo if pool size ever diverges from configured size.

Apply:

-    def _next_grpc_client(self) -> int:
-        current_index = self._grpc_client_next_index
-        self._grpc_client_next_index = (
-            self._grpc_client_next_index + 1
-        ) % self._get_grpc_pool_size()
-        return current_index
+    def _next_grpc_client(self) -> int:
+        # Protect against concurrent access
+        with self._grpc_rr_lock:  # type: ignore[attr-defined]
+            length = len(self._grpc_channel_pool)
+            if length <= 0:
+                return 0
+            current_index = self._grpc_client_next_index % length
+            self._grpc_client_next_index = (current_index + 1) % length
+            return current_index

---

213-219: Add locks for round‑robin and pool init to avoid races and leaks.
Concurrent threads can double‑init the pool and race the RR counter.

Apply:

@@
-        self._grpc_client_next_index: int = 0  # The next index to use
+        self._grpc_client_next_index: int = 0  # The next index to use
+        # Synchronization for multithreaded use
+        import threading  # local import acceptable; consider hoisting to module imports
+        self._grpc_rr_lock = threading.Lock()
+        self._grpc_init_lock = threading.Lock()

qdrant_client/qdrant_remote.py (3)

258-269: grpc_grace is unused in sync close().
Either document as ignored for sync or remove the param to avoid confusion.

---

311-323: Auth token provider: reject async provider in sync client.
Passing an async callable to the sync interceptor will fail at runtime.

Consider validating and warning:

+        if callable(self._auth_token_provider) and getattr(self._auth_token_provider, "__await__", None):
+            show_warning("Async auth_token_provider is not supported in sync client.", category=UserWarning, stacklevel=4)
+            self._auth_token_provider = None

---

259-269: Nit: hasattr guard is redundant.
Field is always set in init.

-        if hasattr(self, "_grpc_channel_pool") and len(self._grpc_channel_pool) > 0:
+        if self._grpc_channel_pool:

qdrant_client/async_qdrant_remote.py (2)

259-278: Preserve original traceback; avoid bare Exception.
Raise from the caught error. Keeps debugging intact.

Apply:

-        except Exception as e:
-            raise RuntimeError(f"Error initializing the grpc connection(s): {e}")
+        except Exception as e:
+            raise RuntimeError("Error initializing the grpc connection(s).") from e

Note: This file is autogenerated; update the generator to persist.

Would you like me to propose the corresponding change in tools/async_client_generator so regeneration keeps this behavior?

---

304-309: Use actual pool length for RR modulo (consistency with sync fix).
Prevents future drift if pool size differs at runtime.

Apply:

-    def _next_grpc_client(self) -> int:
-        current_index = self._grpc_client_next_index
-        self._grpc_client_next_index = (
-            self._grpc_client_next_index + 1
-        ) % self._get_grpc_pool_size()
-        return current_index
+    def _next_grpc_client(self) -> int:
+        length = len(self._grpc_channel_pool)
+        if length <= 0:
+            return 0
+        current_index = self._grpc_client_next_index % length
+        self._grpc_client_next_index = (current_index + 1) % length
+        return current_index

Since this file is autogenerated, please update the generator accordingly.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro