@atom8n/n8n-nodes-langchain 2.2.0

package/dist/nodes/vector_store/shared/MemoryManager/MemoryCalculator.js

@@ -0,0 +1,78 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MemoryCalculator_exports = {};
+__export(MemoryCalculator_exports, {
+  MemoryCalculator: () => MemoryCalculator
+});
+module.exports = __toCommonJS(MemoryCalculator_exports);
+const FLOAT_SIZE_BYTES = 8;
+const CHAR_SIZE_BYTES = 2;
+const VECTOR_OVERHEAD_BYTES = 200;
+const EMBEDDING_DIMENSIONS = 1536;
+const EMBEDDING_SIZE_BYTES = EMBEDDING_DIMENSIONS * FLOAT_SIZE_BYTES;
+const AVG_METADATA_SIZE_BYTES = 100;
+class MemoryCalculator {
+  /**
+   * Fast batch size estimation for multiple documents
+   */
+  estimateBatchSize(documents) {
+    if (documents.length === 0) return 0;
+    let totalContentSize = 0;
+    let totalMetadataSize = 0;
+    for (const doc of documents) {
+      if (doc.pageContent) {
+        totalContentSize += doc.pageContent.length * CHAR_SIZE_BYTES;
+      }
+      if (doc.metadata) {
+        const metadataKeys = Object.keys(doc.metadata).length;
+        if (metadataKeys > 0) {
+          totalMetadataSize += metadataKeys * AVG_METADATA_SIZE_BYTES;
+        }
+      }
+    }
+    const embeddingSize = documents.length * EMBEDDING_SIZE_BYTES;
+    const overhead = documents.length * VECTOR_OVERHEAD_BYTES;
+    const calculatedSize = totalContentSize + totalMetadataSize + embeddingSize + overhead;
+    return Math.ceil(calculatedSize);
+  }
+  /**
+   * Calculate the size of a vector store by examining its contents
+   */
+  calculateVectorStoreSize(vectorStore) {
+    if (!vectorStore.memoryVectors || vectorStore.memoryVectors.length === 0) {
+      return 0;
+    }
+    let storeSize = 0;
+    for (const vector of vectorStore.memoryVectors) {
+      storeSize += vector.embedding.length * FLOAT_SIZE_BYTES;
+      storeSize += vector.content ? vector.content.length * CHAR_SIZE_BYTES : 0;
+      if (vector.metadata) {
+        const metadataStr = JSON.stringify(vector.metadata);
+        storeSize += metadataStr.length * CHAR_SIZE_BYTES;
+      }
+      storeSize += VECTOR_OVERHEAD_BYTES;
+    }
+    return Math.ceil(storeSize);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryCalculator
+});
+//# sourceMappingURL=MemoryCalculator.js.map

package/dist/nodes/vector_store/shared/MemoryManager/MemoryCalculator.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../nodes/vector_store/shared/MemoryManager/MemoryCalculator.ts"],"sourcesContent":["import type { Document } from '@langchain/core/documents';\nimport type { MemoryVectorStore } from '@langchain/classic/vectorstores/memory';\n\nimport type { IMemoryCalculator } from './types';\n\n// Memory estimation constants\nconst FLOAT_SIZE_BYTES = 8; // Size of a float64 in bytes\nconst CHAR_SIZE_BYTES = 2; // Size of a JavaScript character in bytes(2 bytes per character in UTF-16)\nconst VECTOR_OVERHEAD_BYTES = 200; // Estimated overhead per vector\nconst EMBEDDING_DIMENSIONS = 1536; // Fixed embedding dimensions\nconst EMBEDDING_SIZE_BYTES = EMBEDDING_DIMENSIONS * FLOAT_SIZE_BYTES;\nconst AVG_METADATA_SIZE_BYTES = 100; // Average size for simple metadata\n\n/**\n * Calculates memory usage for vector stores and documents\n */\nexport class MemoryCalculator implements IMemoryCalculator {\n\t/**\n\t * Fast batch size estimation for multiple documents\n\t */\n\testimateBatchSize(documents: Document[]): number {\n\t\tif (documents.length === 0) return 0;\n\n\t\tlet totalContentSize = 0;\n\t\tlet totalMetadataSize = 0;\n\n\t\t// Single pass through documents for content and metadata estimation\n\t\tfor (const doc of documents) {\n\t\t\tif (doc.pageContent) {\n\t\t\t\ttotalContentSize += doc.pageContent.length * CHAR_SIZE_BYTES;\n\t\t\t}\n\n\t\t\t// Metadata size estimation\n\t\t\tif (doc.metadata) {\n\t\t\t\t// For simple objects, estimate based on key count\n\t\t\t\tconst metadataKeys = Object.keys(doc.metadata).length;\n\t\t\t\tif (metadataKeys > 0) {\n\t\t\t\t\t// For each key, estimate the key name plus a typical value\n\t\t\t\t\t// plus some overhead for object structure\n\t\t\t\t\ttotalMetadataSize += metadataKeys * AVG_METADATA_SIZE_BYTES;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// Fixed size components (embedding vectors and overhead)\n\t\t// Each embedding is a fixed-size array of floating point numbers\n\t\tconst embeddingSize = documents.length * EMBEDDING_SIZE_BYTES;\n\n\t\t// Object overhead, each vector is stored with additional JS object structure\n\t\tconst overhead = documents.length * VECTOR_OVERHEAD_BYTES;\n\n\t\t// Calculate total batch size with a safety factor to avoid underestimation\n\t\tconst calculatedSize = totalContentSize + totalMetadataSize + embeddingSize + overhead;\n\n\t\treturn Math.ceil(calculatedSize);\n\t}\n\n\t/**\n\t * Calculate the size of a vector store by examining its contents\n\t */\n\tcalculateVectorStoreSize(vectorStore: MemoryVectorStore): number {\n\t\tif (!vectorStore.memoryVectors || vectorStore.memoryVectors.length === 0) {\n\t\t\treturn 0;\n\t\t}\n\n\t\tlet storeSize = 0;\n\n\t\t// Calculate size of each vector\n\t\tfor (const vector of vectorStore.memoryVectors) {\n\t\t\t// Size of embedding (float64 array)\n\t\t\tstoreSize += vector.embedding.length * FLOAT_SIZE_BYTES;\n\n\t\t\t// Size of content string (2 bytes per character in JS)\n\t\t\tstoreSize += vector.content ? vector.content.length * CHAR_SIZE_BYTES : 0;\n\n\t\t\t// Estimate metadata size\n\t\t\tif (vector.metadata) {\n\t\t\t\t// Use a more accurate calculation for metadata\n\t\t\t\tconst metadataStr = JSON.stringify(vector.metadata);\n\t\t\t\tstoreSize += metadataStr.length * CHAR_SIZE_BYTES;\n\t\t\t}\n\n\t\t\t// Add overhead for object structure\n\t\t\tstoreSize += VECTOR_OVERHEAD_BYTES;\n\t\t}\n\n\t\treturn Math.ceil(storeSize);\n\t}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,MAAM,mBAAmB;AACzB,MAAM,kBAAkB;AACxB,MAAM,wBAAwB;AAC9B,MAAM,uBAAuB;AAC7B,MAAM,uBAAuB,uBAAuB;AACpD,MAAM,0BAA0B;AAKzB,MAAM,iBAA8C;AAAA;AAAA;AAAA;AAAA,EAI1D,kBAAkB,WAA+B;AAChD,QAAI,UAAU,WAAW,EAAG,QAAO;AAEnC,QAAI,mBAAmB;AACvB,QAAI,oBAAoB;AAGxB,eAAW,OAAO,WAAW;AAC5B,UAAI,IAAI,aAAa;AACpB,4BAAoB,IAAI,YAAY,SAAS;AAAA,MAC9C;AAGA,UAAI,IAAI,UAAU;AAEjB,cAAM,eAAe,OAAO,KAAK,IAAI,QAAQ,EAAE;AAC/C,YAAI,eAAe,GAAG;AAGrB,+BAAqB,eAAe;AAAA,QACrC;AAAA,MACD;AAAA,IACD;AAIA,UAAM,gBAAgB,UAAU,SAAS;AAGzC,UAAM,WAAW,UAAU,SAAS;AAGpC,UAAM,iBAAiB,mBAAmB,oBAAoB,gBAAgB;AAE9E,WAAO,KAAK,KAAK,cAAc;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA,EAKA,yBAAyB,aAAwC;AAChE,QAAI,CAAC,YAAY,iBAAiB,YAAY,cAAc,WAAW,GAAG;AACzE,aAAO;AAAA,IACR;AAEA,QAAI,YAAY;AAGhB,eAAW,UAAU,YAAY,eAAe;AAE/C,mBAAa,OAAO,UAAU,SAAS;AAGvC,mBAAa,OAAO,UAAU,OAAO,QAAQ,SAAS,kBAAkB;AAGxE,UAAI,OAAO,UAAU;AAEpB,cAAM,cAAc,KAAK,UAAU,OAAO,QAAQ;AAClD,qBAAa,YAAY,SAAS;AAAA,MACnC;AAGA,mBAAa;AAAA,IACd;AAEA,WAAO,KAAK,KAAK,SAAS;AAAA,EAC3B;AACD;","names":[]}

