@robthepcguy/rag-vault 1.7.2 → 1.9.0

package/dist/vectordb/index.js

@@ -1,6 +1,6 @@
 // VectorStore implementation with LanceDB integration
 import { createHash } from 'node:crypto';
-import { Index, connect } from '@lancedb/lancedb';
+import { connect, Index } from '@lancedb/lancedb';
 import { DatabaseError } from '../errors/index.js';
 // Re-export error class for backwards compatibility
 export { DatabaseError } from '../errors/index.js';
@@ -15,7 +15,9 @@ function parseEnvNumber(envVar, defaultValue) {
     if (!value)
         return defaultValue;
     const parsed = Number.parseFloat(value);
-    return Number.isNaN(parsed) ? defaultValue : parsed;
+    if (Number.isNaN(parsed) || !Number.isFinite(parsed))
+        return defaultValue;
+    return parsed;
 }
 /**
  * Parse an integer environment variable with fallback
@@ -25,7 +27,9 @@ function parseEnvInt(envVar, defaultValue) {
     if (!value)
         return defaultValue;
     const parsed = Number.parseInt(value, 10);
-    return Number.isNaN(parsed) ? defaultValue : parsed;
+    if (Number.isNaN(parsed) || !Number.isFinite(parsed))
+        return defaultValue;
+    return parsed;
 }
 /**
  * Standard deviation multiplier for detecting group boundaries.
@@ -39,6 +43,17 @@ const GROUPING_BOUNDARY_STD_MULTIPLIER = parseEnvNumber('RAG_GROUPING_STD_MULTIP
  * Configure via RAG_HYBRID_CANDIDATE_MULTIPLIER environment variable.
  */
 const HYBRID_SEARCH_CANDIDATE_MULTIPLIER = parseEnvInt('RAG_HYBRID_CANDIDATE_MULTIPLIER', 2);
+/**
+ * RRF smoothing constant (k). Higher values produce smoother rank fusion.
+ * Standard value is 60. Configure via RAG_RRF_K environment variable.
+ */
+const RRF_K = parseEnvInt('RAG_RRF_K', 60);
+const SEARCH_MODE = (() => {
+    const mode = process.env['RAG_SEARCH_MODE']?.toLowerCase().trim();
+    if (mode === 'rrf')
+        return 'rrf';
+    return 'boost'; // default: backward-compatible
+})();
 /** FTS index name (bump version when changing tokenizer settings) */
 const FTS_INDEX_NAME = 'fts_index_v2';
 /** Threshold for cleaning up old index versions (1 minute) */
@@ -81,6 +96,27 @@ const CUSTOM_METADATA_ALL_FIELDS = '__all__';
  * Rejects paths with SQL injection attempts or path traversal.
  */
 const SAFE_PATH_REGEX = /^[a-zA-Z0-9\\/_.:\- ]+$/;
+/**
+ * Retry a read-only async operation with exponential backoff.
+ * Used for transient disk/IO errors on VectorStore reads.
+ */
+async function withRetry(fn, label, maxAttempts = 3, baseDelayMs = 100) {
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < maxAttempts) {
+                const delayMs = baseDelayMs * 2 ** (attempt - 1);
+                console.warn(`${label}: attempt ${attempt}/${maxAttempts} failed (${lastError.message}), retrying in ${delayMs}ms...`);
+                await new Promise((resolve) => setTimeout(resolve, delayMs));
+            }
+        }
+    }
+    throw lastError;
+}
 /**
  * Validate file path to prevent SQL injection and path traversal attacks.
  * @param filePath - The file path to validate
@@ -121,7 +157,7 @@ function normalizeTextForFingerprint(text) {
  * Uses SHA-256 hash of normalized text (first 16 hex chars for compactness).
  * This enables stable chunk identification across re-indexing.
  */
