@vinaes/succ 1.3.19

package/dist/lib/storage/vector/qdrant.js

@@ -0,0 +1,880 @@
+/**
+ * Qdrant vector store implementation — Approach C: Full Hybrid Search.
+ *
+ * When Qdrant is configured (storage.vector = "qdrant"), it becomes the
+ * single search engine for ALL backends (SQLite + Qdrant, PgSQL + Qdrant).
+ *
+ * Uses Qdrant's built-in server-side BM25 (Qdrant/bm25 model) + dense vectors
+ * + RRF (Reciprocal Rank Fusion) — all in a single API call.
+ *
+ * Collections (named vectors):
+ * - {prefix}documents — dense (384d) + bm25 sparse
+ * - {prefix}memories — dense (384d) + bm25 sparse
+ * - {prefix}global_memories — dense (384d) + bm25 sparse
+ *
+ * Payloads store full metadata so search results can be returned
+ * without a second round-trip to PG/SQLite.
+ */
+import { DependencyError } from '../../errors.js';
+// Lazy-load qdrant client
+let QdrantClient = null;
+import { logWarn } from '../../fault-logger.js';
+async function loadQdrant() {
+    if (QdrantClient)
+        return QdrantClient;
+    try {
+        const module = await import('@qdrant/js-client-rest');
+        QdrantClient = module.QdrantClient;
+        return QdrantClient;
+    }
+    catch {
+        throw new DependencyError('Qdrant support requires the "@qdrant/js-client-rest" package. ' +
+            'Install it with: npm install @qdrant/js-client-rest');
+    }
+}
+// ============================================================================
+// QdrantVectorStore — Approach C
+// ============================================================================
+export class QdrantVectorStore {
+    client = null;
+    config;
+    dimensions = 384;
+    prefix;
+    searchEf;
+    useQuantization;
+    projectId = null;
+    initialized = {
+        documents: false,
+        memories: false,
+        globalMemories: false,
+    };
+    constructor(config) {
+        this.config = config;
+        this.prefix = config.collectionPrefix ?? 'succ_';
+        this.searchEf = config.searchEf ?? 128;
+        this.useQuantization = config.useQuantization ?? true;
+        this.projectId = config.projectId ?? null;
+    }
+    setProjectId(projectId) {
+        this.projectId = projectId;
+    }
+    getProjectId() {
+        return this.projectId;
+    }
+    async getClient() {
+        if (this.client)
+            return this.client;
+        const ClientClass = await loadQdrant();
+        this.client = new ClientClass({
+            url: this.config.url ?? 'http://localhost:6333',
+            apiKey: this.config.apiKey,
+        });
+        return this.client;
+    }
+    collectionName(type) {
+        return `${this.prefix}${type}`;
+    }
+    initKey(type) {
+        return type === 'global_memories' ? 'globalMemories' : type;
+    }
+    async init(dimensions) {
+        this.dimensions = dimensions;
+        await this.getClient();
+        await this.ensureCollection('documents');
+        await this.ensureCollection('memories');
+        await this.ensureCollection('global_memories');
+    }
+    // ==========================================================================
+    // Collection Management — Multi-Vector Schema
+    // ==========================================================================
+    async ensureCollection(type) {
+        const client = await this.getClient();
+        const name = this.collectionName(type);
+        const key = this.initKey(type);
+        try {
+            const info = await client.getCollection(name);
+            // All collections must use multi-vector schema (dense + bm25).
+            // Auto-migrate old unnamed-vector collections by recreating them.
+            const vectors = info.config?.params?.vectors;
+            if (vectors && typeof vectors === 'object' && 'dense' in vectors) {
+                const storedSize = vectors.dense?.size;
+                if (storedSize != null && storedSize !== this.dimensions) {
+                    logWarn('qdrant', `Collection "${name}" has ${storedSize} dims, need ${this.dimensions}. Recreating. Re-indexing required.`);
+                    await client.deleteCollection(name);
+                    await this.createMultiVectorCollection(name, type);
+                }
+            }
+            else {
+                logWarn('qdrant', `Collection "${name}" uses old single-vector schema. Recreating with multi-vector schema. Re-indexing required.`);
+                await client.deleteCollection(name);
+                await this.createMultiVectorCollection(name, type);
+            }
+            this.initialized[key] = true;
+        }
+        catch (e) {
+            if (e.status === 404 || e.message?.includes('Not found')) {
+                await this.createMultiVectorCollection(name, type);
+                this.initialized[key] = true;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    async createMultiVectorCollection(name, type) {
+        const client = await this.getClient();
+        const collectionConfig = {
+            vectors: {
+                dense: {
+                    size: this.dimensions,
+                    distance: 'Cosine',
+                },
+            },
+            sparse_vectors: {
+                bm25: {
+                    modifier: 'idf',
+                },
+            },
+            hnsw_config: {
+                m: 16,
+                ef_construct: 100,
+            },
+        };
+        if (this.useQuantization) {
+            collectionConfig.quantization_config = {
+                scalar: {
+                    type: 'int8',
+                    always_ram: true,
+                },
+            };
+        }
+        await client.createCollection(name, collectionConfig);
+        // Create payload indexes for fast filtering
+        await this.createPayloadIndexes(name, type);
+    }
+    async createPayloadIndexes(name, type) {
+        const client = await this.getClient();
+        if (type === 'documents') {
+            await client.createPayloadIndex(name, { field_name: 'doc_type', field_schema: 'keyword' });
+            await client.createPayloadIndex(name, { field_name: 'project_id', field_schema: 'keyword' });
+            await client.createPayloadIndex(name, { field_name: 'symbol_type', field_schema: 'keyword' });
+        }
+        else {
+            // memories + global_memories
+            await client.createPayloadIndex(name, { field_name: 'project_id', field_schema: 'keyword' });
+            await client.createPayloadIndex(name, {
+                field_name: 'invalidated_by',
+                field_schema: 'integer',
+            });
+            await client.createPayloadIndex(name, { field_name: 'created_at', field_schema: 'keyword' });
+            await client.createPayloadIndex(name, { field_name: 'tags', field_schema: 'keyword' });
+            await client.createPayloadIndex(name, { field_name: 'type', field_schema: 'keyword' });
+        }
+    }
+    async close() {
+        this.client = null;
+        this.initialized = { documents: false, memories: false, globalMemories: false };
+    }
+    isAvailable() {
+        return this.client !== null;
+    }
+    // ==========================================================================
+    // Document Vectors — VectorStore interface
+    // ==========================================================================
+    async upsertDocumentVector(id, embedding) {
+        const client = await this.getClient();
+        const name = this.collectionName('documents');
+        await client.upsert(name, {
+            points: [
+                {
+                    id,
+                    vector: { dense: embedding },
+                    payload: { doc_type: 'doc', project_id: this.projectId ?? '' },
+                },
+            ],
+        });
+    }
+    async upsertDocumentVectorsBatch(items) {
+        if (items.length === 0)
+            return;
+        const client = await this.getClient();
+        const name = this.collectionName('documents');
+        const batchSize = 100;
+        for (let i = 0; i < items.length; i += batchSize) {
+            const batch = items.slice(i, i + batchSize);
+            await client.upsert(name, {
+                points: batch.map((item) => ({
+                    id: item.id,
+                    vector: { dense: item.embedding },
+                    payload: { doc_type: 'doc', project_id: this.projectId ?? '' },
+                })),
+            });
+        }
+    }
+    async deleteDocumentVector(id) {
+        const client = await this.getClient();
+        await client.delete(this.collectionName('documents'), { points: [id] });
+    }
+    async deleteDocumentVectorsByIds(docIds) {
+        if (docIds.length === 0)
+            return;
+        const client = await this.getClient();
+        await client.delete(this.collectionName('documents'), { points: docIds });
+    }
+    async searchDocuments(query, limit, threshold) {
+        const client = await this.getClient();
+        const name = this.collectionName('documents');
+        const results = await client.query(name, {
+            query: query,
+            using: 'dense',
+            limit,
+            score_threshold: threshold,
+            params: { hnsw_ef: this.searchEf, exact: false },
+            with_payload: false,
+        });
+        return (results.points ?? results).map((r) => ({
+            id: typeof r.id === 'number' ? r.id : parseInt(r.id),
+            similarity: r.score,
+        }));
+    }
+    // ==========================================================================
+    // Memory Vectors — VectorStore interface
+    // ==========================================================================
+    async upsertMemoryVector(id, embedding, projectId) {
+        const client = await this.getClient();
+        const name = this.collectionName('memories');
+        const pid = projectId ?? this.projectId;
+        await client.upsert(name, {
+            points: [
+                {
+                    id,
+                    vector: { dense: embedding },
+                    payload: { project_id: pid, type: 'memory' },
+                },
+            ],
+        });
+    }
+    async deleteMemoryVector(id) {
+        const client = await this.getClient();
+        await client.delete(this.collectionName('memories'), { points: [id] });
+    }
+    async searchMemories(query, limit, threshold, options) {
+        const client = await this.getClient();
+        const name = this.collectionName('memories');
+        const projectId = options?.projectId ?? this.projectId;
+        const includeGlobal = options?.includeGlobal ?? true;
+        let filter = undefined;
+        if (projectId) {
+            if (includeGlobal) {
+                filter = {
+                    should: [
+                        { key: 'project_id', match: { value: projectId } },
+                        { is_null: { key: 'project_id' } },
+                    ],
+                };
+            }
+            else {
+                filter = { must: [{ key: 'project_id', match: { value: projectId } }] };
+            }
+        }
+        else {
+            filter = { must: [{ is_null: { key: 'project_id' } }] };
+        }
+        const results = await client.query(name, {
+            query: query,
+            using: 'dense',
+            limit,
+            score_threshold: threshold,
+            filter,
+            params: { hnsw_ef: this.searchEf, exact: false },
+            with_payload: false,
+        });
+        return (results.points ?? results).map((r) => ({
+            id: typeof r.id === 'number' ? r.id : parseInt(r.id),
+            similarity: r.score,
+        }));
+    }
+    // ==========================================================================
+    // Global Memory Vectors — VectorStore interface
+    // ==========================================================================
+    async upsertGlobalMemoryVector(id, embedding) {
+        const client = await this.getClient();
+        const name = this.collectionName('global_memories');
+        await client.upsert(name, {
+            points: [
+                {
+                    id,
+                    vector: { dense: embedding },
+                    payload: { type: 'global_memory' },
+                },
+            ],
+        });
+    }
+    async deleteGlobalMemoryVector(id) {
+        const client = await this.getClient();
+        await client.delete(this.collectionName('global_memories'), { points: [id] });
+    }
+    async searchGlobalMemories(query, limit, threshold) {
+        const client = await this.getClient();
+        const name = this.collectionName('global_memories');
+        const results = await client.query(name, {
+            query: query,
+            using: 'dense',
+            limit,
+            score_threshold: threshold,
+            params: { hnsw_ef: this.searchEf, exact: false },
+            with_payload: false,
+        });
+        return (results.points ?? results).map((r) => ({
+            id: typeof r.id === 'number' ? r.id : parseInt(r.id),
+            similarity: r.score,
+        }));
+    }
+    // ==========================================================================
+    // Maintenance — VectorStore interface
+    // ==========================================================================
+    async rebuildDocumentVectors(items) {
+        const client = await this.getClient();
+        const name = this.collectionName('documents');
+        try {
+            await client.delete(name, {
+                filter: { must: [{ key: 'doc_type', match: { value: 'code' } }] },
+            });
+            await client.delete(name, {
+                filter: { must: [{ key: 'doc_type', match: { value: 'doc' } }] },
+            });
+        }
+        catch (err) {
+            logWarn('qdrant', 'Pre-upsert delete failed (documents)', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        await this.upsertDocumentVectorsBatch(items);
+    }
+    async rebuildMemoryVectors(items) {
+        const client = await this.getClient();
+        const name = this.collectionName('memories');
+        try {
+            await client.delete(name, {
+                filter: { must: [{ has_id: items.map((i) => i.id) }] },
+            });
+        }
+        catch (err) {
+            logWarn('qdrant', 'Pre-upsert delete failed', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        const batchSize = 100;
+        for (let i = 0; i < items.length; i += batchSize) {
+            const batch = items.slice(i, i + batchSize);
+            await client.upsert(name, {
+                points: batch.map((item) => ({
+                    id: item.id,
+                    vector: { dense: item.embedding },
+                    payload: { type: 'memory' },
+                })),
+            });
+        }
+    }
+    async rebuildGlobalMemoryVectors(items) {
+        const client = await this.getClient();
+        const name = this.collectionName('global_memories');
+        try {
+            await client.delete(name, {
+                filter: { must: [{ has_id: items.map((i) => i.id) }] },
+            });
+        }
+        catch (err) {
+            logWarn('qdrant', 'Pre-upsert delete failed', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        const batchSize = 100;
+        for (let i = 0; i < items.length; i += batchSize) {
+            const batch = items.slice(i, i + batchSize);
+            await client.upsert(name, {
+                points: batch.map((item) => ({
+                    id: item.id,
+                    vector: { dense: item.embedding },
+                    payload: { type: 'global_memory' },
+                })),
+            });
+        }
+    }
+    // ==========================================================================
+    // NEW: Full-Payload Upserts (Approach C)
+    // ==========================================================================
+    /**
+     * Upsert a document with full payload + BM25 text for hybrid search.
+     * Called from dispatcher when Qdrant is configured.
+     */
+    async upsertDocumentWithPayload(id, embedding, meta) {
+        const client = await this.getClient();
+        const name = this.collectionName('documents');
+        const docType = meta.filePath.startsWith('code:') ? 'code' : 'doc';
+        await client.upsert(name, {
+            points: [
+                {
+                    id,
+                    vector: {
+                        dense: embedding,
+                        bm25: { text: meta.content, model: 'Qdrant/bm25' },
+                    },
+                    payload: {
+                        doc_type: docType,
+                        file_path: meta.filePath,
+                        content: meta.content,
+                        start_line: meta.startLine,
+                        end_line: meta.endLine,
+                        project_id: meta.projectId,
+                        symbol_name: meta.symbolName ?? null,
+                        symbol_type: meta.symbolType ?? null,
+                        signature: meta.signature ?? null,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Batch upsert documents with full payload + BM25 text.
+     */
+    async upsertDocumentsBatchWithPayload(items) {
+        if (items.length === 0)
+            return;
+        const client = await this.getClient();
+        const name = this.collectionName('documents');
+        const batchSize = 100;
+        for (let i = 0; i < items.length; i += batchSize) {
+            const batch = items.slice(i, i + batchSize);
+            await client.upsert(name, {
+                points: batch.map((item) => {
+                    const docType = item.meta.filePath.startsWith('code:') ? 'code' : 'doc';
+                    return {
+                        id: item.id,
+                        vector: {
+                            dense: item.embedding,
+                            bm25: { text: item.meta.content, model: 'Qdrant/bm25' },
+                        },
+                        payload: {
+                            doc_type: docType,
+                            file_path: item.meta.filePath,
+                            content: item.meta.content,
+                            start_line: item.meta.startLine,
+                            end_line: item.meta.endLine,
+                            project_id: item.meta.projectId,
+                            symbol_name: item.meta.symbolName ?? null,
+                            symbol_type: item.meta.symbolType ?? null,
+                            signature: item.meta.signature ?? null,
+                        },
+                    };
+                }),
+            });
+        }
+    }
+    /**
+     * Upsert a memory with full payload + BM25 text for hybrid search.
+     */
+    async upsertMemoryWithPayload(id, embedding, meta) {
+        const client = await this.getClient();
+        const name = this.collectionName('memories');
+        await client.upsert(name, {
+            points: [
+                {
+                    id,
+                    vector: {
+                        dense: embedding,
+                        bm25: { text: meta.content, model: 'Qdrant/bm25' },
+                    },
+                    payload: {
+                        content: meta.content,
+                        tags: meta.tags,
+                        source: meta.source ?? null,
+                        type: meta.type ?? null,
+                        project_id: meta.projectId ?? null,
+                        created_at: meta.createdAt,
+                        valid_from: meta.validFrom ?? null,
+                        valid_until: meta.validUntil ?? null,
+                        invalidated_by: null,
+                        access_count: 0,
+                        last_accessed: null,
+                        quality_score: null,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Upsert a global memory with full payload + BM25 text.
+     */
+    async upsertGlobalMemoryWithPayload(id, embedding, meta) {
+        const client = await this.getClient();
+        const name = this.collectionName('global_memories');
+        await client.upsert(name, {
+            points: [
+                {
+                    id,
+                    vector: {
+                        dense: embedding,
+                        bm25: { text: meta.content, model: 'Qdrant/bm25' },
+                    },
+                    payload: {
+                        content: meta.content,
+                        tags: meta.tags,
+                        source: meta.source ?? null,
+                        type: meta.type ?? null,
+                        project_id: null,
+                        created_at: meta.createdAt,
+                        valid_from: meta.validFrom ?? null,
+                        valid_until: meta.validUntil ?? null,
+                        invalidated_by: null,
+                        access_count: 0,
+                        last_accessed: null,
+                        quality_score: null,
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * Batch upsert memories with full payload + BM25 text.
+     */
+    async upsertMemoriesBatchWithPayload(items) {
+        if (items.length === 0)
+            return;
+        const client = await this.getClient();
+        const name = this.collectionName('memories');
+        const batchSize = 100;
+        for (let i = 0; i < items.length; i += batchSize) {
+            const batch = items.slice(i, i + batchSize);
+            await client.upsert(name, {
+                points: batch.map((item) => ({
+                    id: item.id,
+                    vector: {
+                        dense: item.embedding,
+                        bm25: { text: item.meta.content, model: 'Qdrant/bm25' },
+                    },
+                    payload: {
+                        content: item.meta.content,
+                        tags: item.meta.tags,
+                        source: item.meta.source ?? null,
+                        type: item.meta.type ?? null,
+                        project_id: item.meta.projectId ?? null,
+                        created_at: item.meta.createdAt,
+                        valid_from: item.meta.validFrom ?? null,
+                        valid_until: item.meta.validUntil ?? null,
+                        invalidated_by: item.meta.invalidatedBy ?? null,
+                        access_count: item.meta.accessCount ?? 0,
+                        last_accessed: item.meta.lastAccessed ?? null,
+                        quality_score: item.meta.qualityScore ?? null,
+                    },
+                })),
+            });
+        }
+    }
+    /**
+     * Batch upsert global memories with full payload + BM25 text.
+     */
+    async upsertGlobalMemoriesBatchWithPayload(items) {
+        if (items.length === 0)
+            return;
+        const client = await this.getClient();
+        const name = this.collectionName('global_memories');
+        const batchSize = 100;
+        for (let i = 0; i < items.length; i += batchSize) {
+            const batch = items.slice(i, i + batchSize);
+            await client.upsert(name, {
+                points: batch.map((item) => ({
+                    id: item.id,
+                    vector: {
+                        dense: item.embedding,
+                        bm25: { text: item.meta.content, model: 'Qdrant/bm25' },
+                    },
+                    payload: {
+                        content: item.meta.content,
+                        tags: item.meta.tags,
+                        source: item.meta.source ?? null,
+                        type: item.meta.type ?? null,
+                        project_id: null,
+                        created_at: item.meta.createdAt,
+                        valid_from: item.meta.validFrom ?? null,
+                        valid_until: item.meta.validUntil ?? null,
+                        invalidated_by: item.meta.invalidatedBy ?? null,
+                        access_count: item.meta.accessCount ?? 0,
+                        last_accessed: item.meta.lastAccessed ?? null,
+                        quality_score: item.meta.qualityScore ?? null,
+                    },
+                })),
+            });
+        }
+    }
+    // ==========================================================================
+    // NEW: Hybrid Search Methods (Approach C — BM25 + Dense + RRF)
+    // ==========================================================================
+    /**
+     * Hybrid search for documents using BM25 + dense vectors + RRF fusion.
+     * Returns full document data from Qdrant payload (no PG round-trip needed).
+     */
+    async hybridSearchDocuments(query, queryEmbedding, limit, threshold, options) {
+        const client = await this.getClient();
+        const name = this.collectionName('documents');
+        // Build filter
+        const must = [];
+        if (options?.codeOnly)
+            must.push({ key: 'doc_type', match: { value: 'code' } });
+        if (options?.docsOnly)
+            must.push({ key: 'doc_type', match: { value: 'doc' } });
+        if (options?.projectId)
+            must.push({ key: 'project_id', match: { value: options.projectId } });
+        if (options?.symbolType)
+            must.push({ key: 'symbol_type', match: { value: options.symbolType } });
+        const filter = must.length > 0 ? { must } : undefined;
+        const results = await client.query(name, {
+            prefetch: [
+                {
+                    query: { text: query, model: 'Qdrant/bm25' },
+                    using: 'bm25',
+                    limit: limit * 3,
+                },
+                {
+                    query: queryEmbedding,
+                    using: 'dense',
+                    limit: limit * 3,
+                    params: { hnsw_ef: this.searchEf, exact: false },
+                },
+            ],
+            query: { fusion: 'rrf' },
+            filter,
+            score_threshold: threshold,
+            with_payload: true,
+            limit,
+        });
+        const points = results.points ?? results;
+        return points.map((p) => ({
+            id: typeof p.id === 'number' ? p.id : parseInt(p.id),
+            file_path: p.payload?.file_path ?? '',
+            content: p.payload?.content ?? '',
+            start_line: p.payload?.start_line ?? 0,
+            end_line: p.payload?.end_line ?? 0,
+            similarity: p.score,
+            bm25Score: 0, // RRF doesn't expose individual scores
+            vectorScore: 0,
+            symbol_name: p.payload?.symbol_name ?? null,
+            symbol_type: p.payload?.symbol_type ?? null,
+            signature: p.payload?.signature ?? null,
+        }));
+    }
+    /**
+     * Hybrid search for memories using BM25 + dense vectors + RRF fusion.
+     * Returns full memory data from Qdrant payload.
+     */
+    async hybridSearchMemories(query, queryEmbedding, limit, threshold, options) {
+        const client = await this.getClient();
+        const name = this.collectionName('memories');
+        const projectId = options?.projectId ?? this.projectId;
+        const now = options?.asOfDate ?? new Date();
+        const must = [];
+        const should = [];
+        // Soft-delete filter
+        must.push({ is_null: { key: 'invalidated_by' } });
+        // Project scoping
+        if (projectId) {
+            if (options?.includeGlobal !== false) {
+                should.push({ key: 'project_id', match: { value: projectId } });
+                should.push({ is_null: { key: 'project_id' } });
+            }
+            else {
+                must.push({ key: 'project_id', match: { value: projectId } });
+            }
+        }
+        // Temporal validity (unless includeExpired)
+        if (!options?.includeExpired) {
+            must.push({
+                should: [
+                    { is_null: { key: 'valid_from' } },
+                    { key: 'valid_from', range: { lte: now.toISOString() } },
+                ],
+            });
+            must.push({
+                should: [
+                    { is_null: { key: 'valid_until' } },
+                    { key: 'valid_until', range: { gt: now.toISOString() } },
+                ],
+            });
+        }
+        // Since filter
+        if (options?.since) {
+            must.push({ key: 'created_at', range: { gte: options.since.toISOString() } });
+        }
+        // Created-before filter (for point-in-time queries)
+        if (options?.createdBefore) {
+            must.push({ key: 'created_at', range: { lte: options.createdBefore.toISOString() } });
+        }
+        // Tag filter
+        if (options?.tags?.length) {
+            for (const tag of options.tags) {
+                must.push({ key: 'tags', match: { value: tag } });
+            }
+        }
+        const filter = {};
+        if (must.length)
+            filter.must = must;
+        if (should.length)
+            filter.should = should;
+        const results = await client.query(name, {
+            prefetch: [
+                {
+                    query: { text: query, model: 'Qdrant/bm25' },
+                    using: 'bm25',
+                    limit: limit * 3,
+                },
+                {
+                    query: queryEmbedding,
+                    using: 'dense',
+                    limit: limit * 3,
+                    params: { hnsw_ef: this.searchEf, exact: false },
+                },
+            ],
+            query: { fusion: 'rrf' },
+            filter: Object.keys(filter).length > 0 ? filter : undefined,
+            score_threshold: threshold,
+            with_payload: true,
+            limit,
+        });
+        const points = results.points ?? results;
+        return points.map((p) => this.payloadToMemory(p));
+    }
+    /**
+     * Hybrid search for global memories using BM25 + dense + RRF.
+     */
+    async hybridSearchGlobalMemories(query, queryEmbedding, limit, threshold, options) {
+        const client = await this.getClient();
+        const name = this.collectionName('global_memories');
+        const must = [];
+        // Soft-delete
+        must.push({ is_null: { key: 'invalidated_by' } });
+        // Temporal validity
+        if (!options?.includeExpired) {
+            const now = new Date();
+            must.push({
+                should: [
+                    { is_null: { key: 'valid_from' } },
+                    { key: 'valid_from', range: { lte: now.toISOString() } },
+                ],
+            });
+            must.push({
+                should: [
+                    { is_null: { key: 'valid_until' } },
+                    { key: 'valid_until', range: { gt: now.toISOString() } },
+                ],
+            });
+        }
+        if (options?.since) {
+            must.push({ key: 'created_at', range: { gte: options.since.toISOString() } });
+        }
+        if (options?.tags?.length) {
+            for (const tag of options.tags) {
+                must.push({ key: 'tags', match: { value: tag } });
+            }
+        }
+        const filter = must.length > 0 ? { must } : undefined;
+        const results = await client.query(name, {
+            prefetch: [
+                {
+                    query: { text: query, model: 'Qdrant/bm25' },
+                    using: 'bm25',
+                    limit: limit * 3,
+                },
+                {
+                    query: queryEmbedding,
+                    using: 'dense',
+                    limit: limit * 3,
+                    params: { hnsw_ef: this.searchEf, exact: false },
+                },
+            ],
+            query: { fusion: 'rrf' },
+            filter,
+            score_threshold: threshold,
+            with_payload: true,
+            limit,
+        });
+        const points = results.points ?? results;
+        return points.map((p) => this.payloadToMemory(p));
+    }
+    /**
+     * Dense-only similarity search (for dedup checks — no BM25 needed).
+     */
+    async findSimilarVector(collection, embedding, limit, threshold, filter) {
+        const client = await this.getClient();
+        const name = this.collectionName(collection);
+        const results = await client.query(name, {
+            query: embedding,
+            using: 'dense',
+            filter,
+            score_threshold: threshold,
+            limit,
+            with_payload: false,
+        });
+        const points = results.points ?? results;
+        return points.map((r) => ({
+            id: typeof r.id === 'number' ? r.id : parseInt(r.id),
+            similarity: r.score,
+        }));
+    }
+    /**
+     * Dense-only search with payload (for dedup — returns content).
+     */
+    async findSimilarWithContent(collection, embedding, limit, threshold) {
+        const client = await this.getClient();
+        const name = this.collectionName(collection);
+        const results = await client.query(name, {
+            query: embedding,
+            using: 'dense',
+            score_threshold: threshold,
+            limit,
+            with_payload: ['content'],
+        });
+        const points = results.points ?? results;
+        return points.map((r) => ({
+            id: typeof r.id === 'number' ? r.id : parseInt(r.id),
+            content: r.payload?.content ?? '',
+            similarity: r.score,
+        }));
+    }
+    // ==========================================================================
+    // Private Helpers
+    // ==========================================================================
+    /** Convert a Qdrant point with memory payload to a Memory + similarity. */
+    payloadToMemory(point) {
+        const p = point.payload ?? {};
+        return {
+            id: typeof point.id === 'number' ? point.id : parseInt(point.id),
+            content: p.content ?? '',
+            tags: Array.isArray(p.tags) ? p.tags : [],
+            source: p.source ?? null,
+            type: p.type ?? null,
+            quality_score: p.quality_score ?? null,
+            quality_factors: null,
+            access_count: p.access_count ?? 0,
+            last_accessed: p.last_accessed ?? null,
+            correction_count: p.correction_count ?? 0,
+            is_invariant: !!p.is_invariant,
+            priority_score: p.priority_score ?? null,
+            valid_from: p.valid_from ?? null,
+            valid_until: p.valid_until ?? null,
+            created_at: p.created_at ?? '',
+            similarity: point.score,
+        };
+    }
+}
+/**
+ * Create Qdrant vector store from storage config.
+ */
+export function createQdrantVectorStore(config) {
+    const qdrantConfig = config.qdrant ?? {};
+    return new QdrantVectorStore({
+        url: qdrantConfig.url,
+        apiKey: qdrantConfig.api_key,
+        collectionPrefix: qdrantConfig.collection_prefix,
+    });
+}
+//# sourceMappingURL=qdrant.js.map