package/dist/nodes/vector_store/shared/MemoryManager/MemoryVectorStoreManager.js

@@ -0,0 +1,237 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var MemoryVectorStoreManager_exports = {};
+__export(MemoryVectorStoreManager_exports, {
+  MemoryVectorStoreManager: () => MemoryVectorStoreManager
+});
+module.exports = __toCommonJS(MemoryVectorStoreManager_exports);
+var import_memory = require("@langchain/classic/vectorstores/memory");
+var import_config = require("./config");
+var import_MemoryCalculator = require("./MemoryCalculator");
+var import_StoreCleanupService = require("./StoreCleanupService");
+const _MemoryVectorStoreManager = class _MemoryVectorStoreManager {
+  constructor(embeddings, logger) {
+    this.embeddings = embeddings;
+    this.logger = logger;
+    this.memoryUsageBytes = 0;
+    // Inactive TTL cleanup timer
+    this.ttlCleanupIntervalId = null;
+    this.vectorStoreBuffer = /* @__PURE__ */ new Map();
+    this.storeMetadata = /* @__PURE__ */ new Map();
+    this.logger = logger;
+    const config = (0, import_config.getConfig)();
+    this.maxMemorySizeBytes = (0, import_config.mbToBytes)(config.maxMemoryMB);
+    this.inactiveTtlMs = (0, import_config.hoursToMs)(config.ttlHours);
+    this.memoryCalculator = new import_MemoryCalculator.MemoryCalculator();
+    this.cleanupService = new import_StoreCleanupService.StoreCleanupService(
+      this.maxMemorySizeBytes,
+      this.inactiveTtlMs,
+      this.vectorStoreBuffer,
+      this.storeMetadata,
+      this.handleCleanup.bind(this)
+    );
+    this.setupTtlCleanup();
+  }
+  /**
+   * Get singleton instance
+   */
+  static getInstance(embeddings, logger) {
+    if (!_MemoryVectorStoreManager.instance) {
+      _MemoryVectorStoreManager.instance = new _MemoryVectorStoreManager(embeddings, logger);
+    } else {
+      _MemoryVectorStoreManager.instance.embeddings = embeddings;
+      _MemoryVectorStoreManager.instance.vectorStoreBuffer.forEach((vectorStoreInstance) => {
+        vectorStoreInstance.embeddings = embeddings;
+      });
+    }
+    return _MemoryVectorStoreManager.instance;
+  }
+  /**
+   * Set up timer for TTL-based cleanup
+   */
+  setupTtlCleanup() {
+    if (this.inactiveTtlMs <= 0) {
+      return;
+    }
+    const CLEANUP_INTERVAL_MS = 60 * 60 * 1e3;
+    if (this.ttlCleanupIntervalId) {
+      clearInterval(this.ttlCleanupIntervalId);
+    }
+    this.ttlCleanupIntervalId = setInterval(() => {
+      this.cleanupService.cleanupInactiveStores();
+    }, CLEANUP_INTERVAL_MS);
+  }
+  /**
+   * Handle cleanup events from the cleanup service
+   */
+  handleCleanup(removedKeys, freedBytes, reason) {
+    this.memoryUsageBytes -= freedBytes;
+    if (reason === "ttl") {
+      const ttlHours = Math.round(this.inactiveTtlMs / (60 * 60 * 1e3));
+      this.logger.info(
+        `TTL cleanup: removed ${removedKeys.length} inactive vector stores (${ttlHours}h TTL) to free ${Math.round(freedBytes / (1024 * 1024))}MB of memory`
+      );
+    } else {
+      this.logger.info(
+        `Memory cleanup: removed ${removedKeys.length} oldest vector stores to free ${Math.round(freedBytes / (1024 * 1024))}MB of memory`
+      );
+    }
+  }
+  getMemoryKeysList() {
+    return Array.from(this.vectorStoreBuffer.keys());
+  }
+  /**
+   * Get or create a vector store by key
+   */
+  async getVectorStore(memoryKey) {
+    let vectorStoreInstance = this.vectorStoreBuffer.get(memoryKey);
+    if (!vectorStoreInstance) {
+      vectorStoreInstance = await import_memory.MemoryVectorStore.fromExistingIndex(this.embeddings);
+      this.vectorStoreBuffer.set(memoryKey, vectorStoreInstance);
+      this.storeMetadata.set(memoryKey, {
+        size: 0,
+        createdAt: /* @__PURE__ */ new Date(),
+        lastAccessed: /* @__PURE__ */ new Date()
+      });
+    } else {
+      const metadata = this.storeMetadata.get(memoryKey);
+      if (metadata) {
+        metadata.lastAccessed = /* @__PURE__ */ new Date();
+      }
+    }
+    return vectorStoreInstance;
+  }
+  /**
+   * Reset a store's metadata when it's cleared
+   */
+  clearStoreMetadata(memoryKey) {
+    const metadata = this.storeMetadata.get(memoryKey);
+    if (metadata) {
+      this.memoryUsageBytes -= metadata.size;
+      metadata.size = 0;
+      metadata.lastAccessed = /* @__PURE__ */ new Date();
+    }
+  }
+  /**
+   * Get memory usage in bytes
+   */
+  getMemoryUsage() {
+    return this.memoryUsageBytes;
+  }
+  /**
+   * Get memory usage as a formatted string (MB)
+   */
+  getMemoryUsageFormatted() {
+    return `${Math.round(this.memoryUsageBytes / (1024 * 1024))}MB`;
+  }
+  /**
+   * Recalculate memory usage from actual vector store contents
+   * This ensures tracking accuracy for large stores
+   */
+  recalculateMemoryUsage() {
+    this.memoryUsageBytes = 0;
+    for (const [key, vectorStore] of this.vectorStoreBuffer.entries()) {
+      const storeSize = this.memoryCalculator.calculateVectorStoreSize(vectorStore);
+      const metadata = this.storeMetadata.get(key);
+      if (metadata) {
+        metadata.size = storeSize;
+        this.memoryUsageBytes += storeSize;
+      }
+    }
+    this.logger.debug(`Recalculated vector store memory: ${this.getMemoryUsageFormatted()}`);
+  }
+  /**
+   * Add documents to a vector store
+   */
+  async addDocuments(memoryKey, documents, clearStore) {
+    if (clearStore) {
+      this.clearStoreMetadata(memoryKey);
+      this.vectorStoreBuffer.delete(memoryKey);
+    }
+    const estimatedAddedSize = this.memoryCalculator.estimateBatchSize(documents);
+    this.cleanupService.cleanupOldestStores(estimatedAddedSize);
+    const vectorStoreInstance = await this.getVectorStore(memoryKey);
+    const vectorCountBefore = vectorStoreInstance.memoryVectors?.length || 0;
+    await vectorStoreInstance.addDocuments(documents);
+    const metadata = this.storeMetadata.get(memoryKey);
+    if (metadata) {
+      metadata.size += estimatedAddedSize;
+      metadata.lastAccessed = /* @__PURE__ */ new Date();
+      this.memoryUsageBytes += estimatedAddedSize;
+    }
+    const vectorCount = vectorStoreInstance.memoryVectors?.length || 0;
+    if (vectorCount > 0 && vectorCount % 100 === 0 || documents.length > 20 || vectorCountBefore === 0 && vectorCount > 0) {
+      this.recalculateMemoryUsage();
+    }
+    const maxMemoryMB = this.maxMemorySizeBytes > 0 ? (this.maxMemorySizeBytes / (1024 * 1024)).toFixed(0) : "unlimited";
+    this.logger.debug(
+      `Vector store memory: ${this.getMemoryUsageFormatted()}/${maxMemoryMB}MB (${vectorCount} vectors in ${this.vectorStoreBuffer.size} stores)`
+    );
+  }
+  /**
+   * Get statistics about the vector store memory usage
+   */
+  getStats() {
+    const now = Date.now();
+    let inactiveStoreCount = 0;
+    this.recalculateMemoryUsage();
+    const stats = {
+      totalSizeBytes: this.memoryUsageBytes,
+      totalSizeMB: Math.round(this.memoryUsageBytes / (1024 * 1024) * 100) / 100,
+      percentOfLimit: this.maxMemorySizeBytes > 0 ? Math.round(this.memoryUsageBytes / this.maxMemorySizeBytes * 100) : 0,
+      maxMemoryMB: this.maxMemorySizeBytes > 0 ? this.maxMemorySizeBytes / (1024 * 1024) : -1,
+      // -1 indicates unlimited
+      storeCount: this.vectorStoreBuffer.size,
+      inactiveStoreCount: 0,
+      ttlHours: this.inactiveTtlMs > 0 ? this.inactiveTtlMs / (60 * 60 * 1e3) : -1,
+      // -1 indicates disabled
+      stores: {}
+    };
+    for (const [key, metadata] of this.storeMetadata.entries()) {
+      const store = this.vectorStoreBuffer.get(key);
+      if (store) {
+        const lastAccessedTime = metadata.lastAccessed.getTime();
+        const inactiveTimeMs = now - lastAccessedTime;
+        const isInactive = this.cleanupService.isStoreInactive(metadata);
+        if (isInactive) {
+          inactiveStoreCount++;
+        }
+        stats.stores[key] = {
+          sizeBytes: metadata.size,
+          sizeMB: Math.round(metadata.size / (1024 * 1024) * 100) / 100,
+          percentOfTotal: Math.round(metadata.size / this.memoryUsageBytes * 100) || 0,
+          vectors: store.memoryVectors?.length || 0,
+          createdAt: metadata.createdAt.toISOString(),
+          lastAccessed: metadata.lastAccessed.toISOString(),
+          inactive: isInactive,
+          inactiveForHours: Math.round(inactiveTimeMs / (60 * 60 * 1e3))
+        };
+      }
+    }
+    stats.inactiveStoreCount = inactiveStoreCount;
+    return stats;
+  }
+};
+_MemoryVectorStoreManager.instance = null;
+let MemoryVectorStoreManager = _MemoryVectorStoreManager;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MemoryVectorStoreManager
+});
+//# sourceMappingURL=MemoryVectorStoreManager.js.map

