node-red-contrib-ai-agent 0.0.5 → 0.0.7

package/README.md

@@ -71,8 +71,14 @@ A configuration node that initializes the conversation context in memory. The ag
 A configuration node that initializes the conversation context with file-based persistence. The agent node uses this configuration to manage the conversation context across restarts.
 
 **Properties:**
-- **Max Items**: Maximum number of conversation turns to keep
-- **File Path**: Path to store the conversation history
+- **Filename**: Path to store the memory file (relative to Node-RED user directory)
+- **Max Conversations**: Maximum number of conversations to store
+- **Max Messages Per Conversation**: Maximum messages per conversation history
+- **Backups**: Enable/disable automatic backups
+- **Backup Count**: Number of backups to keep
+- **Consolidation**: Threshold of messages to trigger auto-summarization
+- **Long-Term Memory**: Enable/disable vector-based storage
+- **Embedding Model**: The model used for semantic embeddings (e.g., text-embedding-ada-002)
 - **Name**: Display name for the node
 
 ### AI Model
@@ -187,10 +193,24 @@ This allows for complex conversation flows where different agents handle differe
 
 ## Advanced Features
 
-- **Tool Integration**: Extend functionality with custom tools (Function and HTTP)
-- **Context Management**: Maintain conversation history
-- **Flexible Configuration**: Customize model parameters and behavior
-- **Template Variables**: Use dynamic values in HTTP requests
+### 1. Vector Storage (Long-Term Memory)
+The `AI Memory (File)` node supports vector-based storage. When enabled, it can store embeddings of summaries or key information. This allows for **semantic search** using the `query` command.
+
+### 2. Memory Consolidation
+Automatically (or manually) summarize conversation threads to save space and maintain long-term context. After a threshold of messages is reached, the node can use an AI model to summarize the history and store it in the vector database.
+
+### 3. Memory Commands
+Memory nodes support the following commands via `msg.command`:
+- **add**: Add a message to a conversation (`msg.message` required).
+- **get**: Retrieve messages for a conversation (`msg.conversationId` optional).
+- **search**: Plain-text search across conversations (`msg.query` required).
+- **query**: Semantic (vector) search in long-term memory (`msg.query` text or vector required).
+- **consolidate**: Manually trigger summarization and long-term storage.
+- **clear**: Clear short-term, long-term, or all memory.
+- **delete**: Delete a specific conversation (`msg.conversationId` required).
+
+### 4. Template Variables
+Use dynamic values in HTTP requests via `${input.property}` syntax.
 
 ## Contributing
 

package/memory-file/memory-file.html

