ydb-qdrant 4.7.2 → 4.8.1

package/dist/repositories/collectionsRepo.js

@@ -1,4 +1,4 @@
-import { TypedValues, withSession } from "../ydb/client.js";
+import { TypedValues, withSession, createExecuteQuerySettings, } from "../ydb/client.js";
 import { mapDistanceToIndexParam } from "../utils/distance.js";
 import { COLLECTION_STORAGE_MODE, isOneTableMode, } from "../config/env.js";
 import { GLOBAL_POINTS_TABLE } from "../ydb/schema.js";
@@ -20,9 +20,10 @@ export async function getCollectionMeta(metaKey) {
     WHERE collection = $collection;
   `;
     const res = await withSession(async (s) => {
+        const settings = createExecuteQuerySettings();
         return await s.executeQuery(qry, {
             $collection: TypedValues.utf8(metaKey),
-        });
+        }, undefined, settings);
     });
     const rowset = res.resultSets?.[0];
     if (!rowset || rowset.rows?.length !== 1)

package/dist/repositories/collectionsRepo.multi-table.js

@@ -1,4 +1,4 @@
-import { Types, TypedValues, withSession, TableDescription, Column, } from "../ydb/client.js";
+import { Types, TypedValues, withSession, TableDescription, Column, createExecuteQuerySettings, } from "../ydb/client.js";
 import { upsertCollectionMeta } from "./collectionsRepo.shared.js";
 export async function createCollectionMultiTable(metaKey, dim, distance, vectorType, tableName) {
     await withSession(async (s) => {
@@ -18,6 +18,7 @@ export async function deleteCollectionMultiTable(metaKey, tableName) {
     DELETE FROM qdr__collections WHERE collection = $collection;
   `;
     await withSession(async (s) => {
-        await s.executeQuery(delMeta, { $collection: TypedValues.utf8(metaKey) });
+        const settings = createExecuteQuerySettings();
+        await s.executeQuery(delMeta, { $collection: TypedValues.utf8(metaKey) }, undefined, settings);
     });
 }

package/dist/repositories/collectionsRepo.one-table.js

@@ -1,6 +1,63 @@
-import { TypedValues, withSession } from "../ydb/client.js";
+import { TypedValues, Types, withSession, createExecuteQuerySettings, } from "../ydb/client.js";
 import { GLOBAL_POINTS_TABLE, ensureGlobalPointsTable } from "../ydb/schema.js";
 import { upsertCollectionMeta } from "./collectionsRepo.shared.js";
+import { withRetry, isTransientYdbError } from "../utils/retry.js";
+const DELETE_COLLECTION_BATCH_SIZE = 10000;
+function isOutOfBufferMemoryYdbError(error) {
+    const msg = error instanceof Error ? error.message : String(error);
+    if (/Out of buffer memory/i.test(msg)) {
+        return true;
+    }
+    if (typeof error === "object" && error !== null) {
+        const issues = error.issues;
+        if (issues !== undefined) {
+            const issuesText = typeof issues === "string" ? issues : JSON.stringify(issues);
+            return /Out of buffer memory/i.test(issuesText);
+        }
+    }
+    return false;
+}
+async function deletePointsForUidInChunks(s, uid) {
+    const selectYql = `
+    DECLARE $uid AS Utf8;
+    DECLARE $limit AS Uint32;
+    SELECT point_id
+    FROM ${GLOBAL_POINTS_TABLE}
+    WHERE uid = $uid
+    LIMIT $limit;
+  `;
+    const deleteBatchYql = `
+    DECLARE $uid AS Utf8;
+    DECLARE $ids AS List<Utf8>;
+    DELETE FROM ${GLOBAL_POINTS_TABLE}
+    WHERE uid = $uid AND point_id IN $ids;
+  `;
+    // Best‑effort loop: stop when there are no more rows for this uid.
+    // Each iteration only touches a limited number of rows to avoid
+    // hitting YDB's per‑operation buffer limits.
+    let iterations = 0;
+    const MAX_ITERATIONS = 1000;
+    const settings = createExecuteQuerySettings();
+    while (iterations++ < MAX_ITERATIONS) {
+        const rs = (await s.executeQuery(selectYql, {
+            $uid: TypedValues.utf8(uid),
+            $limit: TypedValues.uint32(DELETE_COLLECTION_BATCH_SIZE),
+        }, undefined, settings));
+        const rowset = rs.resultSets?.[0];
+        const rows = rowset?.rows ?? [];
+        const ids = rows
+            .map((row) => row.items?.[0]?.textValue)
+            .filter((id) => typeof id === "string");
+        if (ids.length === 0) {
+            break;
+        }
+        const idsValue = TypedValues.list(Types.UTF8, ids);
+        await s.executeQuery(deleteBatchYql, {
+            $uid: TypedValues.utf8(uid),
+            $ids: idsValue,
+        }, undefined, settings);
+    }
+}
 export async function createCollectionOneTable(metaKey, dim, distance, vectorType) {
     await upsertCollectionMeta(metaKey, dim, distance, vectorType, GLOBAL_POINTS_TABLE);
 }