-export function generateChunkFingerprint(text) {
+function generateChunkFingerprint(text) {
     const normalized = normalizeTextForFingerprint(text);
     const hash = createHash('sha256').update(normalized, 'utf8').digest('hex');
     // Use first 16 characters (64 bits) - sufficient for practical uniqueness
@@ -223,6 +259,7 @@ export class VectorStore {
     db = null;
     table = null;
     config;
+    rrfMaxDistanceWarned = false;
     ftsEnabled = false;
     ftsFailureCount = 0;
     ftsLastFailure = null;
@@ -507,6 +544,48 @@ export class VectorStore {
             // Ignorable errors (no matching records) are logged but not thrown
         }
     }
+    /**
+     * Delete chunks for a file, excluding a set of IDs.
+     * Used by insert-then-delete re-ingestion to remove old vectors
+     * while keeping newly inserted ones.
+     *
+     * @param filePath - File path whose old chunks should be removed
+     * @param excludeIds - Set of chunk IDs to keep (the new batch)
+     */
+    async deleteChunksExcluding(filePath, excludeIds) {
+        if (!this.table || excludeIds.size === 0) {
+            return;
+        }
+        if (!isValidFilePath(filePath)) {
+            throw new DatabaseError('Invalid file path: contains disallowed characters or patterns');
+        }
+        const escapedFilePath = filePath.replace(/'/g, "''");
+        try {
+            // Query existing chunks for this file to find old IDs
+            const existing = await this.table
+                .query()
+                .where(`\`filePath\` = '${escapedFilePath}'`)
+                .select(['id'])
+                .toArray();
+            const oldIds = existing.map((row) => row.id).filter((id) => !excludeIds.has(id));
+            if (oldIds.length === 0) {
+                return;
+            }
+            // Delete old chunks by ID
+            const idList = oldIds.map((id) => `'${id.replace(/'/g, "''")}'`).join(', ');
+            await this.table.delete(`\`id\` IN (${idList})`);
+            console.error(`VectorStore: Removed ${oldIds.length} old chunks for "${filePath}"`);
+            await this.rebuildFtsIndex();
+        }
+        catch (error) {
+            // Non-fatal: temporary duplicates are acceptable
+            const errorMessage = error.message.toLowerCase();
+            const isIgnorable = DELETE_IGNORABLE_PATTERNS.some((pattern) => errorMessage.includes(pattern));
+            if (!isIgnorable) {
+                throw new DatabaseError(`Failed to clean up old chunks for file: ${filePath}`, error);
+            }
+        }
+    }
     /**
      * Batch insert vector chunks
      *
@@ -669,18 +748,22 @@ export class VectorStore {
     }
     /**
      * Execute vector search with quality filtering
-     * Architecture: Semantic search → Filter (maxDistance, grouping) → Keyword boost
      *
-     * This "prefetch then rerank" approach ensures:
-     * - maxDistance and grouping work on meaningful vector distances
-     * - Keyword matching acts as a boost, not a replacement for semantic similarity
+     * Supports two search modes (configured via RAG_SEARCH_MODE):
+     * - 'rrf': Reciprocal Rank Fusion — vector and BM25 are independent voters,
+     *   results are fused by rank position. Recommended for most use cases.
+     * - 'boost': Legacy mode — BM25 multiplicatively boosts vector distances.
+     *
+     * Architecture (RRF mode): Vector search + FTS search → RRF fusion → Grouping → Limit
+     * Architecture (Boost mode): Vector search → Grouping → Keyword boost → Limit
      *
      * @param queryVector - Query vector (dimension depends on model)
-     * @param queryText - Optional query text for keyword boost (BM25)
+     * @param queryText - Optional query text for keyword matching (BM25)
      * @param limit - Number of results to retrieve (default 10)
+     * @param additionalVectors - Optional additional query vectors with weights (for HyDE)
      * @returns Array of search results (sorted by distance ascending, filtered by quality settings)
      */
-    async search(queryVector, queryText, limit = 10) {
+    async search(queryVector, queryText, limit = 10, additionalVectors) {
         if (!this.table) {
             console.error('VectorStore: Returning empty results as table does not exist');
             return [];
@@ -688,55 +771,153 @@ export class VectorStore {
         if (limit < 1 || limit > 20) {
             throw new DatabaseError(`Invalid limit: expected 1-20, got ${limit}`);
         }
-        try {
-            // Step 1: Semantic (vector) search - always the primary search
-            const candidateLimit = limit * HYBRID_SEARCH_CANDIDATE_MULTIPLIER;
-            // Assumes normalized embeddings so dot behaves like cosine distance (lower is better, [0,2]).
-            let query = this.table.vectorSearch(queryVector).distanceType('dot').limit(candidateLimit);
-            // Apply distance threshold at query level
-            if (this.config.maxDistance !== undefined) {
-                query = query.distanceRange(undefined, this.config.maxDistance);
-            }
-            const vectorResults = await query.toArray();
-            // Convert to SearchResult format with type validation
-            let results = vectorResults.map((result) => toSearchResult(result));
-            // Step 2: Apply grouping filter on vector distances (before keyword boost)
-            // Grouping is meaningful only on semantic distances, not after keyword boost
-            if (this.config.grouping && results.length > 1) {
-                results = this.applyGrouping(results, this.config.grouping);
-            }
-            // Step 3: Apply keyword boost if enabled (with circuit breaker)
-            const hybridWeight = this.getHybridWeight();
-            if (this.shouldAttemptFts() && queryText && queryText.trim().length > 0 && hybridWeight > 0) {
-                try {
-                    // Get unique filePaths from vector results to filter FTS search
-                    const uniqueFilePaths = [...new Set(results.map((r) => r.filePath))];
-                    // Build WHERE clause with IN for targeted FTS search
-                    // Use backticks for column name (required for camelCase in LanceDB)
-                    const escapedPaths = uniqueFilePaths.map((p) => `'${p.replace(/'/g, "''")}'`);
-                    const whereClause = `\`filePath\` IN (${escapedPaths.join(', ')})`;
-                    const ftsResults = await this.table
-                        .search(queryText, 'fts', 'text')
-                        .where(whereClause)
-                        .select(['filePath', 'chunkIndex', 'text', 'metadata', '_score'])
-                        .limit(results.length * 2) // Enough to cover all vector results
-                        .toArray();
-                    results = this.applyKeywordBoost(results, ftsResults, hybridWeight);
-                    // FTS succeeded - reset circuit breaker
-                    this.recordFtsSuccess();
+        const table = this.table;
+        return withRetry(async () => {
+            try {
+                const candidateLimit = limit * HYBRID_SEARCH_CANDIDATE_MULTIPLIER;
+                const hybridWeight = this.getHybridWeight();
+                const useRRF = (this.config.searchMode ?? SEARCH_MODE) === 'rrf';
+                if (useRRF && this.config.maxDistance !== undefined && !this.rrfMaxDistanceWarned) {
+                    this.rrfMaxDistanceWarned = true;
+                    console.error(`Warning: maxDistance (${this.config.maxDistance}) is set with RRF search mode. ` +
+                        'In RRF mode, scores are rank-based pseudo-distances, not vector distances. ' +
+                        'Your threshold may not behave as expected. Consider using top-k limiting instead, ' +
+                        'or set RAG_SEARCH_MODE=boost for distance-based filtering.');
                 }
-                catch (ftsError) {
-                    // Record failure for circuit breaker (will auto-recover after cooldown)
-                    this.recordFtsFailure(ftsError);
-                    // Continue with vector-only results
+                // Step 1: Primary vector search
+                let vectorQuery = table.vectorSearch(queryVector).distanceType('dot').limit(candidateLimit);
+                if (!useRRF && this.config.maxDistance !== undefined) {
+                    vectorQuery = vectorQuery.distanceRange(undefined, this.config.maxDistance);
                 }
+                const vectorRaw = await vectorQuery.toArray();
+                let results = vectorRaw.map((result) => toSearchResult(result));
+                if (useRRF) {
+                    // ===== RRF MODE =====
+                    // Collect all vector results into a single RRF candidate pool
+                    // Primary query has weight 1.0; additional vectors (HyDE) have their own weights
+                    const allVectorResults = [
+                        { results, weight: 1.0 },
+                    ];
+                    // Run additional vector searches (HyDE expansions) in parallel if provided
+                    if (additionalVectors && additionalVectors.length > 0) {
+                        const additionalSearches = additionalVectors.map(async ({ vector, weight }) => {
+                            const addlQuery = table.vectorSearch(vector).distanceType('dot').limit(candidateLimit);
+                            const addlRaw = await addlQuery.toArray();
+                            return {
+                                results: addlRaw.map((r) => toSearchResult(r)),
+                                weight,
+                            };
+                        });
+                        allVectorResults.push(...(await Promise.all(additionalSearches)));
+                    }
+                    // Build unified candidate map with RRF scoring across all vector queries
+                    const candidates = new Map();
+                    const k = this.config.rrfK ?? RRF_K;
+                    for (const { results: vecResults, weight: queryWeight } of allVectorResults) {
+                        const vectorWeight = queryWeight * (1 - hybridWeight);
+                        for (let rank = 0; rank < vecResults.length; rank++) {
+                            const r = vecResults[rank];
+                            if (!r)
+                                continue;
+                            const key = `${r.filePath}:${r.chunkIndex}`;
+                            const contribution = vectorWeight / (k + rank + 1);
+                            const existing = candidates.get(key);
+                            if (existing) {
+                                existing.rrfScore += contribution;
+                            }
+                            else {
+                                candidates.set(key, { result: r, rrfScore: contribution });
+                            }
+                        }
+                    }
+                    // FTS channel (BM25) — run independently, no pre-filtering by vector results
+                    if (this.shouldAttemptFts() &&
+                        queryText &&
+                        queryText.trim().length > 0 &&
+                        hybridWeight > 0) {
+                        try {
+                            const ftsResults = await table
+                                .search(queryText, 'fts', 'text')
+                                .select(['filePath', 'chunkIndex', 'text', 'metadata', '_score'])
+                                .limit(candidateLimit)
+                                .toArray();
+                            // BM25 channel votes
+                            const bm25Weight = hybridWeight;
+                            for (let rank = 0; rank < ftsResults.length; rank++) {
+                                const ftsResult = ftsResults[rank];
+                                if (!ftsResult)
+                                    continue;
+                                const key = `${ftsResult['filePath']}:${ftsResult['chunkIndex']}`;
+                                const contribution = bm25Weight / (k + rank + 1);
+                                const existing = candidates.get(key);
+                                if (existing) {
+                                    existing.rrfScore += contribution;
+                                }
+                                else {
+                                    try {
+                                        const searchResult = toSearchResult(ftsResult);
+                                        candidates.set(key, { result: searchResult, rrfScore: contribution });
+                                    }
+                                    catch { }
+                                }
+                            }
+                            this.recordFtsSuccess();
+                        }
+                        catch (ftsError) {
+                            this.recordFtsFailure(ftsError);
+                        }
+                    }
+                    // Sort by RRF score descending, convert to pseudo-distance
+                    const sorted = Array.from(candidates.values()).sort((a, b) => b.rrfScore - a.rrfScore);
+                    results = sorted.map(({ result, rrfScore }) => ({
+                        ...result,
+                        score: 1 / (1 + rrfScore),
+                    }));
+                    // Apply maxDistance filter on pseudo-distances
+                    if (this.config.maxDistance !== undefined) {
+                        results = results.filter((r) => r.score <= this.config.maxDistance);
+                    }
+                    // Apply grouping on RRF pseudo-distances
+                    if (this.config.grouping && results.length > 1) {
+                        results = this.applyGrouping(results, this.config.grouping);
+                    }
+                }
+                else {
+                    // ===== LEGACY BOOST MODE =====
+                    // Step 2: Apply grouping on vector distances (before keyword boost)
+                    if (this.config.grouping && results.length > 1) {
+                        results = this.applyGrouping(results, this.config.grouping);
+                    }
+                    // Step 3: Apply keyword boost if enabled (with circuit breaker)
+                    if (this.shouldAttemptFts() &&
+                        queryText &&
+                        queryText.trim().length > 0 &&
+                        hybridWeight > 0) {
+                        try {
+                            const uniqueFilePaths = [...new Set(results.map((r) => r.filePath))];
+                            const escapedPaths = uniqueFilePaths.map((p) => `'${p.replace(/'/g, "''")}'`);
+                            const whereClause = `\`filePath\` IN (${escapedPaths.join(', ')})`;
+                            const ftsResults = await table
+                                .search(queryText, 'fts', 'text')
+                                .where(whereClause)
+                                .select(['filePath', 'chunkIndex', 'text', 'metadata', '_score'])
+                                .limit(results.length * 2)
+                                .toArray();
+                            results = this.applyKeywordBoost(results, ftsResults, hybridWeight);
+                            this.recordFtsSuccess();
+                        }
+                        catch (ftsError) {
+                            this.recordFtsFailure(ftsError);
+                        }
+                    }
+                }
+                // Return top results after all filtering and fusion
+                return results.slice(0, limit);
             }
-            // Return top results after all filtering and boosting
-            return results.slice(0, limit);
-        }
-        catch (error) {
-            throw new DatabaseError('Failed to search vectors', error);
-        }
+            catch (error) {
+                throw new DatabaseError('Failed to search vectors', error);
+            }
+        }, 'VectorStore.search');
     }
     /**
      * Apply keyword boost to rerank vector search results
@@ -798,52 +979,55 @@ export class VectorStore {
         if (!this.table) {
             return []; // Return empty array if table doesn't exist
         }
-        try {
-            // Retrieve all records - LanceDB doesn't support GROUP BY aggregation,
-            // so we must fetch records and group in memory
-            // TODO(perf): Consider caching file list or using incremental updates for very large datasets
-            const allRecords = await this.table.query().toArray();
-            // Group by file path
-            const fileMap = new Map();
-            for (const record of allRecords) {
-                const filePath = record.filePath;
-                const timestamp = record.timestamp;
-                if (fileMap.has(filePath)) {
-                    const fileInfo = fileMap.get(filePath);
-                    if (fileInfo) {
-                        fileInfo.chunkCount += 1;
-                        // Keep most recent timestamp
-                        if (timestamp > fileInfo.timestamp) {
-                            fileInfo.timestamp = timestamp;
+        const table = this.table;
+        return withRetry(async () => {
+            try {
+                // Retrieve all records - LanceDB doesn't support GROUP BY aggregation,
+                // so we must fetch records and group in memory
+                // TODO(perf): Consider caching file list or using incremental updates for very large datasets
+                const allRecords = await table.query().toArray();
+                // Group by file path
+                const fileMap = new Map();
+                for (const record of allRecords) {
+                    const filePath = record.filePath;
+                    const timestamp = record.timestamp;
+                    if (fileMap.has(filePath)) {
+                        const fileInfo = fileMap.get(filePath);
+                        if (fileInfo) {
+                            fileInfo.chunkCount += 1;
+                            // Keep most recent timestamp
+                            if (timestamp > fileInfo.timestamp) {
+                                fileInfo.timestamp = timestamp;
+                            }
                         }
                     }
+                    else {
+                        fileMap.set(filePath, { chunkCount: 1, timestamp });
+                    }
                 }
-                else {
-                    fileMap.set(filePath, { chunkCount: 1, timestamp });
+                // Convert Map to array of objects
+                let results = Array.from(fileMap.entries()).map(([filePath, info]) => ({
+                    filePath,
+                    chunkCount: info.chunkCount,
+                    timestamp: info.timestamp,
+                }));
+                // Sort by timestamp descending (most recent first)
+                results.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+                // Apply pagination if provided
+                const offset = options?.offset ?? 0;
+                const limit = options?.limit;
+                if (offset > 0) {
+                    results = results.slice(offset);
                 }
+                if (limit !== undefined && limit > 0) {
+                    results = results.slice(0, limit);
+                }
+                return results;
             }
-            // Convert Map to array of objects
-            let results = Array.from(fileMap.entries()).map(([filePath, info]) => ({
-                filePath,
-                chunkCount: info.chunkCount,
-                timestamp: info.timestamp,
-            }));
-            // Sort by timestamp descending (most recent first)
-            results.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
-            // Apply pagination if provided
-            const offset = options?.offset ?? 0;
-            const limit = options?.limit;
-            if (offset > 0) {
-                results = results.slice(offset);
-            }
-            if (limit !== undefined && limit > 0) {
-                results = results.slice(0, limit);
+            catch (error) {
+                throw new DatabaseError('Failed to list files', error);
             }
-            return results;
-        }
-        catch (error) {
-            throw new DatabaseError('Failed to list files', error);
-        }
+        }, 'VectorStore.listFiles');
     }
     /**
      * Close the database connection and release resources
@@ -902,30 +1086,30 @@ export class VectorStore {
         if (!isValidFilePath(filePath)) {
             throw new DatabaseError(`Invalid file path: contains disallowed characters or patterns`);
         }
-        try {
-            const escapedFilePath = filePath.replace(/'/g, "''");
-            const results = await this.table
-                .query()
-                .where(`\`filePath\` = '${escapedFilePath}'`)
-                .toArray();
-            // Convert to SearchResult format and sort by chunkIndex
-            const chunks = results.map((record) => {
-                const text = record.text;
-                return {
-                    filePath: record.filePath,
-                    chunkIndex: record.chunkIndex,
-                    text,
-                    score: 0, // No distance score for direct retrieval
-                    metadata: record.metadata,
-                    // Include fingerprint - generate if not stored (backwards compatibility)
-                    fingerprint: record.fingerprint || generateChunkFingerprint(text),
-                };
-            });
-            return chunks.sort((a, b) => a.chunkIndex - b.chunkIndex);
-        }
-        catch (error) {
-            throw new DatabaseError(`Failed to get document chunks for: ${filePath}`, error);
-        }
+        const table = this.table;
+        return withRetry(async () => {
+            try {
+                const escapedFilePath = filePath.replace(/'/g, "''");
+                const results = await table.query().where(`\`filePath\` = '${escapedFilePath}'`).toArray();
+                // Convert to SearchResult format and sort by chunkIndex
+                const chunks = results.map((record) => {
+                    const text = record.text;
+                    return {
+                        filePath: record.filePath,
+                        chunkIndex: record.chunkIndex,
+                        text,
+                        score: 0, // No distance score for direct retrieval
+                        metadata: record.metadata,
+                        // Include fingerprint - generate if not stored (backwards compatibility)
+                        fingerprint: record.fingerprint || generateChunkFingerprint(text),
+                    };
+                });
+                return chunks.sort((a, b) => a.chunkIndex - b.chunkIndex);
+            }
+            catch (error) {
+                throw new DatabaseError(`Failed to get document chunks for: ${filePath}`, error);
+            }
+        }, 'VectorStore.getDocumentChunks');
     }
     /**
      * Find related chunks using a chunk's stored embedding
@@ -944,59 +1128,62 @@ export class VectorStore {
         if (!isValidFilePath(filePath)) {
             throw new DatabaseError(`Invalid file path: contains disallowed characters or patterns`);
         }
-        try {
-            // First, fetch the source chunk to get its vector
-            const escapedFilePath = filePath.replace(/'/g, "''");
-            const sourceResults = await this.table
-                .query()
-                .where(`\`filePath\` = '${escapedFilePath}' AND \`chunkIndex\` = ${chunkIndex}`)
-                .toArray();
-            if (sourceResults.length === 0) {
-                return [];
-            }
-            const sourceChunk = sourceResults[0];
-            const rawVector = sourceChunk?.vector;
-            // LanceDB may return vectors as Arrow Vector or Float32Array, not plain Array
-            // Convert to number[] for compatibility
-            let sourceVector;
-            if (rawVector) {
-                if (Array.isArray(rawVector)) {
-                    sourceVector = rawVector;
+        const table = this.table;
+        return withRetry(async () => {
+            try {
+                // First, fetch the source chunk to get its vector
+                const escapedFilePath = filePath.replace(/'/g, "''");
+                const sourceResults = await table
+                    .query()
+                    .where(`\`filePath\` = '${escapedFilePath}' AND \`chunkIndex\` = ${chunkIndex}`)
+                    .toArray();
+                if (sourceResults.length === 0) {
+                    return [];
                 }
-                else if (typeof rawVector === 'object' && 'length' in rawVector) {
-                    // Handle Arrow Vector, Float32Array, or other array-like objects
-                    sourceVector = Array.from(rawVector);
+                const sourceChunk = sourceResults[0];
+                const rawVector = sourceChunk?.vector;
+                // LanceDB may return vectors as Arrow Vector or Float32Array, not plain Array
+                // Convert to number[] for compatibility
+                let sourceVector;
+                if (rawVector) {
+                    if (Array.isArray(rawVector)) {
+                        sourceVector = rawVector;
+                    }
+                    else if (typeof rawVector === 'object' && 'length' in rawVector) {
+                        // Handle Arrow Vector, Float32Array, or other array-like objects
+                        sourceVector = Array.from(rawVector);
+                    }
                 }
+                if (!sourceVector || sourceVector.length === 0) {
+                    // Chunk exists but has no embedding (e.g., upload timed out mid-process)
+                    // Return empty results instead of throwing - allows batch operations to continue
+                    console.warn(`Chunk ${filePath}:${chunkIndex} has no valid vector (possibly corrupted)`);
+                    return [];
+                }
+                // Search for similar chunks using the source vector
+                // Request more candidates to allow for filtering
+                const candidateLimit = excludeSameDocument ? limit * 3 : limit + 1;
+                let query = table.vectorSearch(sourceVector).distanceType('dot').limit(candidateLimit);
+                // Apply distance threshold if configured
+                if (this.config.maxDistance !== undefined) {
+                    query = query.distanceRange(undefined, this.config.maxDistance);
+                }
+                const vectorResults = await query.toArray();
+                // Convert to SearchResult format with type validation
+                let results = vectorResults.map((result) => toSearchResult(result));
+                // Filter out the source chunk itself
+                results = results.filter((r) => !(r.filePath === filePath && r.chunkIndex === chunkIndex));
+                // Optionally filter out same-document chunks
+                if (excludeSameDocument) {
+                    results = results.filter((r) => r.filePath !== filePath);
+                }
+                return results.slice(0, limit);
             }
-            if (!sourceVector || sourceVector.length === 0) {
-                // Chunk exists but has no embedding (e.g., upload timed out mid-process)
-                // Return empty results instead of throwing - allows batch operations to continue
-                console.warn(`Chunk ${filePath}:${chunkIndex} has no valid vector (possibly corrupted)`);
-                return [];
-            }
-            // Search for similar chunks using the source vector
-            // Request more candidates to allow for filtering
-            const candidateLimit = excludeSameDocument ? limit * 3 : limit + 1;
-            let query = this.table.vectorSearch(sourceVector).distanceType('dot').limit(candidateLimit);
-            // Apply distance threshold if configured
-            if (this.config.maxDistance !== undefined) {
-                query = query.distanceRange(undefined, this.config.maxDistance);
-            }
-            const vectorResults = await query.toArray();
-            // Convert to SearchResult format with type validation
-            let results = vectorResults.map((result) => toSearchResult(result));
-            // Filter out the source chunk itself
-            results = results.filter((r) => !(r.filePath === filePath && r.chunkIndex === chunkIndex));
-            // Optionally filter out same-document chunks
-            if (excludeSameDocument) {
-                results = results.filter((r) => r.filePath !== filePath);
+            catch (error) {
+                const cause = error instanceof Error ? error.message : String(error);
+                throw new DatabaseError(`Failed to find related chunks for: ${filePath}:${chunkIndex}: ${cause}`, error);
             }
-            return results.slice(0, limit);
-        }
-        catch (error) {
-            const cause = error instanceof Error ? error.message : String(error);
-            throw new DatabaseError(`Failed to find related chunks for: ${filePath}:${chunkIndex}: ${cause}`, error);
-        }
+        }, 'VectorStore.findRelatedChunks');
     }
     /**
      * Get system status
@@ -1034,7 +1221,13 @@ export class VectorStore {
                 memoryUsage,
                 uptime,
                 ftsIndexEnabled: this.ftsEnabled,
-                searchMode: ftsEffectivelyEnabled && this.getHybridWeight() > 0 ? 'hybrid' : 'vector-only',
+                searchMode: (this.config.searchMode ?? SEARCH_MODE) === 'rrf'
+                    ? ftsEffectivelyEnabled && this.getHybridWeight() > 0
+                        ? 'hybrid-rrf'
+                        : 'vector-rrf'
+                    : ftsEffectivelyEnabled && this.getHybridWeight() > 0
+                        ? 'hybrid'
+                        : 'vector-only',
             };
         }
         catch (error) {