@mcampa/ai-context-core 0.0.2 → 0.1.0-beta.ff0e631

package/dist/vectordb/qdrant-vectordb.js

@@ -0,0 +1,856 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QdrantVectorDatabase = void 0;
+const fs = __importStar(require("node:fs/promises"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const js_client_grpc_1 = require("@qdrant/js-client-grpc");
+const base_vector_database_1 = require("./base/base-vector-database");
+const simple_bm25_1 = require("./sparse/simple-bm25");
+/**
+ * Qdrant Vector Database implementation using gRPC client
+ *
+ * Features:
+ * - Named vectors (dense + sparse)
+ * - Hybrid search with RRF fusion
+ * - BM25 sparse vector generation
+ * - Self-hosted and cloud support
+ *
+ * Architecture:
+ * - Dense vectors: From embedding providers (OpenAI, VoyageAI, etc.)
+ * - Sparse vectors: Generated using SimpleBM25 for keyword matching
+ * - Hybrid search: Combines both using Qdrant's prefetch + RRF
+ */
+class QdrantVectorDatabase extends base_vector_database_1.BaseVectorDatabase {
+    constructor(config) {
+        super(config);
+        this.client = null;
+        // Named vector configurations
+        this.DENSE_VECTOR_NAME = "dense";
+        this.SPARSE_VECTOR_NAME = "sparse";
+        this.bm25Generator = new simple_bm25_1.SimpleBM25(config.bm25Config);
+    }
+    /**
+     * Initialize Qdrant client connection
+     */
+    async initialize() {
+        const resolvedAddress = await this.resolveAddress();
+        await this.initializeClient(resolvedAddress);
+    }
+    /**
+     * Create Qdrant client instance
+     */
+    async initializeClient(address) {
+        console.log("[QdrantDB] 🔌 Connecting to Qdrant at:", address);
+        // Parse address to extract host and port
+        const url = new URL(address.startsWith("http") ? address : `http://${address}`);
+        const host = url.hostname;
+        const port = url.port ? Number.parseInt(url.port) : 6334;
+        this.client = new js_client_grpc_1.QdrantClient({
+            host,
+            port,
+            apiKey: this.config.apiKey,
+            timeout: this.config.timeout || 10000,
+        });
+        // Suppress MaxListenersExceededWarning for gRPC connections
+        // Multiple operations on the same collection trigger multiple listeners
+        // This is normal for gRPC HTTP/2 multiplexing and not a memory leak
+        if (this.client &&
+            typeof this.client.setMaxListeners === "function") {
+            this.client.setMaxListeners(50);
+        }
+        console.log("[QdrantDB] ✅ Connected to Qdrant successfully");
+    }
+    /**
+     * Resolve address from config
+     * Unlike Milvus, Qdrant doesn't have auto-provisioning
+     */
+    async resolveAddress() {
+        if (!this.config.address) {
+            throw new Error("Qdrant address is required. Set QDRANT_URL environment variable.");
+        }
+        return this.config.address;
+    }
+    /**
+     * Override to add client null check
+     */
+    async ensureInitialized() {
+        await super.ensureInitialized();
+        if (!this.client) {
+            throw new Error("QdrantClient is not initialized");
+        }
+    }
+    /**
+     * Qdrant doesn't require explicit collection loading
+     * Collections are loaded on-demand automatically
+     */
+    async ensureLoaded(_collectionName) {
+        // No-op for Qdrant - collections are loaded automatically
+        return Promise.resolve();
+    }
+    /**
+     * Create collection with dense vectors only
+     */
+    async createCollection(collectionName, dimension, _description) {
+        await this.ensureInitialized();
+        console.log("[QdrantDB] 🔧 Creating collection:", collectionName);
+        console.log("[QdrantDB] 📏 Vector dimension:", dimension);
+        await this.client.api("collections").create({
+            collectionName,
+            vectorsConfig: {
+                config: {
+                    case: "paramsMap",
+                    value: {
+                        map: {
+                            [this.DENSE_VECTOR_NAME]: {
+                                size: BigInt(dimension),
+                                distance: 1, // Cosine = 1
+                            },
+                        },
+                    },
+                },
+            },
+        });
+        console.log("[QdrantDB] ✅ Collection created successfully");
+    }
+    /**
+     * Create collection with hybrid search support (dense + sparse vectors)
+     */
+    async createHybridCollection(collectionName, dimension, _description) {
+        await this.ensureInitialized();
+        console.log("[QdrantDB] 🔧 Creating hybrid collection:", collectionName);
+        console.log("[QdrantDB] 📏 Dense vector dimension:", dimension);
+        await this.client.api("collections").create({
+            collectionName,
+            vectorsConfig: {
+                config: {
+                    case: "paramsMap",
+                    value: {
+                        map: {
+                            [this.DENSE_VECTOR_NAME]: {
+                                size: BigInt(dimension),
+                                distance: 1, // Cosine = 1
+                            },
+                        },
+                    },
+                },
+            },
+            sparseVectorsConfig: {
+                map: {
+                    [this.SPARSE_VECTOR_NAME]: {
+                        modifier: js_client_grpc_1.Modifier.Idf,
+                    },
+                },
+            },
+        });
+        console.log("[QdrantDB] ✅ Hybrid collection created successfully");
+    }
+    /**
+     * Drop collection
+     */
+    async dropCollection(collectionName) {
+        await this.ensureInitialized();
+        console.log("[QdrantDB] 🗑️  Dropping collection:", collectionName);
+        await this.client.api("collections").delete({
+            collectionName,
+        });
+        console.log("[QdrantDB] ✅ Collection dropped successfully");
+    }
+    /**
+     * Check if collection exists
+     */
+    async hasCollection(collectionName) {
+        await this.ensureInitialized();
+        try {
+            const response = await this.client.api("collections").get({
+                collectionName,
+            });
+            return response.result !== undefined;
+        }
+        catch (error) {
+            // Handle gRPC NOT_FOUND error (code 5) or check error messages
+            if (error.code === 5 || // gRPC NOT_FOUND status code
+                error.rawMessage?.includes("not found") ||
+                error.rawMessage?.includes("does not exist") ||
+                error.message?.includes("not found") ||
+                error.message?.includes("does not exist")) {
+                return false;
+            }
+            throw error;
+        }
+    }
+    /**
+     * List all collections
+     */
+    async listCollections() {
+        await this.ensureInitialized();
+        const response = await this.client.api("collections").list({});
+        return response.collections.map((c) => c.name);
+    }
+    /**
+     * Insert documents with dense vectors only
+     */
+    async insert(collectionName, documents) {
+        await this.ensureInitialized();
+        await this.ensureLoaded(collectionName);
+        console.log("[QdrantDB] 📝 Inserting", documents.length, "documents into:", collectionName);
+        const points = documents.map((doc) => ({
+            id: {
+                pointIdOptions: {
+                    case: "num",
+                    value: this.convertToNumericId(doc.id),
+                },
+            },
+            vectors: {
+                vectorsOptions: {
+                    case: "vectors",
+                    value: {
+                        vectors: {
+                            [this.DENSE_VECTOR_NAME]: {
+                                vector: {
+                                    case: "dense",
+                                    value: {
+                                        data: doc.vector,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            payload: {
+                content: { kind: { case: "stringValue", value: doc.content } },
+                relativePath: {
+                    kind: { case: "stringValue", value: doc.relativePath },
+                },
+                startLine: {
+                    kind: { case: "integerValue", value: BigInt(doc.startLine) },
+                },
+                endLine: {
+                    kind: { case: "integerValue", value: BigInt(doc.endLine) },
+                },
+                fileExtension: {
+                    kind: { case: "stringValue", value: doc.fileExtension },
+                },
+                metadata: {
+                    kind: {
+                        case: "stringValue",
+                        value: JSON.stringify(doc.metadata),
+                    },
+                },
+            },
+        }));
+        await this.client.api("points").upsert({
+            collectionName,
+            wait: true,
+            points,
+        });
+        console.log("[QdrantDB] ✅ Documents inserted successfully");
+    }
+    /**
+     * Insert documents with hybrid vectors (dense + sparse)
+     */
+    async insertHybrid(collectionName, documents) {
+        await this.ensureInitialized();
+        await this.ensureLoaded(collectionName);
+        console.log("[QdrantDB] 📝 Inserting", documents.length, "hybrid documents into:", collectionName);
+        // Ensure BM25 is trained before insertion
+        if (!this.bm25Generator.isTrained()) {
+            // The BM25 model must be trained on the full corpus before insertion for accurate sparse vectors.
+            // Training on a single batch leads to incorrect IDF scores and poor search quality.
+            throw new Error("BM25 generator is not trained. The caller must explicitly train it via `getBM25Generator().learn(corpus)` before calling `insertHybrid`.");
+        }
+        // Generate sparse vectors for all documents
+        const sparseVectors = documents.map((doc) => this.bm25Generator.generate(doc.content));
+        const points = documents.map((doc, index) => ({
+            id: {
+                pointIdOptions: {
+                    case: "num",
+                    value: this.convertToNumericId(doc.id),
+                },
+            },
+            vectors: {
+                vectorsOptions: {
+                    case: "vectors",
+                    value: {
+                        vectors: {
+                            [this.DENSE_VECTOR_NAME]: {
+                                vector: {
+                                    case: "dense",
+                                    value: {
+                                        data: doc.vector,
+                                    },
+                                },
+                            },
+                            [this.SPARSE_VECTOR_NAME]: {
+                                vector: {
+                                    case: "sparse",
+                                    value: {
+                                        indices: sparseVectors[index].indices,
+                                        values: sparseVectors[index].values,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                },
+            },
+            payload: {
+                content: { kind: { case: "stringValue", value: doc.content } },
+                relativePath: {
+                    kind: { case: "stringValue", value: doc.relativePath },
+                },
+                startLine: {
+                    kind: { case: "integerValue", value: BigInt(doc.startLine) },
+                },
+                endLine: {
+                    kind: { case: "integerValue", value: BigInt(doc.endLine) },
+                },
+                fileExtension: {
+                    kind: { case: "stringValue", value: doc.fileExtension },
+                },
+                metadata: {
+                    kind: {
+                        case: "stringValue",
+                        value: JSON.stringify(doc.metadata),
+                    },
+                },
+            },
+        }));
+        await this.client.api("points").upsert({
+            collectionName,
+            wait: true,
+            points,
+        });
+        console.log("[QdrantDB] ✅ Hybrid documents inserted successfully");
+    }
+    /**
+     * Search with dense vectors only
+     */
+    async search(collectionName, queryVector, options) {
+        await this.ensureInitialized();
+        await this.ensureLoaded(collectionName);
+        console.log("[QdrantDB] 🔍 Searching in collection:", collectionName);
+        const searchParams = {
+            collectionName,
+            vector: queryVector,
+            vectorName: this.DENSE_VECTOR_NAME,
+            limit: BigInt(options?.topK || 10),
+            // For gRPC API, omitting withPayload returns all payload fields
+            // Using withPayload causes "No PayloadSelector" error
+        };
+        // Apply filter if provided
+        if (options?.filterExpr && options.filterExpr.trim().length > 0) {
+            searchParams.filter = this.parseFilterExpression(options.filterExpr);
+        }
+        const results = await this.client.api("points").search(searchParams);
+        return results.result.map((result) => ({
+            document: {
+                id: result.id?.str || result.id?.num?.toString() || "",
+                vector: queryVector,
+                content: result.payload?.content?.stringValue || "",
+                relativePath: result.payload?.relativePath?.stringValue || "",
+                startLine: Number(result.payload?.startLine?.integerValue || 0),
+                endLine: Number(result.payload?.endLine?.integerValue || 0),
+                fileExtension: result.payload?.fileExtension?.stringValue || "",
+                metadata: JSON.parse(result.payload?.metadata?.stringValue || "{}"),
+            },
+            score: result.score,
+        }));
+    }
+    /**
+     * Hybrid search with dense + sparse vectors using RRF fusion
+     */
+    async hybridSearch(collectionName, searchRequests, options) {
+        await this.ensureInitialized();
+        await this.ensureLoaded(collectionName);
+        console.log("[QdrantDB] 🔍 Performing hybrid search in collection:", collectionName);
+        // Extract dense vector and query text from search requests by inspecting data types
+        const denseQueryReq = searchRequests.find((req) => Array.isArray(req.data));
+        const textQueryReq = searchRequests.find((req) => typeof req.data === "string");
+        if (!denseQueryReq || !textQueryReq) {
+            throw new Error("Hybrid search requires one dense vector request (number[] data) and one text request (string data).");
+        }
+        const denseQuery = denseQueryReq.data;
+        const textQuery = textQueryReq.data;
+        // Generate sparse vector using BM25
+        if (!this.bm25Generator.isTrained()) {
+            console.warn("[QdrantDB] ⚠️  BM25 generator not trained. Hybrid search may have reduced quality.");
+        }
+        const sparseQuery = this.bm25Generator.isTrained()
+            ? this.bm25Generator.generate(textQuery)
+            : { indices: [], values: [] };
+        console.log("[QdrantDB] 🔍 Dense query vector length:", denseQuery.length);
+        console.log("[QdrantDB] 🔍 Sparse query terms:", sparseQuery.indices.length);
+        console.log("[QdrantDB] 🔍 Sparse query indices:", sparseQuery.indices.slice(0, 5));
+        console.log("[QdrantDB] 🔍 Sparse query values:", sparseQuery.values.slice(0, 5));
+        // Validate sparse query has valid data
+        if (sparseQuery.indices.length === 0 ||
+            sparseQuery.values.length === 0 ||
+            sparseQuery.indices.length !== sparseQuery.values.length) {
+            console.warn("[QdrantDB] ⚠️  Invalid or empty sparse query. Falling back to dense-only search.");
+            console.warn(`[QdrantDB] ⚠️  indices.length=${sparseQuery.indices.length}, values.length=${sparseQuery.values.length}`);
+            return await this.search(collectionName, denseQuery, {
+                topK: options?.limit || 10,
+                filterExpr: options?.filterExpr,
+            });
+        }
+        // Validate all values are positive (Qdrant requirement for sparse vectors)
+        const hasNegativeValues = sparseQuery.values.some((v) => v <= 0);
+        if (hasNegativeValues) {
+            console.error("[QdrantDB] ❌ Sparse query contains non-positive values! This should not happen.");
+            console.error("[QdrantDB] ❌ Falling back to dense-only search.");
+            return await this.search(collectionName, denseQuery, {
+                topK: options?.limit || 10,
+                filterExpr: options?.filterExpr,
+            });
+        }
+        console.log("[QdrantDB] ✅ Sparse query validated, proceeding with hybrid search");
+        // Qdrant query API with nested prefetch for hybrid search
+        // Using RRF (Reciprocal Rank Fusion) to combine sparse and dense results
+        // Structure: prefetch contains one item with nested prefetch for dense/sparse, then fusion
+        //
+        // Note: Using plain objects that match the protobuf structure defined in:
+        // @qdrant/js-client-grpc/dist/types/proto/points_pb.d.ts
+        //
+        // QueryPoints structure:
+        //   - collectionName: string
+        //   - prefetch: PrefetchQuery[]
+        //   - limit: bigint
+        //
+        // PrefetchQuery structure:
+        //   - prefetch?: PrefetchQuery[]  (nested prefetches)
+        //   - query?: Query               (query to apply)
+        //   - using?: string              (vector name)
+        //   - limit?: bigint
+        //
+        // Query structure (oneof variant):
+        //   - variant: { case: 'nearest', value: VectorInput } | { case: 'fusion', value: Fusion } | ...
+        //
+        // VectorInput structure (oneof variant):
+        //   - variant: { case: 'dense', value: DenseVector } | { case: 'sparse', value: SparseVector } | ...
+        //
+        // DenseVector: { data: number[] }
+        // SparseVector: { indices: number[], values: number[] }
+        // Fusion enum: RRF = 0, DBSF = 1
+        const queryParams = {
+            collectionName,
+            prefetch: [
+                {
+                    // Dense vector prefetch
+                    query: {
+                        variant: {
+                            case: "nearest",
+                            value: {
+                                variant: {
+                                    case: "dense",
+                                    value: {
+                                        data: denseQuery,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    using: this.DENSE_VECTOR_NAME,
+                    limit: BigInt(denseQueryReq.limit || 25),
+                },
+                {
+                    // Sparse vector prefetch
+                    query: {
+                        variant: {
+                            case: "nearest",
+                            value: {
+                                variant: {
+                                    case: "sparse",
+                                    value: {
+                                        indices: sparseQuery.indices.map((i) => Number(i)),
+                                        values: sparseQuery.values,
+                                    },
+                                },
+                            },
+                        },
+                    },
+                    using: this.SPARSE_VECTOR_NAME,
+                    limit: BigInt(textQueryReq.limit || 25),
+                },
+            ],
+            // Fusion query to combine results from prefetches
+            query: {
+                variant: {
+                    case: "fusion",
+                    value: 0, // Fusion.RRF = 0
+                },
+            },
+            limit: BigInt(options?.limit || 10),
+            withPayload: {
+                selectorOptions: {
+                    case: "enable",
+                    value: true,
+                },
+            },
+        };
+        // Apply filter if provided
+        if (options?.filterExpr && options.filterExpr.trim().length > 0) {
+            queryParams.filter = this.parseFilterExpression(options.filterExpr);
+        }
+        const results = await this.client.api("points").query(queryParams);
+        console.log("[QdrantDB] ✅ Found", results.result.length, "results from hybrid search");
+        return results.result.map((result) => ({
+            document: {
+                id: result.id?.str || result.id?.num?.toString() || "",
+                content: result.payload?.content?.kind?.value || "",
+                vector: [],
+                relativePath: result.payload?.relativePath?.kind?.value || "",
+                startLine: Number(result.payload?.startLine?.kind?.value || 0),
+                endLine: Number(result.payload?.endLine?.kind?.value || 0),
+                fileExtension: result.payload?.fileExtension?.kind?.value || "",
+                metadata: JSON.parse(result.payload?.metadata?.kind?.value || "{}"),
+            },
+            score: result.score,
+        }));
+    }
+    /**
+     * Delete documents by IDs
+     */
+    async delete(collectionName, ids) {
+        await this.ensureInitialized();
+        await this.ensureLoaded(collectionName);
+        console.log("[QdrantDB] 🗑️  Deleting", ids.length, "documents from:", collectionName);
+        await this.client.api("points").delete({
+            collectionName,
+            wait: true,
+            points: {
+                pointsSelectorOneOf: {
+                    case: "points",
+                    value: {
+                        ids: ids.map((id) => ({
+                            pointIdOptions: {
+                                case: "num",
+                                value: this.convertToNumericId(id),
+                            },
+                        })),
+                    },
+                },
+            },
+        });
+        console.log("[QdrantDB] ✅ Documents deleted successfully");
+    }
+    /**
+     * Query documents with filter conditions
+     */
+    async query(collectionName, filter, outputFields, limit) {
+        await this.ensureInitialized();
+        await this.ensureLoaded(collectionName);
+        console.log("[QdrantDB] 📋 Querying collection:", collectionName);
+        // Build scroll parameters
+        // For gRPC API, omitting withPayload returns all payload fields
+        // Using withPayload: true causes "No PayloadSelector" error
+        const scrollParams = {
+            collectionName,
+            limit: limit || 100,
+            withVector: false,
+        };
+        // Parse filter expression if provided
+        if (filter && filter.trim().length > 0) {
+            scrollParams.filter = this.parseFilterExpression(filter);
+        }
+        const results = await this.client.api("points").scroll(scrollParams);
+        // Dynamically map results based on requested outputFields
+        return results.result.map((point) => {
+            // Extract ID from protobuf structure
+            // In gRPC API, id can be: {pointIdOptions: {case: 'num', value: bigint}} or {case: 'str', value: string}
+            let idValue = "";
+            if (point.id?.pointIdOptions?.case === "num") {
+                idValue = point.id.pointIdOptions.value.toString();
+            }
+            else if (point.id?.pointIdOptions?.case === "str") {
+                idValue = point.id.pointIdOptions.value;
+            }
+            else if (point.id?.num !== undefined) {
+                // Fallback for backward compatibility
+                idValue = point.id.num.toString();
+            }
+            else if (point.id?.str !== undefined) {
+                idValue = point.id.str;
+            }
+            const result = {
+                id: idValue,
+            };
+            // If no specific fields requested, return all known fields
+            if (outputFields.length === 0) {
+                // In gRPC client, payload values are wrapped in {kind: {case: 'stringValue', value: '...'}}
+                result.content =
+                    point.payload?.content?.kind?.value ||
+                        point.payload?.content?.stringValue;
+                result.relativePath =
+                    point.payload?.relativePath?.kind?.value ||
+                        point.payload?.relativePath?.stringValue;
+                result.startLine = Number(point.payload?.startLine?.kind?.value ||
+                    point.payload?.startLine?.integerValue ||
+                    0);
+                result.endLine = Number(point.payload?.endLine?.kind?.value ||
+                    point.payload?.endLine?.integerValue ||
+                    0);
+                result.fileExtension =
+                    point.payload?.fileExtension?.kind?.value ||
+                        point.payload?.fileExtension?.stringValue;
+                const metadataStr = point.payload?.metadata?.kind?.value ||
+                    point.payload?.metadata?.stringValue;
+                result.metadata = JSON.parse(metadataStr || "{}");
+            }
+            else {
+                // Only include requested fields
+                for (const field of outputFields) {
+                    if (point.payload?.[field]) {
+                        const value = point.payload[field];
+                        // Handle different value types based on protobuf structure
+                        // In gRPC client, value is wrapped in {kind: {case: 'stringValue', value: '...'}}
+                        if (value.kind?.case === "stringValue") {
+                            result[field] =
+                                field === "metadata"
+                                    ? JSON.parse(value.kind.value || "{}")
+                                    : value.kind.value;
+                        }
+                        else if (value.kind?.case === "integerValue") {
+                            result[field] = Number(value.kind.value);
+                        }
+                        else if (value.kind?.case === "doubleValue") {
+                            result[field] = value.kind.value;
+                        }
+                        else if (value.kind?.case === "boolValue") {
+                            result[field] = value.kind.value;
+                        }
+                        // Fallback for direct value access (backward compatibility)
+                        else if (value.stringValue !== undefined) {
+                            result[field] =
+                                field === "metadata"
+                                    ? JSON.parse(value.stringValue || "{}")
+                                    : value.stringValue;
+                        }
+                        else if (value.integerValue !== undefined) {
+                            result[field] = Number(value.integerValue);
+                        }
+                        else if (value.doubleValue !== undefined) {
+                            result[field] = value.doubleValue;
+                        }
+                        else if (value.boolValue !== undefined) {
+                            result[field] = value.boolValue;
+                        }
+                    }
+                }
+            }
+            return result;
+        });
+    }
+    /**
+     * Check collection limit
+     * Qdrant doesn't have hard collection limits like Zilliz Cloud
+     */
+    async checkCollectionLimit() {
+        // Qdrant (self-hosted or cloud) doesn't have hard collection limits
+        return Promise.resolve(true);
+    }
+    /**
+     * Parse Milvus-style filter expression to Qdrant filter format
+     *
+     * Example:
+     * - "fileExtension == '.ts'" -> { must: [{ key: 'fileExtension', match: { value: '.ts' } }] }
+     * - "fileExtension in ['.ts', '.js']" -> { must: [{ key: 'fileExtension', match: { any: ['.ts', '.js'] } }] }
+     */
+    parseFilterExpression(expr) {
+        // Simple parser for common filter patterns
+        // Format: "field == 'value'" or "field in ['val1', 'val2']"
+        if (expr.includes(" in ")) {
+            // Handle "field in [...]" pattern
+            const match = expr.match(/(\w+)\s+in\s+\[(.*)\]/);
+            if (match) {
+                const field = match[1];
+                const values = match[2]
+                    .split(",")
+                    .map((v) => v.trim().replace(/['"]/g, ""));
+                // For "IN" operator, use a "must" clause with "any" match for better performance
+                return {
+                    must: [
+                        {
+                            conditionOneOf: {
+                                case: "field",
+                                value: {
+                                    key: field,
+                                    match: {
+                                        matchValue: {
+                                            case: "any",
+                                            value: {
+                                                values: values.map((value) => ({
+                                                    kind: { case: "stringValue", value },
+                                                })),
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                };
+            }
+        }
+        else if (expr.includes("==")) {
+            // Handle "field == value" pattern
+            const match = expr.match(/(\w+)\s*==\s*['"]?([^'"]+)['"]?/);
+            if (match) {
+                const field = match[1];
+                const value = match[2].trim();
+                return {
+                    must: [
+                        {
+                            conditionOneOf: {
+                                case: "field",
+                                value: {
+                                    key: field,
+                                    match: {
+                                        matchValue: {
+                                            case: "keyword",
+                                            value,
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    ],
+                };
+            }
+        }
+        // If parsing fails, return undefined (no filtering)
+        console.warn("[QdrantDB] ⚠️  Could not parse filter expression:", expr);
+        return undefined;
+    }
+    /**
+     * Convert chunk ID to numeric ID for Qdrant
+     * Extracts the hex hash from chunk_XXXXXXXXXXXXXXXX and converts to bigint
+     *
+     * Example: chunk_edf5558e3dbbf10b -> 17141645883789484811n
+     */
+    convertToNumericId(chunkId) {
+        // Extract hex portion from chunk_XXXXXXXXXXXXXXXX format
+        const hex = chunkId.replace("chunk_", "");
+        // Convert hex string to bigint (16 hex chars = 64 bits)
+        return BigInt(`0x${hex}`);
+    }
+    /**
+     * Get BM25 generator (for testing/debugging)
+     */
+    getBM25Generator() {
+        return this.bm25Generator;
+    }
+    /**
+     * Get BM25 model file path for a collection
+     */
+    getBM25ModelPath(collectionName) {
+        const homeDir = os.homedir();
+        const modelDir = path.join(homeDir, ".context", "bm25");
+        return path.join(modelDir, `${collectionName}.json`);
+    }
+    /**
+     * Save BM25 model to disk
+     */
+    async saveBM25Model(collectionName) {
+        if (!this.bm25Generator.isTrained()) {
+            console.log("[QdrantDB] ⚠️  BM25 model is not trained, skipping save");
+            return;
+        }
+        try {
+            const modelPath = this.getBM25ModelPath(collectionName);
+            const modelDir = path.dirname(modelPath);
+            // Ensure directory exists
+            await fs.mkdir(modelDir, { recursive: true });
+            // Serialize and save BM25 model
+            const modelJson = this.bm25Generator.toJSON();
+            await fs.writeFile(modelPath, modelJson, "utf-8");
+            console.log(`[QdrantDB] 💾 Saved BM25 model to: ${modelPath}`);
+        }
+        catch (error) {
+            console.error(`[QdrantDB] ❌ Failed to save BM25 model:`, error);
+            throw error;
+        }
+    }
+    /**
+     * Load BM25 model from disk
+     */
+    async loadBM25Model(collectionName) {
+        try {
+            const modelPath = this.getBM25ModelPath(collectionName);
+            // Check if model file exists
+            try {
+                await fs.access(modelPath);
+            }
+            catch {
+                console.log(`[QdrantDB] ℹ️  No saved BM25 model found at: ${modelPath}`);
+                return false;
+            }
+            // Load and deserialize BM25 model
+            const modelJson = await fs.readFile(modelPath, "utf-8");
+            this.bm25Generator = simple_bm25_1.SimpleBM25.fromJSON(modelJson);
+            console.log(`[QdrantDB] 📂 Loaded BM25 model from: ${modelPath}`);
+            return true;
+        }
+        catch (error) {
+            console.error(`[QdrantDB] ❌ Failed to load BM25 model:`, error);
+            return false;
+        }
+    }
+    /**
+     * Delete saved BM25 model
+     */
+    async deleteBM25Model(collectionName) {
+        try {
+            const modelPath = this.getBM25ModelPath(collectionName);
+            // Check if model file exists
+            try {
+                await fs.access(modelPath);
+            }
+            catch {
+                // File doesn't exist, nothing to delete
+                return;
+            }
+            await fs.unlink(modelPath);
+            console.log(`[QdrantDB] 🗑️  Deleted BM25 model at: ${modelPath}`);
+        }
+        catch (error) {
+            console.warn(`[QdrantDB] ⚠️  Failed to delete BM25 model:`, error);
+        }
+    }
+}
+exports.QdrantVectorDatabase = QdrantVectorDatabase;
+//# sourceMappingURL=qdrant-vectordb.js.map