llmjs2 1.3.9 → 1.6.1

package/chain/lib/memory/in-memory.js

@@ -0,0 +1,117 @@
+/**
+ * InMemory class for managing conversation history and data storage
+ * Provides methods to save, retrieve, and search conversation data
+ */
+class InMemory {
+  /**
+   * Create a new Memory instance
+   */
+  constructor() {
+    this.messages = [];
+  }
+
+  /**
+   * Get session history for a specific resource and thread
+   * @param {string} resourceId - The resource identifier
+   * @param {string} threadId - The thread identifier
+   * @param {number} limit - Maximum number of messages to retrieve (default: 10)
+   * @returns {Promise<Array>} Array of messages in the session
+   */
+  async getSessionHistory(resourceId, threadId, limit = 10) {
+    // Filter messages by resourceId and threadId
+    const filtered = this.messages.filter(msg =>
+      msg.resourceId === resourceId &&
+      msg.threadId === threadId
+    );
+
+    // Sort by timestamp (newest first) and apply limit
+    const sorted = filtered
+      .sort((a, b) => a.timestamp - b.timestamp)
+      .slice(0, limit);
+
+    return sorted;
+  }
+
+  /**
+   * Search messages by query
+   * @param {string} query - Search query
+   * @param {string} resourceId - The resource identifier to search within
+   * @param {number} limit - Maximum number of results (default: 5)
+   * @returns {Promise<Array>} Array of matching messages
+   */
+  async search(query, resourceId, limit = 5) {
+    const queryLower = query.toLowerCase();
+
+    // Filter messages by resourceId and search content
+    const filtered = this.messages.filter(msg =>
+      msg.resourceId === resourceId &&
+      (msg.content.toLowerCase().includes(queryLower) ||
+       msg.role.toLowerCase().includes(queryLower))
+    );
+
+    // Sort by relevance (exact matches first) and apply limit
+    const sorted = filtered
+      .sort((a, b) => {
+        const aExact = a.content.toLowerCase() === queryLower ? 1 : 0;
+        const bExact = b.content.toLowerCase() === queryLower ? 1 : 0;
+        return bExact - aExact;
+      })
+      .slice(0, limit);
+
+    return sorted;
+  }
+
+  /**
+   * Save a message to memory
+   * @param {string} content - The message content
+   * @param {string} resourceId - The resource identifier
+   * @param {string} threadId - The thread identifier
+   * @param {string} role - The role (user, assistant, system, tool)
+   * @param {string} type - The message type
+   * @param {string} generationId - Optional generation identifier
+   * @param {string} remarks - Optional remarks
+   * @returns {Promise<Object>} The saved message object
+   */
+  async save(content, resourceId, threadId, role, type, generationId = null, remarks = null) {
+    const message = {
+      id: this.generateId(),
+      content: content,
+      resourceId: resourceId,
+      threadId: threadId,
+      role: role,
+      type: type,
+      generationId: generationId,
+      remarks: remarks,
+      timestamp: Date.now()
+    };
+
+    this.messages.push(message);
+
+    return message;
+  }
+
+  /**
+   * Generate a unique ID for messages
+   * @returns {string} Unique ID
+   */
+  generateId() {
+    return `msg_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+  }
+
+  /**
+   * Get all messages (for debugging/testing)
+   * @returns {Array} All messages
+   */
+  getAllMessages() {
+    return this.messages;
+  }
+
+  /**
+   * Clear all messages
+   */
+  clear() {
+    this.messages = [];
+  }
+}
+
+module.exports = { InMemory };

package/chain/lib/memory/index.js

@@ -0,0 +1,36 @@
+const { InMemory } = require('./in-memory');
+const { LanceMemory } = require('./lance-memory');
+const { SQLiteMemory } = require('./sqlite-memory');
+
+/**
+ * Memory factory for creating different types of memory instances
+ */
+const memory = {
+  /**
+   * Create a memory instance
+   * @param {Object} options - Memory configuration
+   * @param {string} options.type - Type of memory ('in-memory', 'lancedb', 'sqlite')
+   * @param {Object} options.config - Configuration for the specific memory type
+   * @returns {InMemory|LanceMemory|SQLiteMemory} Memory instance
+   */
+  create(options = {}) {
+    const { type = 'in-memory', config = {} } = options;
+
+    switch (type.toLowerCase()) {
+      case 'in-memory':
+        return new InMemory(config);
+
+      case 'lancedb':
+      case 'lance':
+        return new LanceMemory(config);
+
+      case 'sqlite':
+        return new SQLiteMemory(config);
+
+      default:
+        throw new Error(`Unknown memory type: ${type}. Supported types: in-memory, lancedb, sqlite`);
+    }
+  }
+};
+
+module.exports = { memory, InMemory, LanceMemory, SQLiteMemory };

package/chain/lib/memory/lance-memory.js

@@ -0,0 +1,225 @@
+const { InMemory } = require('./in-memory');
+const lancedb = require('@lancedb/lancedb');
+const { pipeline } = require('@huggingface/transformers');
+const path = require('path');
+const fs = require('fs');
+const crypto = require('crypto');
+
+// LanceDB schema will be inferred from first record
+// but we ensure consistent types by providing proper values
+
+/**
+ * LanceMemory class for managing conversation history with persistent storage
+ * Uses LanceDB for vector search and metadata storage
+ */
+class LanceMemory extends InMemory {
+  /**
+   * Create a new LanceMemory instance
+   * @param {Object} options - Memory configuration
+   * @param {string} options.db - Database name (default: 'lance')
+   * @param {string} options.dir - Data directory (default: './lance_data')
+   * @param {string} options.model - Embedding model (default: 'onnx-community/Qwen3-Embedding-0.6B-ONNX')
+   */
+  constructor({ db = 'lance', dir = './lance_data', model = 'onnx-community/Qwen3-Embedding-0.6B-ONNX' } = {}) {
+    super();
+    this.db = db;
+    this.dir = dir;
+    this.model = model;
+
+    // Create directory if it doesn't exist
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+
+    this.lanceTable = null;
+    this.extractor = null;
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize the embedding model and LanceDB connection
+   */
+  async init() {
+    if (this.initialized) return;
+
+    this.extractor = await pipeline(
+      'feature-extraction',
+      this.model,
+      { dtype: 'q8', quantized: true }
+    );
+
+    // Warm up the embedding model
+    for (let i = 0; i < 3; i++) {
+      await this.#getEmbedding("warming up warming up " + i + crypto.randomBytes(50).toString('hex'));
+    }
+
+    console.log("LanceMemory embedding is up");
+
+    const db = await lancedb.connect(path.join(this.dir, `${this.db}.lance`));
+    try {
+      this.lanceTable = await db.openTable(this.db);
+    } catch (e) {
+      this.lanceTable = null;
+    }
+
+    this.initialized = true;
+  }
+
+  /**
+   * Get embedding for a text
+   * @param {string} text - Text to embed
+   * @returns {Promise<Array>} Embedding vector
+   */
+  async #getEmbedding(text) {
+    const output = await this.extractor(text, { pooling: 'mean', normalize: true });
+    return Array.from(output.data);
+  }
+
+  /**
+   * Save a message to memory
+   * @param {string} content - The message content
+   * @param {string} resourceId - The resource identifier
+   * @param {string} threadId - The thread identifier
+   * @param {string} role - The role (user, assistant, system, tool)
+   * @param {string} type - The message type
+   * @param {string} generationId - Optional generation identifier
+   * @param {string} remarks - Optional remarks
+   * @returns {Promise<Object>} The saved message object
+   */
+  async save(content, resourceId, threadId, role, type, generationId = null, remarks = null) {
+    if (!this.initialized) await this.init();
+
+    // Generate unique ID
+    const id = `${resourceId}_${threadId}_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+    const createdAt = new Date().toISOString();
+
+    console.time('getEmbedding for save');
+    const vector = await this.#getEmbedding(content);
+    console.timeEnd('getEmbedding for save');
+
+    // LanceDB Store - ensure all fields are properly typed
+    const record = {
+      id,
+      resourceId,
+      threadId,
+      role,
+      type,
+      vector,
+      content,
+      generationId: generationId || '',
+      remarks: remarks || '',
+      created_at: createdAt
+    };
+
+    if (!this.lanceTable) {
+      const db = await lancedb.connect(path.join(this.dir, `${this.db}.lance`));
+      this.lanceTable = await db.createTable(this.db, [record]);
+    } else {
+      await this.lanceTable.add([record]);
+    }
+
+    // Also add to in-memory cache
+    const message = {
+      id,
+      content,
+      resourceId,
+      threadId,
+      role,
+      type,
+      generationId,
+      remarks,
+      timestamp: Date.now()
+    };
+
+    this.messages.push(message);
+
+    return message;
+  }
+
+  /**
+   * Get session history for a specific resource and thread
+   * @param {string} resourceId - The resource identifier
+   * @param {string} threadId - The thread identifier
+   * @param {number} limit - Maximum number of messages to retrieve (default: 10)
+   * @returns {Promise<Array>} Array of messages in the session
+   */
+  async getSessionHistory(resourceId, threadId, limit = 10) {
+    if (!this.initialized) await this.init();
+    if (!this.lanceTable) return [];
+
+    const results = await this.lanceTable
+      .query()
+      .where(`resourceId = "${resourceId}" AND threadId = "${threadId}"`)
+      .limit(limit)
+      .toArray();
+
+    return results.map(res => ({
+      id: res.id,
+      content: res.content,
+      resourceId: res.resourceId,
+      threadId: res.threadId,
+      role: res.role,
+      type: res.type,
+      generationId: res.generationId,
+      remarks: res.remarks,
+      timestamp: new Date(res.created_at).getTime()
+    }));
+  }
+
+  /**
+   * Search messages by query
+   * @param {string} query - Search query
+   * @param {string} resourceId - The resource identifier to search within
+   * @param {number} limit - Maximum number of results (default: 5)
+   * @returns {Promise<Array>} Array of matching messages
+   */
+  async search(query, resourceId, limit = 5) {
+    if (!this.initialized) await this.init();
+    if (!this.lanceTable) return [];
+
+    console.time('getEmbedding for search');
+    const queryVector = await this.#getEmbedding(query);
+    console.timeEnd('getEmbedding for search');
+
+    const results = await this.lanceTable
+      .search(queryVector)
+      .where(`resourceId = "${resourceId}"`)
+      .limit(limit)
+      .toArray();
+
+    return results.map(res => ({
+      id: res.id,
+      content: res.content,
+      resourceId: res.resourceId,
+      threadId: res.threadId,
+      role: res.role,
+      type: res.type,
+      generationId: res.generationId,
+      remarks: res.remarks,
+      timestamp: new Date(res.created_at).getTime(),
+      distance: res._distance
+    }));
+  }
+
+  /**
+   * Clear all messages from memory and database
+   */
+  async clear() {
+    this.messages = [];
+
+    // Drop LanceDB table
+    if (this.lanceTable) {
+      await this.lanceTable.delete('1=1');
+    }
+  }
+
+  /**
+   * Close the database connections and cleanup
+   */
+  async close() {
+    if (this.extractor) {
+      await this.extractor.cleanup();
+    }
+    this.initialized = false;
+  }
+}
+
+module.exports = { LanceMemory };

