@futdevpro/nts-dynamo 1.15.53 → 1.15.55

package/src/_modules/local-vector-search/_services/lvs-vector-pool.control-service.ts

@@ -1,220 +1,220 @@
-import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
-import { LVS_SearchResult } from '../_models/lvs-search-result.interface';
-
-/**
- * Vektor pool kezelő utility class
- * Instance-based class, amely in-memory vektor pool-t kezel és vektor hasonlósági számításokat végez
- * Minden instance saját vektor pool-t tart fenn
- */
-export class LVS_VectorPool_ControlService {
-  /**
-   * In-memory vektor pool tárolás
-   * Key: vektor ID, Value: vektor értékek
-   */
-  private vectorPool: Map<string, number[]> = new Map<string, number[]>();
-
-  /**
-   * Normalizált vektor pool tárolás (L2 normalizált másolatok)
-   * Key: vektor ID, Value: L2 normalizált vektor értékek
-   */
-  private normalizedVectorPool: Map<string, number[]> = new Map<string, number[]>();
-
-  /**
-   * Hozzáad egy vektort a pool-hoz
-   * Opcionálisan L2 normalizált másolatot is tárol
-   */
-  addVector(id: string, vector: number[]): void {
-    if (!id) {
-      throw new Error('Vector ID is required');
-    }
-
-    if (!Array.isArray(vector) || vector.length === 0) {
-      throw new Error('Vector must be a non-empty array');
-    }
-
-    // Validáljuk, hogy a vektor számokból áll
-    for (let i: number = 0; i < vector.length; i++) {
-      if (typeof vector[i] !== 'number' || !isFinite(vector[i])) {
-        throw new Error(`Vector must contain only finite numbers at index ${i}`);
-      }
-    }
-
-    // Tároljuk az eredeti vektort
-    this.vectorPool.set(id, vector);
-
-    // L2 normalizált másolatot is tárolunk a cosine similarity számításokhoz
-    const normalized: number[] = LVS_VectorPool_ControlService.l2Normalize(vector);
-    this.normalizedVectorPool.set(id, normalized);
-  }
-
-  /**
-   * Eltávolít egy vektort a pool-ból
-   */
-  removeVector(id: string): void {
-    this.vectorPool.delete(id);
-    this.normalizedVectorPool.delete(id);
-  }
-
-  /**
-   * Frissít egy vektort a pool-ban
-   */
-  updateVector(id: string, vector: number[]): void {
-    if (!this.vectorPool.has(id)) {
-      throw new Error(`Vector with ID "${id}" does not exist`);
-    }
-
-    this.addVector(id, vector);
-  }
-
-  /**
-   * Törli az összes vektort a pool-ból
-   */
-  clearPool(): void {
-    this.vectorPool.clear();
-    this.normalizedVectorPool.clear();
-  }
-
-  /**
-   * Visszaadja az összes vektort a pool-ból
-   * Debugging és export céljára
-   */
-  getAll(): Map<string, number[]> {
-    return new Map<string, number[]>(this.vectorPool);
-  }
-
-  /**
-   * L2 normalizálás egy vektorra
-   * A vektor hosszát 1-re normalizálja
-   * Statikus metódus, mivel nincs szüksége instance state-re
-   */
-  private static l2Normalize(vector: number[]): number[] {
-    const magnitude: number = Math.sqrt(
-      vector.reduce((sum: number, value: number) => sum + value * value, 0)
-    );
-
-    if (magnitude === 0) {
-      // Ha a vektor nullvektor, akkor nullvektort adunk vissza
-      return new Array<number>(vector.length).fill(0);
-    }
-
-    return vector.map((value: number) => value / magnitude);
-  }
-
-  /**
-   * Cosine similarity számítás két vektor között
-   * Normalizált vektorokat használ a számításhoz
-   * Eredmény: 0 és 1 közötti érték, ahol 1 a legnagyobb hasonlóság
-   * Statikus metódus, mivel nincs szüksége instance state-re
-   */
-  static cosineSimilarity(a: number[], b: number[]): number {
-    if (a.length !== b.length) {
-      throw new Error(
-        `Vectors must have the same dimension. Got ${a.length} and ${b.length}`
-      );
-    }
-
-    // Normalizáljuk a vektorokat
-    const normalizedA: number[] = this.l2Normalize(a);
-    const normalizedB: number[] = this.l2Normalize(b);
-
-    // Dot product számítása
-    let dotProduct: number = 0;
-    for (let i: number = 0; i < normalizedA.length; i++) {
-      dotProduct += normalizedA[i] * normalizedB[i];
-    }
-
-    // Cosine similarity = dot product of normalized vectors
-    // Mivel a vektorok normalizáltak, ez egyenlő a cosine similarity-vel
-    return dotProduct;
-  }
-
-  /**
-   * L2 distance (Euklideszi távolság) számítás két vektor között
-   * Eredmény: 0 vagy pozitív érték, ahol 0 a legkisebb távolság
-   * Statikus metódus, mivel nincs szüksége instance state-re
-   */
-  static l2Distance(a: number[], b: number[]): number {
-    if (a.length !== b.length) {
-      throw new Error(
-        `Vectors must have the same dimension. Got ${a.length} and ${b.length}`
-      );
-    }
-
-    // L2 distance = sqrt(sum((a[i] - b[i])^2))
-    let sumSquaredDiff: number = 0;
-    for (let i: number = 0; i < a.length; i++) {
-      const diff: number = a[i] - b[i];
-      sumSquaredDiff += diff * diff;
-    }
-
-    return Math.sqrt(sumSquaredDiff);
-  }
-
-  /**
-   * Vektor keresés a pool-ban
-   * Brute-force megközelítés (lineáris keresés)
-   * 
-   * @param query A keresési query vektor
-   * @param k A visszaadandó találatok száma (top-K)
-   * @param mode A keresési mód (cosine similarity vagy L2 distance)
-   * @returns A top-K találatok ID-val és score-rel, megfelelő sorrendben
-   */
-  search(
-    query: number[],
-    k: number,
-    mode: LVS_Search_Mode
-  ): LVS_SearchResult[] {
-    if (!Array.isArray(query) || query.length === 0) {
-      throw new Error('Query vector must be a non-empty array');
-    }
-
-    if (k <= 0) {
-      throw new Error('k must be a positive number');
-    }
-
-    if (this.vectorPool.size === 0) {
-      return [];
-    }
-
-    // Validáljuk, hogy minden vektor ugyanolyan dimenziójú-e
-    const firstVector: number[] | undefined = Array.from(this.vectorPool.values())[0];
-    if (firstVector && firstVector.length !== query.length) {
-      throw new Error(
-        `Query vector dimension (${query.length}) does not match pool vector ` +
-        `dimension (${firstVector.length})`
-      );
-    }
-
-    // Számoljuk ki a hasonlóságot/távolságot minden vektorra
-    const results: LVS_SearchResult[] = [];
-
-    for (const [id, vector] of this.vectorPool.entries()) {
-      let score: number;
-
-      if (mode === LVS_Search_Mode.cosineSimilarity) {
-        // Cosine similarity: nagyobb érték = jobb hasonlóság
-        score = LVS_VectorPool_ControlService.cosineSimilarity(query, vector);
-      } else if (mode === LVS_Search_Mode.l2Distance) {
-        // L2 distance: kisebb érték = jobb hasonlóság
-        score = LVS_VectorPool_ControlService.l2Distance(query, vector);
-      } else {
-        throw new Error(`Unknown search mode: ${mode}`);
-      }
-
-      results.push({ id, score });
-    }
-
-    // Rendezzük az eredményeket
-    if (mode === LVS_Search_Mode.cosineSimilarity) {
-      // Cosine similarity: csökkenő sorrend (legnagyobb hasonlóság először)
-      results.sort((a: LVS_SearchResult, b: LVS_SearchResult) => b.score - a.score);
-    } else {
-      // L2 distance: növekvő sorrend (legkisebb távolság először)
-      results.sort((a: LVS_SearchResult, b: LVS_SearchResult) => a.score - b.score);
-    }
-
-    // Visszaadjuk a top-K találatot
-    return results.slice(0, k);
-  }
-}
-
+import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
+import { LVS_SearchResult } from '../_models/lvs-search-result.interface';
+
+/**
+ * Vektor pool kezelő utility class
+ * Instance-based class, amely in-memory vektor pool-t kezel és vektor hasonlósági számításokat végez
+ * Minden instance saját vektor pool-t tart fenn
+ */
+export class LVS_VectorPool_ControlService {
+  /**
+   * In-memory vektor pool tárolás
+   * Key: vektor ID, Value: vektor értékek
+   */
+  private vectorPool: Map<string, number[]> = new Map<string, number[]>();
+
+  /**
+   * Normalizált vektor pool tárolás (L2 normalizált másolatok)
+   * Key: vektor ID, Value: L2 normalizált vektor értékek
+   */
+  private normalizedVectorPool: Map<string, number[]> = new Map<string, number[]>();
+
+  /**
+   * Hozzáad egy vektort a pool-hoz
+   * Opcionálisan L2 normalizált másolatot is tárol
+   */
+  addVector(id: string, vector: number[]): void {
+    if (!id) {
+      throw new Error('Vector ID is required');
+    }
+
+    if (!Array.isArray(vector) || vector.length === 0) {
+      throw new Error('Vector must be a non-empty array');
+    }
+
+    // Validáljuk, hogy a vektor számokból áll
+    for (let i: number = 0; i < vector.length; i++) {
+      if (typeof vector[i] !== 'number' || !isFinite(vector[i])) {
+        throw new Error(`Vector must contain only finite numbers at index ${i}`);
+      }
+    }
+
+    // Tároljuk az eredeti vektort
+    this.vectorPool.set(id, vector);
+
+    // L2 normalizált másolatot is tárolunk a cosine similarity számításokhoz
+    const normalized: number[] = LVS_VectorPool_ControlService.l2Normalize(vector);
+    this.normalizedVectorPool.set(id, normalized);
+  }
+
+  /**
+   * Eltávolít egy vektort a pool-ból
+   */
+  removeVector(id: string): void {
+    this.vectorPool.delete(id);
+    this.normalizedVectorPool.delete(id);
+  }
+
+  /**
+   * Frissít egy vektort a pool-ban
+   */
+  updateVector(id: string, vector: number[]): void {
+    if (!this.vectorPool.has(id)) {
+      throw new Error(`Vector with ID "${id}" does not exist`);
+    }
+
+    this.addVector(id, vector);
+  }
+
+  /**
+   * Törli az összes vektort a pool-ból
+   */
+  clearPool(): void {
+    this.vectorPool.clear();
+    this.normalizedVectorPool.clear();
+  }
+
+  /**
+   * Visszaadja az összes vektort a pool-ból
+   * Debugging és export céljára
+   */
+  getAll(): Map<string, number[]> {
+    return new Map<string, number[]>(this.vectorPool);
+  }
+
+  /**
+   * L2 normalizálás egy vektorra
+   * A vektor hosszát 1-re normalizálja
+   * Statikus metódus, mivel nincs szüksége instance state-re
+   */
+  private static l2Normalize(vector: number[]): number[] {
+    const magnitude: number = Math.sqrt(
+      vector.reduce((sum: number, value: number) => sum + value * value, 0)
+    );
+
+    if (magnitude === 0) {
+      // Ha a vektor nullvektor, akkor nullvektort adunk vissza
+      return new Array<number>(vector.length).fill(0);
+    }
+
+    return vector.map((value: number) => value / magnitude);
+  }
+
+  /**
+   * Cosine similarity számítás két vektor között
+   * Normalizált vektorokat használ a számításhoz
+   * Eredmény: 0 és 1 közötti érték, ahol 1 a legnagyobb hasonlóság
+   * Statikus metódus, mivel nincs szüksége instance state-re
+   */
+  static cosineSimilarity(a: number[], b: number[]): number {
+    if (a.length !== b.length) {
+      throw new Error(
+        `Vectors must have the same dimension. Got ${a.length} and ${b.length}`
+      );
+    }
+
+    // Normalizáljuk a vektorokat
+    const normalizedA: number[] = this.l2Normalize(a);
+    const normalizedB: number[] = this.l2Normalize(b);
+
+    // Dot product számítása
+    let dotProduct: number = 0;
+    for (let i: number = 0; i < normalizedA.length; i++) {
+      dotProduct += normalizedA[i] * normalizedB[i];
+    }
+
+    // Cosine similarity = dot product of normalized vectors
+    // Mivel a vektorok normalizáltak, ez egyenlő a cosine similarity-vel
+    return dotProduct;
+  }
+
+  /**
+   * L2 distance (Euklideszi távolság) számítás két vektor között
+   * Eredmény: 0 vagy pozitív érték, ahol 0 a legkisebb távolság
+   * Statikus metódus, mivel nincs szüksége instance state-re
+   */
+  static l2Distance(a: number[], b: number[]): number {
+    if (a.length !== b.length) {
+      throw new Error(
+        `Vectors must have the same dimension. Got ${a.length} and ${b.length}`
+      );
+    }
+
+    // L2 distance = sqrt(sum((a[i] - b[i])^2))
+    let sumSquaredDiff: number = 0;
+    for (let i: number = 0; i < a.length; i++) {
+      const diff: number = a[i] - b[i];
+      sumSquaredDiff += diff * diff;
+    }
+
+    return Math.sqrt(sumSquaredDiff);
+  }
+
+  /**
+   * Vektor keresés a pool-ban
+   * Brute-force megközelítés (lineáris keresés)
+   * 
+   * @param query A keresési query vektor
+   * @param k A visszaadandó találatok száma (top-K)
+   * @param mode A keresési mód (cosine similarity vagy L2 distance)
+   * @returns A top-K találatok ID-val és score-rel, megfelelő sorrendben
+   */
+  search(
+    query: number[],
+    k: number,
+    mode: LVS_Search_Mode
+  ): LVS_SearchResult[] {
+    if (!Array.isArray(query) || query.length === 0) {
+      throw new Error('Query vector must be a non-empty array');
+    }
+
+    if (k <= 0) {
+      throw new Error('k must be a positive number');
+    }
+
+    if (this.vectorPool.size === 0) {
+      return [];
+    }
+
+    // Validáljuk, hogy minden vektor ugyanolyan dimenziójú-e
+    const firstVector: number[] | undefined = Array.from(this.vectorPool.values())[0];
+    if (firstVector && firstVector.length !== query.length) {
+      throw new Error(
+        `Query vector dimension (${query.length}) does not match pool vector ` +
+        `dimension (${firstVector.length})`
+      );
+    }
+
+    // Számoljuk ki a hasonlóságot/távolságot minden vektorra
+    const results: LVS_SearchResult[] = [];
+
+    for (const [id, vector] of this.vectorPool.entries()) {
+      let score: number;
+
+      if (mode === LVS_Search_Mode.cosineSimilarity) {
+        // Cosine similarity: nagyobb érték = jobb hasonlóság
+        score = LVS_VectorPool_ControlService.cosineSimilarity(query, vector);
+      } else if (mode === LVS_Search_Mode.l2Distance) {
+        // L2 distance: kisebb érték = jobb hasonlóság
+        score = LVS_VectorPool_ControlService.l2Distance(query, vector);
+      } else {
+        throw new Error(`Unknown search mode: ${mode}`);
+      }
+
+      results.push({ id, score });
+    }
+
+    // Rendezzük az eredményeket
+    if (mode === LVS_Search_Mode.cosineSimilarity) {
+      // Cosine similarity: csökkenő sorrend (legnagyobb hasonlóság először)
+      results.sort((a: LVS_SearchResult, b: LVS_SearchResult) => b.score - a.score);
+    } else {
+      // L2 distance: növekvő sorrend (legkisebb távolság először)
+      results.sort((a: LVS_SearchResult, b: LVS_SearchResult) => a.score - b.score);
+    }
+
+    // Visszaadjuk a top-K találatot
+    return results.slice(0, k);
+  }
+}
+