@@ -5,30 +5,46 @@
         color: '#a6bbcf',
         defaults: {
             name: { value: "" },
-            filename: { 
+            filename: {
                 value: "ai-memories.json",
                 required: true,
-                validate: function(v) {
+                validate: function (v) {
                     return v.length > 0;
                 }
-            }
+            },
+            maxConversations: { value: 50, validate: RED.validators.number() },
+            maxMessagesPerConversation: { value: 100, validate: RED.validators.number() },
+            backupEnabled: { value: true },
+            backupCount: { value: 3, validate: RED.validators.number() },
+            vectorEnabled: { value: false },
+            embeddingModel: { value: "text-embedding-ada-002" },
+            consolidationThreshold: { value: 10, validate: RED.validators.number() }
         },
+
         inputs: 1,
         outputs: 1,
         icon: "file.png",
-        label: function() {
+        label: function () {
             return this.name || "AI Memory (File)";
         },
-        labelStyle: function() {
+        labelStyle: function () {
             return this.name ? "node_label_italic" : "";
         },
-        oneditprepare: function() {
-            // Initialize any UI components here
+        oneditprepare: function () {
+            $("#node-input-vectorEnabled").on("change", function () {
+                if ($(this).is(":checked")) {
+                    $(".vector-row").show();
+                } else {
+                    $(".vector-row").hide();
+                }
+            });
+            $("#node-input-vectorEnabled").trigger("change");
         },
-        oneditsave: function() {
+
+        oneditsave: function () {
             // Handle save if needed
         },
-        oneditcancel: function() {
+        oneditcancel: function () {
             // Cleanup if needed
         }
     });
@@ -43,6 +59,49 @@
         <label for="node-input-filename"><i class="fa fa-file"></i> Filename</label>
         <input type="text" id="node-input-filename" placeholder="ai-memories.json">
     </div>
+    <div class="form-row">
+        <label for="node-input-maxConversations"><i class="fa fa-list"></i> Max Conversations</label>
+        <input type="number" id="node-input-maxConversations" placeholder="50">
+    </div>
+    <div class="form-row">
+        <label for="node-input-maxMessagesPerConversation"><i class="fa fa-commenting"></i> Max Messages/Conv</label>
+        <input type="number" id="node-input-maxMessagesPerConversation" placeholder="100">
+    </div>
+    <div class="form-row">
+        <label for="node-input-backupEnabled"><i class="fa fa-shield"></i> Backups</label>
+        <input type="checkbox" id="node-input-backupEnabled" style="display:inline-block; width:auto; vertical-align:top;">
+        <label for="node-input-backupEnabled" style="width: auto;">Enable automatic backups</label>
+    </div>
+    <div class="form-row" id="backupCount-row">
+        <label for="node-input-backupCount"><i class="fa fa-history"></i> Backup Count</label>
+        <input type="number" id="node-input-backupCount" placeholder="3">
+    </div>
+
+    <hr>
+    <h4>AI Context & Consolidation</h4>
+    <div class="form-row">
+        <label for="node-input-consolidationThreshold"><i class="fa fa-compress"></i> Consolidation</label>
+        <input type="number" id="node-input-consolidationThreshold" placeholder="10">
+        <div style="margin-left: 105px; font-size: 0.8em; color: #666;">
+            Threshold of messages to trigger auto-consolidation.
+        </div>
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-vectorEnabled"><i class="fa fa-cube"></i> Long-Term</label>
+        <input type="checkbox" id="node-input-vectorEnabled" style="display:inline-block; width:auto; vertical-align:top;">
+        <label for="node-input-vectorEnabled" style="width: auto;">Enable Long-Term Vector Memory</label>
+    </div>
+
+    <div class="form-row vector-row">
+        <label for="node-input-embeddingModel"><i class="fa fa-braille"></i> Embedding</label>
+        <select id="node-input-embeddingModel">
+            <option value="text-embedding-ada-002">OpenAI Ada 002</option>
+            <option value="text-embedding-3-small">OpenAI 3 Small</option>
+            <option value="text-embedding-3-large">OpenAI 3 Large</option>
+        </select>
+    </div>
+
     <div class="form-tips">
         <p>Memories will be stored in Node-RED's user directory.</p>
     </div>
@@ -60,4 +119,4 @@
         <dt>payload <span>object|string</span></dt>
         <dd>The processed message with memory operations applied.</dd>
     </dl>
-</script>
+</script>

package/memory-file/memory-file.js

@@ -1,55 +1,608 @@
-module.exports = function(RED) {
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+
+class VectorStorage {
+    constructor(options = {}) {
+        this.vectors = [];
+        this.metadata = [];
+        this.dimensions = options.dimensions || 1536;
+    }
+
+    addItem(text, vector, metadata = {}) {
+        const id = Math.random().toString(36).substring(7);
+        this.vectors.push({ id, vector, text });
+        this.metadata.push({ id, ...metadata, timestamp: new Date().toISOString() });
+        return id;
+    }
+
+    search(queryVector, limit = 5) {
+        if (!queryVector || this.vectors.length === 0) return [];
+
+        const results = this.vectors.map((item, index) => {
+            return {
+                id: item.id,
+                text: item.text,
+                similarity: this.calculateSimilarity(queryVector, item.vector),
+                metadata: this.metadata[index]
+            };
+        });
+
+        return results
+            .sort((a, b) => b.similarity - a.similarity)
+            .slice(0, limit);
+    }
+
+    calculateSimilarity(vec1, vec2) {
+        if (vec1.length !== vec2.length) return 0;
+        let dotProduct = 0;
+        let normA = 0;
+        let normB = 0;
+        for (let i = 0; i < vec1.length; i++) {
+            dotProduct += vec1[i] * vec2[i];
+            normA += vec1[i] * vec1[i];
+            normB += vec2[i] * vec2[i];
+        }
+        return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+    }
+
+    toJSON() {
+        return {
+            vectors: this.vectors,
+            metadata: this.metadata,
+            dimensions: this.dimensions
+        };
+    }
+
+    fromJSON(data) {
+        if (data) {
+            this.vectors = data.vectors || [];
+            this.metadata = data.metadata || [];
+            this.dimensions = data.dimensions || 1536;
+        }
+    }
+}
+
+
+class SimpleFileStorage {
+    constructor(options = {}) {
+        this.filePath = options.filePath;
+        this.backupEnabled = options.backupEnabled !== false;
+        this.backupCount = options.backupCount || 3;
+    }
+
+    async save(data) {
+        try {
+            const dir = path.dirname(this.filePath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+
+            data.metadata = data.metadata || {};
+            data.metadata.lastUpdated = new Date().toISOString();
+
+            await fs.promises.writeFile(
+                this.filePath,
+                JSON.stringify(data, null, 2)
+            );
+
+            if (this.backupEnabled) {
+                await this.createBackup();
+            }
+
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    loadSync() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const data = fs.readFileSync(this.filePath, 'utf8');
+                return JSON.parse(data);
+            }
+            return null;
+        } catch (error) {
+            // Backup recovery is still async, but for initial load sync is safer
+            return null;
+        }
+    }
+
+    async load() {
+        try {
+            if (fs.existsSync(this.filePath)) {
+                const data = await fs.promises.readFile(this.filePath, 'utf8');
+                return JSON.parse(data);
+            }
+            return null;
+        } catch (error) {
+            return await this.recoverFromBackup();
+        }
+    }
+
+    async createBackup() {
+        try {
+            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+            const backupPath = `${this.filePath}.${timestamp}.bak`;
+
+            await fs.promises.copyFile(this.filePath, backupPath);
+
+            const backups = await this.listBackups();
+            if (backups.length > this.backupCount) {
+                const oldestBackups = backups
+                    .sort((a, b) => a.time - b.time)
+                    .slice(0, backups.length - this.backupCount);
+
+                for (const backup of oldestBackups) {
+                    await fs.promises.unlink(backup.path);
+                }
+            }
+
+            return true;
+        } catch (error) {
+            return false;
+        }
+    }
+
+    async listBackups() {
+        try {
+            const dir = path.dirname(this.filePath);
+            const base = path.basename(this.filePath);
+
+            const files = await fs.promises.readdir(dir);
+
+            return files
+                .filter(file => file.startsWith(`${base}.`) && file.endsWith('.bak'))
+                .map(file => {
+                    const match = file.match(/\.(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-\d{3}Z)\.bak$/);
+                    const timestamp = match ? match[1].replace(/-/g, ':').replace(/-(\d{3})Z$/, '.$1Z') : null;
+
+                    return {
+                        path: path.join(dir, file),
+                        time: timestamp ? new Date(timestamp).getTime() : 0
+                    };
+                });
+        } catch (error) {
+            return [];
+        }
+    }
+
+    async recoverFromBackup() {
+        try {
+            const backups = await this.listBackups();
+
+            if (backups.length === 0) {
+                return null;
+            }
+
+            const latestBackup = backups.sort((a, b) => b.time - a.time)[0];
+            const data = await fs.promises.readFile(latestBackup.path, 'utf8');
+            return JSON.parse(data);
+        } catch (error) {
+            return null;
+        }
+    }
+}
+
+class SimpleMemoryManager {
+    constructor(options = {}) {
+        this.maxConversations = options.maxConversations || 50;
+        this.maxMessagesPerConversation = options.maxMessagesPerConversation || 100;
+        this.conversations = [];
+        this.longTerm = new VectorStorage();
+    }
+
+
+    addMessage(conversationId, message) {
+        let conversation = this.conversations.find(c => c.id === conversationId);
+
+        if (!conversation) {
+            conversation = {
+                id: conversationId,
+                messages: [],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+
+            this.conversations.push(conversation);
+
+            if (this.conversations.length > this.maxConversations) {
+                this.conversations = this.conversations
+                    .sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt))
+                    .slice(0, this.maxConversations);
+            }
+        }
+
+        conversation.messages.push({
+            ...message,
+            timestamp: new Date().toISOString()
+        });
+
+        conversation.updatedAt = new Date().toISOString();
+
+        if (conversation.messages.length > this.maxMessagesPerConversation) {
+            conversation.messages = conversation.messages.slice(-this.maxMessagesPerConversation);
+        }
+
+        return conversation;
+    }
+
+    getConversation(conversationId) {
+        return this.conversations.find(c => c.id === conversationId) || null;
+    }
+
+    getConversationMessages(conversationId, limit = null) {
+        const conversation = this.getConversation(conversationId);
+
+        if (!conversation) {
+            return [];
+        }
+
+        const messages = conversation.messages;
+
+        if (limit && messages.length > limit) {
+            return messages.slice(-limit);
+        }
+
+        return messages;
+    }
+
+    searchConversations(query, options = {}) {
+        const results = [];
+
+        for (const conversation of this.conversations) {
+            const matchingMessages = conversation.messages.filter(message =>
+                message.content && message.content.toLowerCase().includes(query.toLowerCase())
+            );
+
+            if (matchingMessages.length > 0) {
+                results.push({
+                    conversation,
+                    matchingMessages: options.includeMessages ? matchingMessages : matchingMessages.length
+                });
+            }
+        }
+
+        return results.sort((a, b) =>
+            new Date(b.conversation.updatedAt) - new Date(a.conversation.updatedAt)
+        );
+    }
+
+    deleteConversation(conversationId) {
+        const index = this.conversations.findIndex(c => c.id === conversationId);
+
+        if (index !== -1) {
+            this.conversations.splice(index, 1);
+            return true;
+        }
+
+        return false;
+    }
+
+    clearAllConversations() {
+        this.conversations = [];
+        return true;
+    }
+
+    async consolidate(node, msg, aiConfig) {
+        if (!msg.conversationId) return { success: false, error: "No conversationId" };
+        const conversation = this.getConversation(msg.conversationId);
+        if (!conversation || conversation.messages.length < 2) return { success: false, error: "Not enough messages to consolidate" };
+
+        const textToSummarize = conversation.messages.map(m => `${m.role}: ${m.content}`).join('\n');
+
+        try {
+            const prompt = `Summarize the following conversation for long-term memory storage. Focus on key facts, decisions, and preferences. Keep it concise:\n\n${textToSummarize}`;
+
+            const response = await axios.post(
+                'https://openrouter.ai/api/v1/chat/completions',
+                {
+                    model: aiConfig.model,
+                    messages: [{ role: 'system', content: 'You are a memory consolidation assistant.' }, { role: 'user', content: prompt }]
+                },
+                {
+                    headers: {
+                        'Authorization': `Bearer ${aiConfig.apiKey}`,
+                        'Content-Type': 'application/json'
+                    }
+                }
+            );
+
+            const summary = response.data.choices[0]?.message?.content?.trim();
+            if (summary) {
+                // Generate embedding for the summary
+                const embeddingResponse = await axios.post(
+                    'https://openrouter.ai/api/v1/embeddings',
+                    {
+                        model: 'text-embedding-ada-002', // Default embedding model
+                        input: summary
+                    },
+                    {
+                        headers: {
+                            'Authorization': `Bearer ${aiConfig.apiKey}`,
+                            'Content-Type': 'application/json'
+                        }
+                    }
+                );
+
+                const vector = embeddingResponse.data.data[0].embedding;
+                this.longTerm.addItem(summary, vector, {
+                    conversationId: msg.conversationId,
+                    type: 'summary',
+                    originalMessageCount: conversation.messages.length
+                });
+
+                return { success: true, summary };
+            }
+        } catch (error) {
+            node.error("Consolidation error: " + error.message);
+            return { success: false, error: error.message };
+        }
+    }
+
+    toJSON() {
+        return {
+            conversations: this.conversations,
+            longTerm: this.longTerm.toJSON(),
+            metadata: {
+                version: '1.1',
+                lastUpdated: new Date().toISOString(),
+                stats: {
+                    conversationCount: this.conversations.length,
+                    longTermItemCount: this.longTerm.vectors.length,
+                    messageCount: this.conversations.reduce((count, conv) => count + conv.messages.length, 0)
+                }
+            }
+        };
+    }
+
+    fromJSON(data) {
+        if (data) {
+            this.conversations = data.conversations || [];
+            if (data.longTerm) {
+                this.longTerm.fromJSON(data.longTerm);
+            }
+        } else {
+            this.conversations = [];
+        }
+    }
+}
+
+
+module.exports = function (RED) {
     'use strict';
 
     function MemoryFileNode(config) {
         RED.nodes.createNode(this, config);
         const node = this;
-        
+
         // Configuration
         node.name = config.name || 'AI Memory (File)';
         node.filename = config.filename || 'ai-memories.json';
-        
-        // Initialize empty memories array
-        node.memories = [];
-        
-        // Load existing memories from file if they exist
-        const fs = require('fs');
-        const path = require('path');
-        const filePath = path.join(RED.settings.userDir, node.filename);
-        
-        try {
-            if (fs.existsSync(filePath)) {
-                const data = fs.readFileSync(filePath, 'utf8');
-                node.memories = JSON.parse(data);
-                node.status({fill:"green",shape:"dot",text:"Ready"});
+        node.maxConversations = parseInt(config.maxConversations) || 50;
+        node.maxMessagesPerConversation = parseInt(config.maxMessagesPerConversation) || 100;
+        node.backupEnabled = config.backupEnabled !== false;
+        node.backupCount = parseInt(config.backupCount) || 3;
+        node.vectorEnabled = config.vectorEnabled === true;
+        node.embeddingModel = config.embeddingModel || 'text-embedding-ada-002';
+        node.consolidationThreshold = parseInt(config.consolidationThreshold) || 10;
+
+
+        const userDir = (RED.settings && RED.settings.userDir) || process.cwd();
+        const filePath = path.join(userDir, node.filename);
+
+        // Create storage and memory manager
+        node.fileStorage = new SimpleFileStorage({
+            filePath,
+            backupEnabled: node.backupEnabled,
+            backupCount: node.backupCount
+        });
+
+        node.memoryManager = new SimpleMemoryManager({
+            maxConversations: node.maxConversations,
+            maxMessagesPerConversation: node.maxMessagesPerConversation
+        });
+
+        // Load existing memories synchronously at startup
+        try {
+            const data = node.fileStorage.loadSync();
+            if (data) {
+                node.memoryManager.fromJSON(data);
+                node.status({
+                    fill: "green",
+                    shape: "dot",
+                    text: `${node.memoryManager.conversations.length} conversations`
+                });
             } else {
-                node.status({fill:"blue",shape:"ring",text:"New file will be created"});
+                node.status({ fill: "blue", shape: "ring", text: "New memory file will be created" });
             }
         } catch (err) {
             node.error("Error loading memory file: " + err.message);
-            node.status({fill:"red",shape:"ring",text:"Error loading"});
+            node.status({ fill: "red", shape: "ring", text: "Error loading" });
         }
 
         // Handle incoming messages
-        node.on('input', function(msg) {
+        node.on('input', async function (msg, send, done) {
+            // Use send and done for Node-RED 1.0+ compatibility
+            send = send || function () { node.send.apply(node, arguments) };
+
             try {
-                // For now, just pass through the message
-                // We'll add memory operations in the next iteration
-                node.send(msg);
-                
-                // Update status
-                node.status({fill:"green",shape:"dot",text:node.memories.length + " memories"});
+                msg.aimemory = msg.aimemory || {};
+
+                if (msg.command) {
+                    await processCommand(node, msg);
+                } else {
+                    const conversationId = msg.conversationId || 'default';
+                    const messages = node.memoryManager.getConversationMessages(conversationId);
+
+                    // Auto-consolidate if threshold reached
+                    if (messages.length >= node.consolidationThreshold && msg.aiagent) {
+                        node.memoryManager.consolidate(node, msg, msg.aiagent);
+                    }
+
+                    msg.aimemory = {
+                        type: 'file',
+                        conversationId,
+                        context: messages,
+                        longTermEnabled: node.vectorEnabled
+                    };
+                }
+
+                send(msg);
+
+                node.status({
+                    fill: "green",
+                    shape: "dot",
+                    text: `${node.memoryManager.conversations.length} convs, ${node.memoryManager.longTerm.vectors.length} long-term`
+                });
+
+                if (done) done();
             } catch (err) {
+
                 node.error("Error in memory node: " + err.message, msg);
-                node.status({fill:"red",shape:"ring",text:"Error"});
+                node.status({ fill: "red", shape: "ring", text: "Error" });
+                if (done) done(err);
             }
         });
 
-        // Cleanup on node removal
-        node.on('close', function() {
-            // Save memories to file
+        async function processCommand(node, msg) {
+            const command = msg.command;
+
+            switch (command) {
+                case 'add':
+                    if (!msg.message) {
+                        throw new Error('No message content provided');
+                    }
+
+                    const conversationId = msg.conversationId || 'default';
+                    const conversation = node.memoryManager.addMessage(conversationId, msg.message);
+
+                    msg.result = {
+                        success: true,
+                        operation: 'add',
+                        conversationId,
+                        messageCount: conversation.messages.length
+                    };
+
+                    await node.fileStorage.save(node.memoryManager.toJSON());
+                    break;
+
+                case 'get':
+                    const getConversationId = msg.conversationId || 'default';
+                    const limit = msg.limit || null;
+
+                    msg.result = {
+                        success: true,
+                        operation: 'get',
+                        conversationId: getConversationId,
+                        messages: node.memoryManager.getConversationMessages(getConversationId, limit)
+                    };
+                    break;
+
+                case 'search':
+                    if (!msg.query) {
+                        throw new Error('No search query provided');
+                    }
+
+                    msg.result = {
+                        success: true,
+                        operation: 'search',
+                        query: msg.query,
+                        results: node.memoryManager.searchConversations(msg.query, {
+                            includeMessages: msg.includeMessages !== false
+                        })
+                    };
+                    break;
+
+                case 'delete':
+                    if (!msg.conversationId) {
+                        throw new Error('No conversation ID provided');
+                    }
+
+                    const deleted = node.memoryManager.deleteConversation(msg.conversationId);
+
+                    msg.result = {
+                        success: deleted,
+                        operation: 'delete',
+                        conversationId: msg.conversationId
+                    };
+
+                    if (deleted) {
+                        await node.fileStorage.save(node.memoryManager.toJSON());
+                    }
+                    break;
+
+                case 'clear':
+                    node.memoryManager.clearAllConversations();
+                    node.memoryManager.longTerm = new VectorStorage();
+
+                    msg.result = {
+                        success: true,
+                        operation: 'clear'
+                    };
+
+                    await node.fileStorage.save(node.memoryManager.toJSON());
+                    break;
+
+                case 'consolidate':
+                    if (!msg.aiagent) {
+                        throw new Error('AI Agent configuration (msg.aiagent) required for consolidation');
+                    }
+                    msg.result = await node.memoryManager.consolidate(node, msg, msg.aiagent);
+                    await node.fileStorage.save(node.memoryManager.toJSON());
+                    break;
+
+                case 'query':
+                    if (!node.vectorEnabled) {
+                        throw new Error('Vector storage not enabled for this node');
+                    }
+                    if (!msg.query) {
+                        throw new Error('No query text/vector provided');
+                    }
+                    if (!msg.aiagent) {
+                        throw new Error('AI Agent configuration (msg.aiagent) required for semantic search');
+                    }
+
+                    try {
+                        // Generate embedding for query if it's text
+                        let queryVector = msg.query;
+                        if (typeof msg.query === 'string') {
+                            const embeddingResponse = await axios.post(
+                                'https://openrouter.ai/api/v1/embeddings',
+                                {
+                                    model: node.embeddingModel,
+                                    input: msg.query
+                                },
+                                {
+                                    headers: {
+                                        'Authorization': `Bearer ${msg.aiagent.apiKey}`,
+                                        'Content-Type': 'application/json'
+                                    }
+                                }
+                            );
+                            queryVector = embeddingResponse.data.data[0].embedding;
+                        }
+
+                        msg.result = {
+                            success: true,
+                            operation: 'query',
+                            results: node.memoryManager.longTerm.search(queryVector, msg.limit || 5)
+                        };
+                    } catch (error) {
+                        throw new Error("Semantic search error: " + error.message);
+                    }
+                    break;
+
+                default:
+                    throw new Error(`Unknown command: ${command}`);
+            }
+        }
+
+
+        node.on('close', async function () {
             try {
-                fs.writeFileSync(filePath, JSON.stringify(node.memories, null, 2));
+                await node.fileStorage.save(node.memoryManager.toJSON());
             } catch (err) {
                 node.error("Error saving memory file: " + err.message);
             }
@@ -57,6 +610,5 @@ module.exports = function(RED) {
         });
     }
 
-    // Register the node type
     RED.nodes.registerType("ai-memory-file", MemoryFileNode);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-red-contrib-ai-agent",
-    "version": "0.0.5",
+    "version": "0.0.7",
     "description": "AI Agent for Node-RED",
     "repository": {
         "type": "git",
@@ -63,4 +63,4 @@
             "ai-memory-inmem": "./memory-inmem/memory-inmem.js"
         }
     }
-}
+}