@@ -10,16 +67,36 @@ export async function deleteCollectionOneTable(metaKey, uid) {
     DECLARE $uid AS Utf8;
     DELETE FROM ${GLOBAL_POINTS_TABLE} WHERE uid = $uid;
   `;
-    await withSession(async (s) => {
-        await s.executeQuery(deletePointsYql, {
-            $uid: TypedValues.utf8(uid),
-        });
+    await withRetry(() => withSession(async (s) => {
+        const settings = createExecuteQuerySettings();
+        try {
+            await s.executeQuery(deletePointsYql, {
+                $uid: TypedValues.utf8(uid),
+            }, undefined, settings);
+        }
+        catch (err) {
+            if (!isOutOfBufferMemoryYdbError(err)) {
+                throw err;
+            }
+            await deletePointsForUidInChunks(s, uid);
+        }
+    }), {
+        isTransient: isTransientYdbError,
+        context: {
+            operation: "deleteCollectionOneTable",
+            tableName: GLOBAL_POINTS_TABLE,
+            metaKey,
+            uid,
+        },
     });
     const delMeta = `
     DECLARE $collection AS Utf8;
     DELETE FROM qdr__collections WHERE collection = $collection;
   `;
     await withSession(async (s) => {
-        await s.executeQuery(delMeta, { $collection: TypedValues.utf8(metaKey) });
+        const settings = createExecuteQuerySettings();
+        await s.executeQuery(delMeta, {
+            $collection: TypedValues.utf8(metaKey),
+        }, undefined, settings);
     });
 }

package/dist/repositories/pointsRepo.multi-table.js

@@ -1,4 +1,4 @@
-import { Types, TypedValues, withSession } from "../ydb/client.js";
+import { Types, TypedValues, withSession, createExecuteQuerySettings, } from "../ydb/client.js";
 import { buildVectorParam } from "../ydb/helpers.js";
 import { logger } from "../logging/logger.js";
 import { notifyUpsert } from "../indexing/IndexScheduler.js";
@@ -15,6 +15,7 @@ export async function upsertPointsMultiTable(tableName, points, dimension) {
     }
     let upserted = 0;
     await withSession(async (s) => {
+        const settings = createExecuteQuerySettings();
         for (let i = 0; i < points.length; i += UPSERT_BATCH_SIZE) {
             const batch = points.slice(i, i + UPSERT_BATCH_SIZE);
             const ddl = `
@@ -44,7 +45,7 @@ export async function upsertPointsMultiTable(tableName, points, dimension) {
             const params = {
                 $rows: rowsValue,
             };
-            await withRetry(() => s.executeQuery(ddl, params), {
+            await withRetry(() => s.executeQuery(ddl, params, undefined, settings), {
                 isTransient: isTransientYdbError,
                 context: { tableName, batchSize: batch.length },
             });
@@ -64,6 +65,7 @@ export async function searchPointsMultiTable(tableName, queryVector, top, withPa
         $qf: qf,
         $k2: TypedValues.uint32(top),
     };
+    const settings = createExecuteQuerySettings();
     const buildQuery = (useIndex) => `
     DECLARE $qf AS List<Float>;
     DECLARE $k2 AS Uint32;
@@ -77,7 +79,7 @@ export async function searchPointsMultiTable(tableName, queryVector, top, withPa
     if (VECTOR_INDEX_BUILD_ENABLED) {
         try {
             rs = await withSession(async (s) => {
-                return await s.executeQuery(buildQuery(true), params);
+                return await s.executeQuery(buildQuery(true), params, undefined, settings);
             });
             logger.info({ tableName }, "vector index found; using index for search");
         }
@@ -87,7 +89,7 @@ export async function searchPointsMultiTable(tableName, queryVector, top, withPa
             if (indexUnavailable) {
                 logger.info({ tableName }, "vector index not available (missing or building); falling back to table scan");
                 rs = await withSession(async (s) => {
-                    return await s.executeQuery(buildQuery(false), params);
+                    return await s.executeQuery(buildQuery(false), params, undefined, settings);
                 });
             }
             else {
@@ -97,7 +99,7 @@ export async function searchPointsMultiTable(tableName, queryVector, top, withPa
     }
     else {
         rs = await withSession(async (s) => {
-            return await s.executeQuery(buildQuery(false), params);
+            return await s.executeQuery(buildQuery(false), params, undefined, settings);
         });
     }
     const rowset = rs.resultSets?.[0];
@@ -128,6 +130,7 @@ export async function searchPointsMultiTable(tableName, queryVector, top, withPa
 export async function deletePointsMultiTable(tableName, ids) {
     let deleted = 0;
     await withSession(async (s) => {
+        const settings = createExecuteQuerySettings();
         for (const id of ids) {
             const yql = `
         DECLARE $id AS Utf8;
@@ -136,7 +139,7 @@ export async function deletePointsMultiTable(tableName, ids) {
             const params = {
                 $id: TypedValues.utf8(String(id)),
             };
-            await s.executeQuery(yql, params);
+            await s.executeQuery(yql, params, undefined, settings);
             deleted += 1;
         }
     });

package/dist/repositories/pointsRepo.one-table.js

@@ -1,4 +1,4 @@
-import { TypedValues, Types, withSession } from "../ydb/client.js";
+import { TypedValues, Types, withSession, createExecuteQuerySettings, } from "../ydb/client.js";
 import { buildVectorParam, buildVectorBinaryParams } from "../ydb/helpers.js";
 import { notifyUpsert } from "../indexing/IndexScheduler.js";
 import { mapDistanceToKnnFn, mapDistanceToBitKnnFn, } from "../utils/distance.js";
@@ -25,6 +25,7 @@ export async function upsertPointsOneTable(tableName, points, dimension, uid) {
     }
     let upserted = 0;
     await withSession(async (s) => {
+        const settings = createExecuteQuerySettings();
         for (let i = 0; i < points.length; i += UPSERT_BATCH_SIZE) {
             const batch = points.slice(i, i + UPSERT_BATCH_SIZE);
             let ddl;
@@ -120,7 +121,7 @@ export async function upsertPointsOneTable(tableName, points, dimension, uid) {
                     })),
                 },
             }, "one_table upsert: executing YQL");