package/src/_modules/local-vector-search/index.ts

@@ -1,12 +1,12 @@
-
-
-// ENUMS
-export * from './_enums/lvs-search-mode.enum';
-
-// INTERFACES
-export * from './_models/lvs-search-result.interface';
-
-// SERVICES
-export * from './_services/lvs-doc-chunk-data.service';
-export * from './_services/lvs-local-vector-search.data-service';
+
+
+// ENUMS
+export * from './_enums/lvs-search-mode.enum';
+
+// INTERFACES
+export * from './_models/lvs-search-result.interface';
+
+// SERVICES
+export * from './_services/lvs-doc-chunk-data.service';
+export * from './_services/lvs-local-vector-search.data-service';
 export * from './_services/lvs-vector-pool.control-service';

package/src/_modules/logs/index.ts

@@ -1,11 +1,11 @@
-export { DyNTS_Logs_Service } from './logs.service';
-export { DyNTS_Logs_Controller, DyNTS_LogsController_Config } from './logs.controller';
-export { DyNTS_getLogsRoutingModule } from './get-logs-routing-module.util';
-export { DyNTS_FileLog_Service } from './file-log.service';
-export { DyNTS_FileLogs_Controller, DyNTS_FileLogsController_Config } from './file-logs.controller';
-export {
-  DyNTS_getFileLogsRoutingModule,
-  DyNTS_FileLogsRoutingModule_Config,
-} from './get-file-logs-routing-module.util';
-export { DyNTS_FileLog_Entry } from './_models/file-log-entry.interface';
-export { DyNTS_FileLog_ReadResult, DyNTS_FileLog_ReadOptions } from './_models/file-log-read-result.interface';
+export { DyNTS_Logs_Service } from './logs.service';
+export { DyNTS_Logs_Controller, DyNTS_LogsController_Config } from './logs.controller';
+export { DyNTS_getLogsRoutingModule } from './get-logs-routing-module.util';
+export { DyNTS_FileLog_Service } from './file-log.service';
+export { DyNTS_FileLogs_Controller, DyNTS_FileLogsController_Config } from './file-logs.controller';
+export {
+  DyNTS_getFileLogsRoutingModule,
+  DyNTS_FileLogsRoutingModule_Config,
+} from './get-file-logs-routing-module.util';
+export { DyNTS_FileLog_Entry } from './_models/file-log-entry.interface';
+export { DyNTS_FileLog_ReadResult, DyNTS_FileLog_ReadOptions } from './_models/file-log-read-result.interface';