package/chain/lib/memory/sqlite-memory.js

@@ -0,0 +1,309 @@
+const { InMemory } = require('./in-memory');
+const { pipeline } = require('@huggingface/transformers');
+
+/**
+ * SQLiteMemory class for managing conversation history with SQLite storage
+ * Uses better-sqlite3, sqlite-vec, and HuggingFace transformers for vector search
+ */
+class SQLiteMemory extends InMemory {
+  /**
+   * Create a new SQLiteMemory instance
+   * @param {Object} options - Memory configuration
+   * @param {string} options.db - Database file path (default: './sqlite_memory.db')
+   * @param {string} options.model - Embedding model (default: 'onnx-community/Qwen3-Embedding-0.6B-ONNX')
+   */
+  constructor({ db = './sqlite_memory.db', model = 'onnx-community/Qwen3-Embedding-0.6B-ONNX' } = {}) {
+    super();
+    this.dbPath = db;
+    this.model = model;
+    this.db = null;
+    this.extractor = null;
+    this.initialized = false;
+  }
+
+  /**
+   * Initialize the SQLite database, vector extensions, and embedding model
+   */
+  async init() {
+    if (this.initialized) return;
+
+    // Initialize embedding model
+    this.extractor = await pipeline(
+      'feature-extraction',
+      this.model,
+      { dtype: 'q8', quantized: true }
+    );
+
+    // Warm up the embedding model
+    for (let i = 0; i < 3; i++) {
+      await this._getEmbedding("warming up warming up " + i + Math.random().toString(36));
+    }
+
+    console.log("SQLiteMemory embedding is up");
+
+    const Database = require('better-sqlite3');
+    this.db = new Database(this.dbPath);
+
+    // Enable vector extension if available
+    try {
+      this.db.loadExtension(require('sqlite-vec'));
+      // Create vector table for embeddings
+      this.db.exec(`
+        CREATE VIRTUAL TABLE IF NOT EXISTS vec_messages USING vec0(
+          id TEXT PRIMARY KEY,
+          vector float[768]
+        );
+      `);
+    } catch (error) {
+      console.warn('sqlite-vec extension not available, falling back to basic search');
+    }
+
+    // Create main messages table
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS messages (
+        id TEXT PRIMARY KEY,
+        resourceId TEXT,
+        threadId TEXT,
+        role TEXT,
+        type TEXT,
+        content TEXT,
+        generationId TEXT,
+        remarks TEXT,
+        vector BLOB,
+        created_at TEXT
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_resource_thread ON messages(resourceId, threadId);
+      CREATE INDEX IF NOT EXISTS idx_created_at ON messages(created_at);
+    `);
+
+    // Prepare statements
+    this.insertStmt = this.db.prepare(`
+      INSERT OR REPLACE INTO messages (id, resourceId, threadId, role, type, content, generationId, remarks, vector, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+
+    this.selectStmt = this.db.prepare(`
+      SELECT * FROM messages
+      WHERE resourceId = ? AND threadId = ?
+      ORDER BY created_at DESC
+      LIMIT ?
+    `);
+
+    this.searchStmt = this.db.prepare(`
+      SELECT * FROM messages
+      WHERE resourceId = ?
+      ORDER BY created_at DESC
+      LIMIT ?
+    `);
+
+    this.deleteStmt = this.db.prepare('DELETE FROM messages');
+
+    // Vector search statements (if sqlite-vec is available)
+    if (this.db.loadExtension) {
+      try {
+        this.vectorInsertStmt = this.db.prepare(`
+          INSERT OR REPLACE INTO vec_messages (id, vector) VALUES (?, ?)
+        `);
+
+        this.vectorSearchStmt = this.db.prepare(`
+          SELECT id, distance
+          FROM vec_messages
+          WHERE vector MATCH ? AND k = ?
+          ORDER BY distance
+        `);
+      } catch (error) {
+        console.warn('Vector search not available:', error.message);
+      }
+    }
+
+    this.initialized = true;
+  }
+
+  /**
+   * Get embedding for a text
+   * @param {string} text - Text to embed
+   * @returns {Promise<Array>} Embedding vector
+   */
+  async _getEmbedding(text) {
+    const output = await this.extractor(text, { pooling: 'mean', normalize: true });
+    return Array.from(output.data);
+  }
+
+  /**
+   * Save a message to memory
+   * @param {string} content - The message content
+   * @param {string} resourceId - The resource identifier
+   * @param {string} threadId - The thread identifier
+   * @param {string} role - The role (user, assistant, system, tool)
+   * @param {string} type - The message type
+   * @param {string} generationId - Optional generation identifier
+   * @param {string} remarks - Optional remarks
+   * @returns {Promise<Object>} The saved message object
+   */
+  async save(content, resourceId, threadId, role, type, generationId = null, remarks = null) {
+    if (!this.initialized) await this.init();
+
+    const id = `${resourceId}_${threadId}_${Date.now()}_${Math.random().toString(36).substring(2, 15)}`;
+    const createdAt = new Date().toISOString();
+
+    console.time('getEmbedding for save');
+    const vector = await this._getEmbedding(content);
+    console.timeEnd('getEmbedding for save');
+
+    // Store vector as JSON for basic storage, and also in vector table if available
+    const vectorJson = JSON.stringify(vector);
+
+    this.insertStmt.run(
+      id, resourceId, threadId, role, type, content,
+      generationId || '', remarks || '', vectorJson, createdAt
+    );
+
+    // Store in vector table if available
+    if (this.vectorInsertStmt) {
+      try {
+        this.vectorInsertStmt.run(id, vector);
+      } catch (error) {
+        console.warn('Failed to store vector:', error.message);
+      }
+    }
+
+    const message = {
+      id,
+      content,
+      resourceId,
+      threadId,
+      role,
+      type,
+      generationId,
+      remarks,
+      timestamp: Date.now()
+    };
+
+    // Also add to in-memory cache for faster access
+    this.messages.push(message);
+
+    return message;
+  }
+
+  /**
+   * Get session history for a specific resource and thread
+   * @param {string} resourceId - The resource identifier
+   * @param {string} threadId - The thread identifier
+   * @param {number} limit - Maximum number of messages to retrieve (default: 10)
+   * @returns {Promise<Array>} Array of messages in the session
+   */
+  async getSessionHistory(resourceId, threadId, limit = 10) {
+    if (!this.initialized) await this.init();
+
+    const rows = this.selectStmt.all(resourceId, threadId, limit);
+    return rows.map(row => ({
+      id: row.id,
+      content: row.content,
+      resourceId: row.resourceId,
+      threadId: row.threadId,
+      role: row.role,
+      type: row.type,
+      generationId: row.generationId,
+      remarks: row.remarks,
+      timestamp: new Date(row.created_at).getTime()
+    }));
+  }
+
+  /**
+   * Search messages by query using vector search when available
+   * @param {string} query - Search query
+   * @param {string} resourceId - The resource identifier to search within
+   * @param {number} limit - Maximum number of results (default: 5)
+   * @returns {Promise<Array>} Array of matching messages
+   */
+  async search(query, resourceId, limit = 5) {
+    if (!this.initialized) await this.init();
+
+    // Try vector search first if available
+    if (this.vectorSearchStmt) {
+      try {
+        console.time('getEmbedding for search');
+        const queryVector = await this._getEmbedding(query);
+        console.timeEnd('getEmbedding for search');
+
+        const vectorResults = this.vectorSearchStmt.all(JSON.stringify(queryVector), limit);
+
+        if (vectorResults && vectorResults.length > 0) {
+          // Get full message details for the vector search results
+          const ids = vectorResults.map(r => r.id);
+          const messages = [];
+
+          for (const id of ids) {
+            const row = this.db.prepare('SELECT * FROM messages WHERE id = ?').get(id);
+            if (row) {
+              messages.push({
+                id: row.id,
+                content: row.content,
+                resourceId: row.resourceId,
+                threadId: row.threadId,
+                role: row.role,
+                type: row.type,
+                generationId: row.generationId,
+                remarks: row.remarks,
+                timestamp: new Date(row.created_at).getTime(),
+                distance: vectorResults.find(r => r.id === id)?.distance
+              });
+            }
+          }
+
+          return messages;
+        }
+      } catch (error) {
+        console.warn('Vector search failed, falling back to text search:', error.message);
+      }
+    }
+
+    // Fallback to basic text search
+    const queryLower = query.toLowerCase();
+    const rows = this.searchStmt.all(resourceId, limit * 2); // Get more to filter
+
+    const filtered = rows.filter(row =>
+      row.content.toLowerCase().includes(queryLower) ||
+      row.role.toLowerCase().includes(queryLower)
+    );
+
+    return filtered.slice(0, limit).map(row => ({
+      id: row.id,
+      content: row.content,
+      resourceId: row.resourceId,
+      threadId: row.threadId,
+      role: row.role,
+      type: row.type,
+      generationId: row.generationId,
+      remarks: row.remarks,
+      timestamp: new Date(row.created_at).getTime()
+    }));
+  }
+
+  /**
+   * Clear all messages from memory and database
+   */
+  async clear() {
+    this.messages = [];
+
+    if (this.db) {
+      this.deleteStmt.run();
+    }
+  }
+
+  /**
+   * Close the database connection and cleanup embedding model
+   */
+  async close() {
+    if (this.extractor) {
+      await this.extractor.cleanup();
+    }
+    if (this.db) {
+      this.db.close();
+    }
+    this.initialized = false;
+  }
+}
+
+module.exports = { SQLiteMemory };