package/dist/nodes/vector_store/shared/MemoryManager/MemoryVectorStoreManager.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../nodes/vector_store/shared/MemoryManager/MemoryVectorStoreManager.ts"],"sourcesContent":["import type { Document } from '@langchain/core/documents';\nimport type { Embeddings } from '@langchain/core/embeddings';\nimport type { OpenAIEmbeddings, AzureOpenAIEmbeddings } from '@langchain/openai';\nimport { MemoryVectorStore } from '@langchain/classic/vectorstores/memory';\nimport type { Logger } from 'n8n-workflow';\n\nimport { getConfig, mbToBytes, hoursToMs } from './config';\nimport { MemoryCalculator } from './MemoryCalculator';\nimport { StoreCleanupService } from './StoreCleanupService';\nimport type { VectorStoreMetadata, VectorStoreStats } from './types';\n\n/**\n * Manages in-memory vector stores with memory limits and auto-cleanup\n */\nexport class MemoryVectorStoreManager {\n\tprivate static instance: MemoryVectorStoreManager | null = null;\n\n\t// Storage\n\tprotected vectorStoreBuffer: Map<string, MemoryVectorStore>;\n\n\tprotected storeMetadata: Map<string, VectorStoreMetadata>;\n\n\tprotected memoryUsageBytes: number = 0;\n\n\t// Dependencies\n\tprotected memoryCalculator: MemoryCalculator;\n\n\tprotected cleanupService: StoreCleanupService;\n\n\tprotected static logger: Logger;\n\n\t// Config values\n\tprotected maxMemorySizeBytes: number;\n\n\tprotected inactiveTtlMs: number;\n\n\t// Inactive TTL cleanup timer\n\tprotected ttlCleanupIntervalId: NodeJS.Timeout | null = null;\n\n\tprotected constructor(\n\t\tprotected embeddings: Embeddings | OpenAIEmbeddings | AzureOpenAIEmbeddings,\n\t\tprotected logger: Logger,\n\t) {\n\t\t// Initialize storage\n\t\tthis.vectorStoreBuffer = new Map();\n\t\tthis.storeMetadata = new Map();\n\t\tthis.logger = logger;\n\n\t\tconst config = getConfig();\n\t\tthis.maxMemorySizeBytes = mbToBytes(config.maxMemoryMB);\n\t\tthis.inactiveTtlMs = hoursToMs(config.ttlHours);\n\n\t\t// Initialize services\n\t\tthis.memoryCalculator = new MemoryCalculator();\n\t\tthis.cleanupService = new StoreCleanupService(\n\t\t\tthis.maxMemorySizeBytes,\n\t\t\tthis.inactiveTtlMs,\n\t\t\tthis.vectorStoreBuffer,\n\t\t\tthis.storeMetadata,\n\t\t\tthis.handleCleanup.bind(this),\n\t\t);\n\n\t\tthis.setupTtlCleanup();\n\t}\n\n\t/**\n\t * Get singleton instance\n\t */\n\tstatic getInstance(\n\t\tembeddings: Embeddings | OpenAIEmbeddings | AzureOpenAIEmbeddings,\n\t\tlogger: Logger,\n\t): MemoryVectorStoreManager {\n\t\tif (!MemoryVectorStoreManager.instance) {\n\t\t\tMemoryVectorStoreManager.instance = new MemoryVectorStoreManager(embeddings, logger);\n\t\t} else {\n\t\t\t// We need to update the embeddings in the existing instance.\n\t\t\t// This is important as embeddings instance is wrapped in a logWrapper,\n\t\t\t// which relies on supplyDataFunctions context which changes on each workflow run\n\t\t\tMemoryVectorStoreManager.instance.embeddings = embeddings;\n\t\t\tMemoryVectorStoreManager.instance.vectorStoreBuffer.forEach((vectorStoreInstance) => {\n\t\t\t\tvectorStoreInstance.embeddings = embeddings;\n\t\t\t});\n\t\t}\n\n\t\treturn MemoryVectorStoreManager.instance;\n\t}\n\n\t/**\n\t * Set up timer for TTL-based cleanup\n\t */\n\tprivate setupTtlCleanup(): void {\n\t\t// Skip setup if TTL is disabled\n\t\tif (this.inactiveTtlMs <= 0) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Cleanup check interval (run every hour)\n\t\tconst CLEANUP_INTERVAL_MS = 60 * 60 * 1000;\n\n\t\t// Clear any existing interval\n\t\tif (this.ttlCleanupIntervalId) {\n\t\t\tclearInterval(this.ttlCleanupIntervalId);\n\t\t}\n\n\t\t// Setup new interval for TTL cleanup\n\t\tthis.ttlCleanupIntervalId = setInterval(() => {\n\t\t\tthis.cleanupService.cleanupInactiveStores();\n\t\t}, CLEANUP_INTERVAL_MS);\n\t}\n\n\t/**\n\t * Handle cleanup events from the cleanup service\n\t */\n\tprivate handleCleanup(removedKeys: string[], freedBytes: number, reason: 'ttl' | 'memory'): void {\n\t\t// Update total memory usage\n\t\tthis.memoryUsageBytes -= freedBytes;\n\n\t\t// Log cleanup event\n\t\tif (reason === 'ttl') {\n\t\t\tconst ttlHours = Math.round(this.inactiveTtlMs / (60 * 60 * 1000));\n\t\t\tthis.logger.info(\n\t\t\t\t`TTL cleanup: removed ${removedKeys.length} inactive vector stores (${ttlHours}h TTL) to free ${Math.round(freedBytes / (1024 * 1024))}MB of memory`,\n\t\t\t);\n\t\t} else {\n\t\t\tthis.logger.info(\n\t\t\t\t`Memory cleanup: removed ${removedKeys.length} oldest vector stores to free ${Math.round(freedBytes / (1024 * 1024))}MB of memory`,\n\t\t\t);\n\t\t}\n\t}\n\n\tgetMemoryKeysList(): string[] {\n\t\treturn Array.from(this.vectorStoreBuffer.keys());\n\t}\n\n\t/**\n\t * Get or create a vector store by key\n\t */\n\tasync getVectorStore(memoryKey: string): Promise<MemoryVectorStore> {\n\t\tlet vectorStoreInstance = this.vectorStoreBuffer.get(memoryKey);\n\n\t\tif (!vectorStoreInstance) {\n\t\t\tvectorStoreInstance = await MemoryVectorStore.fromExistingIndex(this.embeddings);\n\t\t\tthis.vectorStoreBuffer.set(memoryKey, vectorStoreInstance);\n\n\t\t\tthis.storeMetadata.set(memoryKey, {\n\t\t\t\tsize: 0,\n\t\t\t\tcreatedAt: new Date(),\n\t\t\t\tlastAccessed: new Date(),\n\t\t\t});\n\t\t} else {\n\t\t\tconst metadata = this.storeMetadata.get(memoryKey);\n\t\t\tif (metadata) {\n\t\t\t\tmetadata.lastAccessed = new Date();\n\t\t\t}\n\t\t}\n\n\t\treturn vectorStoreInstance;\n\t}\n\n\t/**\n\t * Reset a store's metadata when it's cleared\n\t */\n\tprotected clearStoreMetadata(memoryKey: string): void {\n\t\tconst metadata = this.storeMetadata.get(memoryKey);\n\t\tif (metadata) {\n\t\t\tthis.memoryUsageBytes -= metadata.size;\n\t\t\tmetadata.size = 0;\n\t\t\tmetadata.lastAccessed = new Date();\n\t\t}\n\t}\n\n\t/**\n\t * Get memory usage in bytes\n\t */\n\tgetMemoryUsage(): number {\n\t\treturn this.memoryUsageBytes;\n\t}\n\n\t/**\n\t * Get memory usage as a formatted string (MB)\n\t */\n\tgetMemoryUsageFormatted(): string {\n\t\treturn `${Math.round(this.memoryUsageBytes / (1024 * 1024))}MB`;\n\t}\n\n\t/**\n\t * Recalculate memory usage from actual vector store contents\n\t * This ensures tracking accuracy for large stores\n\t */\n\trecalculateMemoryUsage(): void {\n\t\tthis.memoryUsageBytes = 0;\n\n\t\t// Recalculate for each store\n\t\tfor (const [key, vectorStore] of this.vectorStoreBuffer.entries()) {\n\t\t\tconst storeSize = this.memoryCalculator.calculateVectorStoreSize(vectorStore);\n\n\t\t\t// Update metadata\n\t\t\tconst metadata = this.storeMetadata.get(key);\n\t\t\tif (metadata) {\n\t\t\t\tmetadata.size = storeSize;\n\t\t\t\tthis.memoryUsageBytes += storeSize;\n\t\t\t}\n\t\t}\n\n\t\tthis.logger.debug(`Recalculated vector store memory: ${this.getMemoryUsageFormatted()}`);\n\t}\n\n\t/**\n\t * Add documents to a vector store\n\t */\n\tasync addDocuments(\n\t\tmemoryKey: string,\n\t\tdocuments: Document[],\n\t\tclearStore?: boolean,\n\t): Promise<void> {\n\t\tif (clearStore) {\n\t\t\tthis.clearStoreMetadata(memoryKey);\n\t\t\tthis.vectorStoreBuffer.delete(memoryKey);\n\t\t}\n\n\t\t// Fast batch estimation instead of per-document calculation\n\t\tconst estimatedAddedSize = this.memoryCalculator.estimateBatchSize(documents);\n\n\t\t// Clean up old stores if necessary\n\t\tthis.cleanupService.cleanupOldestStores(estimatedAddedSize);\n\n\t\tconst vectorStoreInstance = await this.getVectorStore(memoryKey);\n\n\t\t// Get vector count before adding documents\n\t\tconst vectorCountBefore = vectorStoreInstance.memoryVectors?.length || 0;\n\n\t\tawait vectorStoreInstance.addDocuments(documents);\n\n\t\t// Update store metadata and memory tracking\n\t\tconst metadata = this.storeMetadata.get(memoryKey);\n\t\tif (metadata) {\n\t\t\tmetadata.size += estimatedAddedSize;\n\t\t\tmetadata.lastAccessed = new Date();\n\t\t\tthis.memoryUsageBytes += estimatedAddedSize;\n\t\t}\n\n\t\t// Get updated vector count\n\t\tconst vectorCount = vectorStoreInstance.memoryVectors?.length || 0;\n\n\t\t// Periodically recalculate actual memory usage to avoid drift\n\t\tif (\n\t\t\t(vectorCount > 0 && vectorCount % 100 === 0) ||\n\t\t\tdocuments.length > 20 ||\n\t\t\t(vectorCountBefore === 0 && vectorCount > 0)\n\t\t) {\n\t\t\tthis.recalculateMemoryUsage();\n\t\t}\n\n\t\t// Logging memory usage\n\t\tconst maxMemoryMB =\n\t\t\tthis.maxMemorySizeBytes > 0\n\t\t\t\t? (this.maxMemorySizeBytes / (1024 * 1024)).toFixed(0)\n\t\t\t\t: 'unlimited';\n\n\t\tthis.logger.debug(\n\t\t\t`Vector store memory: ${this.getMemoryUsageFormatted()}/${maxMemoryMB}MB (${vectorCount} vectors in ${this.vectorStoreBuffer.size} stores)`,\n\t\t);\n\t}\n\n\t/**\n\t * Get statistics about the vector store memory usage\n\t */\n\tgetStats(): VectorStoreStats {\n\t\tconst now = Date.now();\n\t\tlet inactiveStoreCount = 0;\n\n\t\t// Always recalculate when getting stats to ensure accuracy\n\t\tthis.recalculateMemoryUsage();\n\n\t\tconst stats: VectorStoreStats = {\n\t\t\ttotalSizeBytes: this.memoryUsageBytes,\n\t\t\ttotalSizeMB: Math.round((this.memoryUsageBytes / (1024 * 1024)) * 100) / 100,\n\t\t\tpercentOfLimit:\n\t\t\t\tthis.maxMemorySizeBytes > 0\n\t\t\t\t\t? Math.round((this.memoryUsageBytes / this.maxMemorySizeBytes) * 100)\n\t\t\t\t\t: 0,\n\t\t\tmaxMemoryMB: this.maxMemorySizeBytes > 0 ? this.maxMemorySizeBytes / (1024 * 1024) : -1, // -1 indicates unlimited\n\t\t\tstoreCount: this.vectorStoreBuffer.size,\n\t\t\tinactiveStoreCount: 0,\n\t\t\tttlHours: this.inactiveTtlMs > 0 ? this.inactiveTtlMs / (60 * 60 * 1000) : -1, // -1 indicates disabled\n\t\t\tstores: {},\n\t\t};\n\n\t\t// Add stats for each store\n\t\tfor (const [key, metadata] of this.storeMetadata.entries()) {\n\t\t\tconst store = this.vectorStoreBuffer.get(key);\n\n\t\t\tif (store) {\n\t\t\t\tconst lastAccessedTime = metadata.lastAccessed.getTime();\n\t\t\t\tconst inactiveTimeMs = now - lastAccessedTime;\n\t\t\t\tconst isInactive = this.cleanupService.isStoreInactive(metadata);\n\n\t\t\t\tif (isInactive) {\n\t\t\t\t\tinactiveStoreCount++;\n\t\t\t\t}\n\n\t\t\t\tstats.stores[key] = {\n\t\t\t\t\tsizeBytes: metadata.size,\n\t\t\t\t\tsizeMB: Math.round((metadata.size / (1024 * 1024)) * 100) / 100,\n\t\t\t\t\tpercentOfTotal: Math.round((metadata.size / this.memoryUsageBytes) * 100) || 0,\n\t\t\t\t\tvectors: store.memoryVectors?.length || 0,\n\t\t\t\t\tcreatedAt: metadata.createdAt.toISOString(),\n\t\t\t\t\tlastAccessed: metadata.lastAccessed.toISOString(),\n\t\t\t\t\tinactive: isInactive,\n\t\t\t\t\tinactiveForHours: Math.round(inactiveTimeMs / (60 * 60 * 1000)),\n\t\t\t\t};\n\t\t\t}\n\t\t}\n\n\t\tstats.inactiveStoreCount = inactiveStoreCount;\n\n\t\treturn stats;\n\t}\n}\n"],"mappings":"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","names":[]}

package/dist/nodes/vector_store/shared/MemoryManager/StoreCleanupService.js

@@ -0,0 +1,128 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var StoreCleanupService_exports = {};
+__export(StoreCleanupService_exports, {
+  StoreCleanupService: () => StoreCleanupService
+});
+module.exports = __toCommonJS(StoreCleanupService_exports);
+class StoreCleanupService {
+  // 5 seconds
+  constructor(maxMemorySizeBytes, inactiveTtlMs, vectorStores, storeMetadata, onCleanup) {
+    this.maxMemorySizeBytes = maxMemorySizeBytes;
+    this.inactiveTtlMs = inactiveTtlMs;
+    this.vectorStores = vectorStores;
+    this.storeMetadata = storeMetadata;
+    this.onCleanup = onCleanup;
+    // Cache for oldest stores sorted by creation time
+    this.oldestStoreKeys = [];
+    this.lastSortTime = 0;
+    this.CACHE_TTL_MS = 5e3;
+  }
+  /**
+   * Check if a store has been inactive for longer than the TTL
+   */
+  isStoreInactive(metadata) {
+    if (this.inactiveTtlMs <= 0) {
+      return false;
+    }
+    const now = Date.now();
+    const lastAccessedTime = metadata.lastAccessed.getTime();
+    return now - lastAccessedTime > this.inactiveTtlMs;
+  }
+  /**
+   * Remove vector stores that haven't been accessed for longer than TTL
+   */
+  cleanupInactiveStores() {
+    if (this.inactiveTtlMs <= 0) {
+      return;
+    }
+    let freedBytes = 0;
+    const removedStores = [];
+    for (const [key, metadata] of this.storeMetadata.entries()) {
+      if (this.isStoreInactive(metadata)) {
+        this.vectorStores.delete(key);
+        freedBytes += metadata.size;
+        removedStores.push(key);
+      }
+    }
+    for (const key of removedStores) {
+      this.storeMetadata.delete(key);
+    }
+    if (removedStores.length > 0) {
+      this.oldestStoreKeys = [];
+      this.onCleanup(removedStores, freedBytes, "ttl");
+    }
+  }
+  /**
+   * Remove the oldest vector stores to free up memory
+   */
+  cleanupOldestStores(requiredBytes) {
+    if (this.maxMemorySizeBytes <= 0) {
+      return;
+    }
+    let currentMemoryUsage = 0;
+    for (const metadata of this.storeMetadata.values()) {
+      currentMemoryUsage += metadata.size;
+    }
+    this.cleanupInactiveStores();
+    currentMemoryUsage = 0;
+    for (const metadata of this.storeMetadata.values()) {
+      currentMemoryUsage += metadata.size;
+    }
+    if (currentMemoryUsage + requiredBytes <= this.maxMemorySizeBytes) {
+      return;
+    }
+    const now = Date.now();
+    if (this.oldestStoreKeys.length === 0 || now - this.lastSortTime > this.CACHE_TTL_MS) {
+      const stores = [];
+      for (const [key, metadata] of this.storeMetadata.entries()) {
+        stores.push([key, metadata.createdAt.getTime()]);
+      }
+      stores.sort((a, b) => a[1] - b[1]);
+      this.oldestStoreKeys = stores.map(([key]) => key);
+      this.lastSortTime = now;
+    }
+    let freedBytes = 0;
+    const removedStores = [];
+    for (const key of this.oldestStoreKeys) {
+      if (!this.storeMetadata.has(key)) continue;
+      if (currentMemoryUsage - freedBytes + requiredBytes <= this.maxMemorySizeBytes) {
+        break;
+      }
+      const metadata = this.storeMetadata.get(key);
+      if (metadata) {
+        this.vectorStores.delete(key);
+        freedBytes += metadata.size;
+        removedStores.push(key);
+      }
+    }
+    for (const key of removedStores) {
+      this.storeMetadata.delete(key);
+    }
+    if (removedStores.length > 0) {
+      this.oldestStoreKeys = this.oldestStoreKeys.filter((key) => !removedStores.includes(key));
+      this.onCleanup(removedStores, freedBytes, "memory");
+    }
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StoreCleanupService
+});
+//# sourceMappingURL=StoreCleanupService.js.map

package/dist/nodes/vector_store/shared/MemoryManager/StoreCleanupService.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../nodes/vector_store/shared/MemoryManager/StoreCleanupService.ts"],"sourcesContent":["import type { MemoryVectorStore } from '@langchain/classic/vectorstores/memory';\n\nimport type { VectorStoreMetadata, IStoreCleanupService } from './types';\n\n/**\n * Service for cleaning up vector stores based on inactivity or memory pressure\n */\nexport class StoreCleanupService implements IStoreCleanupService {\n\t// Cache for oldest stores sorted by creation time\n\tprivate oldestStoreKeys: string[] = [];\n\n\tprivate lastSortTime = 0;\n\n\tprivate readonly CACHE_TTL_MS = 5000; // 5 seconds\n\n\tconstructor(\n\t\tprivate readonly maxMemorySizeBytes: number,\n\t\tprivate readonly inactiveTtlMs: number,\n\t\tprivate readonly vectorStores: Map<string, MemoryVectorStore>,\n\t\tprivate readonly storeMetadata: Map<string, VectorStoreMetadata>,\n\t\tprivate readonly onCleanup: (\n\t\t\tremovedKeys: string[],\n\t\t\tfreedBytes: number,\n\t\t\treason: 'ttl' | 'memory',\n\t\t) => void,\n\t) {}\n\n\t/**\n\t * Check if a store has been inactive for longer than the TTL\n\t */\n\tisStoreInactive(metadata: VectorStoreMetadata): boolean {\n\t\t// If TTL is disabled, nothing is considered inactive\n\t\tif (this.inactiveTtlMs <= 0) {\n\t\t\treturn false;\n\t\t}\n\n\t\tconst now = Date.now();\n\t\tconst lastAccessedTime = metadata.lastAccessed.getTime();\n\t\treturn now - lastAccessedTime > this.inactiveTtlMs;\n\t}\n\n\t/**\n\t * Remove vector stores that haven't been accessed for longer than TTL\n\t */\n\tcleanupInactiveStores(): void {\n\t\t// Skip if TTL is disabled\n\t\tif (this.inactiveTtlMs <= 0) {\n\t\t\treturn;\n\t\t}\n\n\t\tlet freedBytes = 0;\n\t\tconst removedStores: string[] = [];\n\n\t\t// Find and remove inactive stores\n\t\tfor (const [key, metadata] of this.storeMetadata.entries()) {\n\t\t\tif (this.isStoreInactive(metadata)) {\n\t\t\t\t// Remove this inactive store\n\t\t\t\tthis.vectorStores.delete(key);\n\t\t\t\tfreedBytes += metadata.size;\n\t\t\t\tremovedStores.push(key);\n\t\t\t}\n\t\t}\n\n\t\t// Remove from metadata after iteration to avoid concurrent modification\n\t\tfor (const key of removedStores) {\n\t\t\tthis.storeMetadata.delete(key);\n\t\t}\n\n\t\t// Invalidate cache if we removed any stores\n\t\tif (removedStores.length > 0) {\n\t\t\tthis.oldestStoreKeys = [];\n\t\t\tthis.onCleanup(removedStores, freedBytes, 'ttl');\n\t\t}\n\t}\n\n\t/**\n\t * Remove the oldest vector stores to free up memory\n\t */\n\tcleanupOldestStores(requiredBytes: number): void {\n\t\t// Skip if memory limit is disabled\n\t\tif (this.maxMemorySizeBytes <= 0) {\n\t\t\treturn;\n\t\t}\n\n\t\t// Calculate current total memory usage\n\t\tlet currentMemoryUsage = 0;\n\t\tfor (const metadata of this.storeMetadata.values()) {\n\t\t\tcurrentMemoryUsage += metadata.size;\n\t\t}\n\n\t\t// First, try to clean up inactive stores\n\t\tthis.cleanupInactiveStores();\n\n\t\t// Recalculate memory usage after inactive cleanup\n\t\tcurrentMemoryUsage = 0;\n\t\tfor (const metadata of this.storeMetadata.values()) {\n\t\t\tcurrentMemoryUsage += metadata.size;\n\t\t}\n\n\t\t// If no more cleanup needed, return early\n\t\tif (currentMemoryUsage + requiredBytes <= this.maxMemorySizeBytes) {\n\t\t\treturn;\n\t\t}\n\n\t\tconst now = Date.now();\n\n\t\t// Reuse cached ordering if available and not stale\n\t\tif (this.oldestStoreKeys.length === 0 || now - this.lastSortTime > this.CACHE_TTL_MS) {\n\t\t\t// Collect and sort store keys by age\n\t\t\tconst stores: Array<[string, number]> = [];\n\n\t\t\tfor (const [key, metadata] of this.storeMetadata.entries()) {\n\t\t\t\tstores.push([key, metadata.createdAt.getTime()]);\n\t\t\t}\n\n\t\t\t// Sort by creation time (oldest first)\n\t\t\tstores.sort((a, b) => a[1] - b[1]);\n\n\t\t\t// Extract just the keys\n\t\t\tthis.oldestStoreKeys = stores.map(([key]) => key);\n\t\t\tthis.lastSortTime = now;\n\t\t}\n\n\t\tlet freedBytes = 0;\n\t\tconst removedStores: string[] = [];\n\n\t\t// Remove stores in order until we have enough space\n\t\tfor (const key of this.oldestStoreKeys) {\n\t\t\t// Skip if store no longer exists\n\t\t\tif (!this.storeMetadata.has(key)) continue;\n\n\t\t\t// Stop if we've freed enough space\n\t\t\tif (currentMemoryUsage - freedBytes + requiredBytes <= this.maxMemorySizeBytes) {\n\t\t\t\tbreak;\n\t\t\t}\n\n\t\t\tconst metadata = this.storeMetadata.get(key);\n\t\t\tif (metadata) {\n\t\t\t\tthis.vectorStores.delete(key);\n\t\t\t\tfreedBytes += metadata.size;\n\t\t\t\tremovedStores.push(key);\n\t\t\t}\n\t\t}\n\n\t\t// Remove from metadata after iteration to avoid concurrent modification\n\t\tfor (const key of removedStores) {\n\t\t\tthis.storeMetadata.delete(key);\n\t\t}\n\n\t\t// Update our cache if we removed stores\n\t\tif (removedStores.length > 0) {\n\t\t\t// Filter out removed stores from cached keys\n\t\t\tthis.oldestStoreKeys = this.oldestStoreKeys.filter((key) => !removedStores.includes(key));\n\t\t\tthis.onCleanup(removedStores, freedBytes, 'memory');\n\t\t}\n\t}\n}\n"],"mappings":"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","names":[]}

package/dist/nodes/vector_store/shared/MemoryManager/config.js

@@ -0,0 +1,62 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  getConfig: () => getConfig,
+  hoursToMs: () => hoursToMs,
+  mbToBytes: () => mbToBytes
+});
+module.exports = __toCommonJS(config_exports);
+const DEFAULT_MAX_MEMORY_MB = -1;
+const DEFAULT_INACTIVE_TTL_HOURS = -1;
+function getConfig() {
+  let maxMemoryMB = DEFAULT_MAX_MEMORY_MB;
+  if (process.env.N8N_VECTOR_STORE_MAX_MEMORY) {
+    const parsed = parseInt(process.env.N8N_VECTOR_STORE_MAX_MEMORY, 10);
+    if (!isNaN(parsed)) {
+      maxMemoryMB = parsed;
+    }
+  }
+  let ttlHours = DEFAULT_INACTIVE_TTL_HOURS;
+  if (process.env.N8N_VECTOR_STORE_TTL_HOURS) {
+    const parsed = parseInt(process.env.N8N_VECTOR_STORE_TTL_HOURS, 10);
+    if (!isNaN(parsed)) {
+      ttlHours = parsed;
+    }
+  }
+  return {
+    maxMemoryMB,
+    ttlHours
+  };
+}
+function mbToBytes(mb) {
+  if (mb <= 0) return -1;
+  return mb * 1024 * 1024;
+}
+function hoursToMs(hours) {
+  if (hours <= 0) return -1;
+  return hours * 60 * 60 * 1e3;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getConfig,
+  hoursToMs,
+  mbToBytes
+});
+//# sourceMappingURL=config.js.map

