ydb-qdrant 6.0.0 → 8.1.0

package/dist/config/env.d.ts

@@ -3,8 +3,6 @@ export declare const YDB_ENDPOINT: string;
 export declare const YDB_DATABASE: string;
 export declare const PORT: number;
 export declare const LOG_LEVEL: string;
-export declare const GLOBAL_POINTS_AUTOMIGRATE_ENABLED: boolean;
-export declare const USE_BATCH_DELETE_FOR_COLLECTIONS: boolean;
 export declare enum SearchMode {
     Exact = "exact",
     Approximate = "approximate"
@@ -12,7 +10,6 @@ export declare enum SearchMode {
 export declare function resolveSearchMode(raw: string | undefined): SearchMode;
 export declare const SEARCH_MODE: SearchMode;
 export declare const OVERFETCH_MULTIPLIER: number;
-export declare const CLIENT_SIDE_SERIALIZATION_ENABLED: boolean;
 export declare const UPSERT_BATCH_SIZE: number;
 export declare const SESSION_POOL_MIN_SIZE: number;
 export declare const SESSION_POOL_MAX_SIZE: number;

package/dist/config/env.js

@@ -20,22 +20,6 @@ function parseIntegerEnv(value, defaultValue, opts) {
     }
     return result;
 }
-function parseBooleanEnv(value, defaultValue) {
-    if (value === undefined) {
-        return defaultValue;
-    }
-    const normalized = value.trim().toLowerCase();
-    if (normalized === "" ||
-        normalized === "0" ||
-        normalized === "false" ||
-        normalized === "no" ||
-        normalized === "off") {
-        return false;
-    }
-    return true;
-}
-export const GLOBAL_POINTS_AUTOMIGRATE_ENABLED = parseBooleanEnv(process.env.YDB_QDRANT_GLOBAL_POINTS_AUTOMIGRATE, false);
-export const USE_BATCH_DELETE_FOR_COLLECTIONS = parseBooleanEnv(process.env.YDB_QDRANT_USE_BATCH_DELETE, false);
 export var SearchMode;
 (function (SearchMode) {
     SearchMode["Exact"] = "exact";
@@ -57,7 +41,6 @@ function resolveSearchModeEnv() {
 }
 export const SEARCH_MODE = resolveSearchModeEnv();
 export const OVERFETCH_MULTIPLIER = parseIntegerEnv(process.env.YDB_QDRANT_OVERFETCH_MULTIPLIER, 10, { min: 1 });
-export const CLIENT_SIDE_SERIALIZATION_ENABLED = parseBooleanEnv(process.env.YDB_QDRANT_CLIENT_SIDE_SERIALIZATION_ENABLED, false);
 export const UPSERT_BATCH_SIZE = parseIntegerEnv(process.env.YDB_QDRANT_UPSERT_BATCH_SIZE, 100, { min: 1 });
 // Session pool configuration
 const RAW_SESSION_POOL_MIN_SIZE = parseIntegerEnv(process.env.YDB_SESSION_POOL_MIN_SIZE, 5, { min: 1, max: 500 });

package/dist/package/api.d.ts

@@ -3,6 +3,7 @@ import { createCollection as serviceCreateCollection, deleteCollection as servic
 import { upsertPoints as serviceUpsertPoints, searchPoints as serviceSearchPoints, deletePoints as serviceDeletePoints } from "../services/PointsService.js";
 export { QdrantServiceError } from "../services/errors.js";
 export { CreateCollectionReq, UpsertPointsReq, SearchReq, DeletePointsReq, } from "../types.js";
+export type { UpsertPointsBody, SearchPointsBody } from "../types.js";
 type CreateCollectionResult = Awaited<ReturnType<typeof serviceCreateCollection>>;
 type GetCollectionResult = Awaited<ReturnType<typeof serviceGetCollection>>;
 type DeleteCollectionResult = Awaited<ReturnType<typeof serviceDeleteCollection>>;
@@ -22,7 +23,9 @@ export interface YdbQdrantTenantClient {
     getCollection(collection: string): Promise<GetCollectionResult>;
     deleteCollection(collection: string): Promise<DeleteCollectionResult>;
     putCollectionIndex(collection: string): Promise<PutIndexResult>;
+    upsertPoints(collection: string, body: import("../types.js").UpsertPointsBody): Promise<UpsertPointsResult>;
     upsertPoints(collection: string, body: unknown): Promise<UpsertPointsResult>;
+    searchPoints(collection: string, body: import("../types.js").SearchPointsBody): Promise<SearchPointsResult>;
     searchPoints(collection: string, body: unknown): Promise<SearchPointsResult>;
     deletePoints(collection: string, body: unknown): Promise<DeletePointsResult>;
 }

package/dist/qdrant/QdrantRestTypes.d.ts

@@ -0,0 +1,35 @@
+import type { Schemas } from "@qdrant/js-client-rest";
+/**
+ * Type-only surface derived from Qdrant's official REST OpenAPI schema.
+ *
+ * Important:
+ * - This module must remain type-only (no runtime imports/exports from @qdrant/*).
+ * - Prefer referencing these aliases across the codebase to keep our shapes aligned
+ *   with upstream Qdrant where appropriate, while preserving our runtime behavior.
+ */
+export type QdrantSchemas = Schemas;
+export type QdrantDistance = Schemas["Distance"];
+export type QdrantExtendedPointId = Schemas["ExtendedPointId"];
+export type QdrantPayload = Schemas["Payload"];
+export type QdrantFilter = Schemas["Filter"];
+export type QdrantPointsSelector = Schemas["PointsSelector"];
+export type QdrantPointStruct = Schemas["PointStruct"];
+export type QdrantSearchRequest = Schemas["SearchRequest"];
+export type QdrantScoredPoint = Schemas["ScoredPoint"];
+export type QdrantWithPayloadInterface = Schemas["WithPayloadInterface"];
+/**
+ * Project-specific narrowing for our Qdrant-compatible subset.
+ * These types are intentionally tighter than Qdrant's full schema.
+ */
+export type YdbQdrantPointId = Extract<QdrantExtendedPointId, string | number>;
+export type YdbQdrantVector = number[];
+export type YdbQdrantUpsertPoint = Omit<QdrantPointStruct, "id" | "vector" | "payload"> & {
+    id: YdbQdrantPointId;
+    vector: YdbQdrantVector;
+    payload?: QdrantPayload;
+};
+export type YdbQdrantScoredPoint = {
+    id: string;
+    score: QdrantScoredPoint["score"];
+    payload?: QdrantPayload;
+};

package/dist/qdrant/QdrantRestTypes.js

@@ -0,0 +1 @@
+export {};

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

@@ -1,8 +1,7 @@
-import { TypedValues, Types, withSession, createExecuteQuerySettings, } from "../ydb/client.js";
+import { TypedValues, Types, withSession, withQuerySession, 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";
-import { USE_BATCH_DELETE_FOR_COLLECTIONS } from "../config/env.js";
 const DELETE_COLLECTION_BATCH_SIZE = 10000;
 function isOutOfBufferMemoryYdbError(error) {
     const msg = error instanceof Error ? error.message : String(error);
@@ -37,7 +36,7 @@ async function deletePointsForUidInChunks(s, 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 MAX_ITERATIONS = 10000;
     const settings = createExecuteQuerySettings();
     while (iterations++ < MAX_ITERATIONS) {
         const rs = (await s.executeQuery(selectYql, {
@@ -64,68 +63,43 @@ export async function createCollectionOneTable(metaKey, dim, distance, vectorTyp
 }
 export async function deleteCollectionOneTable(metaKey, uid) {
     await ensureGlobalPointsTable();
-    if (USE_BATCH_DELETE_FOR_COLLECTIONS) {
-        const batchDeletePointsYql = `
-      DECLARE $uid AS Utf8;
-      BATCH DELETE FROM ${GLOBAL_POINTS_TABLE}
-      WHERE uid = $uid;
-    `;
-        await withRetry(() => withSession(async (s) => {
-            const settings = createExecuteQuerySettings();
-            try {
-                await s.executeQuery(batchDeletePointsYql, {
-                    $uid: TypedValues.utf8(uid),
-                }, undefined, settings);
-            }
-            catch (err) {
-                if (!isOutOfBufferMemoryYdbError(err)) {
-                    throw err;
-                }
-                // BATCH DELETE already deletes in chunks per partition, but if YDB
-                // still reports an out-of-buffer-memory condition, fall back to
-                // the same per-uid chunked deletion strategy as the legacy path.
-                await deletePointsForUidInChunks(s, uid);
-            }
-        }), {
-            isTransient: isTransientYdbError,
-            context: {
-                operation: "deleteCollectionOneTable",
-                tableName: GLOBAL_POINTS_TABLE,
-                metaKey,
-                uid,
-                mode: "batch_delete",
-            },
-        });
-    }
-    else {
-        const deletePointsYql = `
-      DECLARE $uid AS Utf8;
-      DELETE FROM ${GLOBAL_POINTS_TABLE} WHERE uid = $uid;
-    `;
-        await withRetry(() => withSession(async (s) => {
-            const settings = createExecuteQuerySettings();
-            try {
-                await s.executeQuery(deletePointsYql, {
-                    $uid: TypedValues.utf8(uid),
-                }, undefined, settings);
+    const batchDeletePointsYql = `
+    DECLARE $uid AS Utf8;
+    BATCH DELETE FROM ${GLOBAL_POINTS_TABLE}
+    WHERE uid = $uid;
+  `;
+    await withRetry(async () => {
+        try {
+            await withQuerySession(async (qs) => {
+                await qs.execute({
+                    text: batchDeletePointsYql,
+                    parameters: {
+                        $uid: TypedValues.utf8(uid),
+                    },
+                });
+            });
+        }
+        catch (err) {
+            if (!isOutOfBufferMemoryYdbError(err)) {
+                throw err;
             }
-            catch (err) {
-                if (!isOutOfBufferMemoryYdbError(err)) {
-                    throw err;
-                }
+            // BATCH DELETE already deletes in chunks per partition, but if YDB
+            // still reports an out-of-buffer-memory condition, fall back to
+            // per-uid chunked deletion strategy to complete the deletion.
+            await withSession(async (s) => {
                 await deletePointsForUidInChunks(s, uid);
-            }
-        }), {
-            isTransient: isTransientYdbError,
-            context: {
-                operation: "deleteCollectionOneTable",
-                tableName: GLOBAL_POINTS_TABLE,
-                metaKey,
-                uid,
-                mode: "legacy_chunked",
-            },
-        });
-    }
+            });
+        }
+    }, {
+        isTransient: isTransientYdbError,
+        context: {
+            operation: "deleteCollectionOneTable",
+            tableName: GLOBAL_POINTS_TABLE,
+            metaKey,
+            uid,
+            mode: "batch_delete",
+        },
+    });
     const delMeta = `
     DECLARE $collection AS Utf8;
     DELETE FROM qdr__collections WHERE collection = $collection;

package/dist/repositories/collectionsRepo.shared.js

@@ -1,4 +1,5 @@
-import { TypedValues, withSession } from "../ydb/client.js";
+import { UPSERT_OPERATION_TIMEOUT_MS } from "../config/env.js";
+import { TypedValues, withSession, createExecuteQuerySettingsWithTimeout, } from "../ydb/client.js";
 export async function upsertCollectionMeta(metaKey, dim, distance, vectorType, tableName) {
     const now = new Date();
     const upsertMeta = `
@@ -13,6 +14,11 @@ export async function upsertCollectionMeta(metaKey, dim, distance, vectorType, t
     VALUES ($collection, $table, $dim, $distance, $vtype, $created, $last_accessed);
   `;
     await withSession(async (s) => {
+        const settings = createExecuteQuerySettingsWithTimeout({
+            keepInCache: true,
+            idempotent: true,
+            timeoutMs: UPSERT_OPERATION_TIMEOUT_MS,
+        });
         await s.executeQuery(upsertMeta, {
             $collection: TypedValues.utf8(metaKey),
             $table: TypedValues.utf8(tableName),
@@ -21,6 +27,6 @@ export async function upsertCollectionMeta(metaKey, dim, distance, vectorType, t
             $vtype: TypedValues.utf8(vectorType),
             $created: TypedValues.timestamp(now),
             $last_accessed: TypedValues.timestamp(now),
-        });
+        }, undefined, settings);
     });
 }

package/dist/repositories/pointsRepo.d.ts

@@ -1,12 +1,6 @@
-import type { DistanceKind } from "../types";
-export declare function upsertPoints(tableName: string, points: Array<{
-    id: string | number;
-    vector: number[];
-    payload?: Record<string, unknown>;
-}>, dimension: number, uid: string): Promise<number>;
-export declare function searchPoints(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, dimension: number, uid: string): Promise<Array<{
-    id: string;
-    score: number;
-    payload?: Record<string, unknown>;
-}>>;
+import type { DistanceKind, UpsertPoint } from "../types.js";
+import type { YdbQdrantScoredPoint } from "../qdrant/QdrantRestTypes.js";
+export declare function upsertPoints(tableName: string, points: UpsertPoint[], dimension: number, uid: string): Promise<number>;
+export declare function searchPoints(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, dimension: number, uid: string, filterPaths?: Array<Array<string>>): Promise<YdbQdrantScoredPoint[]>;
 export declare function deletePoints(tableName: string, ids: Array<string | number>, uid: string): Promise<number>;
+export declare function deletePointsByPathSegments(tableName: string, uid: string, paths: Array<Array<string>>): Promise<number>;

package/dist/repositories/pointsRepo.js

@@ -1,12 +1,15 @@
 import { SEARCH_MODE, OVERFETCH_MULTIPLIER, } from "../config/env.js";
-import { upsertPointsOneTable, searchPointsOneTable, deletePointsOneTable, } from "./pointsRepo.one-table.js";
+import { upsertPointsOneTable, searchPointsOneTable, deletePointsOneTable, deletePointsByPathSegmentsOneTable, } from "./pointsRepo.one-table.js";
 export async function upsertPoints(tableName, points, dimension, uid) {
     return await upsertPointsOneTable(tableName, points, dimension, uid);
 }
-export async function searchPoints(tableName, queryVector, top, withPayload, distance, dimension, uid) {
+export async function searchPoints(tableName, queryVector, top, withPayload, distance, dimension, uid, filterPaths) {
     const mode = SEARCH_MODE;
-    return await searchPointsOneTable(tableName, queryVector, top, withPayload, distance, dimension, uid, mode, OVERFETCH_MULTIPLIER);
+    return await searchPointsOneTable(tableName, queryVector, top, withPayload, distance, dimension, uid, mode, OVERFETCH_MULTIPLIER, filterPaths);
 }
 export async function deletePoints(tableName, ids, uid) {
     return await deletePointsOneTable(tableName, ids, uid);
 }
+export async function deletePointsByPathSegments(tableName, uid, paths) {
+    return await deletePointsByPathSegmentsOneTable(tableName, uid, paths);
+}

package/dist/repositories/pointsRepo.one-table/Delete.d.ts

@@ -0,0 +1,2 @@
+export declare function deletePointsOneTable(tableName: string, ids: Array<string | number>, uid: string): Promise<number>;
+export declare function deletePointsByPathSegmentsOneTable(tableName: string, uid: string, paths: Array<Array<string>>): Promise<number>;

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

@@ -0,0 +1,166 @@
+import { TypedValues, withSession, createExecuteQuerySettings, } from "../../ydb/client.js";
+import { withRetry, isTransientYdbError } from "../../utils/retry.js";
+import { buildPathSegmentsWhereClause } from "./PathSegmentsFilter.js";
+const DELETE_FILTER_SELECT_BATCH_SIZE = 1000;
+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;
+        DECLARE $id AS Utf8;
+        DELETE FROM ${tableName} WHERE uid = $uid AND point_id = $id;
+      `;
+            const params = {
+                $uid: TypedValues.utf8(uid),
+                $id: TypedValues.utf8(String(id)),
+            };
+            await withRetry(() => s.executeQuery(yql, params, undefined, settings), {
+                isTransient: isTransientYdbError,
+                context: { tableName, uid, pointId: String(id) },
+            });
+            deleted += 1;
+        }
+    });
+    return deleted;
+}
+const MAX_SAFE_BIGINT = BigInt(Number.MAX_SAFE_INTEGER);
+function bigintToSafeNumberOrNull(value) {
+    if (value > MAX_SAFE_BIGINT || value < -MAX_SAFE_BIGINT) {
+        return null;
+    }
+    return Number(value);
+}
+function longLikeToBigInt(value) {
+    const low = BigInt(value.low >>> 0);
+    const high = BigInt(value.high >>> 0);
+    let n = low + (high << 32n);
+    // If this is a signed Long-like and the sign bit is set, interpret as a negative 64-bit integer.
+    const isUnsigned = value.unsigned === true;
+    const signBitSet = (value.high & 0x8000_0000) !== 0;
+    if (!isUnsigned && signBitSet) {
+        n -= 1n << 64n;
+    }
+    return n;
+}
+function toNumber(value) {
+    if (typeof value === "number" && Number.isFinite(value))
+        return value;
+    if (typeof value === "bigint") {
+        return bigintToSafeNumberOrNull(value);
+    }
+    if (typeof value === "string") {
+        // Prefer exact parsing for integer strings to avoid silent precision loss.
+        if (/^-?\d+$/.test(value.trim())) {
+            try {
+                const b = BigInt(value.trim());
+                return bigintToSafeNumberOrNull(b);
+            }
+            catch {
+                return null;
+            }
+        }
+        const n = Number(value);
+        return Number.isFinite(n) ? n : null;
+    }
+    if (value && typeof value === "object") {
+        // ydb-sdk may return Uint64/Int64 as protobufjs Long-like objects:
+        // { low: number, high: number, unsigned?: boolean }
+        const v = value;
+        if (typeof v.low === "number" && typeof v.high === "number") {
+            const b = longLikeToBigInt({
+                low: v.low,
+                high: v.high,
+                unsigned: v.unsigned === true,
+            });
+            return bigintToSafeNumberOrNull(b);
+        }
+    }
+    return null;
+}
+function readDeletedCountFromResult(rs) {
+    const sets = rs.resultSets ?? [];
+    for (let i = sets.length - 1; i >= 0; i -= 1) {
+        const rowset = sets[i];
+        const rows = rowset?.rows ?? [];
+        const cell = rows[0]?.items?.[0];
+        if (!cell)
+            continue;
+        const candidates = [
+            cell.uint64Value,
+            cell.int64Value,
+            cell.uint32Value,
+            cell.int32Value,
+            cell.textValue,
+        ];
+        for (const c of candidates) {
+            const n = toNumber(c);
+            if (n !== null)
+                return n;
+        }
+        // We got a result cell but couldn't parse any of its known numeric representations.
+        // Returning 0 here would silently stop the delete loop, so fail loud.
+        throw new Error("Unable to parse deleted count from YDB result.");
+    }
+    return 0;
+}
+export async function deletePointsByPathSegmentsOneTable(tableName, uid, paths) {
+    if (paths.length === 0) {
+        return 0;
+    }
+    const { whereSql, params: whereParams } = buildPathSegmentsWhereClause(paths);
+    const whereParamDeclarations = Object.keys(whereParams)
+        .sort()
+        .map((key) => `DECLARE ${key} AS Utf8;`)
+        .join("\n    ");
+    const deleteBatchYql = `
+    DECLARE $uid AS Utf8;
+    DECLARE $limit AS Uint32;
+    ${whereParamDeclarations}
+
+    $to_delete = (
+      SELECT uid, point_id
+      FROM ${tableName}
+      WHERE uid = $uid AND ${whereSql}
+      LIMIT $limit
+    );
+
+    DELETE FROM ${tableName} ON
+    SELECT uid, point_id FROM $to_delete;
+
+    SELECT CAST(COUNT(*) AS Uint32) AS deleted FROM $to_delete;
+  `;
+    let deleted = 0;
+    await withSession(async (s) => {
+        const settings = createExecuteQuerySettings();
+        // Best-effort loop: stop when there are no more matching rows.
+        // Use limited batches to avoid per-operation buffer limits.
+        while (true) {
+            const rs = (await withRetry(() => s.executeQuery(deleteBatchYql, {
+                ...whereParams,
+                $uid: TypedValues.utf8(uid),
+                $limit: TypedValues.uint32(DELETE_FILTER_SELECT_BATCH_SIZE),
+            }, undefined, settings), {
+                isTransient: isTransientYdbError,
+                context: {
+                    tableName,
+                    uid,
+                    filterPathsCount: paths.length,
+                    batchLimit: DELETE_FILTER_SELECT_BATCH_SIZE,
+                },
+            }));
+            const batchDeleted = readDeletedCountFromResult(rs);
+            if (!Number.isSafeInteger(batchDeleted) ||
+                batchDeleted < 0 ||
+                batchDeleted > DELETE_FILTER_SELECT_BATCH_SIZE) {
+                throw new Error(`Unexpected deleted count from YDB: ${String(batchDeleted)}. Expected an integer in [0, ${DELETE_FILTER_SELECT_BATCH_SIZE}].`);
+            }
+            if (batchDeleted <= 0) {
+                break;
+            }
+            deleted += batchDeleted;
+        }
+    });
+    return deleted;
+}

package/dist/repositories/pointsRepo.one-table/PathSegmentsFilter.d.ts

@@ -0,0 +1,14 @@
+import type { Ydb } from "ydb-sdk";
+type QueryParams = {
+    [key: string]: Ydb.ITypedValue;
+};
+export declare function buildPathSegmentsWhereClause(paths: Array<Array<string>>): {
+    whereSql: string;
+    params: QueryParams;
+};
+export declare function buildPathSegmentsFilter(paths: Array<Array<string>> | undefined): {
+    whereSql: string;
+    whereParamDeclarations: string;
+    whereParams: QueryParams;
+} | undefined;
+export {};

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

@@ -0,0 +1,33 @@
+import { TypedValues } from "../../ydb/client.js";
+export function buildPathSegmentsWhereClause(paths) {
+    const params = {};
+    const orGroups = [];
+    for (let pIdx = 0; pIdx < paths.length; pIdx += 1) {
+        const segs = paths[pIdx];
+        if (segs.length === 0) {
+            throw new Error("delete-by-filter: empty path segments");
+        }
+        const andParts = [];
+        for (let sIdx = 0; sIdx < segs.length; sIdx += 1) {
+            const paramName = `$p${pIdx}_${sIdx}`;
+            // payload is JsonDocument; JSON_VALUE supports JsonPath access.
+            andParts.push(`JSON_VALUE(payload, '$.pathSegments."${sIdx}"') = ${paramName}`);
+            params[paramName] = TypedValues.utf8(segs[sIdx]);
+        }
+        orGroups.push(`(${andParts.join(" AND ")})`);
+    }
+    return {
+        whereSql: orGroups.length === 1 ? orGroups[0] : `(${orGroups.join(" OR ")})`,
+        params,
+    };
+}
+export function buildPathSegmentsFilter(paths) {
+    if (!paths || paths.length === 0)
+        return undefined;
+    const { whereSql, params: whereParams } = buildPathSegmentsWhereClause(paths);
+    const whereParamDeclarations = Object.keys(whereParams)
+        .sort()
+        .map((key) => `DECLARE ${key} AS Utf8;`)
+        .join("\n        ");
+    return { whereSql, whereParamDeclarations, whereParams };
+}

package/dist/repositories/pointsRepo.one-table/Search.d.ts

@@ -0,0 +1,4 @@
+import type { DistanceKind } from "../../types.js";
+import { SearchMode } from "../../config/env.js";
+import type { YdbQdrantScoredPoint } from "../../qdrant/QdrantRestTypes.js";
+export declare function searchPointsOneTable(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, dimension: number, uid: string, mode: SearchMode | undefined, overfetchMultiplier: number, filterPaths?: Array<Array<string>>): Promise<YdbQdrantScoredPoint[]>;