-            await withRetry(() => s.executeQuery(ddl, params), {
+            await withRetry(() => s.executeQuery(ddl, params, undefined, settings), {
                 isTransient: isTransientYdbError,
                 context: { tableName, batchSize: batch.length },
             });
@@ -193,7 +194,8 @@ async function searchPointsOneTableExact(tableName, queryVector, top, withPayloa
                 vectorPreview: queryVector.slice(0, 3),
             },
         }, "one_table search (exact): executing YQL");
-        const rs = await s.executeQuery(yql, params);
+        const settings = createExecuteQuerySettings();
+        const rs = await s.executeQuery(yql, params, undefined, settings);
         const rowset = rs.resultSets?.[0];
         const rows = (rowset?.rows ?? []);
         return rows.map((row) => {
@@ -231,195 +233,114 @@ async function searchPointsOneTableApproximate(tableName, queryVector, top, with
     const rawCandidateLimit = safeTop * overfetchMultiplier;
     const candidateLimit = Math.max(safeTop, rawCandidateLimit);
     const results = await withSession(async (s) => {
+        let yql;
+        let params;
         if (CLIENT_SIDE_SERIALIZATION_ENABLED) {
             const binaries = buildVectorBinaryParams(queryVector);
-            // Phase 1: approximate candidate selection using embedding_quantized
-            const phase1Query = `
+            yql = `
         DECLARE $qbin_bit AS String;
-        DECLARE $k AS Uint32;
+        DECLARE $qbinf AS String;
+        DECLARE $candidateLimit AS Uint32;
+        DECLARE $safeTop AS Uint32;
         DECLARE $uid AS Utf8;
-        SELECT point_id
+
+        $candidates = (
+          SELECT point_id
+          FROM ${tableName}
+          WHERE uid = $uid AND embedding_quantized IS NOT NULL
+          ORDER BY ${bitFn}(embedding_quantized, $qbin_bit) ${bitOrder}
+          LIMIT $candidateLimit
+        );
+
+        SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
         FROM ${tableName}
-        WHERE uid = $uid AND embedding_quantized IS NOT NULL
-        ORDER BY ${bitFn}(embedding_quantized, $qbin_bit) ${bitOrder}
-        LIMIT $k;
+        WHERE uid = $uid
+          AND point_id IN $candidates
+        ORDER BY score ${order}
+        LIMIT $safeTop;
       `;
+            params = {
+                $qbin_bit: typeof TypedValues.bytes === "function"
+                    ? TypedValues.bytes(binaries.bit)
+                    : binaries.bit,
+                $qbinf: typeof TypedValues.bytes === "function"
+                    ? TypedValues.bytes(binaries.float)
+                    : binaries.float,
+                $candidateLimit: TypedValues.uint32(candidateLimit),
+                $safeTop: TypedValues.uint32(safeTop),
+                $uid: TypedValues.utf8(uid),
+            };
             logger.debug({
                 tableName,
                 distance,
                 top,
                 safeTop,
                 candidateLimit,
-                mode: "one_table_approximate_phase1_client_side_serialization",
-                yql: phase1Query,
+                mode: "one_table_approximate_client_side_serialization",
+                yql,
                 params: {
                     uid,
-                    top: candidateLimit,
+                    safeTop,
+                    candidateLimit,
                     vectorLength: queryVector.length,
                     vectorPreview: queryVector.slice(0, 3),
                 },
-            }, "one_table search (approximate, phase 1): executing YQL");
-            const phase1Params = {
-                $qbin_bit: typeof TypedValues.bytes === "function"
-                    ? TypedValues.bytes(binaries.bit)
-                    : binaries.bit,
-                $k: TypedValues.uint32(candidateLimit),
-                $uid: TypedValues.utf8(uid),
-            };
-            const rs1 = await s.executeQuery(phase1Query, phase1Params);
-            const rowset1 = rs1.resultSets?.[0];
-            const rows1 = (rowset1?.rows ?? []);
-            const candidateIds = rows1
-                .map((row) => row.items?.[0]?.textValue)
-                .filter((id) => typeof id === "string");
-            if (candidateIds.length === 0) {
-                return [];
-            }
-            // Phase 2: exact re-ranking on full-precision embedding for candidates only
-            const phase2Query = `
-        DECLARE $qbinf AS String;
-        DECLARE $k AS Uint32;
+            }, "one_table search (approximate): executing YQL with client-side serialization");
+        }
+        else {
+            const qf = buildVectorParam(queryVector);
+            yql = `
+        DECLARE $qf AS List<Float>;
+        DECLARE $candidateLimit AS Uint32;
+        DECLARE $safeTop AS Uint32;
         DECLARE $uid AS Utf8;
-        DECLARE $ids AS List<Utf8>;
+
+        $qbin_bit = Knn::ToBinaryStringBit($qf);
+        $qbinf = Knn::ToBinaryStringFloat($qf);
+
+        $candidates = (
+          SELECT point_id
+          FROM ${tableName}
+          WHERE uid = $uid AND embedding_quantized IS NOT NULL
+          ORDER BY ${bitFn}(embedding_quantized, $qbin_bit) ${bitOrder}
+          LIMIT $candidateLimit
+        );
+
         SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
         FROM ${tableName}
-        WHERE uid = $uid AND point_id IN $ids
+        WHERE uid = $uid
+          AND point_id IN $candidates
         ORDER BY score ${order}
-        LIMIT $k;
+        LIMIT $safeTop;
       `;
+            params = {
+                $qf: qf,
+                $candidateLimit: TypedValues.uint32(candidateLimit),
+                $safeTop: TypedValues.uint32(safeTop),
+                $uid: TypedValues.utf8(uid),
+            };
             logger.debug({
                 tableName,
                 distance,
                 top,
                 safeTop,
-                candidateCount: candidateIds.length,
-                mode: "one_table_approximate_phase2_client_side_serialization",
-                yql: phase2Query,
+                candidateLimit,
+                mode: "one_table_approximate",
+                yql,
                 params: {
                     uid,
-                    top: safeTop,
+                    safeTop,
+                    candidateLimit,
                     vectorLength: queryVector.length,
                     vectorPreview: queryVector.slice(0, 3),
-                    ids: candidateIds,
                 },
-            }, "one_table search (approximate, phase 2): executing YQL");
-            const idsParam = TypedValues.list(Types.UTF8, candidateIds);
-            const phase2Params = {
-                $qbinf: typeof TypedValues.bytes === "function"
-                    ? TypedValues.bytes(binaries.float)
-                    : binaries.float,
-                $k: TypedValues.uint32(safeTop),
-                $uid: TypedValues.utf8(uid),
-                $ids: idsParam,
-            };
-            const rs2 = await s.executeQuery(phase2Query, phase2Params);
-            const rowset2 = rs2.resultSets?.[0];
-            const rows2 = (rowset2?.rows ?? []);
-            return rows2.map((row) => {
-                const id = row.items?.[0]?.textValue;
-                if (typeof id !== "string") {
-                    throw new Error("point_id is missing in YDB search result");
-                }
-                let payload;
-                let scoreIdx = 1;
-                if (withPayload) {
-                    const payloadText = row.items?.[1]?.textValue;
-                    if (payloadText) {
-                        try {
-                            payload = JSON.parse(payloadText);
-                        }
-                        catch {
-                            payload = undefined;
-                        }
-                    }
-                    scoreIdx = 2;
-                }
-                const score = Number(row.items?.[scoreIdx]?.floatValue ?? row.items?.[scoreIdx]?.textValue);
-                return { id, score, ...(payload ? { payload } : {}) };
-            });
+            }, "one_table search (approximate): executing YQL");
         }
-        const qf = buildVectorParam(queryVector);
-        // Phase 1: approximate candidate selection using embedding_quantized
-        const phase1Query = `
-      DECLARE $qf AS List<Float>;
-      DECLARE $k AS Uint32;
-      DECLARE $uid AS Utf8;
-      $qbin_bit = Knn::ToBinaryStringBit($qf);
-      SELECT point_id
-      FROM ${tableName}
-      WHERE uid = $uid AND embedding_quantized IS NOT NULL
-      ORDER BY ${bitFn}(embedding_quantized, $qbin_bit) ${bitOrder}
-      LIMIT $k;
-    `;
-        logger.debug({
-            tableName,
-            distance,
-            top,
-            safeTop,
-            candidateLimit,
-            mode: "one_table_approximate_phase1",
-            yql: phase1Query,
-            params: {
-                uid,
-                top: candidateLimit,
-                vectorLength: queryVector.length,
-                vectorPreview: queryVector.slice(0, 3),
-            },
-        }, "one_table search (approximate, phase 1): executing YQL");
-        const phase1Params = {
-            $qf: qf,
-            $k: TypedValues.uint32(candidateLimit),
-            $uid: TypedValues.utf8(uid),
-        };
-        const rs1 = await s.executeQuery(phase1Query, phase1Params);
-        const rowset1 = rs1.resultSets?.[0];
-        const rows1 = (rowset1?.rows ?? []);
-        const candidateIds = rows1
-            .map((row) => row.items?.[0]?.textValue)
-            .filter((id) => typeof id === "string");
-        if (candidateIds.length === 0) {
-            return [];
-        }
-        // Phase 2: exact re-ranking on full-precision embedding for candidates only
-        const phase2Query = `
-      DECLARE $qf AS List<Float>;
-      DECLARE $k AS Uint32;
-      DECLARE $uid AS Utf8;
-      DECLARE $ids AS List<Utf8>;
-      $qbinf = Knn::ToBinaryStringFloat($qf);
-      SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
-      FROM ${tableName}
-      WHERE uid = $uid AND point_id IN $ids
-      ORDER BY score ${order}
-      LIMIT $k;
-    `;
-        logger.debug({
-            tableName,
-            distance,
-            top,
-            safeTop,
-            candidateCount: candidateIds.length,
-            mode: "one_table_approximate_phase2",
-            yql: phase2Query,
-            params: {
-                uid,
-                top: safeTop,
-                vectorLength: queryVector.length,
-                vectorPreview: queryVector.slice(0, 3),
-                ids: candidateIds,
-            },
-        }, "one_table search (approximate, phase 2): executing YQL");
-        const idsParam = TypedValues.list(Types.UTF8, candidateIds);
-        const phase2Params = {
-            $qf: qf,
-            $k: TypedValues.uint32(safeTop),
-            $uid: TypedValues.utf8(uid),
-            $ids: idsParam,
-        };
-        const rs2 = await s.executeQuery(phase2Query, phase2Params);
-        const rowset2 = rs2.resultSets?.[0];
-        const rows2 = (rowset2?.rows ?? []);
-        return rows2.map((row) => {
+        const settings = createExecuteQuerySettings();
+        const rs = await s.executeQuery(yql, params, undefined, settings);
+        const rowset = rs.resultSets?.[0];
+        const rows = (rowset?.rows ?? []);
+        return rows.map((row) => {
             const id = row.items?.[0]?.textValue;
             if (typeof id !== "string") {
                 throw new Error("point_id is missing in YDB search result");
@@ -453,6 +374,7 @@ export async function searchPointsOneTable(tableName, queryVector, top, withPayl
 export async function deletePointsOneTable(tableName, ids, uid) {
     let deleted = 0;
     await withSession(async (s) => {
+        const settings = createExecuteQuerySettings();
         for (const id of ids) {
             const yql = `
         DECLARE $uid AS Utf8;
@@ -463,7 +385,7 @@ export async function deletePointsOneTable(tableName, ids, uid) {
                 $uid: TypedValues.utf8(uid),
                 $id: TypedValues.utf8(String(id)),
             };
-            await s.executeQuery(yql, params);
+            await s.executeQuery(yql, params, undefined, settings);
             deleted += 1;
         }
     });

package/dist/services/PointsService.js

@@ -118,13 +118,23 @@ async function executeSearch(ctx, normalizedSearch, source) {
         throw err;
     }
     const threshold = normalizedSearch.scoreThreshold;
+    // For Cosine, repository hits use distance scores; convert to a
+    // similarity-like score so API consumers and IDE thresholds see
+    // "higher is better". This keeps ranking identical (monotonic 1 - d).
+    const normalizedHits = meta.distance === "Cosine"
+        ? hits.map((hit) => ({
+            ...hit,
+            score: 1 - hit.score,
+        }))
+        : hits;
     const filtered = threshold === undefined
-        ? hits
-        : hits.filter((hit) => {
-            const isSimilarity = meta.distance === "Cosine" || meta.distance === "Dot";
-            if (isSimilarity) {
+        ? normalizedHits
+        : normalizedHits.filter((hit) => {
+            if (meta.distance === "Dot" || meta.distance === "Cosine") {
+                // Similarity metrics: threshold is minimum similarity.
                 return hit.score >= threshold;
             }
+            // Euclid / Manhattan: pure distance metrics; threshold is max distance.
             return hit.score <= threshold;
         });
     logger.info({

package/dist/utils/distance.d.ts

@@ -5,13 +5,13 @@ export declare function mapDistanceToKnnFn(distance: DistanceKind): {
 };
 export declare function mapDistanceToIndexParam(distance: DistanceKind): string;
 /**
- * Maps a user-specified distance metric to a YDB Knn distance function
+ * Maps a user-specified distance metric to a YDB Knn function
  * suitable for bit-quantized vectors (Phase 1 approximate candidate selection).
- * Always returns a distance function (lower is better, ASC ordering).
+ * Cosine uses similarity (DESC); other metrics use distance (ASC).
  * For Dot, falls back to CosineDistance as a proxy since there is no
  * direct distance equivalent for inner product.
  */
 export declare function mapDistanceToBitKnnFn(distance: DistanceKind): {
     fn: string;
-    order: "ASC";
+    order: "ASC" | "DESC";
 };

package/dist/utils/distance.js

@@ -1,7 +1,7 @@
 export function mapDistanceToKnnFn(distance) {
     switch (distance) {
         case "Cosine":
-            return { fn: "Knn::CosineSimilarity", order: "DESC" };
+            return { fn: "Knn::CosineDistance", order: "ASC" };
         case "Dot":
             return { fn: "Knn::InnerProductSimilarity", order: "DESC" };
         case "Euclid":
@@ -9,7 +9,7 @@ export function mapDistanceToKnnFn(distance) {
         case "Manhattan":
             return { fn: "Knn::ManhattanDistance", order: "ASC" };
         default:
-            return { fn: "Knn::CosineSimilarity", order: "DESC" };
+            return { fn: "Knn::CosineDistance", order: "ASC" };
     }
 }
 export function mapDistanceToIndexParam(distance) {
@@ -27,18 +27,17 @@ export function mapDistanceToIndexParam(distance) {
     }
 }
 /**
- * Maps a user-specified distance metric to a YDB Knn distance function
+ * Maps a user-specified distance metric to a YDB Knn function
  * suitable for bit-quantized vectors (Phase 1 approximate candidate selection).
- * Always returns a distance function (lower is better, ASC ordering).
+ * Cosine uses similarity (DESC); other metrics use distance (ASC).
  * For Dot, falls back to CosineDistance as a proxy since there is no
  * direct distance equivalent for inner product.
  */
 export function mapDistanceToBitKnnFn(distance) {
     switch (distance) {
         case "Cosine":
-            return { fn: "Knn::CosineDistance", order: "ASC" };
+            return { fn: "Knn::CosineSimilarity", order: "DESC" };
         case "Dot":
-            // No direct distance equivalent; use Cosine as proxy
             return { fn: "Knn::CosineDistance", order: "ASC" };
         case "Euclid":
             return { fn: "Knn::EuclideanDistance", order: "ASC" };

package/dist/utils/retry.js

@@ -3,7 +3,19 @@ const DEFAULT_MAX_RETRIES = 6;
 const DEFAULT_BASE_DELAY_MS = 250;
 export function isTransientYdbError(error) {
     const msg = error instanceof Error ? error.message : String(error);
-    return /Aborted|schema version mismatch|Table metadata loading|Failed to load metadata/i.test(msg);
+    if (/Aborted|schema version mismatch|Table metadata loading|Failed to load metadata|overloaded|is in process of split|wrong shard state|Rejecting data TxId/i.test(msg)) {
+        return true;
+    }
+    if (typeof error === "object" && error !== null) {
+        const issues = error.issues;
+        if (issues !== undefined) {
+            const issuesText = typeof issues === "string" ? issues : JSON.stringify(issues);
+            if (/overloaded|is in process of split|wrong shard state|Rejecting data TxId/i.test(issuesText)) {
+                return true;
+            }
+        }
+    }
+    return false;
 }
 export async function withRetry(fn, options = {}) {
     const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;

package/dist/ydb/client.d.ts

@@ -1,6 +1,10 @@
-import type { Session, IAuthService } from "ydb-sdk";
-declare const Types: typeof import("ydb-sdk").Types, TypedValues: typeof import("ydb-sdk").TypedValues, TableDescription: typeof import("ydb-sdk").TableDescription, Column: typeof import("ydb-sdk").Column;
-export { Types, TypedValues, TableDescription, Column };
+import type { Session, IAuthService, ExecuteQuerySettings as YdbExecuteQuerySettings } from "ydb-sdk";
+declare const Types: typeof import("ydb-sdk").Types, TypedValues: typeof import("ydb-sdk").TypedValues, TableDescription: typeof import("ydb-sdk").TableDescription, Column: typeof import("ydb-sdk").Column, ExecuteQuerySettings: typeof YdbExecuteQuerySettings;
+export { Types, TypedValues, TableDescription, Column, ExecuteQuerySettings };
+export declare function createExecuteQuerySettings(options?: {
+    keepInCache?: boolean;
+    idempotent?: boolean;
+}): YdbExecuteQuerySettings;
 type DriverConfig = {
     endpoint?: string;
     database?: string;

package/dist/ydb/client.js

@@ -2,8 +2,19 @@ import { createRequire } from "module";
 import { YDB_DATABASE, YDB_ENDPOINT, SESSION_POOL_MIN_SIZE, SESSION_POOL_MAX_SIZE, SESSION_KEEPALIVE_PERIOD_MS, } from "../config/env.js";
 import { logger } from "../logging/logger.js";
 const require = createRequire(import.meta.url);
-const { Driver, getCredentialsFromEnv, Types, TypedValues, TableDescription, Column, } = require("ydb-sdk");
-export { Types, TypedValues, TableDescription, Column };
+const { Driver, getCredentialsFromEnv, Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, } = require("ydb-sdk");
+export { Types, TypedValues, TableDescription, Column, ExecuteQuerySettings };
+export function createExecuteQuerySettings(options) {
+    const { keepInCache = true, idempotent = true } = options ?? {};
+    const settings = new ExecuteQuerySettings();
+    if (keepInCache) {
+        settings.withKeepInCache(true);
+    }
+    if (idempotent) {
+        settings.withIdempotent(true);
+    }
+    return settings;
+}
 const DRIVER_READY_TIMEOUT_MS = 15000;
 const TABLE_SESSION_TIMEOUT_MS = 20000;
 const YDB_HEALTHCHECK_READY_TIMEOUT_MS = 5000;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ydb-qdrant",
-  "version": "4.7.2",
+  "version": "4.8.1",
   "main": "dist/package/api.js",
   "types": "dist/package/api.d.ts",
   "exports": {