server kit: in-collection resume + async upserts + batch 512

server/load_all.py

@@ -33,7 +33,7 @@ TARBALLS = {
     "qdrant_eqc_qa.tar.gz": ["eqc_qa"],
     "qdrant_publications.tar.gz": ["publications"],
 }
-BATCH = 256
+BATCH = 512
 
 # The embedded (local-mode) indexes cannot persist payload indexes, so they are
 # re-created here exactly as the original loaders defined them.
@@ -97,46 +97,60 @@ def migrate_collection(local: QdrantClient, remote: QdrantClient,
     info = local.get_collection(coll)
     total = local.count(coll).count
 
+    skip_first = 0
     if remote.collection_exists(coll):
         have = remote.count(coll).count
         if have == total and not recreate:
             log(f"{coll}: server already has {have}/{total} points — skip "
                 f"(--recreate to force)")
             return
-        log(f"{coll}: server has {have}/{total} — recreating")
-        remote.delete_collection(coll)
-
-    remote.create_collection(
-        collection_name=coll,
-        vectors_config=info.config.params.vectors,
-        sparse_vectors_config=info.config.params.sparse_vectors,
-        on_disk_payload=True,
-    )
-    indexes = {f: s.data_type for f, s in (info.payload_schema or {}).items()}
-    if not indexes:
-        indexes = PAYLOAD_INDEXES.get(coll, {})
-    for field, schema in indexes.items():
-        remote.create_payload_index(collection_name=coll, field_name=field,
-                                    field_schema=schema)
-    log(f"{coll}: created (vectors={list(info.config.params.vectors)}, "
-        f"sparse={list(info.config.params.sparse_vectors or {})}, "
-        f"payload indexes={list(indexes)})")
-
-    done, offset, t0 = 0, None, time.time()
+        if recreate or have == 0 or have > total:
+            log(f"{coll}: server has {have}/{total} — recreating")
+            remote.delete_collection(coll)
+        else:
+            # Interrupted copy: local scroll order is deterministic and
+            # upserts are idempotent, so resume with an overlap margin.
+            skip_first = max(0, have - 8 * BATCH)
+            log(f"{coll}: server has {have}/{total} — resuming from "
+                f"~{skip_first} (with overlap)")
+
+    if not remote.collection_exists(coll):
+        remote.create_collection(
+            collection_name=coll,
+            vectors_config=info.config.params.vectors,
+            sparse_vectors_config=info.config.params.sparse_vectors,
+            on_disk_payload=True,
+        )
+        indexes = {f: s.data_type for f, s in (info.payload_schema or {}).items()}
+        if not indexes:
+            indexes = PAYLOAD_INDEXES.get(coll, {})
+        for field, schema in indexes.items():
+            remote.create_payload_index(collection_name=coll, field_name=field,
+                                        field_schema=schema)
+        log(f"{coll}: created (vectors={list(info.config.params.vectors)}, "
+            f"sparse={list(info.config.params.sparse_vectors or {})}, "
+            f"payload indexes={list(indexes)})")
+
+    done, seen, offset, t0 = 0, 0, None, time.time()
     while True:
         points, offset = local.scroll(coll, limit=BATCH, offset=offset,
                                       with_payload=True, with_vectors=True)
         if not points:
             break
-        remote.upsert(coll, points=[
-            models.PointStruct(id=p.id, vector=p.vector, payload=p.payload)
-            for p in points])
-        done += len(points)
-        if done % (BATCH * 40) == 0 or offset is None:
+        seen += len(points)
+        if seen > skip_first:
+            batch = points if seen - len(points) >= skip_first else \
+                points[-(seen - skip_first):]
+            remote.upsert(coll, wait=False, points=[
+                models.PointStruct(id=p.id, vector=p.vector, payload=p.payload)
+                for p in batch])
+            done += len(batch)
+        if seen % (BATCH * 40) == 0 or offset is None:
             rate = done / max(time.time() - t0, 1e-9)
-            log(f"{coll}: {done}/{total} ({rate:.0f} pts/s)")
+            log(f"{coll}: {skip_first + done}/{total} ({rate:.0f} pts/s live)")
         if offset is None:
             break
+    time.sleep(2)  # let async upserts settle before the count check
 
     got = remote.count(coll).count
     status = "OK" if got == total else "MISMATCH"