ydb-qdrant 2.3.0 → 4.0.0

package/README.md

@@ -400,7 +400,7 @@ curl -X POST http://localhost:8080/collections/mycol/points/delete \
 ## Notes
 - One YDB table is created per collection; metadata is tracked in table `qdr__collections`.
 - Each collection table schema: `point_id Utf8` (PK), `embedding String` (binary), `payload JsonDocument`.
-- Vectors are serialized with `Knn::ToBinaryStringFloat` (or `Knn::ToBinaryStringUint8` if collection uses uint8).
+- Vectors are serialized with `Knn::ToBinaryStringFloat`.
 - Search uses a single-phase top‑k over `embedding` with automatic YDB vector index (`emb_idx`) when available; falls back to table scan if missing.
 - **Vector index auto-build**: After ≥100 points upserted + 5s quiet window, a `vector_kmeans_tree` index (levels=1, clusters=128) is built automatically. Incremental updates (<100 points) skip index rebuild.
 - **Concurrency**: During index rebuilds, YDB may return transient `Aborted`/schema metadata errors. Upserts include bounded retries with backoff to handle this automatically.

package/dist/SmokeTest.js

@@ -1,5 +1,5 @@
 import "dotenv/config";
-import { createYdbQdrantClient } from "./package/Api.js";
+import { createYdbQdrantClient } from "./package/api.js";
 async function main() {
     const tenant = process.env.SMOKE_TENANT ?? "smoke";
     const collection = process.env.SMOKE_COLLECTION ?? "demo";

package/dist/package/{Api.d.ts → api.d.ts}

@@ -1,6 +1,7 @@
 import type { IAuthService } from "ydb-sdk";
-import { createCollection as serviceCreateCollection, deleteCollection as serviceDeleteCollection, getCollection as serviceGetCollection, putCollectionIndex as servicePutCollectionIndex, upsertPoints as serviceUpsertPoints, searchPoints as serviceSearchPoints, deletePoints as serviceDeletePoints } from "../services/QdrantService.js";
-export { QdrantServiceError } from "../services/QdrantService.js";
+import { createCollection as serviceCreateCollection, deleteCollection as serviceDeleteCollection, getCollection as serviceGetCollection, putCollectionIndex as servicePutCollectionIndex } from "../services/CollectionService.js";
+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";
 type CreateCollectionResult = Awaited<ReturnType<typeof serviceCreateCollection>>;
 type GetCollectionResult = Awaited<ReturnType<typeof serviceGetCollection>>;

package/dist/package/api.js

@@ -0,0 +1,55 @@
+import { readyOrThrow, configureDriver } from "../ydb/client.js";
+import { ensureMetaTable } from "../ydb/schema.js";
+import { createCollection as serviceCreateCollection, deleteCollection as serviceDeleteCollection, getCollection as serviceGetCollection, putCollectionIndex as servicePutCollectionIndex, } from "../services/CollectionService.js";
+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";
+function buildTenantClient(resolveTenant) {
+    return {
+        createCollection(collection, body) {
+            return serviceCreateCollection({ tenant: resolveTenant(), collection }, body);
+        },
+        getCollection(collection) {
+            return serviceGetCollection({ tenant: resolveTenant(), collection });
+        },
+        deleteCollection(collection) {
+            return serviceDeleteCollection({ tenant: resolveTenant(), collection });
+        },
+        putCollectionIndex(collection) {
+            return servicePutCollectionIndex({ tenant: resolveTenant(), collection });
+        },
+        upsertPoints(collection, body) {
+            return serviceUpsertPoints({ tenant: resolveTenant(), collection }, body);
+        },
+        searchPoints(collection, body) {
+            return serviceSearchPoints({ tenant: resolveTenant(), collection }, body);
+        },
+        deletePoints(collection, body) {
+            return serviceDeletePoints({ tenant: resolveTenant(), collection }, body);
+        },
+    };
+}
+export async function createYdbQdrantClient(options = {}) {
+    if (options.endpoint !== undefined ||
+        options.database !== undefined ||
+        options.connectionString !== undefined ||
+        options.authService !== undefined) {
+        configureDriver({
+            endpoint: options.endpoint,
+            database: options.database,
+            connectionString: options.connectionString,
+            authService: options.authService,
+        });
+    }
+    await readyOrThrow();
+    await ensureMetaTable();
+    const defaultTenant = options.defaultTenant ?? "default";
+    const baseClient = buildTenantClient(() => defaultTenant);
+    const client = {
+        ...baseClient,
+        forTenant(tenantId) {
+            return buildTenantClient(() => tenantId);
+        },
+    };
+    return client;
+}

package/dist/repositories/collectionsRepo.js

@@ -1,4 +1,5 @@
 import { Types, TypedValues, withSession, TableDescription, Column, } from "../ydb/client.js";
+import { mapDistanceToIndexParam } from "../utils/distance.js";
 export async function createCollection(metaKey, dim, distance, vectorType, tableName) {
     await withSession(async (s) => {
         const desc = new TableDescription()
@@ -103,17 +104,3 @@ export async function buildVectorIndex(tableName, dimension, distance, vectorTyp
         await rawSession.api.executeSchemeQuery(createReq);
     });
 }
-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";
-    }
-}

package/dist/repositories/pointsRepo.d.ts

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

package/dist/repositories/pointsRepo.js