package/dist/nodes/vector_store/shared/MemoryManager/config.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../nodes/vector_store/shared/MemoryManager/config.ts"],"sourcesContent":["import type { MemoryVectorStoreConfig } from './types';\n\n// Defaults\nconst DEFAULT_MAX_MEMORY_MB = -1;\nconst DEFAULT_INACTIVE_TTL_HOURS = -1;\n\n/**\n * Helper function to get the configuration from environment variables\n */\nexport function getConfig(): MemoryVectorStoreConfig {\n\t// Get memory limit from env var or use default\n\tlet maxMemoryMB = DEFAULT_MAX_MEMORY_MB;\n\tif (process.env.N8N_VECTOR_STORE_MAX_MEMORY) {\n\t\tconst parsed = parseInt(process.env.N8N_VECTOR_STORE_MAX_MEMORY, 10);\n\t\tif (!isNaN(parsed)) {\n\t\t\tmaxMemoryMB = parsed;\n\t\t}\n\t}\n\n\t// Get TTL from env var or use default\n\tlet ttlHours = DEFAULT_INACTIVE_TTL_HOURS;\n\tif (process.env.N8N_VECTOR_STORE_TTL_HOURS) {\n\t\tconst parsed = parseInt(process.env.N8N_VECTOR_STORE_TTL_HOURS, 10);\n\t\tif (!isNaN(parsed)) {\n\t\t\tttlHours = parsed;\n\t\t}\n\t}\n\n\treturn {\n\t\tmaxMemoryMB,\n\t\tttlHours,\n\t};\n}\n\n/**\n * Convert memory size from MB to bytes\n */\nexport function mbToBytes(mb: number): number {\n\t// -1 - \"unlimited\"\n\tif (mb <= 0) return -1;\n\treturn mb * 1024 * 1024;\n}\n\n/**\n * Convert TTL from hours to milliseconds\n */\nexport function hoursToMs(hours: number): number {\n\t// -1 - \"disabled\"\n\tif (hours <= 0) return -1;\n\treturn hours * 60 * 60 * 1000;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAGA,MAAM,wBAAwB;AAC9B,MAAM,6BAA6B;AAK5B,SAAS,YAAqC;AAEpD,MAAI,cAAc;AAClB,MAAI,QAAQ,IAAI,6BAA6B;AAC5C,UAAM,SAAS,SAAS,QAAQ,IAAI,6BAA6B,EAAE;AACnE,QAAI,CAAC,MAAM,MAAM,GAAG;AACnB,oBAAc;AAAA,IACf;AAAA,EACD;AAGA,MAAI,WAAW;AACf,MAAI,QAAQ,IAAI,4BAA4B;AAC3C,UAAM,SAAS,SAAS,QAAQ,IAAI,4BAA4B,EAAE;AAClE,QAAI,CAAC,MAAM,MAAM,GAAG;AACnB,iBAAW;AAAA,IACZ;AAAA,EACD;AAEA,SAAO;AAAA,IACN;AAAA,IACA;AAAA,EACD;AACD;AAKO,SAAS,UAAU,IAAoB;AAE7C,MAAI,MAAM,EAAG,QAAO;AACpB,SAAO,KAAK,OAAO;AACpB;AAKO,SAAS,UAAU,OAAuB;AAEhD,MAAI,SAAS,EAAG,QAAO;AACvB,SAAO,QAAQ,KAAK,KAAK;AAC1B;","names":[]}

