ydb-qdrant 4.8.1 → 5.1.0

package/README.md

@@ -7,9 +7,7 @@
 [![k6 Stress Load Test](https://img.shields.io/github/actions/workflow/status/astandrik/ydb-qdrant/ci-load-stress.yml?branch=main&label=k6%20stress%20load%20test)](https://github.com/astandrik/ydb-qdrant/actions/workflows/ci-load-stress.yml)
 [![Coverage](https://coveralls.io/repos/github/astandrik/ydb-qdrant/badge.svg?branch=main)](https://coveralls.io/github/astandrik/ydb-qdrant?branch=main)
 
-[![Recall (multi_table)](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astandrik/ydb-qdrant/recall-badges/recall-multi-table.json)](https://github.com/astandrik/ydb-qdrant/actions/workflows/ci-recall.yml)
 [![Recall (one_table)](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astandrik/ydb-qdrant/recall-badges/recall-one-table.json)](https://github.com/astandrik/ydb-qdrant/actions/workflows/ci-recall.yml)
-[![F1 (multi_table)](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astandrik/ydb-qdrant/recall-badges/f1-multi-table.json)](https://github.com/astandrik/ydb-qdrant/actions/workflows/ci-recall.yml)
 [![F1 (one_table)](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astandrik/ydb-qdrant/recall-badges/f1-one-table.json)](https://github.com/astandrik/ydb-qdrant/actions/workflows/ci-recall.yml)
 
 [![npm version](https://img.shields.io/npm/v/ydb-qdrant.svg)](https://www.npmjs.com/package/ydb-qdrant)
@@ -18,7 +16,7 @@
 
 # YDB Qdrant-compatible Service
 
-Qdrant-compatible Node.js/TypeScript **service and npm library** that stores and searches vectors in YDB using single‑phase top‑k with an automatic YDB vector index (`vector_kmeans_tree`) and table‑scan fallback. Topics: ydb, vector-search, qdrant-compatible, nodejs, typescript, express, yql, ann, semantic-search, rag.
+Qdrant-compatible Node.js/TypeScript **service and npm library** that stores and searches vectors in YDB using a global one-table layout (`qdrant_all_points`) with exact KNN search (single-phase over `embedding`) by default and an optional approximate mode (two‑phase bit-quantized over `embedding_quantized` + `embedding`). Topics: ydb, vector-search, qdrant-compatible, nodejs, typescript, express, yql, ann, semantic-search, rag.
 
 Modes:
 - **HTTP server**: Qdrant-compatible REST API (`/collections`, `/points/*`) on top of YDB.
@@ -35,7 +33,7 @@ Architecture diagrams: [docs page](http://ydb-qdrant.tech/docs/)
 
 - **Vector dimensions and embedding models**: [docs/vector-dimensions.md](docs/vector-dimensions.md)
 - **Deployment and Docker options**: [docs/deployment-and-docker.md](docs/deployment-and-docker.md)
-- **Architecture, storage layout, and vector indexing**: [docs/architecture-and-storage.md](docs/architecture-and-storage.md)
+- **Architecture, storage layout, and search modes**: [docs/architecture-and-storage.md](docs/architecture-and-storage.md)
 - **Evaluation, CI, and release process**: [docs/evaluation-and-ci.md](docs/evaluation-and-ci.md)
 
 ## Requirements
@@ -90,10 +88,8 @@ Optional env:
 # Server
 export PORT=8080
 export LOG_LEVEL=info
-# Collection storage mode (optional; default is multi_table)
-export YDB_QDRANT_COLLECTION_STORAGE_MODE=multi_table   # or one_table
-# One-table search tuning (one_table mode only)
-export YDB_QDRANT_SEARCH_MODE=approximate               # or exact
+# One-table search tuning (default is 'exact' when unset)
+export YDB_QDRANT_SEARCH_MODE=approximate               # approximate or exact (default: exact)
 export YDB_QDRANT_OVERFETCH_MULTIPLIER=10               # candidate multiplier in approximate mode
 ```
 
@@ -334,7 +330,7 @@ curl -X POST http://localhost:8080/collections/mycol/points/delete \
 
 ## Architecture and Storage
 
-For details on the YDB storage layout (multi_table vs one_table), vector serialization, vector index auto-build behavior, request normalization, and Qdrant compatibility semantics, see [docs/architecture-and-storage.md](docs/architecture-and-storage.md).
+For details on the YDB one-table storage layout, vector serialization (full-precision and bit‑quantized), approximate vs exact search modes, request normalization, and Qdrant compatibility semantics, see [docs/architecture-and-storage.md](docs/architecture-and-storage.md).
 
 ## Evaluation, CI, and Release
 

package/dist/config/env.d.ts

@@ -3,18 +3,12 @@ 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 enum CollectionStorageMode {
-    MultiTable = "multi_table",
-    OneTable = "one_table"
-}
-export declare const COLLECTION_STORAGE_MODE: CollectionStorageMode;
 export declare const GLOBAL_POINTS_AUTOMIGRATE_ENABLED: boolean;
-export declare const VECTOR_INDEX_BUILD_ENABLED: boolean;
-export declare function isOneTableMode(mode: CollectionStorageMode): mode is CollectionStorageMode.OneTable;
 export declare enum SearchMode {
     Exact = "exact",
     Approximate = "approximate"
 }
+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;
@@ -22,3 +16,5 @@ export declare const UPSERT_BATCH_SIZE: number;
 export declare const SESSION_POOL_MIN_SIZE: number;
 export declare const SESSION_POOL_MAX_SIZE: number;
 export declare const SESSION_KEEPALIVE_PERIOD_MS: number;
+export declare const UPSERT_OPERATION_TIMEOUT_MS: number;
+export declare const SEARCH_OPERATION_TIMEOUT_MS: number;

package/dist/config/env.js

@@ -34,32 +34,13 @@ function parseBooleanEnv(value, defaultValue) {
     }
     return true;
 }
-export var CollectionStorageMode;
-(function (CollectionStorageMode) {
-    CollectionStorageMode["MultiTable"] = "multi_table";
-    CollectionStorageMode["OneTable"] = "one_table";
-})(CollectionStorageMode || (CollectionStorageMode = {}));
-function resolveCollectionStorageModeEnv() {
-    const explicit = process.env.YDB_QDRANT_COLLECTION_STORAGE_MODE ??
-        process.env.YDB_QDRANT_TABLE_LAYOUT;
-    if (explicit?.trim().toLowerCase() === CollectionStorageMode.OneTable) {
-        return CollectionStorageMode.OneTable;
-    }
-    return CollectionStorageMode.MultiTable;
-}
-export const COLLECTION_STORAGE_MODE = resolveCollectionStorageModeEnv();
 export const GLOBAL_POINTS_AUTOMIGRATE_ENABLED = parseBooleanEnv(process.env.YDB_QDRANT_GLOBAL_POINTS_AUTOMIGRATE, false);
-export const VECTOR_INDEX_BUILD_ENABLED = parseBooleanEnv(process.env.VECTOR_INDEX_BUILD_ENABLED, COLLECTION_STORAGE_MODE === CollectionStorageMode.MultiTable);
-export function isOneTableMode(mode) {
-    return mode === CollectionStorageMode.OneTable;
-}
 export var SearchMode;
 (function (SearchMode) {
     SearchMode["Exact"] = "exact";
     SearchMode["Approximate"] = "approximate";
 })(SearchMode || (SearchMode = {}));
-function resolveSearchModeEnv(mode) {
-    const raw = process.env.YDB_QDRANT_SEARCH_MODE;
+export function resolveSearchMode(raw) {
     const normalized = raw?.trim().toLowerCase();
     if (normalized === SearchMode.Exact) {
         return SearchMode.Exact;
@@ -67,14 +48,13 @@ function resolveSearchModeEnv(mode) {
     if (normalized === SearchMode.Approximate) {
         return SearchMode.Approximate;
     }
-    // Default: keep current behavior for one-table (approximate two-phase search).
-    if (isOneTableMode(mode)) {
-        return SearchMode.Approximate;
-    }
-    // For multi-table, this value is currently unused but defaults to approximate.
-    return SearchMode.Approximate;
+    // Default: exact search (single-phase over full-precision embedding) for the one-table layout.
+    return SearchMode.Exact;
+}
+function resolveSearchModeEnv() {
+    return resolveSearchMode(process.env.YDB_QDRANT_SEARCH_MODE);
 }
-export const SEARCH_MODE = resolveSearchModeEnv(COLLECTION_STORAGE_MODE);
+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 });
@@ -87,3 +67,5 @@ const NORMALIZED_SESSION_POOL_MIN_SIZE = RAW_SESSION_POOL_MIN_SIZE > RAW_SESSION
 export const SESSION_POOL_MIN_SIZE = NORMALIZED_SESSION_POOL_MIN_SIZE;
 export const SESSION_POOL_MAX_SIZE = RAW_SESSION_POOL_MAX_SIZE;
 export const SESSION_KEEPALIVE_PERIOD_MS = parseIntegerEnv(process.env.YDB_SESSION_KEEPALIVE_PERIOD_MS, 5000, { min: 1000, max: 60000 });
+export const UPSERT_OPERATION_TIMEOUT_MS = parseIntegerEnv(process.env.YDB_QDRANT_UPSERT_TIMEOUT_MS, 5000, { min: 1000 });
+export const SEARCH_OPERATION_TIMEOUT_MS = parseIntegerEnv(process.env.YDB_QDRANT_SEARCH_TIMEOUT_MS, 10000, { min: 1000 });

package/dist/index.js

@@ -1,18 +1,23 @@
 import "dotenv/config";
 import { buildServer } from "./server.js";
-import { PORT, COLLECTION_STORAGE_MODE, isOneTableMode, } from "./config/env.js";
+import { PORT } from "./config/env.js";
 import { logger } from "./logging/logger.js";
-import { readyOrThrow } from "./ydb/client.js";
+import { readyOrThrow, isCompilationTimeoutError } from "./ydb/client.js";
 import { ensureMetaTable, ensureGlobalPointsTable } from "./ydb/schema.js";
+import { verifyCollectionsQueryCompilationForStartup } from "./repositories/collectionsRepo.js";
 async function start() {
     try {
         await readyOrThrow();
         await ensureMetaTable();
-        if (isOneTableMode(COLLECTION_STORAGE_MODE)) {
-            await ensureGlobalPointsTable();
-        }
+        await ensureGlobalPointsTable();
+        await verifyCollectionsQueryCompilationForStartup();
+        logger.info("YDB compilation startup probe for qdr__collections completed successfully");
     }
     catch (err) {
+        if (isCompilationTimeoutError(err)) {
+            logger.error({ err }, "Fatal YDB compilation timeout during startup probe; exiting so supervisor can restart the process");
+            process.exit(1);
+        }
         logger.error({ err }, "YDB not ready; startup continues, requests may fail until configured.");
     }
     const app = buildServer();

package/dist/repositories/collectionsRepo.d.ts

@@ -1,11 +1,10 @@
 import type { DistanceKind, VectorType } from "../types";
-import { type CollectionStorageMode } from "../config/env.js";
-export declare function createCollection(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType, tableName: string, layout?: CollectionStorageMode): Promise<void>;
+export declare function createCollection(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType): Promise<void>;
 export declare function getCollectionMeta(metaKey: string): Promise<{
     table: string;
     dimension: number;
     distance: DistanceKind;
     vectorType: VectorType;
 } | null>;
+export declare function verifyCollectionsQueryCompilationForStartup(): Promise<void>;
 export declare function deleteCollection(metaKey: string, uid?: string): Promise<void>;
-export declare function buildVectorIndex(tableName: string, dimension: number, distance: DistanceKind, vectorType: VectorType): Promise<void>;

package/dist/repositories/collectionsRepo.js

@@ -1,16 +1,9 @@
-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";
+import { TypedValues, withSession, createExecuteQuerySettings, withStartupProbeSession, createExecuteQuerySettingsWithTimeout, } from "../ydb/client.js";
 import { uidFor } from "../utils/tenant.js";
-import { createCollectionMultiTable, deleteCollectionMultiTable, } from "./collectionsRepo.multi-table.js";
 import { createCollectionOneTable, deleteCollectionOneTable, } from "./collectionsRepo.one-table.js";
-export async function createCollection(metaKey, dim, distance, vectorType, tableName, layout = COLLECTION_STORAGE_MODE) {
-    if (isOneTableMode(layout)) {
-        await createCollectionOneTable(metaKey, dim, distance, vectorType);
-        return;
-    }
-    await createCollectionMultiTable(metaKey, dim, distance, vectorType, tableName);
+import { withRetry, isTransientYdbError } from "../utils/retry.js";
+export async function createCollection(metaKey, dim, distance, vectorType) {
+    await createCollectionOneTable(metaKey, dim, distance, vectorType);
 }
 export async function getCollectionMeta(metaKey) {
     const qry = `
@@ -35,60 +28,43 @@ export async function getCollectionMeta(metaKey) {
     const vectorType = row.items?.[3]?.textValue ?? "float";
     return { table, dimension, distance, vectorType };
 }
+export async function verifyCollectionsQueryCompilationForStartup() {
+    const probeKey = "__startup_probe__/__startup_probe__";
+    const qry = `
+    DECLARE $collection AS Utf8;
+    SELECT table_name, vector_dimension, distance, vector_type
+    FROM qdr__collections
+    WHERE collection = $collection;
+  `;
+    await withRetry(async () => {
+        await withStartupProbeSession(async (s) => {
+            const settings = createExecuteQuerySettingsWithTimeout({
+                keepInCache: true,
+                idempotent: true,
+                timeoutMs: 3000,
+            });
+            await s.executeQuery(qry, {
+                $collection: TypedValues.utf8(probeKey),
+            }, undefined, settings);
+        });
+    }, {
+        isTransient: isTransientYdbError,
+        maxRetries: 2,
+        baseDelayMs: 200,
+        context: { probe: "collections_startup_compilation" },
+    });
+}
 export async function deleteCollection(metaKey, uid) {
     const meta = await getCollectionMeta(metaKey);
     if (!meta)
         return;
-    if (meta.table === GLOBAL_POINTS_TABLE) {
-        const effectiveUid = uid ??
-            (() => {
-                const [tenant, collection] = metaKey.split("/", 2);
-                if (!tenant || !collection) {
-                    throw new Error(`deleteCollection: cannot derive uid from malformed metaKey=${metaKey}`);
-                }
-                return uidFor(tenant, collection);
-            })();
-        await deleteCollectionOneTable(metaKey, effectiveUid);
-        return;
-    }
-    await deleteCollectionMultiTable(metaKey, meta.table);
-}
-export async function buildVectorIndex(tableName, dimension, distance, vectorType) {
-    const distParam = mapDistanceToIndexParam(distance);
-    // defaults for <100k vectors
-    const levels = 1;
-    const clusters = 128;
-    await withSession(async (s) => {
-        // Drop existing index if present
-        const dropDdl = `ALTER TABLE ${tableName} DROP INDEX emb_idx;`;
-        const rawSession = s;
-        try {
-            const dropReq = { sessionId: rawSession.sessionId, yqlText: dropDdl };
-            await rawSession.api.executeSchemeQuery(dropReq);
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            // ignore if index doesn't exist
-            if (!/not found|does not exist|no such index/i.test(msg)) {
-                throw e;
-            }
+    let effectiveUid = uid;
+    if (!effectiveUid) {
+        const [tenant, collection] = metaKey.split("/", 2);
+        if (!tenant || !collection) {
+            throw new Error(`deleteCollection: cannot derive uid from malformed metaKey=${metaKey}`);
         }
-        // Create new index
-        const createDdl = `
-      ALTER TABLE ${tableName}
-      ADD INDEX emb_idx GLOBAL SYNC USING vector_kmeans_tree
-      ON (embedding)
-      WITH (
-        ${distParam === "inner_product"
-            ? `similarity="inner_product"`
-            : `distance="${distParam}"`},
-        vector_type="${vectorType}",
-        vector_dimension=${dimension},
-        clusters=${clusters},
-        levels=${levels}
-      );
-    `;
-        const createReq = { sessionId: rawSession.sessionId, yqlText: createDdl };
-        await rawSession.api.executeSchemeQuery(createReq);
-    });
+        effectiveUid = uidFor(tenant, collection);
+    }
+    await deleteCollectionOneTable(metaKey, effectiveUid);
 }

package/dist/repositories/pointsRepo.d.ts

@@ -3,10 +3,10 @@ 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<{
+}>, 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>;
 }>>;
-export declare function deletePoints(tableName: string, ids: Array<string | number>, uid?: string): Promise<number>;
+export declare function deletePoints(tableName: string, ids: Array<string | number>, uid: string): Promise<number>;

package/dist/repositories/pointsRepo.js

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

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

@@ -1,10 +1,9 @@
-import { TypedValues, Types, withSession, createExecuteQuerySettings, } from "../ydb/client.js";
+import { TypedValues, Types, withSession, createExecuteQuerySettings, createExecuteQuerySettingsWithTimeout, } from "../ydb/client.js";
 import { buildVectorParam, buildVectorBinaryParams } from "../ydb/helpers.js";
-import { notifyUpsert } from "../indexing/IndexScheduler.js";
 import { mapDistanceToKnnFn, mapDistanceToBitKnnFn, } from "../utils/distance.js";
 import { withRetry, isTransientYdbError } from "../utils/retry.js";
 import { UPSERT_BATCH_SIZE } from "../ydb/schema.js";
-import { CLIENT_SIDE_SERIALIZATION_ENABLED, SearchMode, } from "../config/env.js";
+import { CLIENT_SIDE_SERIALIZATION_ENABLED, SearchMode, UPSERT_OPERATION_TIMEOUT_MS, SEARCH_OPERATION_TIMEOUT_MS, } from "../config/env.js";
 import { logger } from "../logging/logger.js";
 export async function upsertPointsOneTable(tableName, points, dimension, uid) {
     for (const p of points) {
@@ -25,7 +24,11 @@ export async function upsertPointsOneTable(tableName, points, dimension, uid) {
     }
     let upserted = 0;
     await withSession(async (s) => {
-        const settings = createExecuteQuerySettings();
+        const settings = createExecuteQuerySettingsWithTimeout({
+            keepInCache: true,
+            idempotent: true,
+            timeoutMs: UPSERT_OPERATION_TIMEOUT_MS,
+        });
         for (let i = 0; i < points.length; i += UPSERT_BATCH_SIZE) {
             const batch = points.slice(i, i + UPSERT_BATCH_SIZE);
             let ddl;
@@ -128,7 +131,6 @@ export async function upsertPointsOneTable(tableName, points, dimension, uid) {
             upserted += batch.length;
         }
     });
-    notifyUpsert(tableName, upserted);
     return upserted;
 }
 async function searchPointsOneTableExact(tableName, queryVector, top, withPayload, distance, dimension, uid) {
@@ -194,7 +196,11 @@ async function searchPointsOneTableExact(tableName, queryVector, top, withPayloa
                 vectorPreview: queryVector.slice(0, 3),
             },
         }, "one_table search (exact): executing YQL");
-        const settings = createExecuteQuerySettings();
+        const settings = createExecuteQuerySettingsWithTimeout({
+            keepInCache: true,
+            idempotent: true,
+            timeoutMs: SEARCH_OPERATION_TIMEOUT_MS,
+        });
         const rs = await s.executeQuery(yql, params, undefined, settings);
         const rowset = rs.resultSets?.[0];
         const rows = (rowset?.rows ?? []);
@@ -336,7 +342,11 @@ async function searchPointsOneTableApproximate(tableName, queryVector, top, with
                 },
             }, "one_table search (approximate): executing YQL");
         }
-        const settings = createExecuteQuerySettings();
+        const settings = createExecuteQuerySettingsWithTimeout({
+            keepInCache: true,
+            idempotent: true,
+            timeoutMs: SEARCH_OPERATION_TIMEOUT_MS,
+        });
         const rs = await s.executeQuery(yql, params, undefined, settings);
         const rowset = rs.resultSets?.[0];
         const rows = (rowset?.rows ?? []);

package/dist/routes/points.js

@@ -2,6 +2,8 @@ import { Router } from "express";
 import { upsertPoints, searchPoints, queryPoints, deletePoints, } from "../services/PointsService.js";
 import { QdrantServiceError } from "../services/errors.js";
 import { logger } from "../logging/logger.js";
+import { isCompilationTimeoutError } from "../ydb/client.js";
+import { scheduleExit } from "../utils/exit.js";
 export const pointsRouter = Router();
 // Qdrant-compatible: PUT /collections/:collection/points (upsert)
 pointsRouter.put("/:collection/points", async (req, res) => {
@@ -18,8 +20,14 @@ pointsRouter.put("/:collection/points", async (req, res) => {
         if (err instanceof QdrantServiceError) {
             return res.status(err.statusCode).json(err.payload);
         }
-        logger.error({ err }, "upsert points (PUT) failed");
         const errorMessage = err instanceof Error ? err.message : String(err);
+        if (isCompilationTimeoutError(err)) {
+            logger.error({ err }, "YDB compilation error during upsert points (PUT); scheduling process exit");
+            res.status(500).json({ status: "error", error: errorMessage });
+            scheduleExit(1);
+            return;
+        }
+        logger.error({ err }, "upsert points (PUT) failed");
         res.status(500).json({ status: "error", error: errorMessage });
     }
 });
@@ -37,8 +45,14 @@ pointsRouter.post("/:collection/points/upsert", async (req, res) => {
         if (err instanceof QdrantServiceError) {
             return res.status(err.statusCode).json(err.payload);
         }
-        logger.error({ err }, "upsert points failed");
         const errorMessage = err instanceof Error ? err.message : String(err);
+        if (isCompilationTimeoutError(err)) {
+            logger.error({ err }, "YDB compilation error during upsert points; scheduling process exit");
+            res.status(500).json({ status: "error", error: errorMessage });
+            scheduleExit(1);
+            return;
+        }
+        logger.error({ err }, "upsert points failed");
         res.status(500).json({ status: "error", error: errorMessage });
     }
 });
@@ -56,8 +70,14 @@ pointsRouter.post("/:collection/points/search", async (req, res) => {
         if (err instanceof QdrantServiceError) {
             return res.status(err.statusCode).json(err.payload);
         }
-        logger.error({ err }, "search points failed");
         const errorMessage = err instanceof Error ? err.message : String(err);
+        if (isCompilationTimeoutError(err)) {
+            logger.error({ err }, "YDB compilation error during search points; scheduling process exit");
+            res.status(500).json({ status: "error", error: errorMessage });
+            scheduleExit(1);
+            return;
+        }
+        logger.error({ err }, "search points failed");
         res.status(500).json({ status: "error", error: errorMessage });
     }
 });
@@ -76,8 +96,14 @@ pointsRouter.post("/:collection/points/query", async (req, res) => {
         if (err instanceof QdrantServiceError) {
             return res.status(err.statusCode).json(err.payload);
         }
-        logger.error({ err }, "search points (query) failed");
         const errorMessage = err instanceof Error ? err.message : String(err);
+        if (isCompilationTimeoutError(err)) {
+            logger.error({ err }, "YDB compilation error during search points (query); scheduling process exit");
+            res.status(500).json({ status: "error", error: errorMessage });
+            scheduleExit(1);
+            return;
+        }
+        logger.error({ err }, "search points (query) failed");
         res.status(500).json({ status: "error", error: errorMessage });
     }
 });

package/dist/server.js

@@ -2,11 +2,28 @@ import express from "express";
 import { collectionsRouter } from "./routes/collections.js";
 import { pointsRouter } from "./routes/points.js";
 import { requestLogger } from "./middleware/requestLogger.js";
-import { isYdbAvailable } from "./ydb/client.js";
+import { isYdbAvailable, isCompilationTimeoutError } from "./ydb/client.js";
+import { verifyCollectionsQueryCompilationForStartup } from "./repositories/collectionsRepo.js";
+import { logger } from "./logging/logger.js";
+import { scheduleExit } from "./utils/exit.js";
 export async function healthHandler(_req, res) {
     const ok = await isYdbAvailable();
     if (!ok) {
+        logger.error("YDB unavailable during health check; scheduling process exit");
         res.status(503).json({ status: "error", error: "YDB unavailable" });
+        scheduleExit(1);
+        return;
+    }
+    try {
+        await verifyCollectionsQueryCompilationForStartup();
+    }
+    catch (err) {
+        const isTimeout = isCompilationTimeoutError(err);
+        logger.error({ err }, isTimeout
+            ? "YDB compilation timeout during health probe; scheduling process exit"
+            : "YDB health probe failed; scheduling process exit");
+        res.status(503).json({ status: "error", error: "YDB health probe failed" });
+        scheduleExit(1);
         return;
     }
     res.json({ status: "ok" });

package/dist/services/CollectionService.d.ts

@@ -10,13 +10,6 @@ export interface NormalizedCollectionContext {
     collection: string;
     metaKey: string;
 }
-export declare function normalizeCollectionContext(input: CollectionContextInput): NormalizedCollectionContext;
-export declare function resolvePointsTableAndUid(ctx: NormalizedCollectionContext, meta: {
-    table: string;
-}): Promise<{
-    tableName: string;
-    uid: string | undefined;
-}>;
 export declare function putCollectionIndex(ctx: CollectionContextInput): Promise<{
     acknowledged: boolean;
 }>;

package/dist/services/CollectionService.js

@@ -1,24 +1,11 @@
 import { CreateCollectionReq } from "../types.js";
-import { ensureMetaTable, GLOBAL_POINTS_TABLE } from "../ydb/schema.js";
+import { ensureMetaTable } from "../ydb/schema.js";
 import { createCollection as repoCreateCollection, deleteCollection as repoDeleteCollection, getCollectionMeta, } from "../repositories/collectionsRepo.js";
 import { QdrantServiceError } from "./errors.js";
-import { normalizeCollectionContextShared, tableNameFor, } from "./CollectionService.shared.js";
-import { resolvePointsTableAndUidOneTable } from "./CollectionService.one-table.js";
-export function normalizeCollectionContext(input) {
-    return normalizeCollectionContextShared(input.tenant, input.collection, input.apiKey, input.userAgent);
-}
-export async function resolvePointsTableAndUid(ctx, meta) {
-    if (meta?.table === GLOBAL_POINTS_TABLE) {
-        return await resolvePointsTableAndUidOneTable(ctx);
-    }
-    return {
-        tableName: meta.table,
-        uid: undefined,
-    };
-}
+import { normalizeCollectionContextShared } from "./CollectionService.shared.js";
 export async function putCollectionIndex(ctx) {
     await ensureMetaTable();
-    const normalized = normalizeCollectionContext(ctx);
+    const normalized = normalizeCollectionContextShared(ctx.tenant, ctx.collection, ctx.apiKey, ctx.userAgent);
     const meta = await getCollectionMeta(normalized.metaKey);
     if (!meta) {
         throw new QdrantServiceError(404, {
@@ -30,7 +17,7 @@ export async function putCollectionIndex(ctx) {
 }
 export async function createCollection(ctx, body) {
     await ensureMetaTable();
-    const normalized = normalizeCollectionContext(ctx);
+    const normalized = normalizeCollectionContextShared(ctx.tenant, ctx.collection, ctx.apiKey, ctx.userAgent);
     const parsed = CreateCollectionReq.safeParse(body);
     if (!parsed.success) {
         throw new QdrantServiceError(400, {
@@ -54,13 +41,12 @@ export async function createCollection(ctx, body) {
             error: errorMessage,
         });
     }
-    const tableName = tableNameFor(normalized.tenant, normalized.collection);
-    await repoCreateCollection(normalized.metaKey, dim, distance, vectorType, tableName);
+    await repoCreateCollection(normalized.metaKey, dim, distance, vectorType);
     return { name: normalized.collection, tenant: normalized.tenant };
 }
 export async function getCollection(ctx) {
     await ensureMetaTable();
-    const normalized = normalizeCollectionContext(ctx);
+    const normalized = normalizeCollectionContextShared(ctx.tenant, ctx.collection, ctx.apiKey, ctx.userAgent);
     const meta = await getCollectionMeta(normalized.metaKey);
     if (!meta) {
         throw new QdrantServiceError(404, {
@@ -79,7 +65,7 @@ export async function getCollection(ctx) {
 }
 export async function deleteCollection(ctx) {
     await ensureMetaTable();
-    const normalized = normalizeCollectionContext(ctx);
+    const normalized = normalizeCollectionContextShared(ctx.tenant, ctx.collection, ctx.apiKey, ctx.userAgent);
     await repoDeleteCollection(normalized.metaKey);
     return { acknowledged: true };
 }

package/dist/services/CollectionService.one-table.d.ts

@@ -1,5 +1,5 @@
 import { type NormalizedCollectionContextLike } from "./CollectionService.shared.js";
 export declare function resolvePointsTableAndUidOneTable(ctx: NormalizedCollectionContextLike): Promise<{
     tableName: string;
-    uid: string | undefined;
+    uid: string;
 }>;

package/dist/services/PointsService.js

@@ -2,16 +2,14 @@ import { UpsertPointsReq, SearchReq, DeletePointsReq } from "../types.js";
 import { ensureMetaTable } from "../ydb/schema.js";
 import { getCollectionMeta } from "../repositories/collectionsRepo.js";
 import { deletePoints as repoDeletePoints, searchPoints as repoSearchPoints, upsertPoints as repoUpsertPoints, } from "../repositories/pointsRepo.js";
-import { requestIndexBuild } from "../indexing/IndexScheduler.js";
 import { logger } from "../logging/logger.js";
-import { VECTOR_INDEX_BUILD_ENABLED } from "../config/env.js";
 import { QdrantServiceError, isVectorDimensionMismatchError, } from "./errors.js";
-import { normalizeCollectionContext, resolvePointsTableAndUid, } from "./CollectionService.js";
+import { normalizeCollectionContextShared } from "./CollectionService.shared.js";
+import { resolvePointsTableAndUidOneTable } from "./CollectionService.one-table.js";
 import { normalizeSearchBodyForSearch, normalizeSearchBodyForQuery, } from "../utils/normalization.js";
-let loggedIndexBuildDisabled = false;
 export async function upsertPoints(ctx, body) {
     await ensureMetaTable();
-    const normalized = normalizeCollectionContext(ctx);
+    const normalized = normalizeCollectionContextShared(ctx.tenant, ctx.collection, ctx.apiKey, ctx.userAgent);
     const meta = await getCollectionMeta(normalized.metaKey);
     if (!meta) {
         throw new QdrantServiceError(404, {
@@ -26,7 +24,7 @@ export async function upsertPoints(ctx, body) {
             error: parsed.error.flatten(),
         });
     }
-    const { tableName, uid } = await resolvePointsTableAndUid(normalized, meta);
+    const { tableName, uid } = await resolvePointsTableAndUidOneTable(normalized);
     let upserted;
     try {
         upserted = await repoUpsertPoints(tableName, parsed.data.points, meta.dimension, uid);
@@ -46,18 +44,11 @@ export async function upsertPoints(ctx, body) {
         }
         throw err;
     }
-    if (VECTOR_INDEX_BUILD_ENABLED) {
-        requestIndexBuild(tableName, meta.dimension, meta.distance, meta.vectorType);
-    }
-    else if (!loggedIndexBuildDisabled) {
-        logger.info({ table: tableName }, "vector index building disabled by env; skipping automatic emb_idx rebuilds");
-        loggedIndexBuildDisabled = true;
-    }
     return { upserted };
 }
 async function executeSearch(ctx, normalizedSearch, source) {
     await ensureMetaTable();
-    const normalized = normalizeCollectionContext(ctx);
+    const normalized = normalizeCollectionContextShared(ctx.tenant, ctx.collection, ctx.apiKey, ctx.userAgent);
     logger.info({ tenant: normalized.tenant, collection: normalized.collection }, `${source}: resolve collection meta`);
     const meta = await getCollectionMeta(normalized.metaKey);
     if (!meta) {
@@ -87,7 +78,7 @@ async function executeSearch(ctx, normalizedSearch, source) {
             error: parsed.error.flatten(),
         });
     }
-    const { tableName, uid } = await resolvePointsTableAndUid(normalized, meta);
+    const { tableName, uid } = await resolvePointsTableAndUidOneTable(normalized);
     logger.info({
         tenant: normalized.tenant,
         collection: normalized.collection,
@@ -154,7 +145,7 @@ export async function queryPoints(ctx, body) {
 }
 export async function deletePoints(ctx, body) {
     await ensureMetaTable();
-    const normalized = normalizeCollectionContext(ctx);
+    const normalized = normalizeCollectionContextShared(ctx.tenant, ctx.collection, ctx.apiKey, ctx.userAgent);
     const meta = await getCollectionMeta(normalized.metaKey);
     if (!meta) {
         throw new QdrantServiceError(404, {
@@ -169,7 +160,7 @@ export async function deletePoints(ctx, body) {
             error: parsed.error.flatten(),
         });
     }
-    const { tableName, uid } = await resolvePointsTableAndUid(normalized, meta);
+    const { tableName, uid } = await resolvePointsTableAndUidOneTable(normalized);
     const deleted = await repoDeletePoints(tableName, parsed.data.points, uid);
     return { deleted };
 }

package/dist/utils/distance.d.ts

@@ -3,7 +3,6 @@ export declare function mapDistanceToKnnFn(distance: DistanceKind): {
     fn: string;
     order: "ASC" | "DESC";
 };
-export declare function mapDistanceToIndexParam(distance: DistanceKind): string;
 /**
  * Maps a user-specified distance metric to a YDB Knn function
  * suitable for bit-quantized vectors (Phase 1 approximate candidate selection).

package/dist/utils/distance.js

@@ -12,20 +12,6 @@ export function mapDistanceToKnnFn(distance) {
             return { fn: "Knn::CosineDistance", order: "ASC" };
     }
 }
-export function mapDistanceToIndexParam(distance) {
-    switch (distance) {
-        case "Cosine":
-            return "cosine";
-        case "Dot":
-            return "inner_product";
-        case "Euclid":
-            return "euclidean";
-        case "Manhattan":
-            return "manhattan";
-        default:
-            return "cosine";
-    }
-}
 /**
  * Maps a user-specified distance metric to a YDB Knn function
  * suitable for bit-quantized vectors (Phase 1 approximate candidate selection).

package/dist/utils/exit.d.ts

@@ -0,0 +1,2 @@
+export declare function scheduleExit(code: number): void;
+export declare function __setExitFnForTests(fn: (code: number) => void): void;

package/dist/utils/exit.js

@@ -0,0 +1,12 @@
+let exitFn = (code) => {
+    // Use process.exit in production; this will be overridden in tests.
+    process.exit(code);
+};
+export function scheduleExit(code) {
+    // Schedule exit on the next tick so HTTP responses can be flushed first.
+    setImmediate(() => exitFn(code));
+}
+// Test-only: allow overriding the underlying exit behavior.
+export function __setExitFnForTests(fn) {
+    exitFn = fn;
+}

package/dist/ydb/client.d.ts

@@ -1,22 +1,29 @@
 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 };
+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, Ydb: typeof import("ydb-sdk-proto").Ydb;
+export { Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, Ydb, };
 export declare function createExecuteQuerySettings(options?: {
     keepInCache?: boolean;
     idempotent?: boolean;
 }): YdbExecuteQuerySettings;
+export declare function createExecuteQuerySettingsWithTimeout(options: {
+    keepInCache?: boolean;
+    idempotent?: boolean;
+    timeoutMs: number;
+}): YdbExecuteQuerySettings;
 type DriverConfig = {
     endpoint?: string;
     database?: string;
     connectionString?: string;
     authService?: IAuthService;
 };
+export declare function isCompilationTimeoutError(error: unknown): boolean;
 export declare function __setDriverForTests(fake: unknown): void;
 export declare function __setDriverFactoryForTests(factory: ((config: unknown) => unknown) | undefined): void;
 export declare function __resetRefreshStateForTests(): void;
 export declare function configureDriver(config: DriverConfig): void;
 export declare function readyOrThrow(): Promise<void>;
 export declare function withSession<T>(fn: (s: Session) => Promise<T>): Promise<T>;
+export declare function withStartupProbeSession<T>(fn: (s: Session) => Promise<T>): Promise<T>;
 export declare function isYdbAvailable(timeoutMs?: number): Promise<boolean>;
 /**
  * Destroys the current driver and its session pool.

package/dist/ydb/client.js

@@ -2,8 +2,8 @@ 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, ExecuteQuerySettings, } = require("ydb-sdk");
-export { Types, TypedValues, TableDescription, Column, ExecuteQuerySettings };
+const { Driver, getCredentialsFromEnv, Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, OperationParams, Ydb, } = require("ydb-sdk");
+export { Types, TypedValues, TableDescription, Column, ExecuteQuerySettings, Ydb, };
 export function createExecuteQuerySettings(options) {
     const { keepInCache = true, idempotent = true } = options ?? {};
     const settings = new ExecuteQuerySettings();
@@ -15,16 +15,46 @@ export function createExecuteQuerySettings(options) {
     }
     return settings;
 }
+export function createExecuteQuerySettingsWithTimeout(options) {
+    const settings = createExecuteQuerySettings(options);
+    const op = new OperationParams();
+    const seconds = Math.max(1, Math.ceil(options.timeoutMs / 1000));
+    // Limit both overall operation processing time and cancellation time on the
+    // server side so the probe fails fast instead of hanging for the default.
+    op.withOperationTimeoutSeconds(seconds);
+    op.withCancelAfterSeconds(seconds);
+    settings.withOperationParams(op);
+    return settings;
+}
 const DRIVER_READY_TIMEOUT_MS = 15000;
 const TABLE_SESSION_TIMEOUT_MS = 20000;
 const YDB_HEALTHCHECK_READY_TIMEOUT_MS = 5000;
 const DRIVER_REFRESH_COOLDOWN_MS = 30000;
+const STARTUP_PROBE_SESSION_TIMEOUT_MS = 3000;
 let overrideConfig;
 let driver;
 let lastDriverRefreshAt = 0;
 let driverRefreshInFlight = null;
 // Test-only: allows injecting a mock Driver factory
 let driverFactoryOverride;
+export function isCompilationTimeoutError(error) {
+    if (!(error instanceof Error)) {
+        return false;
+    }
+    const msg = error.message ?? "";
+    if (/Timeout \(code 400090\)/i.test(msg) ||
+        /Query compilation timed out/i.test(msg)) {
+        return true;
+    }
+    // Startup probe uses explicit cancel-after; YDB returns Cancelled with
+    // issues like "Cancelling after 3000ms during compilation". Treat this as
+    // a compilation-time failure for fatal startup handling.
+    if (/Cancelled \(code 400160\)/i.test(msg) &&
+        /during compilation/i.test(msg)) {
+        return true;
+    }
+    return false;
+}
 function shouldTriggerDriverRefresh(error) {
     if (!(error instanceof Error)) {
         return false;
@@ -39,6 +69,12 @@ function shouldTriggerDriverRefresh(error) {
     if (/SessionExpired|SESSION_EXPIRED|session.*expired/i.test(msg)) {
         return true;
     }
+    // YDB query compilation timeout (TIMEOUT code 400090) – treat as a signal
+    // to refresh the driver/session pool so that subsequent attempts use a
+    // fresh connection state.
+    if (isCompilationTimeoutError(error)) {
+        return true;
+    }
     return false;
 }
 async function maybeRefreshDriverOnSessionError(error) {
@@ -55,7 +91,8 @@ async function maybeRefreshDriverOnSessionError(error) {
         return;
     }
     lastDriverRefreshAt = now;
-    logger.warn({ err: error }, "YDB session-related error detected; refreshing driver");
+    const errorMessage = error instanceof Error ? error.message ?? "" : String(error);
+    logger.warn({ err: error, errorMessage, lastDriverRefreshAt }, "YDB session-related error detected; refreshing driver");
     try {
         const refreshPromise = refreshDriver();
         driverRefreshInFlight = refreshPromise;
@@ -131,6 +168,16 @@ export async function withSession(fn) {
         throw err;
     }
 }
+export async function withStartupProbeSession(fn) {
+    const d = getOrCreateDriver();
+    try {
+        return await d.tableClient.withSession(fn, STARTUP_PROBE_SESSION_TIMEOUT_MS);
+    }
+    catch (err) {
+        void maybeRefreshDriverOnSessionError(err);
+        throw err;
+    }
+}
 export async function isYdbAvailable(timeoutMs = YDB_HEALTHCHECK_READY_TIMEOUT_MS) {
     const d = getOrCreateDriver();
     try {

package/dist/ydb/schema.js

@@ -1,4 +1,4 @@
-import { withSession, TableDescription, Column, Types } from "./client.js";
+import { withSession, TableDescription, Column, Types, Ydb } from "./client.js";
 import { logger } from "../logging/logger.js";
 import { GLOBAL_POINTS_AUTOMIGRATE_ENABLED } from "../config/env.js";
 export const GLOBAL_POINTS_TABLE = "qdrant_all_points";
@@ -41,10 +41,16 @@ export async function ensureGlobalPointsTable() {
             tableDescription = await s.describeTable(GLOBAL_POINTS_TABLE);
         }
         catch {
-            // Table doesn't exist, create it with all columns using the new schema.
+            // Table doesn't exist, create it with all columns using the new schema and
+            // auto-partitioning enabled.
             const desc = new TableDescription()
                 .withColumns(new Column("uid", Types.UTF8), new Column("point_id", Types.UTF8), new Column("embedding", Types.BYTES), new Column("embedding_quantized", Types.BYTES), new Column("payload", Types.JSON_DOCUMENT))
                 .withPrimaryKeys("uid", "point_id");
+            desc.withPartitioningSettings({
+                partitioningByLoad: Ydb.FeatureFlag.Status.ENABLED,
+                partitioningBySize: Ydb.FeatureFlag.Status.ENABLED,
+                partitionSizeMb: 100,
+            });
             await s.createTable(GLOBAL_POINTS_TABLE, desc);
             globalPointsTableReady = true;
             logger.info(`created global points table ${GLOBAL_POINTS_TABLE}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ydb-qdrant",
-  "version": "4.8.1",
+  "version": "5.1.0",
   "main": "dist/package/api.js",
   "types": "dist/package/api.d.ts",
   "exports": {
@@ -16,8 +16,8 @@
   "scripts": {
     "test": "vitest run --exclude \"test/integration/**\"",
     "test:coverage": "vitest run --coverage --exclude \"test/integration/**\"",
-    "test:integration": "VECTOR_INDEX_BUILD_ENABLED=false vitest run test/integration/YdbRealIntegration.index-disabled.test.ts && VECTOR_INDEX_BUILD_ENABLED=true vitest run test/integration/YdbRealIntegration.test.ts test/integration/YdbRecallIntegration.test.ts && YDB_QDRANT_COLLECTION_STORAGE_MODE=one_table YDB_QDRANT_SEARCH_MODE=approximate vitest run test/integration/YdbRealIntegration.one-table.test.ts && YDB_QDRANT_COLLECTION_STORAGE_MODE=one_table YDB_QDRANT_SEARCH_MODE=exact vitest run test/integration/YdbRealIntegration.one-table.test.ts",
-    "test:recall": "VECTOR_INDEX_BUILD_ENABLED=true vitest run test/integration/YdbRecallIntegration.test.ts && YDB_QDRANT_COLLECTION_STORAGE_MODE=one_table YDB_QDRANT_SEARCH_MODE=approximate vitest run test/integration/YdbRealIntegration.one-table.test.ts && YDB_QDRANT_COLLECTION_STORAGE_MODE=one_table YDB_QDRANT_SEARCH_MODE=exact vitest run test/integration/YdbRealIntegration.one-table.test.ts",
+    "test:integration": "vitest run test/integration/YdbRealIntegration.test.ts && YDB_QDRANT_SEARCH_MODE=approximate vitest run test/integration/YdbRealIntegration.one-table.test.ts && YDB_QDRANT_SEARCH_MODE=exact vitest run test/integration/YdbRealIntegration.one-table.test.ts",
+    "test:recall": "YDB_QDRANT_SEARCH_MODE=approximate vitest run test/integration/YdbRealIntegration.one-table.test.ts && YDB_QDRANT_SEARCH_MODE=exact vitest run test/integration/YdbRealIntegration.one-table.test.ts",
     "load:soak": "k6 run loadtest/soak-test.js",
     "load:stress": "k6 run loadtest/stress-test.js",
     "build": "tsc -p tsconfig.json",
@@ -49,7 +49,7 @@
   ],
   "author": "",
   "license": "Apache-2.0",
-  "description": "Qdrant-compatible Node.js/TypeScript API that stores/searches embeddings in YDB using single-phase top-k vector search with an automatic vector index and table-scan fallback.",
+  "description": "Qdrant-compatible Node.js/TypeScript API that stores/searches embeddings in YDB using a global one-table layout with exact and approximate KNN search over serialized vectors.",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/dist/indexing/IndexScheduler.d.ts

@@ -1,5 +0,0 @@
-import type { DistanceKind, VectorType } from "../types.js";
-export declare function notifyUpsert(tableName: string, count?: number): void;
-export declare function requestIndexBuild(tableName: string, dimension: number, distance: DistanceKind, vectorType: VectorType, opts?: {
-    force?: boolean;
-}): void;

package/dist/indexing/IndexScheduler.js

@@ -1,21 +0,0 @@
-import { GLOBAL_POINTS_TABLE } from "../ydb/schema.js";
-import { state, requestIndexBuildMultiTable, } from "./IndexScheduler.multi-table.js";
-import { requestIndexBuildOneTable } from "./IndexScheduler.one-table.js";
-export function notifyUpsert(tableName, count = 1) {
-    const now = Date.now();
-    const s = state[tableName] ?? {
-        lastUpsertMs: 0,
-        pending: false,
-        pointsUpserted: 0,
-    };
-    s.lastUpsertMs = now;
-    s.pointsUpserted += count;
-    state[tableName] = s;
-}
-export function requestIndexBuild(tableName, dimension, distance, vectorType, opts) {
-    if (tableName === GLOBAL_POINTS_TABLE) {
-        requestIndexBuildOneTable(tableName);
-        return;
-    }
-    requestIndexBuildMultiTable(tableName, dimension, distance, vectorType, opts);
-}

package/dist/indexing/IndexScheduler.multi-table.d.ts

@@ -1,12 +0,0 @@
-import type { DistanceKind, VectorType } from "../types.js";
-type CollectionKey = string;
-export declare const state: Record<CollectionKey, {
-    lastUpsertMs: number;
-    timer?: NodeJS.Timeout;
-    pending: boolean;
-    pointsUpserted: number;
-}>;
-export declare function requestIndexBuildMultiTable(tableName: string, dimension: number, distance: DistanceKind, vectorType: VectorType, opts?: {
-    force?: boolean;
-}): void;
-export {};

package/dist/indexing/IndexScheduler.multi-table.js

@@ -1,54 +0,0 @@
-import { buildVectorIndex } from "../repositories/collectionsRepo.js";
-import { logger } from "../logging/logger.js";
-const QUIET_MS = 10000;
-const MIN_POINTS_THRESHOLD = 100;
-export const state = {};
-export function requestIndexBuildMultiTable(tableName, dimension, distance, vectorType, opts) {
-    const s = state[tableName] ?? {
-        lastUpsertMs: 0,
-        pending: false,
-        pointsUpserted: 0,
-    };
-    state[tableName] = s;
-    if (opts?.force) {
-        logger.info({ tableName }, "index build (force) starting");
-        void buildVectorIndex(tableName, dimension, distance, vectorType)
-            .then(() => {
-            logger.info({ tableName }, "index build (force) completed");
-            s.pointsUpserted = 0;
-        })
-            .catch((err) => {
-            logger.error({ err, tableName }, "index build (force) failed");
-        });
-        return;
-    }
-    if (s.pending && s.timer) {
-        return;
-    }
-    s.pending = true;
-    s.timer = setTimeout(function tryBuild() {
-        const since = Date.now() - (state[tableName]?.lastUpsertMs ?? 0);
-        if (since < QUIET_MS) {
-            s.timer = setTimeout(tryBuild, QUIET_MS - since);
-            return;
-        }
-        const pointsCount = state[tableName]?.pointsUpserted ?? 0;
-        if (pointsCount < MIN_POINTS_THRESHOLD) {
-            logger.info({ tableName, pointsCount, threshold: MIN_POINTS_THRESHOLD }, "index build skipped (below threshold)");
-            s.pending = false;
-            s.timer = undefined;
-            return;
-        }
-        logger.info({ tableName, pointsCount }, "index build (scheduled) starting");
-        void buildVectorIndex(tableName, dimension, distance, vectorType)
-            .then(() => {
-            logger.info({ tableName }, "index build (scheduled) completed");
-            state[tableName].pointsUpserted = 0;
-        })
-            .catch((err) => logger.error({ err, tableName }, "index build (scheduled) failed"))
-            .finally(() => {
-            s.pending = false;
-            s.timer = undefined;
-        });
-    }, QUIET_MS);
-}

package/dist/indexing/IndexScheduler.one-table.d.ts

@@ -1 +0,0 @@
-export declare function requestIndexBuildOneTable(tableName: string): void;

package/dist/indexing/IndexScheduler.one-table.js

@@ -1,4 +0,0 @@
-import { logger } from "../logging/logger.js";
-export function requestIndexBuildOneTable(tableName) {
-    logger.info({ tableName }, "index build skipped (one_table mode: global vector index not supported)");
-}

package/dist/repositories/collectionsRepo.multi-table.d.ts

@@ -1,3 +0,0 @@
-import type { DistanceKind, VectorType } from "../types";
-export declare function createCollectionMultiTable(metaKey: string, dim: number, distance: DistanceKind, vectorType: VectorType, tableName: string): Promise<void>;
-export declare function deleteCollectionMultiTable(metaKey: string, tableName: string): Promise<void>;

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

@@ -1,24 +0,0 @@
-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) => {
-        const desc = new TableDescription()
-            .withColumns(new Column("point_id", Types.UTF8), new Column("embedding", Types.BYTES), new Column("payload", Types.JSON_DOCUMENT))
-            .withPrimaryKey("point_id");
-        await s.createTable(tableName, desc);
-    });
-    await upsertCollectionMeta(metaKey, dim, distance, vectorType, tableName);
-}
-export async function deleteCollectionMultiTable(metaKey, tableName) {
-    await withSession(async (s) => {
-        await s.dropTable(tableName);
-    });
-    const delMeta = `
-    DECLARE $collection AS Utf8;
-    DELETE FROM qdr__collections WHERE collection = $collection;
-  `;
-    await withSession(async (s) => {
-        const settings = createExecuteQuerySettings();
-        await s.executeQuery(delMeta, { $collection: TypedValues.utf8(metaKey) }, undefined, settings);
-    });
-}

package/dist/repositories/pointsRepo.multi-table.d.ts

@@ -1,12 +0,0 @@
-import type { DistanceKind } from "../types";
-export declare function upsertPointsMultiTable(tableName: string, points: Array<{
-    id: string | number;
-    vector: number[];
-    payload?: Record<string, unknown>;
-}>, dimension: number): Promise<number>;
-export declare function searchPointsMultiTable(tableName: string, queryVector: number[], top: number, withPayload: boolean | undefined, distance: DistanceKind, dimension: number): Promise<Array<{
-    id: string;
-    score: number;
-    payload?: Record<string, unknown>;
-}>>;
-export declare function deletePointsMultiTable(tableName: string, ids: Array<string | number>): Promise<number>;

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

@@ -1,147 +0,0 @@
-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";
-import { VECTOR_INDEX_BUILD_ENABLED } from "../config/env.js";
-import { mapDistanceToKnnFn } from "../utils/distance.js";
-import { withRetry, isTransientYdbError } from "../utils/retry.js";
-import { UPSERT_BATCH_SIZE } from "../ydb/schema.js";
-export async function upsertPointsMultiTable(tableName, points, dimension) {
-    for (const p of points) {
-        const id = String(p.id);
-        if (p.vector.length !== dimension) {
-            throw new Error(`Vector dimension mismatch for id=${id}: got ${p.vector.length}, expected ${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 = `
-        DECLARE $rows AS List<Struct<
-          point_id: Utf8,
-          vec: List<Float>,
-          payload: JsonDocument
-        >>;
-
-        UPSERT INTO ${tableName} (point_id, embedding, payload)
-        SELECT
-          point_id,
-          Untag(Knn::ToBinaryStringFloat(vec), "FloatVector") AS embedding,
-          payload
-        FROM AS_TABLE($rows);
-      `;
-            const rowType = Types.struct({
-                point_id: Types.UTF8,
-                vec: Types.list(Types.FLOAT),
-                payload: Types.JSON_DOCUMENT,
-            });
-            const rowsValue = TypedValues.list(rowType, batch.map((p) => ({
-                point_id: String(p.id),
-                vec: p.vector,
-                payload: JSON.stringify(p.payload ?? {}),
-            })));
-            const params = {
-                $rows: rowsValue,
-            };
-            await withRetry(() => s.executeQuery(ddl, params, undefined, settings), {
-                isTransient: isTransientYdbError,
-                context: { tableName, batchSize: batch.length },
-            });
-            upserted += batch.length;
-        }
-    });
-    notifyUpsert(tableName, upserted);
-    return upserted;
-}
-export async function searchPointsMultiTable(tableName, queryVector, top, withPayload, distance, dimension) {
-    if (queryVector.length !== dimension) {
-        throw new Error(`Vector dimension mismatch: got ${queryVector.length}, expected ${dimension}`);
-    }
-    const { fn, order } = mapDistanceToKnnFn(distance);
-    const qf = buildVectorParam(queryVector);
-    const params = {
-        $qf: qf,
-        $k2: TypedValues.uint32(top),
-    };
-    const settings = createExecuteQuerySettings();
-    const buildQuery = (useIndex) => `
-    DECLARE $qf AS List<Float>;
-    DECLARE $k2 AS Uint32;
-    $qbinf = Knn::ToBinaryStringFloat($qf);
-    SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
-    FROM ${tableName}${useIndex ? " VIEW emb_idx" : ""}
-    ORDER BY score ${order}
-    LIMIT $k2;
-  `;
-    let rs;
-    if (VECTOR_INDEX_BUILD_ENABLED) {
-        try {
-            rs = await withSession(async (s) => {
-                return await s.executeQuery(buildQuery(true), params, undefined, settings);
-            });
-            logger.info({ tableName }, "vector index found; using index for search");
-        }
-        catch (e) {
-            const msg = e instanceof Error ? e.message : String(e);
-            const indexUnavailable = /not found|does not exist|no such index|no global index|is not ready to use/i.test(msg);
-            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, undefined, settings);
-                });
-            }
-            else {
-                throw e;
-            }
-        }
-    }
-    else {
-        rs = await withSession(async (s) => {
-            return await s.executeQuery(buildQuery(false), 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");
-        }
-        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 } : {}) };
-    });
-}
-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;
-        DELETE FROM ${tableName} WHERE point_id = $id;
-      `;
-            const params = {
-                $id: TypedValues.utf8(String(id)),
-            };
-            await s.executeQuery(yql, params, undefined, settings);
-            deleted += 1;
-        }
-    });
-    return deleted;
-}

package/dist/services/CollectionService.multi-table.d.ts

@@ -1,5 +0,0 @@
-import { type NormalizedCollectionContextLike } from "./CollectionService.shared.js";
-export declare function resolvePointsTableAndUidMultiTable(ctx: NormalizedCollectionContextLike): {
-    tableName: string;
-    uid: string | undefined;
-};

package/dist/services/CollectionService.multi-table.js

@@ -1,7 +0,0 @@
-import { tableNameFor, } from "./CollectionService.shared.js";
-export function resolvePointsTableAndUidMultiTable(ctx) {
-    return {
-        tableName: tableNameFor(ctx.tenant, ctx.collection),
-        uid: undefined,
-    };
-}