@@ -3,7 +3,9 @@ import { buildJsonOrEmpty, 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";
-export async function upsertPoints(tableName, points, vectorType, dimension) {
+import { mapDistanceToKnnFn } from "../utils/distance.js";
+import { withRetry, isTransientYdbError } from "../utils/retry.js";
+export async function upsertPoints(tableName, points, dimension) {
     let upserted = 0;
     await withSession(async (s) => {
         for (const p of points) {
@@ -13,64 +15,46 @@ export async function upsertPoints(tableName, points, vectorType, dimension) {
             }
             const ddl = `
         DECLARE $id AS Utf8;
-        DECLARE $vec AS List<${vectorType === "uint8" ? "Uint8" : "Float"}>;
+        DECLARE $vec AS List<Float>;
         DECLARE $payload AS JsonDocument;
         UPSERT INTO ${tableName} (point_id, embedding, payload)
         VALUES (
           $id,
-          Untag(Knn::ToBinaryString${vectorType === "uint8" ? "Uint8" : "Float"}($vec), "${vectorType === "uint8" ? "Uint8Vector" : "FloatVector"}"),
+          Untag(Knn::ToBinaryStringFloat($vec), "FloatVector"),
           $payload
         );
       `;
             const params = {
                 $id: TypedValues.utf8(id),
-                $vec: buildVectorParam(p.vector, vectorType),
+                $vec: buildVectorParam(p.vector),
                 $payload: buildJsonOrEmpty(p.payload),
             };
-            // Retry on transient schema/metadata mismatches during index rebuild
-            const maxRetries = 6; // ~ up to ~ (0.25 + jitter) * 2^5 ≈ few seconds
-            let attempt = 0;
-            while (true) {
-                try {
-                    await s.executeQuery(ddl, params);
-                    break;
-                }
-                catch (e) {
-                    const msg = e instanceof Error ? e.message : String(e);
-                    const isTransient = /Aborted|schema version mismatch|Table metadata loading|Failed to load metadata/i.test(msg);
-                    if (!isTransient || attempt >= maxRetries) {
-                        throw e;
-                    }
-                    const backoffMs = Math.floor(250 * Math.pow(2, attempt) + Math.random() * 100);
-                    logger.warn({ tableName, id, attempt, backoffMs }, "upsert aborted due to schema/metadata change; retrying");
-                    await new Promise((r) => setTimeout(r, backoffMs));
-                    attempt += 1;
-                }
-            }
+            await withRetry(() => s.executeQuery(ddl, params), {
+                isTransient: isTransientYdbError,
+                context: { tableName, id },
+            });
             upserted += 1;
         }
     });
-    // notify scheduler for potential end-of-batch index build
     notifyUpsert(tableName, upserted);
-    // No index rebuild; approximate search does not require it
     return upserted;
 }
 // Removed legacy index backfill helper
-export async function searchPoints(tableName, queryVector, top, withPayload, distance, vectorType, dimension) {
+export async function searchPoints(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);
     // Single-phase search over embedding using vector index if present
-    const qf = buildVectorParam(queryVector, vectorType);
+    const qf = buildVectorParam(queryVector);
     const params = {
         $qf: qf,
         $k2: TypedValues.uint32(top),
     };
     const buildQuery = (useIndex) => `
-    DECLARE $qf AS List<${vectorType === "uint8" ? "Uint8" : "Float"}>;
+    DECLARE $qf AS List<Float>;
     DECLARE $k2 AS Uint32;
-    $qbinf = Knn::ToBinaryString${vectorType === "uint8" ? "Uint8" : "Float"}($qf);
+    $qbinf = Knn::ToBinaryStringFloat($qf);
     SELECT point_id, ${withPayload ? "payload, " : ""}${fn}(embedding, $qbinf) AS score
     FROM ${tableName}${useIndex ? " VIEW emb_idx" : ""}
     ORDER BY score ${order}
@@ -147,17 +131,3 @@ export async function deletePoints(tableName, ids) {
     });
     return deleted;
 }
-function mapDistanceToKnnFn(distance) {
-    switch (distance) {
-        case "Cosine":
-            return { fn: "Knn::CosineSimilarity", order: "DESC" };
-        case "Dot":
-            return { fn: "Knn::InnerProductSimilarity", order: "DESC" };
-        case "Euclid":
-            return { fn: "Knn::EuclideanDistance", order: "ASC" };
-        case "Manhattan":
-            return { fn: "Knn::ManhattanDistance", order: "ASC" };
-        default:
-            return { fn: "Knn::CosineSimilarity", order: "DESC" };
-    }
-}

package/dist/routes/collections.js

@@ -1,6 +1,7 @@
 import { Router } from "express";
 import { sanitizeCollectionName, sanitizeTenantId } from "../utils/tenant.js";
-import { QdrantServiceError, putCollectionIndex, createCollection, getCollection, deleteCollection, } from "../services/QdrantService.js";
+import { putCollectionIndex, createCollection, getCollection, deleteCollection, } from "../services/CollectionService.js";
+import { QdrantServiceError } from "../services/errors.js";
 import { logger } from "../logging/logger.js";
 export const collectionsRouter = Router();
 collectionsRouter.put("/:collection/index", async (req, res) => {

package/dist/routes/points.js

@@ -1,5 +1,6 @@
 import { Router } from "express";
-import { QdrantServiceError, upsertPoints, searchPoints, queryPoints, deletePoints, } from "../services/QdrantService.js";
+import { upsertPoints, searchPoints, queryPoints, deletePoints, } from "../services/PointsService.js";
+import { QdrantServiceError } from "../services/errors.js";
 import { logger } from "../logging/logger.js";
 export const pointsRouter = Router();
 // Qdrant-compatible: PUT /collections/:collection/points (upsert)

package/dist/services/CollectionService.d.ts

@@ -0,0 +1,29 @@
+import { type DistanceKind } from "../types.js";
+export interface CollectionContextInput {
+    tenant: string | undefined;
+    collection: string;
+}
+export interface NormalizedCollectionContext {
+    tenant: string;
+    collection: string;
+    metaKey: string;
+}
+export declare function normalizeCollectionContext(input: CollectionContextInput): NormalizedCollectionContext;
+export declare function putCollectionIndex(ctx: CollectionContextInput): Promise<{
+    acknowledged: boolean;
+}>;
+export declare function createCollection(ctx: CollectionContextInput, body: unknown): Promise<{
+    name: string;
+    tenant: string;
+}>;
+export declare function getCollection(ctx: CollectionContextInput): Promise<{
+    name: string;
+    vectors: {
+        size: number;
+        distance: DistanceKind;
+        data_type: string;
+    };
+}>;
+export declare function deleteCollection(ctx: CollectionContextInput): Promise<{
+    acknowledged: boolean;
+}>;

package/dist/services/CollectionService.js

@@ -0,0 +1,78 @@
+import { sanitizeCollectionName, sanitizeTenantId, metaKeyFor, tableNameFor, } from "../utils/tenant.js";
+import { CreateCollectionReq } from "../types.js";
+import { ensureMetaTable } from "../ydb/schema.js";
+import { createCollection as repoCreateCollection, deleteCollection as repoDeleteCollection, getCollectionMeta, } from "../repositories/collectionsRepo.js";
+import { QdrantServiceError } from "./errors.js";
+export function normalizeCollectionContext(input) {
+    const tenant = sanitizeTenantId(input.tenant);
+    const collection = sanitizeCollectionName(input.collection);
+    const metaKey = metaKeyFor(tenant, collection);
+    return { tenant, collection, metaKey };
+}
+export async function putCollectionIndex(ctx) {
+    await ensureMetaTable();
+    const normalized = normalizeCollectionContext(ctx);
+    const meta = await getCollectionMeta(normalized.metaKey);
+    if (!meta) {
+        throw new QdrantServiceError(404, {
+            status: "error",
+            error: "collection not found",
+        });
+    }
+    return { acknowledged: true };
+}
+export async function createCollection(ctx, body) {
+    await ensureMetaTable();
+    const normalized = normalizeCollectionContext(ctx);
+    const parsed = CreateCollectionReq.safeParse(body);
+    if (!parsed.success) {
+        throw new QdrantServiceError(400, {
+            status: "error",
+            error: parsed.error.flatten(),
+        });
+    }
+    const dim = parsed.data.vectors.size;
+    const distance = parsed.data.vectors.distance;
+    const vectorType = parsed.data.vectors.data_type ?? "float";
+    const existing = await getCollectionMeta(normalized.metaKey);
+    if (existing) {
+        if (existing.dimension === dim &&
+            existing.distance === distance &&
+            existing.vectorType === vectorType) {
+            return { name: normalized.collection, tenant: normalized.tenant };
+        }
+        const errorMessage = `Collection already exists with different config: dimension=${existing.dimension}, distance=${existing.distance}, type=${existing.vectorType}`;
+        throw new QdrantServiceError(400, {
+            status: "error",
+            error: errorMessage,
+        });
+    }
+    const tableName = tableNameFor(normalized.tenant, normalized.collection);
+    await repoCreateCollection(normalized.metaKey, dim, distance, vectorType, tableName);
+    return { name: normalized.collection, tenant: normalized.tenant };
+}
+export async function getCollection(ctx) {
+    await ensureMetaTable();
+    const normalized = normalizeCollectionContext(ctx);
+    const meta = await getCollectionMeta(normalized.metaKey);
+    if (!meta) {
+        throw new QdrantServiceError(404, {
+            status: "error",
+            error: "collection not found",
+        });
+    }
+    return {
+        name: normalized.collection,
+        vectors: {
+            size: meta.dimension,
+            distance: meta.distance,
+            data_type: meta.vectorType,
+        },
+    };
+}
+export async function deleteCollection(ctx) {
+    await ensureMetaTable();
+    const normalized = normalizeCollectionContext(ctx);
+    await repoDeleteCollection(normalized.metaKey);
+    return { acknowledged: true };
+}

package/dist/services/PointsService.d.ts

@@ -0,0 +1,23 @@
+import { type CollectionContextInput } from "./CollectionService.js";
+type PointsContextInput = CollectionContextInput;
+export declare function upsertPoints(ctx: PointsContextInput, body: unknown): Promise<{
+    upserted: number;
+}>;
+export declare function searchPoints(ctx: PointsContextInput, body: unknown): Promise<{
+    points: Array<{
+        id: string;
+        score: number;
+        payload?: Record<string, unknown>;
+    }>;
+}>;
+export declare function queryPoints(ctx: PointsContextInput, body: unknown): Promise<{
+    points: Array<{
+        id: string;
+        score: number;
+        payload?: Record<string, unknown>;
+    }>;
+}>;
+export declare function deletePoints(ctx: PointsContextInput, body: unknown): Promise<{
+    deleted: number;
+}>;
+export {};

package/dist/services/PointsService.js

@@ -0,0 +1,125 @@
+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 } from "./errors.js";
+import { normalizeCollectionContext, } from "./CollectionService.js";
+import { normalizeSearchBodyForSearch, normalizeSearchBodyForQuery, } from "../utils/normalization.js";
+let loggedIndexBuildDisabled = false;
+export async function upsertPoints(ctx, body) {
+    await ensureMetaTable();
+    const normalized = normalizeCollectionContext(ctx);
+    const meta = await getCollectionMeta(normalized.metaKey);
+    if (!meta) {
+        throw new QdrantServiceError(404, {
+            status: "error",
+            error: "collection not found",
+        });
+    }
+    const parsed = UpsertPointsReq.safeParse(body);
+    if (!parsed.success) {
+        throw new QdrantServiceError(400, {
+            status: "error",
+            error: parsed.error.flatten(),
+        });
+    }
+    const upserted = await repoUpsertPoints(meta.table, parsed.data.points, meta.dimension);
+    if (VECTOR_INDEX_BUILD_ENABLED) {
+        requestIndexBuild(meta.table, meta.dimension, meta.distance, meta.vectorType);
+    }
+    else if (!loggedIndexBuildDisabled) {
+        logger.info({ table: meta.table }, "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);
+    logger.info({ tenant: normalized.tenant, collection: normalized.collection }, `${source}: resolve collection meta`);
+    const meta = await getCollectionMeta(normalized.metaKey);
+    if (!meta) {
+        logger.warn({
+            tenant: normalized.tenant,
+            collection: normalized.collection,
+            metaKey: normalized.metaKey,
+        }, `${source}: collection not found`);
+        throw new QdrantServiceError(404, {
+            status: "error",
+            error: "collection not found",
+        });
+    }
+    const parsed = SearchReq.safeParse({
+        vector: normalizedSearch.vector,
+        top: normalizedSearch.top,
+        with_payload: normalizedSearch.withPayload,
+    });
+    if (!parsed.success) {
+        logger.warn({
+            tenant: normalized.tenant,
+            collection: normalized.collection,
+            issues: parsed.error.issues,
+        }, `${source}: invalid payload`);
+        throw new QdrantServiceError(400, {
+            status: "error",
+            error: parsed.error.flatten(),
+        });
+    }
+    logger.info({
+        tenant: normalized.tenant,
+        collection: normalized.collection,
+        top: parsed.data.top,
+        queryVectorLen: parsed.data.vector.length,
+        collectionDim: meta.dimension,
+        distance: meta.distance,
+        vectorType: meta.vectorType,
+    }, `${source}: executing`);
+    const hits = await repoSearchPoints(meta.table, parsed.data.vector, parsed.data.top, parsed.data.with_payload, meta.distance, meta.dimension);
+    const threshold = normalizedSearch.scoreThreshold;
+    const filtered = threshold === undefined
+        ? hits
+        : hits.filter((hit) => {
+            const isSimilarity = meta.distance === "Cosine" || meta.distance === "Dot";
+            if (isSimilarity) {
+                return hit.score >= threshold;
+            }
+            return hit.score <= threshold;
+        });
+    logger.info({
+        tenant: normalized.tenant,
+        collection: normalized.collection,
+        hits: hits.length,
+    }, `${source}: completed`);
+    return { points: filtered };
+}
+export async function searchPoints(ctx, body) {
+    const normalizedSearch = normalizeSearchBodyForSearch(body);
+    return await executeSearch(ctx, normalizedSearch, "search");
+}
+export async function queryPoints(ctx, body) {
+    const normalizedSearch = normalizeSearchBodyForQuery(body);
+    return await executeSearch(ctx, normalizedSearch, "query");
+}
+export async function deletePoints(ctx, body) {
+    await ensureMetaTable();
+    const normalized = normalizeCollectionContext(ctx);
+    const meta = await getCollectionMeta(normalized.metaKey);
+    if (!meta) {
+        throw new QdrantServiceError(404, {
+            status: "error",
+            error: "collection not found",
+        });
+    }
+    const parsed = DeletePointsReq.safeParse(body);
+    if (!parsed.success) {
+        throw new QdrantServiceError(400, {
+            status: "error",
+            error: parsed.error.flatten(),
+        });
+    }
+    const deleted = await repoDeletePoints(meta.table, parsed.data.points);
+    return { deleted };
+}

package/dist/services/errors.d.ts

@@ -0,0 +1,9 @@
+export interface QdrantServiceErrorPayload {
+    status: "error";
+    error: unknown;
+}
+export declare class QdrantServiceError extends Error {
+    readonly statusCode: number;
+    readonly payload: QdrantServiceErrorPayload;
+    constructor(statusCode: number, payload: QdrantServiceErrorPayload, message?: string);
+}

package/dist/services/errors.js

@@ -0,0 +1,9 @@
+export class QdrantServiceError extends Error {
+    statusCode;
+    payload;
+    constructor(statusCode, payload, message) {
+        super(message ?? String(payload.error));
+        this.statusCode = statusCode;
+        this.payload = payload;
+    }
+}

package/dist/types.d.ts

@@ -1,13 +1,12 @@
 import { z } from "zod";
 export type DistanceKind = "Cosine" | "Euclid" | "Dot" | "Manhattan";
-export type VectorType = "float" | "uint8";
+export type VectorType = "float";
 export declare const CreateCollectionReq: z.ZodObject<{
     vectors: z.ZodObject<{
         size: z.ZodNumber;
         distance: z.ZodType<DistanceKind>;
         data_type: z.ZodOptional<z.ZodEnum<{
             float: "float";
-            uint8: "uint8";
         }>>;
     }, z.core.$strip>;
 }, z.core.$strip>;

package/dist/types.js

@@ -8,7 +8,7 @@ export const CreateCollectionReq = z.object({
             "Dot",
             "Manhattan",
         ]),
-        data_type: z.enum(["float", "uint8"]).optional(),
+        data_type: z.enum(["float"]).optional(),
     }),
 });
 export const UpsertPointsReq = z.object({

package/dist/utils/distance.d.ts

@@ -0,0 +1,6 @@
+import type { DistanceKind } from "../types.js";
+export declare function mapDistanceToKnnFn(distance: DistanceKind): {
+    fn: string;
+    order: "ASC" | "DESC";
+};
+export declare function mapDistanceToIndexParam(distance: DistanceKind): string;

package/dist/utils/distance.js

@@ -0,0 +1,28 @@
+export function mapDistanceToKnnFn(distance) {
+    switch (distance) {
+        case "Cosine":
+            return { fn: "Knn::CosineSimilarity", order: "DESC" };
+        case "Dot":
+            return { fn: "Knn::InnerProductSimilarity", order: "DESC" };
+        case "Euclid":
+            return { fn: "Knn::EuclideanDistance", order: "ASC" };
+        case "Manhattan":
+            return { fn: "Knn::ManhattanDistance", order: "ASC" };
+        default:
+            return { fn: "Knn::CosineSimilarity", order: "DESC" };
+    }
+}
+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";
+    }
+}

package/dist/utils/normalization.d.ts

@@ -0,0 +1,10 @@
+export interface SearchNormalizationResult {
+    vector: number[] | undefined;
+    top: number | undefined;
+    withPayload: boolean | undefined;
+    scoreThreshold: number | undefined;
+}
+export declare function isNumberArray(value: unknown): value is number[];
+export declare function extractVectorLoose(body: unknown, depth?: number): number[] | undefined;
+export declare function normalizeSearchBodyForSearch(body: unknown): SearchNormalizationResult;
+export declare function normalizeSearchBodyForQuery(body: unknown): SearchNormalizationResult;

package/dist/utils/normalization.js

@@ -0,0 +1,92 @@
+export function isNumberArray(value) {
+    return Array.isArray(value) && value.every((x) => typeof x === "number");
+}
+export function extractVectorLoose(body, depth = 0) {
+    if (!body || typeof body !== "object" || depth > 3) {
+        return undefined;
+    }
+    const obj = body;
+    if (isNumberArray(obj.vector))
+        return obj.vector;
+    if (isNumberArray(obj.embedding))
+        return obj.embedding;
+    const query = obj.query;
+    if (query) {
+        const queryVector = query["vector"];
+        if (isNumberArray(queryVector))
+            return queryVector;
+        const nearest = query["nearest"];
+        if (nearest && isNumberArray(nearest.vector)) {
+            return nearest.vector;
+        }
+    }
+    const nearest = obj.nearest;
+    if (nearest && isNumberArray(nearest.vector)) {
+        return nearest.vector;
+    }
+    for (const key of Object.keys(obj)) {
+        const value = obj[key];
+        if (isNumberArray(value)) {
+            return value;
+        }
+    }
+    for (const key of Object.keys(obj)) {
+        const value = obj[key];
+        if (value && typeof value === "object") {
+            const found = extractVectorLoose(value, depth + 1);
+            if (found) {
+                return found;
+            }
+        }
+    }
+    return undefined;
+}
+export function normalizeSearchBodyForSearch(body) {
+    if (!body || typeof body !== "object") {
+        return {
+            vector: undefined,
+            top: undefined,
+            withPayload: undefined,
+            scoreThreshold: undefined,
+        };
+    }
+    const b = body;
+    const rawVector = b["vector"];
+    const vector = isNumberArray(rawVector) ? rawVector : undefined;
+    return normalizeSearchCommon(b, vector);
+}
+export function normalizeSearchBodyForQuery(body) {
+    if (!body || typeof body !== "object") {
+        return {
+            vector: undefined,
+            top: undefined,
+            withPayload: undefined,
+            scoreThreshold: undefined,
+        };
+    }
+    const b = body;
+    const vector = extractVectorLoose(b);
+    return normalizeSearchCommon(b, vector);
+}
+function normalizeSearchCommon(b, vector) {
+    const rawTop = b["top"];
+    const rawLimit = b["limit"];
+    const topFromTop = typeof rawTop === "number" ? rawTop : undefined;
+    const topFromLimit = typeof rawLimit === "number" ? rawLimit : undefined;
+    const top = topFromTop ?? topFromLimit;
+    let withPayload;
+    const rawWithPayload = b["with_payload"];
+    if (typeof rawWithPayload === "boolean") {
+        withPayload = rawWithPayload;
+    }
+    else if (Array.isArray(rawWithPayload) ||
+        typeof rawWithPayload === "object") {
+        withPayload = true;
+    }
+    const thresholdRaw = b["score_threshold"];
+    const thresholdValue = typeof thresholdRaw === "number" ? thresholdRaw : Number(thresholdRaw);
+    const scoreThreshold = Number.isFinite(thresholdValue)
+        ? thresholdValue
+        : undefined;
+    return { vector, top, withPayload, scoreThreshold };
+}

package/dist/utils/retry.d.ts

@@ -0,0 +1,8 @@
+export interface RetryOptions {
+    maxRetries?: number;
+    baseDelayMs?: number;
+    isTransient?: (error: unknown) => boolean;
+    context?: Record<string, unknown>;
+}
+export declare function isTransientYdbError(error: unknown): boolean;
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;

package/dist/utils/retry.js

@@ -0,0 +1,28 @@
+import { logger } from "../logging/logger.js";
+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);
+}
+export async function withRetry(fn, options = {}) {
+    const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+    const baseDelayMs = options.baseDelayMs ?? DEFAULT_BASE_DELAY_MS;
+    const isTransient = options.isTransient ?? isTransientYdbError;
+    const context = options.context ?? {};
+    let attempt = 0;
+    while (true) {
+        try {
+            return await fn();
+        }
+        catch (e) {
+            if (!isTransient(e) || attempt >= maxRetries) {
+                throw e;
+            }
+            const backoffMs = Math.floor(baseDelayMs * Math.pow(2, attempt) + Math.random() * 100);
+            logger.warn({ ...context, attempt, backoffMs }, "operation aborted due to transient error; retrying");
+            await new Promise((r) => setTimeout(r, backoffMs));
+            attempt += 1;
+        }
+    }
+}

package/dist/ydb/helpers.d.ts

@@ -1,2 +1,2 @@
-export declare function buildVectorParam(vector: number[], vectorType: "float" | "uint8"): import("ydb-sdk-proto").Ydb.ITypedValue;
+export declare function buildVectorParam(vector: number[]): import("ydb-sdk-proto").Ydb.ITypedValue;
 export declare function buildJsonOrEmpty(payload?: Record<string, unknown>): import("ydb-sdk-proto").Ydb.ITypedValue;

package/dist/ydb/helpers.js

@@ -1,44 +1,6 @@
 import { Types, TypedValues } from "./client.js";
-export function buildVectorParam(vector, vectorType) {
-    let list;
-    if (vectorType === "uint8") {
-        // Check if vector is already quantized (integers in [0,255])
-        const isAlreadyQuantized = vector.every(v => Number.isInteger(v) && v >= 0 && v <= 255);
-        if (isAlreadyQuantized) {
-            list = vector;
-        }
-        else {
-            // Float embeddings need quantization. Per YDB docs (knn.md lines 282-294):
-            // Formula: ((x - min) / (max - min)) * 255
-            const min = Math.min(...vector);
-            const max = Math.max(...vector);
-            // Determine quantization strategy based on detected range
-            if (min >= 0 && max <= 1.01) {
-                // Normalized [0,1] embeddings (common for some models)
-                list = vector.map(v => Math.round(Math.max(0, Math.min(1, v)) * 255));
-            }
-            else if (min >= -1.01 && max <= 1.01) {
-                // Normalized [-1,1] embeddings (most common)
-                // Map to [0,255]: ((x + 1) / 2) * 255 = (x + 1) * 127.5
-                list = vector.map(v => Math.round((Math.max(-1, Math.min(1, v)) + 1) * 127.5));
-            }
-            else {
-                // General case: linear scaling from [min,max] to [0,255]
-                const range = max - min;
-                if (range > 0) {
-                    list = vector.map(v => Math.round(((v - min) / range) * 255));
-                }
-                else {
-                    // All values identical; map to midpoint
-                    list = vector.map(() => 127);
-                }
-            }
-        }
-    }
-    else {
-        list = vector;
-    }
-    return TypedValues.list(vectorType === "uint8" ? Types.UINT8 : Types.FLOAT, list);
+export function buildVectorParam(vector) {
+    return TypedValues.list(Types.FLOAT, vector);
 }
 export function buildJsonOrEmpty(payload) {
     return TypedValues.jsonDocument(JSON.stringify(payload ?? {}));

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "ydb-qdrant",
-  "version": "2.3.0",
-  "main": "dist/package/Api.js",
-  "types": "dist/package/Api.d.ts",
+  "version": "4.0.0",
+  "main": "dist/package/api.js",
+  "types": "dist/package/api.d.ts",
   "exports": {
-    ".": "./dist/package/Api.js",
+    ".": "./dist/package/api.js",
     "./server": "./dist/server.js"
   },
   "files": [
@@ -46,7 +46,7 @@
   ],
   "author": "",
   "license": "ISC",
-  "description": "Qdrant-compatible Node.js/TypeScript API that stores/searches embeddings in YDB using approximate coarse-to-fine vector search (quantized uint8 preselect + float refine).",
+  "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.",
   "type": "module",
   "publishConfig": {
     "access": "public"

package/dist/package/Api.js

@@ -1,79 +0,0 @@
-import { readyOrThrow, configureDriver } from "../ydb/client.js";
-import { ensureMetaTable } from "../ydb/schema.js";
-import { createCollection as serviceCreateCollection, deleteCollection as serviceDeleteCollection, getCollection as serviceGetCollection, putCollectionIndex as servicePutCollectionIndex, upsertPoints as serviceUpsertPoints, searchPoints as serviceSearchPoints, deletePoints as serviceDeletePoints, } from "../services/QdrantService.js";
-export { QdrantServiceError } from "../services/QdrantService.js";
-export { CreateCollectionReq, UpsertPointsReq, SearchReq, DeletePointsReq, } from "../types.js";
-export async function createYdbQdrantClient(options = {}) {
-    if (options.endpoint !== undefined ||
-        options.database !== undefined ||
-        options.connectionString !== undefined ||
-        options.authService !== undefined) {
-        configureDriver({
-            endpoint: options.endpoint,
-            database: options.database,
-            connectionString: options.connectionString,
-            authService: options.authService,
-        });
-    }
-    await readyOrThrow();
-    await ensureMetaTable();
-    const defaultTenant = options.defaultTenant ?? "default";
-    const resolveTenant = (tenant) => tenant ?? defaultTenant;
-    const client = {
-        async createCollection(collection, body) {
-            const tenant = resolveTenant(undefined);
-            return await serviceCreateCollection({ tenant, collection }, body);
-        },
-        async getCollection(collection) {
-            const tenant = resolveTenant(undefined);
-            return await serviceGetCollection({ tenant, collection });
-        },
-        async deleteCollection(collection) {
-            const tenant = resolveTenant(undefined);
-            return await serviceDeleteCollection({ tenant, collection });
-        },
-        async putCollectionIndex(collection) {
-            const tenant = resolveTenant(undefined);
-            return await servicePutCollectionIndex({ tenant, collection });
-        },
-        async upsertPoints(collection, body) {
-            const tenant = resolveTenant(undefined);
-            return await serviceUpsertPoints({ tenant, collection }, body);
-        },
-        async searchPoints(collection, body) {
-            const tenant = resolveTenant(undefined);
-            return await serviceSearchPoints({ tenant, collection }, body);
-        },
-        async deletePoints(collection, body) {
-            const tenant = resolveTenant(undefined);
-            return await serviceDeletePoints({ tenant, collection }, body);
-        },
-        forTenant(tenantId) {
-            const tenant = tenantId;
-            return {
-                createCollection(collection, body) {
-                    return serviceCreateCollection({ tenant, collection }, body);
-                },
-                getCollection(collection) {
-                    return serviceGetCollection({ tenant, collection });
-                },
-                deleteCollection(collection) {
-                    return serviceDeleteCollection({ tenant, collection });
-                },
-                putCollectionIndex(collection) {
-                    return servicePutCollectionIndex({ tenant, collection });
-                },
-                upsertPoints(collection, body) {
-                    return serviceUpsertPoints({ tenant, collection }, body);
-                },
-                searchPoints(collection, body) {
-                    return serviceSearchPoints({ tenant, collection }, body);
-                },
-                deletePoints(collection, body) {
-                    return serviceDeletePoints({ tenant, collection }, body);
-                },
-            };
-        },
-    };
-    return client;
-}

package/dist/services/QdrantService.d.ts

@@ -1,54 +0,0 @@
-import { type DistanceKind } from "../types.js";
-export interface QdrantServiceErrorPayload {
-    status: "error";
-    error: unknown;
-}
-export declare class QdrantServiceError extends Error {
-    readonly statusCode: number;
-    readonly payload: QdrantServiceErrorPayload;
-    constructor(statusCode: number, payload: QdrantServiceErrorPayload, message?: string);
-}
-interface CollectionContextInput {
-    tenant: string | undefined;
-    collection: string;
-}
-export declare function putCollectionIndex(ctx: CollectionContextInput): Promise<{
-    acknowledged: boolean;
-}>;
-export declare function createCollection(ctx: CollectionContextInput, body: unknown): Promise<{
-    name: string;
-    tenant: string;
-}>;
-export declare function getCollection(ctx: CollectionContextInput): Promise<{
-    name: string;
-    vectors: {
-        size: number;
-        distance: DistanceKind;
-        data_type: string;
-    };
-}>;
-export declare function deleteCollection(ctx: CollectionContextInput): Promise<{
-    acknowledged: boolean;
-}>;
-type PointsContextInput = CollectionContextInput;
-export declare function upsertPoints(ctx: PointsContextInput, body: unknown): Promise<{
-    upserted: number;
-}>;
-export declare function searchPoints(ctx: PointsContextInput, body: unknown): Promise<{
-    points: Array<{
-        id: string;
-        score: number;
-        payload?: Record<string, unknown>;
-    }>;
-}>;
-export declare function queryPoints(ctx: PointsContextInput, body: unknown): Promise<{
-    points: Array<{
-        id: string;
-        score: number;
-        payload?: Record<string, unknown>;
-    }>;
-}>;
-export declare function deletePoints(ctx: PointsContextInput, body: unknown): Promise<{
-    deleted: number;
-}>;
-export {};

package/dist/services/QdrantService.js

@@ -1,313 +0,0 @@
-import { sanitizeCollectionName, sanitizeTenantId, metaKeyFor, tableNameFor, } from "../utils/tenant.js";
-import { CreateCollectionReq, DeletePointsReq, SearchReq, UpsertPointsReq, } from "../types.js";
-import { ensureMetaTable } from "../ydb/schema.js";
-import { createCollection as repoCreateCollection, deleteCollection as repoDeleteCollection, 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";
-export class QdrantServiceError extends Error {
-    statusCode;
-    payload;
-    constructor(statusCode, payload, message) {
-        super(message ?? String(payload.error));
-        this.statusCode = statusCode;
-        this.payload = payload;
-    }
-}
-function normalizeCollectionContext(input) {
-    const tenant = sanitizeTenantId(input.tenant);
-    const collection = sanitizeCollectionName(input.collection);
-    const metaKey = metaKeyFor(tenant, collection);
-    return { tenant, collection, metaKey };
-}
-export async function putCollectionIndex(ctx) {
-    await ensureMetaTable();
-    const normalized = normalizeCollectionContext(ctx);
-    const meta = await getCollectionMeta(normalized.metaKey);
-    if (!meta) {
-        throw new QdrantServiceError(404, {
-            status: "error",
-            error: "collection not found",
-        });
-    }
-    return { acknowledged: true };
-}
-export async function createCollection(ctx, body) {
-    await ensureMetaTable();
-    const normalized = normalizeCollectionContext(ctx);
-    const parsed = CreateCollectionReq.safeParse(body);
-    if (!parsed.success) {
-        throw new QdrantServiceError(400, {
-            status: "error",
-            error: parsed.error.flatten(),
-        });
-    }
-    const dim = parsed.data.vectors.size;
-    const distance = parsed.data.vectors.distance;
-    const vectorType = parsed.data.vectors.data_type ?? "float";
-    const existing = await getCollectionMeta(normalized.metaKey);
-    if (existing) {
-        if (existing.dimension === dim &&
-            existing.distance === distance &&
-            existing.vectorType === vectorType) {
-            return { name: normalized.collection, tenant: normalized.tenant };
-        }
-        const errorMessage = `Collection already exists with different config: dimension=${existing.dimension}, distance=${existing.distance}, type=${existing.vectorType}`;
-        throw new QdrantServiceError(400, {
-            status: "error",
-            error: errorMessage,
-        });
-    }
-    const tableName = tableNameFor(normalized.tenant, normalized.collection);
-    await repoCreateCollection(normalized.metaKey, dim, distance, vectorType, tableName);
-    return { name: normalized.collection, tenant: normalized.tenant };
-}
-export async function getCollection(ctx) {
-    await ensureMetaTable();
-    const normalized = normalizeCollectionContext(ctx);
-    const meta = await getCollectionMeta(normalized.metaKey);
-    if (!meta) {
-        throw new QdrantServiceError(404, {
-            status: "error",
-            error: "collection not found",
-        });
-    }
-    return {
-        name: normalized.collection,
-        vectors: {
-            size: meta.dimension,
-            distance: meta.distance,
-            data_type: meta.vectorType,
-        },
-    };
-}
-export async function deleteCollection(ctx) {
-    await ensureMetaTable();
-    const normalized = normalizeCollectionContext(ctx);
-    await repoDeleteCollection(normalized.metaKey);
-    return { acknowledged: true };
-}
-let loggedIndexBuildDisabled = false;
-function isNumberArray(value) {
-    return Array.isArray(value) && value.every((x) => typeof x === "number");
-}
-function extractVectorLoose(body, depth = 0) {
-    if (!body || typeof body !== "object" || depth > 3) {
-        return undefined;
-    }
-    const obj = body;
-    if (isNumberArray(obj.vector))
-        return obj.vector;
-    if (isNumberArray(obj.embedding))
-        return obj.embedding;
-    const query = obj.query;
-    if (query) {
-        const queryVector = query["vector"];
-        if (isNumberArray(queryVector))
-            return queryVector;
-        const nearest = query["nearest"];
-        if (nearest && isNumberArray(nearest.vector)) {
-            return nearest.vector;
-        }
-    }
-    const nearest = obj.nearest;
-    if (nearest && isNumberArray(nearest.vector)) {
-        return nearest.vector;
-    }
-    for (const key of Object.keys(obj)) {
-        const value = obj[key];
-        if (isNumberArray(value)) {
-            return value;
-        }
-    }
-    for (const key of Object.keys(obj)) {
-        const value = obj[key];
-        if (value && typeof value === "object") {
-            const found = extractVectorLoose(value, depth + 1);
-            if (found) {
-                return found;
-            }
-        }
-    }
-    return undefined;
-}
-function normalizeSearchBodyForSearch(body) {
-    if (!body || typeof body !== "object") {
-        return {
-            vector: undefined,
-            top: undefined,
-            withPayload: undefined,
-            scoreThreshold: undefined,
-        };
-    }
-    const b = body;
-    const rawVector = b["vector"];
-    const vector = isNumberArray(rawVector) ? rawVector : undefined;
-    const rawTop = b["top"];
-    const rawLimit = b["limit"];
-    const topFromTop = typeof rawTop === "number" ? rawTop : undefined;
-    const topFromLimit = typeof rawLimit === "number" ? rawLimit : undefined;
-    const top = topFromTop ?? topFromLimit;
-    let withPayload;
-    const rawWithPayload = b["with_payload"];
-    if (typeof rawWithPayload === "boolean") {
-        withPayload = rawWithPayload;
-    }
-    else if (Array.isArray(rawWithPayload) ||
-        typeof rawWithPayload === "object") {
-        withPayload = true;
-    }
-    const thresholdRaw = b["score_threshold"];
-    const thresholdValue = typeof thresholdRaw === "number" ? thresholdRaw : Number(thresholdRaw);
-    const scoreThreshold = Number.isFinite(thresholdValue)
-        ? thresholdValue
-        : undefined;
-    return { vector, top, withPayload, scoreThreshold };
-}
-function normalizeSearchBodyForQuery(body) {
-    if (!body || typeof body !== "object") {
-        return {
-            vector: undefined,
-            top: undefined,
-            withPayload: undefined,
-            scoreThreshold: undefined,
-        };
-    }
-    const b = body;
-    const vector = extractVectorLoose(b);
-    const rawTop = b["top"];
-    const rawLimit = b["limit"];
-    const topFromTop = typeof rawTop === "number" ? rawTop : undefined;
-    const topFromLimit = typeof rawLimit === "number" ? rawLimit : undefined;
-    const top = topFromTop ?? topFromLimit;
-    let withPayload;
-    const rawWithPayload = b["with_payload"];
-    if (typeof rawWithPayload === "boolean") {
-        withPayload = rawWithPayload;
-    }
-    else if (Array.isArray(rawWithPayload) ||
-        typeof rawWithPayload === "object") {
-        withPayload = true;
-    }
-    const thresholdRaw = b["score_threshold"];
-    const thresholdValue = typeof thresholdRaw === "number" ? thresholdRaw : Number(thresholdRaw);
-    const scoreThreshold = Number.isFinite(thresholdValue)
-        ? thresholdValue
-        : undefined;
-    return { vector, top, withPayload, scoreThreshold };
-}
-export async function upsertPoints(ctx, body) {
-    await ensureMetaTable();
-    const normalized = normalizeCollectionContext(ctx);
-    const meta = await getCollectionMeta(normalized.metaKey);
-    if (!meta) {
-        throw new QdrantServiceError(404, {
-            status: "error",
-            error: "collection not found",
-        });
-    }
-    const parsed = UpsertPointsReq.safeParse(body);
-    if (!parsed.success) {
-        throw new QdrantServiceError(400, {
-            status: "error",
-            error: parsed.error.flatten(),
-        });
-    }
-    const upserted = await repoUpsertPoints(meta.table, parsed.data.points, meta.vectorType, meta.dimension);
-    if (VECTOR_INDEX_BUILD_ENABLED) {
-        requestIndexBuild(meta.table, meta.dimension, meta.distance, meta.vectorType);
-    }
-    else if (!loggedIndexBuildDisabled) {
-        logger.info({ table: meta.table }, "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);
-    logger.info({ tenant: normalized.tenant, collection: normalized.collection }, `${source}: resolve collection meta`);
-    const meta = await getCollectionMeta(normalized.metaKey);
-    if (!meta) {
-        logger.warn({
-            tenant: normalized.tenant,
-            collection: normalized.collection,
-            metaKey: normalized.metaKey,
-        }, `${source}: collection not found`);
-        throw new QdrantServiceError(404, {
-            status: "error",
-            error: "collection not found",
-        });
-    }
-    const parsed = SearchReq.safeParse({
-        vector: normalizedSearch.vector,
-        top: normalizedSearch.top,
-        with_payload: normalizedSearch.withPayload,
-    });
-    if (!parsed.success) {
-        logger.warn({
-            tenant: normalized.tenant,
-            collection: normalized.collection,
-            issues: parsed.error.issues,
-        }, `${source}: invalid payload`);
-        throw new QdrantServiceError(400, {
-            status: "error",
-            error: parsed.error.flatten(),
-        });
-    }
-    logger.info({
-        tenant: normalized.tenant,
-        collection: normalized.collection,
-        top: parsed.data.top,
-        queryVectorLen: parsed.data.vector.length,
-        collectionDim: meta.dimension,
-        distance: meta.distance,
-        vectorType: meta.vectorType,
-    }, `${source}: executing`);
-    const hits = await repoSearchPoints(meta.table, parsed.data.vector, parsed.data.top, parsed.data.with_payload, meta.distance, meta.vectorType, meta.dimension);
-    const threshold = normalizedSearch.scoreThreshold;
-    const filtered = threshold === undefined
-        ? hits
-        : hits.filter((hit) => {
-            const isSimilarity = meta.distance === "Cosine" || meta.distance === "Dot";
-            if (isSimilarity) {
-                return hit.score >= threshold;
-            }
-            return hit.score <= threshold;
-        });
-    logger.info({
-        tenant: normalized.tenant,
-        collection: normalized.collection,
-        hits: hits.length,
-    }, `${source}: completed`);
-    return { points: filtered };
-}
-export async function searchPoints(ctx, body) {
-    const normalizedSearch = normalizeSearchBodyForSearch(body);
-    return await executeSearch(ctx, normalizedSearch, "search");
-}
-export async function queryPoints(ctx, body) {
-    const normalizedSearch = normalizeSearchBodyForQuery(body);
-    return await executeSearch(ctx, normalizedSearch, "query");
-}
-export async function deletePoints(ctx, body) {
-    await ensureMetaTable();
-    const normalized = normalizeCollectionContext(ctx);
-    const meta = await getCollectionMeta(normalized.metaKey);
-    if (!meta) {
-        throw new QdrantServiceError(404, {
-            status: "error",
-            error: "collection not found",
-        });
-    }
-    const parsed = DeletePointsReq.safeParse(body);
-    if (!parsed.success) {
-        throw new QdrantServiceError(400, {
-            status: "error",
-            error: parsed.error.flatten(),
-        });
-    }
-    const deleted = await repoDeletePoints(meta.table, parsed.data.points);
-    return { deleted };
-}