@futdevpro/nts-dynamo 1.15.155 → 1.15.156

package/build/_modules/local-vector-search/_services/lvs-local-vector-search.data-service.js

@@ -1,295 +1,295 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_LVS_VectorDataService = void 0;
-const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
-const lvs_search_mode_enum_1 = require("../_enums/lvs-search-mode.enum");
-const lvs_vector_pool_control_service_1 = require("./lvs-vector-pool.control-service");
-const lvs_bm25_util_1 = require("./lvs-bm25.util");
-const oai_vector_data_service_1 = require("../../ai/_modules/open-ai/_services/data-services/oai-vector-data.service");
-const global_settings_const_1 = require("../../../_collections/global-settings.const");
-/**
- * Local Vector Data Service
- * Extends {@link DyNTS_OAI_VectorDataService} to perform in-memory vector similarity search
- * instead of MongoDB vector search
- *
- * This service loads data from the database, builds an in-memory vector pool,
- * and performs brute-force vector similarity search using cosine similarity or L2 distance
- *
- * @example
- * ```typescript
- * const service = new DyNTS_OAI_LocalVectorDataService(
- *   data,
- *   dataParams,
- *   openAISettings,
- *   issuer
- * );
- *
- * const results = await service.vectorSearch({
- *   input: 'search query',
- *   searchInKey: 'contentVectorized',
- *   limit: 10,
- *   filterBy: { category: 'docs' }
- * });
- * ```
- */
-class DyNTS_LVS_VectorDataService extends oai_vector_data_service_1.DyNTS_OAI_VectorDataService {
-    /**
-     * Default search mode
-     * Cosine similarity is typically preferred for text embeddings
-     */
-    defaultSearchMode = lvs_search_mode_enum_1.LVS_Search_Mode.cosineSimilarity;
-    /**
-     * Whether to use L2 normalization when storing vectors
-     * Normalized vectors are more efficient for cosine similarity calculations
-     */
-    useL2Normalization = true;
-    /**
-     * Instance-based vector pool utility
-     * Minden service instance saját vektor pool-t tart fenn
-     */
-    vectorPool = new lvs_vector_pool_control_service_1.LVS_VectorPool_ControlService();
-    constructor(
-    /**
-     * Initial data, this will be used by functions on default
-     */
-    data, 
-    /**
-     * DB data params will be used to connect to usable dbService on GlobalService
-     */
-    dataParams, 
-    /**
-     * OpenAI settings
-     */
-    openAISettings, 
-    /**
-     * Initial set for issuer to be able to follow the issuer's activity
-     */
-    issuer) {
-        super(data, dataParams, openAISettings, issuer);
-    }
-    /**
-     * Overrides the parent vectorSearch method to perform local in-memory vector search
-     *
-     * Process:
-     * 1. Load data from DB using filterBy (if provided) or getAll()
-     * 2. Extract vectorized properties from loaded data
-     * 3. Build in-memory vector pool
-     * 4. Vectorize input query
-     * 5. Perform local vector search
-     * 6. Map search results back to full data objects
-     *
-     * @param set Search parameters
-     * @returns Array of data objects sorted by similarity score
-     */
-    async vectorSearch(set) {
-        try {
-            if (!set.input) {
-                throw new fsm_dynamo_1.DyFM_Error({
-                    ...this.getDefaultErrorSettings('vectorSearch', new Error('input is required')),
-                    errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS1`,
-                });
-            }
-            set.limit ??= 3;
-            const { input, searchInKey, limit, filterBy, searchMode, hybridWeight, textSearchKey } = set;
-            const effectiveMode = searchMode ?? this.defaultSearchMode;
-            // Hybrid mode korai validacio
-            if (effectiveMode === lvs_search_mode_enum_1.LVS_Search_Mode.hybrid) {
-                if (!textSearchKey) {
-                    throw new fsm_dynamo_1.DyFM_Error({
-                        ...this.getDefaultErrorSettings('vectorSearch', new Error('textSearchKey is required when searchMode is hybrid')),
-                        errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS4`,
-                    });
-                }
-                if (hybridWeight) {
-                    const w = hybridWeight;
-                    if (!Number.isFinite(w.vector) || !Number.isFinite(w.text) || w.vector < 0 || w.text < 0) {
-                        throw new fsm_dynamo_1.DyFM_Error({
-                            ...this.getDefaultErrorSettings('vectorSearch', new Error('hybridWeight.vector and .text must be non-negative finite numbers')),
-                            errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS5`,
-                        });
-                    }
-                }
-            }
-            // Validáljuk, hogy a searchInKey létezik-e
-            const property = this.dataParams.properties[searchInKey];
-            if (!property) {
-                throw new fsm_dynamo_1.DyFM_Error({
-                    ...this.getDefaultErrorSettings('vectorSearch', new Error(`Property "${searchInKey}" not found! ` +
-                        `while searching "${this.dataParams.dataName}" ` +
-                        `(The searchable properties are: ` +
-                        `${this.vectorizedProperties.map(p => `"${p.key}"`).join(', ')})`)),
-                    errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS2`,
-                    __localStack: this.dataParams.stackLocation,
-                });
-            }
-            // Ellenőrizzük, hogy a property vectorized-e
-            if (!this.vectorizedProperties.some((p) => p.key === searchInKey)) {
-                throw new fsm_dynamo_1.DyFM_Error({
-                    ...this.getDefaultErrorSettings('vectorSearch', new Error(`Property "${searchInKey}" is not a vectorized property! ` +
-                        `(The vectorized properties are: ` +
-                        `${this.vectorizedProperties.map(p => `"${p.key}"`).join(', ')})`)),
-                    errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS3`,
-                    __localStack: this.dataParams.stackLocation,
-                });
-            }
-            // 1. Betöltjük az adatokat a DB-ből (filterBy-val szűrve, ha van)
-            let dataList;
-            if (filterBy) {
-                // Ha van filterBy, akkor először szűrünk a DB-ben
-                if (this.debugLog) {
-                    fsm_dynamo_1.DyFM_Log.log(`Local vector search: filtering data with filterBy...`);
-                }
-                dataList = await this.findDataList(filterBy, true);
-            }
-            else {
-                // Ha nincs filterBy, akkor minden adatot betöltünk
-                if (this.debugLog) {
-                    fsm_dynamo_1.DyFM_Log.log(`Local vector search: loading all data...`);
-                }
-                dataList = await this.getAll(true);
-            }
-            if (dataList.length === 0) {
-                if (this.debugLog) {
-                    fsm_dynamo_1.DyFM_Log.log(`Local vector search: no data found`);
-                }
-                return [];
-            }
-            // 2. Kinyerjük a vectorized property-ket és építjük a vector pool-t
-            if (this.debugLog) {
-                fsm_dynamo_1.DyFM_Log.log(`Local vector search: building vector pool from ${dataList.length} items...`);
-            }
-            // Töröljük a korábbi pool-t
-            this.vectorPool.clearPool();
-            // Hozzáadjuk a vektorokat a pool-hoz
-            const dataMap = new Map();
-            for (const dataItem of dataList) {
-                if (!dataItem._id) {
-                    // Ha nincs _id, akkor kihagyjuk
-                    if (this.debugLog) {
-                        fsm_dynamo_1.DyFM_Log.warn(`Local vector search: skipping item without _id`);
-                    }
-                    continue;
-                }
-                const vectorizedValue = dataItem[searchInKey];
-                if (!vectorizedValue || !Array.isArray(vectorizedValue)) {
-                    // Ha nincs vectorized érték, akkor kihagyjuk
-                    if (this.debugLog) {
-                        fsm_dynamo_1.DyFM_Log.warn(`Local vector search: skipping item "${dataItem._id}" ` +
-                            `without vectorized value for "${searchInKey}"`);
-                    }
-                    continue;
-                }
-                // Hozzáadjuk a vektort a pool-hoz
-                this.vectorPool.addVector(dataItem._id, vectorizedValue);
-                dataMap.set(dataItem._id, dataItem);
-            }
-            if (dataMap.size === 0) {
-                if (this.debugLog) {
-                    fsm_dynamo_1.DyFM_Log.log(`Local vector search: no valid vectors found`);
-                }
-                return [];
-            }
-            // 3. Vectorizáljuk a query input-ot
-            if (this.debugLog) {
-                fsm_dynamo_1.DyFM_Log.log(`Local vector search: vectorizing query input...`);
-            }
-            const queryVector = await this.vectorize(input, property.embeddingModel);
-            // 4. Végrehajtjuk a local vector search-t
-            const mode = effectiveMode;
-            if (this.debugLog) {
-                fsm_dynamo_1.DyFM_Log.log(`Local vector search: searching with mode "${mode}", limit: ${limit}...`);
-            }
-            let searchResults;
-            if (mode === lvs_search_mode_enum_1.LVS_Search_Mode.hybrid) {
-                // Hybrid: cosine ALL candidate-re + BM25 ALL candidate-re + min-max norm + weighted sum
-                const allCandidatesCosine = this.vectorPool.search(queryVector, dataMap.size, lvs_search_mode_enum_1.LVS_Search_Mode.cosineSimilarity);
-                // BM25 corpus epitese a `textSearchKey` property-bol
-                const docs = [];
-                for (const [docId, dataItem] of dataMap) {
-                    const textValue = dataItem[textSearchKey];
-                    docs.push({
-                        id: docId,
-                        text: typeof textValue === 'string' ? textValue : '',
-                    });
-                }
-                const bm25Corpus = new lvs_bm25_util_1.DyNTS_LVS_BM25_Corpus(docs);
-                const bm25Raw = bm25Corpus.score(input);
-                const bm25Normalized = (0, lvs_bm25_util_1.dyNTS_LVS_BM25_minMaxNormalize)(bm25Raw);
-                const bm25ScoreById = new Map();
-                for (const s of bm25Normalized) {
-                    bm25ScoreById.set(s.id, s.score);
-                }
-                const wVector = hybridWeight?.vector ?? 0.5;
-                const wText = hybridWeight?.text ?? 0.5;
-                const merged = allCandidatesCosine.map((c) => {
-                    const bm25Score = bm25ScoreById.get(c.id) ?? 0;
-                    return {
-                        id: c.id,
-                        score: wVector * c.score + wText * bm25Score,
-                    };
-                });
-                merged.sort((a, b) => b.score - a.score);
-                searchResults = merged.slice(0, limit);
-            }
-            else {
-                searchResults = this.vectorPool.search(queryVector, limit, mode);
-            }
-            if (this.debugLog) {
-                fsm_dynamo_1.DyFM_Log.log(`Local vector search: found ${searchResults.length} results`);
-            }
-            // 5. Map-eljük vissza a search results-ot a teljes data objektumokra
-            const results = [];
-            for (const searchResult of searchResults) {
-                const dataItem = dataMap.get(searchResult.id);
-                if (dataItem) {
-                    results.push(dataItem);
-                }
-            }
-            // Töröljük a pool-t a memória felszabadítása érdekében
-            this.vectorPool.clearPool();
-            return results;
-        }
-        catch (error) {
-            // Töröljük a pool-t hiba esetén is
-            this.vectorPool.clearPool();
-            throw new fsm_dynamo_1.DyFM_Error({
-                ...this.getDefaultErrorSettings('vectorSearch', error),
-                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS0`,
-            });
-        }
-    }
-}
-exports.DyNTS_LVS_VectorDataService = DyNTS_LVS_VectorDataService;
-/**
- * @example
- * ```typescript
- * // Create a local vector data service
- * const localVectorService = new DyNTS_OAI_LocalVectorDataService<CodeChunk>(
- *   new CodeChunk(),
- *   codeChunk_dataParams,
- *   openAISettings,
- *   'example-issuer'
- * );
- *
- * // Perform vector search with filterBy
- * const results = await localVectorService.vectorSearch({
- *   input: 'How to implement authentication?',
- *   searchInKey: 'chunkParentedContentVectorized',
- *   limit: 5,
- *   filterBy: {
- *     // Filter by category before vector search
- *     category: 'documentation'
- *   },
- *   searchMode: LVS_Search_Mode.cosineSimilarity
- * });
- *
- * // Results are sorted by similarity score (highest first for cosine)
- * console.log(`Found ${results.length} similar chunks`);
- *
- * // Access the results
- * for (const result of results) {
- *   console.log(`Chunk ID: ${result._id}, Content: ${result.chunkContent}`);
- * }
- * ```
- */
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyNTS_LVS_VectorDataService = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const lvs_search_mode_enum_1 = require("../_enums/lvs-search-mode.enum");
+const lvs_vector_pool_control_service_1 = require("./lvs-vector-pool.control-service");
+const lvs_bm25_util_1 = require("./lvs-bm25.util");
+const oai_vector_data_service_1 = require("../../ai/_modules/open-ai/_services/data-services/oai-vector-data.service");
+const global_settings_const_1 = require("../../../_collections/global-settings.const");
+/**
+ * Local Vector Data Service
+ * Extends {@link DyNTS_OAI_VectorDataService} to perform in-memory vector similarity search
+ * instead of MongoDB vector search
+ *
+ * This service loads data from the database, builds an in-memory vector pool,
+ * and performs brute-force vector similarity search using cosine similarity or L2 distance
+ *
+ * @example
+ * ```typescript
+ * const service = new DyNTS_OAI_LocalVectorDataService(
+ *   data,
+ *   dataParams,
+ *   openAISettings,
+ *   issuer
+ * );
+ *
+ * const results = await service.vectorSearch({
+ *   input: 'search query',
+ *   searchInKey: 'contentVectorized',
+ *   limit: 10,
+ *   filterBy: { category: 'docs' }
+ * });
+ * ```
+ */
+class DyNTS_LVS_VectorDataService extends oai_vector_data_service_1.DyNTS_OAI_VectorDataService {
+    /**
+     * Default search mode
+     * Cosine similarity is typically preferred for text embeddings
+     */
+    defaultSearchMode = lvs_search_mode_enum_1.LVS_Search_Mode.cosineSimilarity;
+    /**
+     * Whether to use L2 normalization when storing vectors
+     * Normalized vectors are more efficient for cosine similarity calculations
+     */
+    useL2Normalization = true;
+    /**
+     * Instance-based vector pool utility
+     * Minden service instance saját vektor pool-t tart fenn
+     */
+    vectorPool = new lvs_vector_pool_control_service_1.LVS_VectorPool_ControlService();
+    constructor(
+    /**
+     * Initial data, this will be used by functions on default
+     */
+    data, 
+    /**
+     * DB data params will be used to connect to usable dbService on GlobalService
+     */
+    dataParams, 
+    /**
+     * OpenAI settings
+     */
+    openAISettings, 
+    /**
+     * Initial set for issuer to be able to follow the issuer's activity
+     */
+    issuer) {
+        super(data, dataParams, openAISettings, issuer);
+    }
+    /**
+     * Overrides the parent vectorSearch method to perform local in-memory vector search
+     *
+     * Process:
+     * 1. Load data from DB using filterBy (if provided) or getAll()
+     * 2. Extract vectorized properties from loaded data
+     * 3. Build in-memory vector pool
+     * 4. Vectorize input query
+     * 5. Perform local vector search
+     * 6. Map search results back to full data objects
+     *
+     * @param set Search parameters
+     * @returns Array of data objects sorted by similarity score
+     */
+    async vectorSearch(set) {
+        try {
+            if (!set.input) {
+                throw new fsm_dynamo_1.DyFM_Error({
+                    ...this.getDefaultErrorSettings('vectorSearch', new Error('input is required')),
+                    errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS1`,
+                });
+            }
+            set.limit ??= 3;
+            const { input, searchInKey, limit, filterBy, searchMode, hybridWeight, textSearchKey } = set;
+            const effectiveMode = searchMode ?? this.defaultSearchMode;
+            // Hybrid mode korai validacio
+            if (effectiveMode === lvs_search_mode_enum_1.LVS_Search_Mode.hybrid) {
+                if (!textSearchKey) {
+                    throw new fsm_dynamo_1.DyFM_Error({
+                        ...this.getDefaultErrorSettings('vectorSearch', new Error('textSearchKey is required when searchMode is hybrid')),
+                        errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS4`,
+                    });
+                }
+                if (hybridWeight) {
+                    const w = hybridWeight;
+                    if (!Number.isFinite(w.vector) || !Number.isFinite(w.text) || w.vector < 0 || w.text < 0) {
+                        throw new fsm_dynamo_1.DyFM_Error({
+                            ...this.getDefaultErrorSettings('vectorSearch', new Error('hybridWeight.vector and .text must be non-negative finite numbers')),
+                            errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS5`,
+                        });
+                    }
+                }
+            }
+            // Validáljuk, hogy a searchInKey létezik-e
+            const property = this.dataParams.properties[searchInKey];
+            if (!property) {
+                throw new fsm_dynamo_1.DyFM_Error({
+                    ...this.getDefaultErrorSettings('vectorSearch', new Error(`Property "${searchInKey}" not found! ` +
+                        `while searching "${this.dataParams.dataName}" ` +
+                        `(The searchable properties are: ` +
+                        `${this.vectorizedProperties.map(p => `"${p.key}"`).join(', ')})`)),
+                    errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS2`,
+                    __localStack: this.dataParams.stackLocation,
+                });
+            }
+            // Ellenőrizzük, hogy a property vectorized-e
+            if (!this.vectorizedProperties.some((p) => p.key === searchInKey)) {
+                throw new fsm_dynamo_1.DyFM_Error({
+                    ...this.getDefaultErrorSettings('vectorSearch', new Error(`Property "${searchInKey}" is not a vectorized property! ` +
+                        `(The vectorized properties are: ` +
+                        `${this.vectorizedProperties.map(p => `"${p.key}"`).join(', ')})`)),
+                    errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS3`,
+                    __localStack: this.dataParams.stackLocation,
+                });
+            }
+            // 1. Betöltjük az adatokat a DB-ből (filterBy-val szűrve, ha van)
+            let dataList;
+            if (filterBy) {
+                // Ha van filterBy, akkor először szűrünk a DB-ben
+                if (this.debugLog) {
+                    fsm_dynamo_1.DyFM_Log.log(`Local vector search: filtering data with filterBy...`);
+                }
+                dataList = await this.findDataList(filterBy, true);
+            }
+            else {
+                // Ha nincs filterBy, akkor minden adatot betöltünk
+                if (this.debugLog) {
+                    fsm_dynamo_1.DyFM_Log.log(`Local vector search: loading all data...`);
+                }
+                dataList = await this.getAll(true);
+            }
+            if (dataList.length === 0) {
+                if (this.debugLog) {
+                    fsm_dynamo_1.DyFM_Log.log(`Local vector search: no data found`);
+                }
+                return [];
+            }
+            // 2. Kinyerjük a vectorized property-ket és építjük a vector pool-t
+            if (this.debugLog) {
+                fsm_dynamo_1.DyFM_Log.log(`Local vector search: building vector pool from ${dataList.length} items...`);
+            }
+            // Töröljük a korábbi pool-t
+            this.vectorPool.clearPool();
+            // Hozzáadjuk a vektorokat a pool-hoz
+            const dataMap = new Map();
+            for (const dataItem of dataList) {
+                if (!dataItem._id) {
+                    // Ha nincs _id, akkor kihagyjuk
+                    if (this.debugLog) {
+                        fsm_dynamo_1.DyFM_Log.warn(`Local vector search: skipping item without _id`);
+                    }
+                    continue;
+                }
+                const vectorizedValue = dataItem[searchInKey];
+                if (!vectorizedValue || !Array.isArray(vectorizedValue)) {
+                    // Ha nincs vectorized érték, akkor kihagyjuk
+                    if (this.debugLog) {
+                        fsm_dynamo_1.DyFM_Log.warn(`Local vector search: skipping item "${dataItem._id}" ` +
+                            `without vectorized value for "${searchInKey}"`);
+                    }
+                    continue;
+                }
+                // Hozzáadjuk a vektort a pool-hoz
+                this.vectorPool.addVector(dataItem._id, vectorizedValue);
+                dataMap.set(dataItem._id, dataItem);
+            }
+            if (dataMap.size === 0) {
+                if (this.debugLog) {
+                    fsm_dynamo_1.DyFM_Log.log(`Local vector search: no valid vectors found`);
+                }
+                return [];
+            }
+            // 3. Vectorizáljuk a query input-ot
+            if (this.debugLog) {
+                fsm_dynamo_1.DyFM_Log.log(`Local vector search: vectorizing query input...`);
+            }
+            const queryVector = await this.vectorize(input, property.embeddingModel);
+            // 4. Végrehajtjuk a local vector search-t
+            const mode = effectiveMode;
+            if (this.debugLog) {
+                fsm_dynamo_1.DyFM_Log.log(`Local vector search: searching with mode "${mode}", limit: ${limit}...`);
+            }
+            let searchResults;
+            if (mode === lvs_search_mode_enum_1.LVS_Search_Mode.hybrid) {
+                // Hybrid: cosine ALL candidate-re + BM25 ALL candidate-re + min-max norm + weighted sum
+                const allCandidatesCosine = this.vectorPool.search(queryVector, dataMap.size, lvs_search_mode_enum_1.LVS_Search_Mode.cosineSimilarity);
+                // BM25 corpus epitese a `textSearchKey` property-bol
+                const docs = [];
+                for (const [docId, dataItem] of dataMap) {
+                    const textValue = dataItem[textSearchKey];
+                    docs.push({
+                        id: docId,
+                        text: typeof textValue === 'string' ? textValue : '',
+                    });
+                }
+                const bm25Corpus = new lvs_bm25_util_1.DyNTS_LVS_BM25_Corpus(docs);
+                const bm25Raw = bm25Corpus.score(input);
+                const bm25Normalized = (0, lvs_bm25_util_1.dyNTS_LVS_BM25_minMaxNormalize)(bm25Raw);
+                const bm25ScoreById = new Map();
+                for (const s of bm25Normalized) {
+                    bm25ScoreById.set(s.id, s.score);
+                }
+                const wVector = hybridWeight?.vector ?? 0.5;
+                const wText = hybridWeight?.text ?? 0.5;
+                const merged = allCandidatesCosine.map((c) => {
+                    const bm25Score = bm25ScoreById.get(c.id) ?? 0;
+                    return {
+                        id: c.id,
+                        score: wVector * c.score + wText * bm25Score,
+                    };
+                });
+                merged.sort((a, b) => b.score - a.score);
+                searchResults = merged.slice(0, limit);
+            }
+            else {
+                searchResults = this.vectorPool.search(queryVector, limit, mode);
+            }
+            if (this.debugLog) {
+                fsm_dynamo_1.DyFM_Log.log(`Local vector search: found ${searchResults.length} results`);
+            }
+            // 5. Map-eljük vissza a search results-ot a teljes data objektumokra
+            const results = [];
+            for (const searchResult of searchResults) {
+                const dataItem = dataMap.get(searchResult.id);
+                if (dataItem) {
+                    results.push(dataItem);
+                }
+            }
+            // Töröljük a pool-t a memória felszabadítása érdekében
+            this.vectorPool.clearPool();
+            return results;
+        }
+        catch (error) {
+            // Töröljük a pool-t hiba esetén is
+            this.vectorPool.clearPool();
+            throw new fsm_dynamo_1.DyFM_Error({
+                ...this.getDefaultErrorSettings('vectorSearch', error),
+                errorCode: `${global_settings_const_1.DyNTS_global_settings.systemShortCodeName}|DyNTS-LVS-VS0`,
+            });
+        }
+    }
+}
+exports.DyNTS_LVS_VectorDataService = DyNTS_LVS_VectorDataService;
+/**
+ * @example
+ * ```typescript
+ * // Create a local vector data service
+ * const localVectorService = new DyNTS_OAI_LocalVectorDataService<CodeChunk>(
+ *   new CodeChunk(),
+ *   codeChunk_dataParams,
+ *   openAISettings,
+ *   'example-issuer'
+ * );
+ *
+ * // Perform vector search with filterBy
+ * const results = await localVectorService.vectorSearch({
+ *   input: 'How to implement authentication?',
+ *   searchInKey: 'chunkParentedContentVectorized',
+ *   limit: 5,
+ *   filterBy: {
+ *     // Filter by category before vector search
+ *     category: 'documentation'
+ *   },
+ *   searchMode: LVS_Search_Mode.cosineSimilarity
+ * });
+ *
+ * // Results are sorted by similarity score (highest first for cosine)
+ * console.log(`Found ${results.length} similar chunks`);
+ *
+ * // Access the results
+ * for (const result of results) {
+ *   console.log(`Chunk ID: ${result._id}, Content: ${result.chunkContent}`);
+ * }
+ * ```
+ */
 //# sourceMappingURL=lvs-local-vector-search.data-service.js.map