package/dist/nodes/vector_store/shared/MemoryManager/types.js

@@ -0,0 +1,17 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);
+//# sourceMappingURL=types.js.map

package/dist/nodes/vector_store/shared/MemoryManager/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../nodes/vector_store/shared/MemoryManager/types.ts"],"sourcesContent":["import type { Document } from '@langchain/core/documents';\nimport type { MemoryVectorStore } from '@langchain/classic/vectorstores/memory';\n\n/**\n * Configuration options for the memory vector store\n */\nexport interface MemoryVectorStoreConfig {\n\t/**\n\t * Maximum memory size in MB, -1 to disable\n\t */\n\tmaxMemoryMB: number;\n\n\t/**\n\t * TTL for inactive stores in hours, -1 to disable\n\t */\n\tttlHours: number;\n}\n\n/**\n * Vector store metadata for tracking usage\n */\nexport interface VectorStoreMetadata {\n\tsize: number;\n\tcreatedAt: Date;\n\tlastAccessed: Date;\n}\n\n/**\n * Per-store statistics for reporting\n */\nexport interface StoreStats {\n\tsizeBytes: number;\n\tsizeMB: number;\n\tpercentOfTotal: number;\n\tvectors: number;\n\tcreatedAt: string;\n\tlastAccessed: string;\n\tinactive?: boolean;\n\tinactiveForHours?: number;\n}\n\n/**\n * Overall vector store statistics\n */\nexport interface VectorStoreStats {\n\ttotalSizeBytes: number;\n\ttotalSizeMB: number;\n\tpercentOfLimit: number;\n\tmaxMemoryMB: number;\n\tstoreCount: number;\n\tinactiveStoreCount: number;\n\tttlHours: number;\n\tstores: Record<string, StoreStats>;\n}\n\n/**\n * Service for calculating memory usage\n */\nexport interface IMemoryCalculator {\n\testimateBatchSize(documents: Document[]): number;\n\tcalculateVectorStoreSize(vectorStore: MemoryVectorStore): number;\n}\n\n/**\n * Service for cleaning up vector stores\n */\nexport interface IStoreCleanupService {\n\tcleanupInactiveStores(): void;\n\tcleanupOldestStores(requiredBytes: number): void;\n}\n"],"mappings":";;;;;;;;;;;;;;AAAA;AAAA;","names":[]}