n8n-nodes-memory 0.5.1 → 0.6.1

package/README.md

@@ -1,6 +1,13 @@
 # n8n-nodes-memory
 
-Custom memory node for n8n AI Agent with external API support.
+Custom memory nodes for n8n AI Agent with workflow-based storage.
+
+## Two Nodes
+
+| Node | Use Case |
+|------|----------|
+| **Memory API** | External webhook/API as memory backend |
+| **Memory Workflow** | Sub-workflow within n8n as memory backend |
 
 ## The Power: Memory as Workflows
 
@@ -81,6 +88,8 @@ Message types: `human` or `ai`
 
 ## Parameters
 
+### Memory API
+
 | Parameter | Description |
 |-----------|-------------|
 | API URL | Your memory webhook URL |
@@ -88,6 +97,14 @@ Message types: `human` or `ai`
 | API Key | Optional Bearer token |
 | Context Window Length | Messages to include (default: 10) |
 
+### Memory Workflow
+
+| Parameter | Description |
+|-----------|-------------|
+| Workflow ID | ID of the sub-workflow to execute |
+| Session ID | Unique conversation identifier |
+| Context Window Length | Messages to include (default: 10) |
+
 ## How It Works
 
 Implements LangChain's `BaseListChatMessageHistory` with `BufferWindowMemory`. The AI Agent calls your workflows automatically during conversation.

package/dist/index.d.ts

@@ -1 +1,2 @@
-export { Memory } from './nodes/Memory/Memory.node';
+export { MemoryApi } from './nodes/Memory/MemoryApi.node';
+export { MemoryWorkflow } from './nodes/Memory/MemoryWorkflow.node';

package/dist/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Memory = void 0;
-var Memory_node_1 = require("./nodes/Memory/Memory.node");
-Object.defineProperty(exports, "Memory", { enumerable: true, get: function () { return Memory_node_1.Memory; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsMERBQW9EO0FBQTNDLHFHQUFBLE1BQU0sT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IE1lbW9yeSB9IGZyb20gJy4vbm9kZXMvTWVtb3J5L01lbW9yeS5ub2RlJztcbiJdfQ==
+exports.MemoryWorkflow = exports.MemoryApi = void 0;
+var MemoryApi_node_1 = require("./nodes/Memory/MemoryApi.node");
+Object.defineProperty(exports, "MemoryApi", { enumerable: true, get: function () { return MemoryApi_node_1.MemoryApi; } });
+var MemoryWorkflow_node_1 = require("./nodes/Memory/MemoryWorkflow.node");
+Object.defineProperty(exports, "MemoryWorkflow", { enumerable: true, get: function () { return MemoryWorkflow_node_1.MemoryWorkflow; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsZ0VBQTBEO0FBQWpELDJHQUFBLFNBQVMsT0FBQTtBQUNsQiwwRUFBb0U7QUFBM0QscUhBQUEsY0FBYyxPQUFBIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHsgTWVtb3J5QXBpIH0gZnJvbSAnLi9ub2Rlcy9NZW1vcnkvTWVtb3J5QXBpLm5vZGUnO1xuZXhwb3J0IHsgTWVtb3J5V29ya2Zsb3cgfSBmcm9tICcuL25vZGVzL01lbW9yeS9NZW1vcnlXb3JrZmxvdy5ub2RlJztcbiJdfQ==

package/dist/nodes/Memory/{Memory.node.d.ts → MemoryApi.node.d.ts}

@@ -1,5 +1,5 @@
 import type { INodeType, INodeTypeDescription, ISupplyDataFunctions, SupplyData } from 'n8n-workflow';
-export declare class Memory implements INodeType {
+export declare class MemoryApi implements INodeType {
     description: INodeTypeDescription;
     supplyData(this: ISupplyDataFunctions, itemIndex: number): Promise<SupplyData>;
 }

package/dist/nodes/Memory/MemoryApi.node.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryApi = void 0;
+const memory_1 = require("langchain/memory");
+const chat_history_1 = require("@langchain/core/chat_history");
+const messages_1 = require("@langchain/core/messages");
+class ApiChatHistory extends chat_history_1.BaseListChatMessageHistory {
+    constructor(apiUrl, sessionId, apiKey) {
+        super();
+        this.apiUrl = apiUrl;
+        this.sessionId = sessionId;
+        this.apiKey = apiKey;
+        this.lc_namespace = ['langchain', 'stores', 'message', 'api'];
+    }
+    getHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+        return headers;
+    }
+    async getMessages() {
+        console.log('[ApiChatHistory] getMessages called for session:', this.sessionId);
+        try {
+            console.log('[ApiChatHistory] Fetching from:', this.apiUrl);
+            const response = await fetch(this.apiUrl, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify({
+                    action: 'get',
+                    sessionId: this.sessionId,
+                }),
+            });
+            if (!response.ok) {
+                console.error(`[ApiChatHistory] API error: ${response.status}`);
+                return [];
+            }
+            const data = await response.json();
+            const messages = data?.messages ?? [];
+            console.log('[ApiChatHistory] Got messages:', messages.length);
+            return messages.map((m) => {
+                if (m.type === 'human') {
+                    return new messages_1.HumanMessage(m.content);
+                }
+                else {
+                    return new messages_1.AIMessage(m.content);
+                }
+            });
+        }
+        catch (error) {
+            console.error('[ApiChatHistory] getMessages error:', error);
+            return [];
+        }
+    }
+    async addMessage(message) {
+        console.log('[ApiChatHistory] addMessage called for session:', this.sessionId);
+        try {
+            const type = message._getType() === 'human' ? 'human' : 'ai';
+            await fetch(this.apiUrl, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify({
+                    action: 'add',
+                    sessionId: this.sessionId,
+                    message: {
+                        type,
+                        content: message.content,
+                    },
+                }),
+            });
+            console.log('[ApiChatHistory] Message added successfully');
+        }
+        catch (error) {
+            console.error('[ApiChatHistory] addMessage error:', error);
+        }
+    }
+    async addMessages(messages) {
+        for (const message of messages) {
+            await this.addMessage(message);
+        }
+    }
+    async clear() {
+        console.log('[ApiChatHistory] clear called for session:', this.sessionId);
+        try {
+            await fetch(this.apiUrl, {
+                method: 'POST',
+                headers: this.getHeaders(),
+                body: JSON.stringify({
+                    action: 'clear',
+                    sessionId: this.sessionId,
+                }),
+            });
+        }
+        catch (error) {
+            console.error('[ApiChatHistory] clear error:', error);
+        }
+    }
+}
+class MemoryApi {
+    constructor() {
+        this.description = {
+            displayName: 'Memory API',
+            name: 'memoryApi',
+            icon: 'fa:brain',
+            group: ['transform'],
+            version: 1,
+            subtitle: 'External API Memory',
+            description: 'Use an external API as chat memory storage',
+            defaults: {
+                name: 'Memory API',
+            },
+            codex: {
+                categories: ['AI'],
+                subcategories: {
+                    AI: ['Memory'],
+                },
+                resources: {
+                    primaryDocumentation: [
+                        {
+                            url: 'https://github.com/filipexyz/n8n-nodes-memory',
+                        },
+                    ],
+                },
+            },
+            inputs: [],
+            outputs: ['ai_memory'],
+            outputNames: ['Memory'],
+            properties: [
+                {
+                    displayName: 'API URL',
+                    name: 'apiUrl',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'URL of the memory API (e.g., n8n webhook URL)',
+                    placeholder: 'https://your-n8n.com/webhook/memory',
+                },
+                {
+                    displayName: 'Session ID',
+                    name: 'sessionId',
+                    type: 'string',
+                    default: '={{ $json.sessionId }}',
+                    required: true,
+                    description: 'Unique identifier for the conversation session',
+                },
+                {
+                    displayName: 'API Key',
+                    name: 'apiKey',
+                    type: 'string',
+                    typeOptions: {
+                        password: true,
+                    },
+                    default: '',
+                    description: 'Optional API key for authentication',
+                },
+                {
+                    displayName: 'Context Window Length',
+                    name: 'contextWindowLength',
+                    type: 'number',
+                    default: 10,
+                    description: 'Number of previous messages to include as context',
+                },
+            ],
+        };
+    }
+    async supplyData(itemIndex) {
+        const apiUrl = this.getNodeParameter('apiUrl', itemIndex);
+        const sessionId = this.getNodeParameter('sessionId', itemIndex);
+        const apiKey = this.getNodeParameter('apiKey', itemIndex, '') || undefined;
+        const contextWindowLength = this.getNodeParameter('contextWindowLength', itemIndex, 10);
+        console.log('[Memory API] Creating memory for session:', sessionId);
+        const chatHistory = new ApiChatHistory(apiUrl, sessionId, apiKey);
+        const memory = new memory_1.BufferWindowMemory({
+            memoryKey: 'chat_history',
+            chatHistory,
+            returnMessages: true,
+            inputKey: 'input',
+            outputKey: 'output',
+            k: contextWindowLength,
+        });
+        return {
+            response: memory,
+        };
+    }
+}
+exports.MemoryApi = MemoryApi;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MemoryApi.node.js","sourceRoot":"","sources":["../../../src/nodes/Memory/MemoryApi.node.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  INodeType,\n  INodeTypeDescription,\n  ISupplyDataFunctions,\n  SupplyData,\n} from 'n8n-workflow';\nimport { BufferWindowMemory } from 'langchain/memory';\nimport { BaseListChatMessageHistory } from '@langchain/core/chat_history';\nimport {\n  BaseMessage,\n  HumanMessage,\n  AIMessage,\n} from '@langchain/core/messages';\n\nclass ApiChatHistory extends BaseListChatMessageHistory {\n  lc_namespace = ['langchain', 'stores', 'message', 'api'];\n\n  constructor(\n    private apiUrl: string,\n    private sessionId: string,\n    private apiKey?: string,\n  ) {\n    super();\n  }\n\n  private getHeaders(): Record<string, string> {\n    const headers: Record<string, string> = {\n      'Content-Type': 'application/json',\n    };\n    if (this.apiKey) {\n      headers['Authorization'] = `Bearer ${this.apiKey}`;\n    }\n    return headers;\n  }\n\n  async getMessages(): Promise<BaseMessage[]> {\n    console.log('[ApiChatHistory] getMessages called for session:', this.sessionId);\n    try {\n      console.log('[ApiChatHistory] Fetching from:', this.apiUrl);\n      const response = await fetch(this.apiUrl, {\n        method: 'POST',\n        headers: this.getHeaders(),\n        body: JSON.stringify({\n          action: 'get',\n          sessionId: this.sessionId,\n        }),\n      });\n\n      if (!response.ok) {\n        console.error(`[ApiChatHistory] API error: ${response.status}`);\n        return [];\n      }\n\n      const data = await response.json() as { messages?: Array<{ type: string; content: string }> };\n      const messages = data?.messages ?? [];\n      console.log('[ApiChatHistory] Got messages:', messages.length);\n\n      return messages.map((m: { type: string; content: string }) => {\n        if (m.type === 'human') {\n          return new HumanMessage(m.content);\n        } else {\n          return new AIMessage(m.content);\n        }\n      });\n    } catch (error) {\n      console.error('[ApiChatHistory] getMessages error:', error);\n      return [];\n    }\n  }\n\n  async addMessage(message: BaseMessage): Promise<void> {\n    console.log('[ApiChatHistory] addMessage called for session:', this.sessionId);\n    try {\n      const type = message._getType() === 'human' ? 'human' : 'ai';\n\n      await fetch(this.apiUrl, {\n        method: 'POST',\n        headers: this.getHeaders(),\n        body: JSON.stringify({\n          action: 'add',\n          sessionId: this.sessionId,\n          message: {\n            type,\n            content: message.content,\n          },\n        }),\n      });\n      console.log('[ApiChatHistory] Message added successfully');\n    } catch (error) {\n      console.error('[ApiChatHistory] addMessage error:', error);\n    }\n  }\n\n  async addMessages(messages: BaseMessage[]): Promise<void> {\n    for (const message of messages) {\n      await this.addMessage(message);\n    }\n  }\n\n  async clear(): Promise<void> {\n    console.log('[ApiChatHistory] clear called for session:', this.sessionId);\n    try {\n      await fetch(this.apiUrl, {\n        method: 'POST',\n        headers: this.getHeaders(),\n        body: JSON.stringify({\n          action: 'clear',\n          sessionId: this.sessionId,\n        }),\n      });\n    } catch (error) {\n      console.error('[ApiChatHistory] clear error:', error);\n    }\n  }\n}\n\nexport class MemoryApi implements INodeType {\n  description: INodeTypeDescription = {\n    displayName: 'Memory API',\n    name: 'memoryApi',\n    icon: 'fa:brain',\n    group: ['transform'],\n    version: 1,\n    subtitle: 'External API Memory',\n    description: 'Use an external API as chat memory storage',\n    defaults: {\n      name: 'Memory API',\n    },\n    codex: {\n      categories: ['AI'],\n      subcategories: {\n        AI: ['Memory'],\n      },\n      resources: {\n        primaryDocumentation: [\n          {\n            url: 'https://github.com/filipexyz/n8n-nodes-memory',\n          },\n        ],\n      },\n    },\n    inputs: [],\n    outputs: ['ai_memory' as const],\n    outputNames: ['Memory'],\n    properties: [\n      {\n        displayName: 'API URL',\n        name: 'apiUrl',\n        type: 'string',\n        default: '',\n        required: true,\n        description: 'URL of the memory API (e.g., n8n webhook URL)',\n        placeholder: 'https://your-n8n.com/webhook/memory',\n      },\n      {\n        displayName: 'Session ID',\n        name: 'sessionId',\n        type: 'string',\n        default: '={{ $json.sessionId }}',\n        required: true,\n        description: 'Unique identifier for the conversation session',\n      },\n      {\n        displayName: 'API Key',\n        name: 'apiKey',\n        type: 'string',\n        typeOptions: {\n          password: true,\n        },\n        default: '',\n        description: 'Optional API key for authentication',\n      },\n      {\n        displayName: 'Context Window Length',\n        name: 'contextWindowLength',\n        type: 'number',\n        default: 10,\n        description: 'Number of previous messages to include as context',\n      },\n    ],\n  };\n\n  async supplyData(\n    this: ISupplyDataFunctions,\n    itemIndex: number\n  ): Promise<SupplyData> {\n    const apiUrl = this.getNodeParameter('apiUrl', itemIndex) as string;\n    const sessionId = this.getNodeParameter('sessionId', itemIndex) as string;\n    const apiKey = (this.getNodeParameter('apiKey', itemIndex, '') as string) || undefined;\n    const contextWindowLength = this.getNodeParameter('contextWindowLength', itemIndex, 10) as number;\n\n    console.log('[Memory API] Creating memory for session:', sessionId);\n\n    const chatHistory = new ApiChatHistory(apiUrl, sessionId, apiKey);\n\n    const memory = new BufferWindowMemory({\n      memoryKey: 'chat_history',\n      chatHistory,\n      returnMessages: true,\n      inputKey: 'input',\n      outputKey: 'output',\n      k: contextWindowLength,\n    });\n\n    return {\n      response: memory,\n    };\n  }\n}\n"]}

package/dist/nodes/Memory/MemoryWorkflow.node.d.ts

@@ -0,0 +1,5 @@
+import type { INodeType, INodeTypeDescription, ISupplyDataFunctions, SupplyData } from 'n8n-workflow';
+export declare class MemoryWorkflow implements INodeType {
+    description: INodeTypeDescription;
+    supplyData(this: ISupplyDataFunctions, itemIndex: number): Promise<SupplyData>;
+}

package/dist/nodes/Memory/MemoryWorkflow.node.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryWorkflow = void 0;
+const memory_1 = require("langchain/memory");
+const chat_history_1 = require("@langchain/core/chat_history");
+const messages_1 = require("@langchain/core/messages");
+class WorkflowChatHistory extends chat_history_1.BaseListChatMessageHistory {
+    constructor(executeWorkflow, sessionId) {
+        super();
+        this.executeWorkflow = executeWorkflow;
+        this.sessionId = sessionId;
+        this.lc_namespace = ['langchain', 'stores', 'message', 'workflow'];
+    }
+    async getMessages() {
+        console.log('[WorkflowChatHistory] getMessages called for session:', this.sessionId);
+        try {
+            const result = await this.executeWorkflow({
+                action: 'get',
+                sessionId: this.sessionId,
+            });
+            const messages = result?.messages ?? [];
+            console.log('[WorkflowChatHistory] Got messages:', messages.length);
+            return messages.map((m) => {
+                if (m.type === 'human') {
+                    return new messages_1.HumanMessage(m.content);
+                }
+                else {
+                    return new messages_1.AIMessage(m.content);
+                }
+            });
+        }
+        catch (error) {
+            console.error('[WorkflowChatHistory] getMessages error:', error);
+            return [];
+        }
+    }
+    async addMessage(message) {
+        console.log('[WorkflowChatHistory] addMessage called for session:', this.sessionId);
+        try {
+            const type = message._getType() === 'human' ? 'human' : 'ai';
+            await this.executeWorkflow({
+                action: 'add',
+                sessionId: this.sessionId,
+                message: {
+                    type,
+                    content: message.content,
+                },
+            });
+            console.log('[WorkflowChatHistory] Message added successfully');
+        }
+        catch (error) {
+            console.error('[WorkflowChatHistory] addMessage error:', error);
+        }
+    }
+    async addMessages(messages) {
+        for (const message of messages) {
+            await this.addMessage(message);
+        }
+    }
+    async clear() {
+        console.log('[WorkflowChatHistory] clear called for session:', this.sessionId);
+        try {
+            await this.executeWorkflow({
+                action: 'clear',
+                sessionId: this.sessionId,
+            });
+        }
+        catch (error) {
+            console.error('[WorkflowChatHistory] clear error:', error);
+        }
+    }
+}
+class MemoryWorkflow {
+    constructor() {
+        this.description = {
+            displayName: 'Memory Workflow',
+            name: 'memoryWorkflow',
+            icon: 'fa:project-diagram',
+            group: ['transform'],
+            version: 1,
+            subtitle: 'Sub-Workflow Memory',
+            description: 'Use a sub-workflow as chat memory storage',
+            defaults: {
+                name: 'Memory Workflow',
+            },
+            codex: {
+                categories: ['AI'],
+                subcategories: {
+                    AI: ['Memory'],
+                },
+                resources: {
+                    primaryDocumentation: [
+                        {
+                            url: 'https://github.com/filipexyz/n8n-nodes-memory',
+                        },
+                    ],
+                },
+            },
+            inputs: [],
+            outputs: ['ai_memory'],
+            outputNames: ['Memory'],
+            properties: [
+                {
+                    displayName: 'Workflow',
+                    name: 'workflowId',
+                    type: 'workflowSelector',
+                    default: '',
+                    required: true,
+                    description: 'The workflow to execute for memory operations',
+                },
+                {
+                    displayName: 'Session ID',
+                    name: 'sessionId',
+                    type: 'string',
+                    default: '={{ $json.sessionId }}',
+                    required: true,
+                    description: 'Unique identifier for the conversation session',
+                },
+                {
+                    displayName: 'Context Window Length',
+                    name: 'contextWindowLength',
+                    type: 'number',
+                    default: 10,
+                    description: 'Number of previous messages to include as context',
+                },
+            ],
+        };
+    }
+    async supplyData(itemIndex) {
+        const workflowIdParam = this.getNodeParameter('workflowId', itemIndex);
+        const workflowId = typeof workflowIdParam === 'string' ? workflowIdParam : workflowIdParam.value;
+        const sessionId = this.getNodeParameter('sessionId', itemIndex);
+        const contextWindowLength = this.getNodeParameter('contextWindowLength', itemIndex, 10);
+        console.log('[Memory Workflow] Creating memory for session:', sessionId);
+        const nodeContext = this;
+        const executeWorkflow = async (data) => {
+            const workflowInfo = {
+                id: workflowId,
+            };
+            const items = [{ json: data }];
+            const result = await nodeContext.executeWorkflow(workflowInfo, items);
+            // Get the output from the last node
+            const lastNodeData = result.data?.[0]?.[0]?.json;
+            return lastNodeData ?? {};
+        };
+        const chatHistory = new WorkflowChatHistory(executeWorkflow, sessionId);
+        const memory = new memory_1.BufferWindowMemory({
+            memoryKey: 'chat_history',
+            chatHistory,
+            returnMessages: true,
+            inputKey: 'input',
+            outputKey: 'output',
+            k: contextWindowLength,
+        });
+        return {
+            response: memory,
+        };
+    }
+}
+exports.MemoryWorkflow = MemoryWorkflow;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"MemoryWorkflow.node.js","sourceRoot":"","sources":["../../../src/nodes/Memory/MemoryWorkflow.node.ts"],"names":[],"mappings":"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","sourcesContent":["import type {\n  INodeType,\n  INodeTypeDescription,\n  ISupplyDataFunctions,\n  SupplyData,\n  IExecuteWorkflowInfo,\n  INodeExecutionData,\n  IDataObject,\n} from 'n8n-workflow';\nimport { BufferWindowMemory } from 'langchain/memory';\nimport { BaseListChatMessageHistory } from '@langchain/core/chat_history';\nimport {\n  BaseMessage,\n  HumanMessage,\n  AIMessage,\n} from '@langchain/core/messages';\n\ntype WorkflowExecutor = (data: Record<string, unknown>) => Promise<Record<string, unknown>>;\n\nclass WorkflowChatHistory extends BaseListChatMessageHistory {\n  lc_namespace = ['langchain', 'stores', 'message', 'workflow'];\n\n  constructor(\n    private executeWorkflow: WorkflowExecutor,\n    private sessionId: string,\n  ) {\n    super();\n  }\n\n  async getMessages(): Promise<BaseMessage[]> {\n    console.log('[WorkflowChatHistory] getMessages called for session:', this.sessionId);\n    try {\n      const result = await this.executeWorkflow({\n        action: 'get',\n        sessionId: this.sessionId,\n      });\n\n      const messages = (result?.messages as Array<{ type: string; content: string }>) ?? [];\n      console.log('[WorkflowChatHistory] Got messages:', messages.length);\n\n      return messages.map((m) => {\n        if (m.type === 'human') {\n          return new HumanMessage(m.content);\n        } else {\n          return new AIMessage(m.content);\n        }\n      });\n    } catch (error) {\n      console.error('[WorkflowChatHistory] getMessages error:', error);\n      return [];\n    }\n  }\n\n  async addMessage(message: BaseMessage): Promise<void> {\n    console.log('[WorkflowChatHistory] addMessage called for session:', this.sessionId);\n    try {\n      const type = message._getType() === 'human' ? 'human' : 'ai';\n\n      await this.executeWorkflow({\n        action: 'add',\n        sessionId: this.sessionId,\n        message: {\n          type,\n          content: message.content,\n        },\n      });\n      console.log('[WorkflowChatHistory] Message added successfully');\n    } catch (error) {\n      console.error('[WorkflowChatHistory] addMessage error:', error);\n    }\n  }\n\n  async addMessages(messages: BaseMessage[]): Promise<void> {\n    for (const message of messages) {\n      await this.addMessage(message);\n    }\n  }\n\n  async clear(): Promise<void> {\n    console.log('[WorkflowChatHistory] clear called for session:', this.sessionId);\n    try {\n      await this.executeWorkflow({\n        action: 'clear',\n        sessionId: this.sessionId,\n      });\n    } catch (error) {\n      console.error('[WorkflowChatHistory] clear error:', error);\n    }\n  }\n}\n\nexport class MemoryWorkflow implements INodeType {\n  description: INodeTypeDescription = {\n    displayName: 'Memory Workflow',\n    name: 'memoryWorkflow',\n    icon: 'fa:project-diagram',\n    group: ['transform'],\n    version: 1,\n    subtitle: 'Sub-Workflow Memory',\n    description: 'Use a sub-workflow as chat memory storage',\n    defaults: {\n      name: 'Memory Workflow',\n    },\n    codex: {\n      categories: ['AI'],\n      subcategories: {\n        AI: ['Memory'],\n      },\n      resources: {\n        primaryDocumentation: [\n          {\n            url: 'https://github.com/filipexyz/n8n-nodes-memory',\n          },\n        ],\n      },\n    },\n    inputs: [],\n    outputs: ['ai_memory' as const],\n    outputNames: ['Memory'],\n    properties: [\n      {\n        displayName: 'Workflow',\n        name: 'workflowId',\n        type: 'workflowSelector',\n        default: '',\n        required: true,\n        description: 'The workflow to execute for memory operations',\n      },\n      {\n        displayName: 'Session ID',\n        name: 'sessionId',\n        type: 'string',\n        default: '={{ $json.sessionId }}',\n        required: true,\n        description: 'Unique identifier for the conversation session',\n      },\n      {\n        displayName: 'Context Window Length',\n        name: 'contextWindowLength',\n        type: 'number',\n        default: 10,\n        description: 'Number of previous messages to include as context',\n      },\n    ],\n  };\n\n  async supplyData(\n    this: ISupplyDataFunctions,\n    itemIndex: number\n  ): Promise<SupplyData> {\n    const workflowIdParam = this.getNodeParameter('workflowId', itemIndex) as string | { value: string };\n    const workflowId = typeof workflowIdParam === 'string' ? workflowIdParam : workflowIdParam.value;\n    const sessionId = this.getNodeParameter('sessionId', itemIndex) as string;\n    const contextWindowLength = this.getNodeParameter('contextWindowLength', itemIndex, 10) as number;\n\n    console.log('[Memory Workflow] Creating memory for session:', sessionId);\n\n    const nodeContext = this;\n\n    const executeWorkflow: WorkflowExecutor = async (data) => {\n      const workflowInfo: IExecuteWorkflowInfo = {\n        id: workflowId,\n      };\n\n      const items: INodeExecutionData[] = [{ json: data as IDataObject }];\n      const result = await nodeContext.executeWorkflow(workflowInfo, items);\n\n      // Get the output from the last node\n      const lastNodeData = result.data?.[0]?.[0]?.json;\n      return lastNodeData as Record<string, unknown> ?? {};\n    };\n\n    const chatHistory = new WorkflowChatHistory(executeWorkflow, sessionId);\n\n    const memory = new BufferWindowMemory({\n      memoryKey: 'chat_history',\n      chatHistory,\n      returnMessages: true,\n      inputKey: 'input',\n      outputKey: 'output',\n      k: contextWindowLength,\n    });\n\n    return {\n      response: memory,\n    };\n  }\n}\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "n8n-nodes-memory",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "description": "Custom memory node for n8n AI Agent with external API support",
   "keywords": [
     "n8n-community-node-package",
@@ -28,7 +28,8 @@
   "n8n": {
     "n8nNodesApiVersion": 1,
     "nodes": [
-      "dist/nodes/Memory/Memory.node.js"
+      "dist/nodes/Memory/MemoryApi.node.js",
+      "dist/nodes/Memory/MemoryWorkflow.node.js"
     ],
     "credentials": []
   },

package/dist/nodes/Memory/ApiMemoryHistory.d.ts

@@ -1,18 +0,0 @@
-import { BaseListChatMessageHistory } from '@langchain/core/chat_history';
-import { BaseMessage } from '@langchain/core/messages';
-export interface ApiMemoryHistoryConfig {
-    apiUrl: string;
-    sessionId: string;
-    apiKey?: string;
-}
-export declare class ApiMemoryHistory extends BaseListChatMessageHistory {
-    lc_namespace: string[];
-    private apiUrl;
-    private sessionId;
-    private apiKey?;
-    constructor(config: ApiMemoryHistoryConfig);
-    getMessages(): Promise<BaseMessage[]>;
-    addMessage(message: BaseMessage): Promise<void>;
-    addMessages(messages: BaseMessage[]): Promise<void>;
-    clear(): Promise<void>;
-}

package/dist/nodes/Memory/ApiMemoryHistory.js

@@ -1,113 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ApiMemoryHistory = void 0;
-const chat_history_1 = require("@langchain/core/chat_history");
-const messages_1 = require("@langchain/core/messages");
-class ApiMemoryHistory extends chat_history_1.BaseListChatMessageHistory {
-    constructor(config) {
-        super();
-        this.lc_namespace = ['langchain', 'stores', 'message', 'api'];
-        this.apiUrl = config.apiUrl;
-        this.sessionId = config.sessionId;
-        this.apiKey = config.apiKey;
-    }
-    async getMessages() {
-        try {
-            const url = new URL(this.apiUrl);
-            url.searchParams.set('sessionId', this.sessionId);
-            url.searchParams.set('action', 'get');
-            const headers = {
-                'Content-Type': 'application/json',
-            };
-            if (this.apiKey) {
-                headers['Authorization'] = `Bearer ${this.apiKey}`;
-            }
-            const response = await fetch(url.toString(), {
-                method: 'GET',
-                headers,
-            });
-            if (!response.ok) {
-                console.error(`Memory API error: ${response.status}`);
-                return [];
-            }
-            const data = await response.json();
-            const messages = data.messages || [];
-            return messages.map((msg) => {
-                switch (msg.type) {
-                    case 'human':
-                        return new messages_1.HumanMessage(msg.content);
-                    case 'ai':
-                        return new messages_1.AIMessage(msg.content);
-                    case 'system':
-                        return new messages_1.SystemMessage(msg.content);
-                    default:
-                        return new messages_1.HumanMessage(msg.content);
-                }
-            });
-        }
-        catch (error) {
-            console.error('Failed to get messages from API:', error);
-            return [];
-        }
-    }
-    async addMessage(message) {
-        try {
-            const headers = {
-                'Content-Type': 'application/json',
-            };
-            if (this.apiKey) {
-                headers['Authorization'] = `Bearer ${this.apiKey}`;
-            }
-            let type = 'human';
-            if (message._getType() === 'ai') {
-                type = 'ai';
-            }
-            else if (message._getType() === 'system') {
-                type = 'system';
-            }
-            await fetch(this.apiUrl, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify({
-                    action: 'add',
-                    sessionId: this.sessionId,
-                    message: {
-                        type,
-                        content: message.content,
-                    },
-                }),
-            });
-        }
-        catch (error) {
-            console.error('Failed to add message to API:', error);
-        }
-    }
-    async addMessages(messages) {
-        for (const message of messages) {
-            await this.addMessage(message);
-        }
-    }
-    async clear() {
-        try {
-            const headers = {
-                'Content-Type': 'application/json',
-            };
-            if (this.apiKey) {
-                headers['Authorization'] = `Bearer ${this.apiKey}`;
-            }
-            await fetch(this.apiUrl, {
-                method: 'POST',
-                headers,
-                body: JSON.stringify({
-                    action: 'clear',
-                    sessionId: this.sessionId,
-                }),
-            });
-        }
-        catch (error) {
-            console.error('Failed to clear messages from API:', error);
-        }
-    }
-}
-exports.ApiMemoryHistory = ApiMemoryHistory;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ApiMemoryHistory.js","sourceRoot":"","sources":["../../../src/nodes/Memory/ApiMemoryHistory.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  BaseListChatMessageHistory,\n} from '@langchain/core/chat_history';\nimport {\n  BaseMessage,\n  HumanMessage,\n  AIMessage,\n  SystemMessage,\n} from '@langchain/core/messages';\n\nexport interface ApiMemoryHistoryConfig {\n  apiUrl: string;\n  sessionId: string;\n  apiKey?: string;\n}\n\ninterface ApiMessage {\n  type: 'human' | 'ai' | 'system';\n  content: string;\n}\n\ninterface ApiResponse {\n  messages?: ApiMessage[];\n}\n\nexport class ApiMemoryHistory extends BaseListChatMessageHistory {\n  lc_namespace = ['langchain', 'stores', 'message', 'api'];\n\n  private apiUrl: string;\n  private sessionId: string;\n  private apiKey?: string;\n\n  constructor(config: ApiMemoryHistoryConfig) {\n    super();\n    this.apiUrl = config.apiUrl;\n    this.sessionId = config.sessionId;\n    this.apiKey = config.apiKey;\n  }\n\n  async getMessages(): Promise<BaseMessage[]> {\n    try {\n      const url = new URL(this.apiUrl);\n      url.searchParams.set('sessionId', this.sessionId);\n      url.searchParams.set('action', 'get');\n\n      const headers: Record<string, string> = {\n        'Content-Type': 'application/json',\n      };\n      if (this.apiKey) {\n        headers['Authorization'] = `Bearer ${this.apiKey}`;\n      }\n\n      const response = await fetch(url.toString(), {\n        method: 'GET',\n        headers,\n      });\n\n      if (!response.ok) {\n        console.error(`Memory API error: ${response.status}`);\n        return [];\n      }\n\n      const data = await response.json() as ApiResponse;\n      const messages: ApiMessage[] = data.messages || [];\n\n      return messages.map((msg) => {\n        switch (msg.type) {\n          case 'human':\n            return new HumanMessage(msg.content);\n          case 'ai':\n            return new AIMessage(msg.content);\n          case 'system':\n            return new SystemMessage(msg.content);\n          default:\n            return new HumanMessage(msg.content);\n        }\n      });\n    } catch (error) {\n      console.error('Failed to get messages from API:', error);\n      return [];\n    }\n  }\n\n  async addMessage(message: BaseMessage): Promise<void> {\n    try {\n      const headers: Record<string, string> = {\n        'Content-Type': 'application/json',\n      };\n      if (this.apiKey) {\n        headers['Authorization'] = `Bearer ${this.apiKey}`;\n      }\n\n      let type: 'human' | 'ai' | 'system' = 'human';\n      if (message._getType() === 'ai') {\n        type = 'ai';\n      } else if (message._getType() === 'system') {\n        type = 'system';\n      }\n\n      await fetch(this.apiUrl, {\n        method: 'POST',\n        headers,\n        body: JSON.stringify({\n          action: 'add',\n          sessionId: this.sessionId,\n          message: {\n            type,\n            content: message.content,\n          },\n        }),\n      });\n    } catch (error) {\n      console.error('Failed to add message to API:', error);\n    }\n  }\n\n  async addMessages(messages: BaseMessage[]): Promise<void> {\n    for (const message of messages) {\n      await this.addMessage(message);\n    }\n  }\n\n  async clear(): Promise<void> {\n    try {\n      const headers: Record<string, string> = {\n        'Content-Type': 'application/json',\n      };\n      if (this.apiKey) {\n        headers['Authorization'] = `Bearer ${this.apiKey}`;\n      }\n\n      await fetch(this.apiUrl, {\n        method: 'POST',\n        headers,\n        body: JSON.stringify({\n          action: 'clear',\n          sessionId: this.sessionId,\n        }),\n      });\n    } catch (error) {\n      console.error('Failed to clear messages from API:', error);\n    }\n  }\n}\n"]}

package/dist/nodes/Memory/Memory.node.js

@@ -1,189 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Memory = void 0;
-const memory_1 = require("langchain/memory");
-const chat_history_1 = require("@langchain/core/chat_history");
-const messages_1 = require("@langchain/core/messages");
-class ApiChatHistory extends chat_history_1.BaseListChatMessageHistory {
-    constructor(apiUrl, sessionId, apiKey) {
-        super();
-        this.apiUrl = apiUrl;
-        this.sessionId = sessionId;
-        this.apiKey = apiKey;
-        this.lc_namespace = ['langchain', 'stores', 'message', 'api'];
-    }
-    getHeaders() {
-        const headers = {
-            'Content-Type': 'application/json',
-        };
-        if (this.apiKey) {
-            headers['Authorization'] = `Bearer ${this.apiKey}`;
-        }
-        return headers;
-    }
-    async getMessages() {
-        console.log('[ApiChatHistory] getMessages called for session:', this.sessionId);
-        try {
-            console.log('[ApiChatHistory] Fetching from:', this.apiUrl);
-            const response = await fetch(this.apiUrl, {
-                method: 'POST',
-                headers: this.getHeaders(),
-                body: JSON.stringify({
-                    action: 'get',
-                    sessionId: this.sessionId,
-                }),
-            });
-            if (!response.ok) {
-                console.error(`[ApiChatHistory] API error: ${response.status}`);
-                return [];
-            }
-            const data = await response.json();
-            const messages = data?.messages ?? [];
-            console.log('[ApiChatHistory] Got messages:', messages.length);
-            return messages.map((m) => {
-                if (m.type === 'human') {
-                    return new messages_1.HumanMessage(m.content);
-                }
-                else {
-                    return new messages_1.AIMessage(m.content);
-                }
-            });
-        }
-        catch (error) {
-            console.error('[ApiChatHistory] getMessages error:', error);
-            return [];
-        }
-    }
-    async addMessage(message) {
-        console.log('[ApiChatHistory] addMessage called for session:', this.sessionId);
-        try {
-            const type = message._getType() === 'human' ? 'human' : 'ai';
-            await fetch(this.apiUrl, {
-                method: 'POST',
-                headers: this.getHeaders(),
-                body: JSON.stringify({
-                    action: 'add',
-                    sessionId: this.sessionId,
-                    message: {
-                        type,
-                        content: message.content,
-                    },
-                }),
-            });
-            console.log('[ApiChatHistory] Message added successfully');
-        }
-        catch (error) {
-            console.error('[ApiChatHistory] addMessage error:', error);
-        }
-    }
-    async addMessages(messages) {
-        for (const message of messages) {
-            await this.addMessage(message);
-        }
-    }
-    async clear() {
-        console.log('[ApiChatHistory] clear called for session:', this.sessionId);
-        try {
-            await fetch(this.apiUrl, {
-                method: 'POST',
-                headers: this.getHeaders(),
-                body: JSON.stringify({
-                    action: 'clear',
-                    sessionId: this.sessionId,
-                }),
-            });
-        }
-        catch (error) {
-            console.error('[ApiChatHistory] clear error:', error);
-        }
-    }
-}
-class Memory {
-    constructor() {
-        this.description = {
-            displayName: 'Memory API',
-            name: 'memoryApi',
-            icon: 'fa:brain',
-            group: ['transform'],
-            version: 1,
-            subtitle: 'External API Memory',
-            description: 'Use an external API as chat memory storage',
-            defaults: {
-                name: 'Memory API',
-            },
-            codex: {
-                categories: ['AI'],
-                subcategories: {
-                    AI: ['Memory'],
-                },
-                resources: {
-                    primaryDocumentation: [
-                        {
-                            url: 'https://github.com/filipexyz/n8n-nodes-memory',
-                        },
-                    ],
-                },
-            },
-            inputs: [],
-            outputs: ['ai_memory'],
-            outputNames: ['Memory'],
-            properties: [
-                {
-                    displayName: 'API URL',
-                    name: 'apiUrl',
-                    type: 'string',
-                    default: '',
-                    required: true,
-                    description: 'URL of the memory API (e.g., n8n webhook URL)',
-                    placeholder: 'https://your-n8n.com/webhook/memory',
-                },
-                {
-                    displayName: 'Session ID',
-                    name: 'sessionId',
-                    type: 'string',
-                    default: '={{ $json.sessionId }}',
-                    required: true,
-                    description: 'Unique identifier for the conversation session',
-                },
-                {
-                    displayName: 'API Key',
-                    name: 'apiKey',
-                    type: 'string',
-                    typeOptions: {
-                        password: true,
-                    },
-                    default: '',
-                    description: 'Optional API key for authentication',
-                },
-                {
-                    displayName: 'Context Window Length',
-                    name: 'contextWindowLength',
-                    type: 'number',
-                    default: 10,
-                    description: 'Number of previous messages to include as context',
-                },
-            ],
-        };
-    }
-    async supplyData(itemIndex) {
-        const apiUrl = this.getNodeParameter('apiUrl', itemIndex);
-        const sessionId = this.getNodeParameter('sessionId', itemIndex);
-        const apiKey = this.getNodeParameter('apiKey', itemIndex, '') || undefined;
-        const contextWindowLength = this.getNodeParameter('contextWindowLength', itemIndex, 10);
-        console.log('[Memory API] Creating memory for session:', sessionId);
-        const chatHistory = new ApiChatHistory(apiUrl, sessionId, apiKey);
-        const memory = new memory_1.BufferWindowMemory({
-            memoryKey: 'chat_history',
-            chatHistory,
-            returnMessages: true,
-            inputKey: 'input',
-            outputKey: 'output',
-            k: contextWindowLength,
-        });
-        return {
-            response: memory,
-        };
-    }
-}
-exports.Memory = Memory;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Memory.node.js","sourceRoot":"","sources":["../../../src/nodes/Memory/Memory.node.ts"],"names":[],"mappings":";;;AAMA,6CAAsD;AACtD,+DAA0E;AAC1E,uDAIkC;AAElC,MAAM,cAAe,SAAQ,yCAA0B;IAGrD,YACU,MAAc,EACd,SAAiB,EACjB,MAAe;QAEvB,KAAK,EAAE,CAAC;QAJA,WAAM,GAAN,MAAM,CAAQ;QACd,cAAS,GAAT,SAAS,CAAQ;QACjB,WAAM,GAAN,MAAM,CAAS;QALzB,iBAAY,GAAG,CAAC,WAAW,EAAE,QAAQ,EAAE,SAAS,EAAE,KAAK,CAAC,CAAC;IAQzD,CAAC;IAEO,UAAU;QAChB,MAAM,OAAO,GAA2B;YACtC,cAAc,EAAE,kBAAkB;SACnC,CAAC;QACF,IAAI,IAAI,CAAC,MAAM,EAAE,CAAC;YAChB,OAAO,CAAC,eAAe,CAAC,GAAG,UAAU,IAAI,CAAC,MAAM,EAAE,CAAC;QACrD,CAAC;QACD,OAAO,OAAO,CAAC;IACjB,CAAC;IAED,KAAK,CAAC,WAAW;QACf,OAAO,CAAC,GAAG,CAAC,kDAAkD,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAChF,IAAI,CAAC;YACH,OAAO,CAAC,GAAG,CAAC,iCAAiC,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;YAC5D,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE;gBACxC,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE,IAAI,CAAC,UAAU,EAAE;gBAC1B,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;oBACnB,MAAM,EAAE,KAAK;oBACb,SAAS,EAAE,IAAI,CAAC,SAAS;iBAC1B,CAAC;aACH,CAAC,CAAC;YAEH,IAAI,CAAC,QAAQ,CAAC,EAAE,EAAE,CAAC;gBACjB,OAAO,CAAC,KAAK,CAAC,+BAA+B,QAAQ,CAAC,MAAM,EAAE,CAAC,CAAC;gBAChE,OAAO,EAAE,CAAC;YACZ,CAAC;YAED,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,IAAI,EAA6D,CAAC;YAC9F,MAAM,QAAQ,GAAG,IAAI,EAAE,QAAQ,IAAI,EAAE,CAAC;YACtC,OAAO,CAAC,GAAG,CAAC,gCAAgC,EAAE,QAAQ,CAAC,MAAM,CAAC,CAAC;YAE/D,OAAO,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAoC,EAAE,EAAE;gBAC3D,IAAI,CAAC,CAAC,IAAI,KAAK,OAAO,EAAE,CAAC;oBACvB,OAAO,IAAI,uBAAY,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBACrC,CAAC;qBAAM,CAAC;oBACN,OAAO,IAAI,oBAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gBAClC,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,qCAAqC,EAAE,KAAK,CAAC,CAAC;YAC5D,OAAO,EAAE,CAAC;QACZ,CAAC;IACH,CAAC;IAED,KAAK,CAAC,UAAU,CAAC,OAAoB;QACnC,OAAO,CAAC,GAAG,CAAC,iDAAiD,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAC/E,IAAI,CAAC;YACH,MAAM,IAAI,GAAG,OAAO,CAAC,QAAQ,EAAE,KAAK,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAC;YAE7D,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE;gBACvB,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE,IAAI,CAAC,UAAU,EAAE;gBAC1B,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;oBACnB,MAAM,EAAE,KAAK;oBACb,SAAS,EAAE,IAAI,CAAC,SAAS;oBACzB,OAAO,EAAE;wBACP,IAAI;wBACJ,OAAO,EAAE,OAAO,CAAC,OAAO;qBACzB;iBACF,CAAC;aACH,CAAC,CAAC;YACH,OAAO,CAAC,GAAG,CAAC,6CAA6C,CAAC,CAAC;QAC7D,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,oCAAoC,EAAE,KAAK,CAAC,CAAC;QAC7D,CAAC;IACH,CAAC;IAED,KAAK,CAAC,WAAW,CAAC,QAAuB;QACvC,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;YAC/B,MAAM,IAAI,CAAC,UAAU,CAAC,OAAO,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IAED,KAAK,CAAC,KAAK;QACT,OAAO,CAAC,GAAG,CAAC,4CAA4C,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC;QAC1E,IAAI,CAAC;YACH,MAAM,KAAK,CAAC,IAAI,CAAC,MAAM,EAAE;gBACvB,MAAM,EAAE,MAAM;gBACd,OAAO,EAAE,IAAI,CAAC,UAAU,EAAE;gBAC1B,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC;oBACnB,MAAM,EAAE,OAAO;oBACf,SAAS,EAAE,IAAI,CAAC,SAAS;iBAC1B,CAAC;aACH,CAAC,CAAC;QACL,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,OAAO,CAAC,KAAK,CAAC,+BAA+B,EAAE,KAAK,CAAC,CAAC;QACxD,CAAC;IACH,CAAC;CACF;AAED,MAAa,MAAM;IAAnB;QACE,gBAAW,GAAyB;YAClC,WAAW,EAAE,YAAY;YACzB,IAAI,EAAE,WAAW;YACjB,IAAI,EAAE,UAAU;YAChB,KAAK,EAAE,CAAC,WAAW,CAAC;YACpB,OAAO,EAAE,CAAC;YACV,QAAQ,EAAE,qBAAqB;YAC/B,WAAW,EAAE,4CAA4C;YACzD,QAAQ,EAAE;gBACR,IAAI,EAAE,YAAY;aACnB;YACD,KAAK,EAAE;gBACL,UAAU,EAAE,CAAC,IAAI,CAAC;gBAClB,aAAa,EAAE;oBACb,EAAE,EAAE,CAAC,QAAQ,CAAC;iBACf;gBACD,SAAS,EAAE;oBACT,oBAAoB,EAAE;wBACpB;4BACE,GAAG,EAAE,+CAA+C;yBACrD;qBACF;iBACF;aACF;YACD,MAAM,EAAE,EAAE;YACV,OAAO,EAAE,CAAC,WAAoB,CAAC;YAC/B,WAAW,EAAE,CAAC,QAAQ,CAAC;YACvB,UAAU,EAAE;gBACV;oBACE,WAAW,EAAE,SAAS;oBACtB,IAAI,EAAE,QAAQ;oBACd,IAAI,EAAE,QAAQ;oBACd,OAAO,EAAE,EAAE;oBACX,QAAQ,EAAE,IAAI;oBACd,WAAW,EAAE,+CAA+C;oBAC5D,WAAW,EAAE,qCAAqC;iBACnD;gBACD;oBACE,WAAW,EAAE,YAAY;oBACzB,IAAI,EAAE,WAAW;oBACjB,IAAI,EAAE,QAAQ;oBACd,OAAO,EAAE,wBAAwB;oBACjC,QAAQ,EAAE,IAAI;oBACd,WAAW,EAAE,gDAAgD;iBAC9D;gBACD;oBACE,WAAW,EAAE,SAAS;oBACtB,IAAI,EAAE,QAAQ;oBACd,IAAI,EAAE,QAAQ;oBACd,WAAW,EAAE;wBACX,QAAQ,EAAE,IAAI;qBACf;oBACD,OAAO,EAAE,EAAE;oBACX,WAAW,EAAE,qCAAqC;iBACnD;gBACD;oBACE,WAAW,EAAE,uBAAuB;oBACpC,IAAI,EAAE,qBAAqB;oBAC3B,IAAI,EAAE,QAAQ;oBACd,OAAO,EAAE,EAAE;oBACX,WAAW,EAAE,mDAAmD;iBACjE;aACF;SACF,CAAC;IA4BJ,CAAC;IA1BC,KAAK,CAAC,UAAU,CAEd,SAAiB;QAEjB,MAAM,MAAM,GAAG,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,SAAS,CAAW,CAAC;QACpE,MAAM,SAAS,GAAG,IAAI,CAAC,gBAAgB,CAAC,WAAW,EAAE,SAAS,CAAW,CAAC;QAC1E,MAAM,MAAM,GAAI,IAAI,CAAC,gBAAgB,CAAC,QAAQ,EAAE,SAAS,EAAE,EAAE,CAAY,IAAI,SAAS,CAAC;QACvF,MAAM,mBAAmB,GAAG,IAAI,CAAC,gBAAgB,CAAC,qBAAqB,EAAE,SAAS,EAAE,EAAE,CAAW,CAAC;QAElG,OAAO,CAAC,GAAG,CAAC,2CAA2C,EAAE,SAAS,CAAC,CAAC;QAEpE,MAAM,WAAW,GAAG,IAAI,cAAc,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC,CAAC;QAElE,MAAM,MAAM,GAAG,IAAI,2BAAkB,CAAC;YACpC,SAAS,EAAE,cAAc;YACzB,WAAW;YACX,cAAc,EAAE,IAAI;YACpB,QAAQ,EAAE,OAAO;YACjB,SAAS,EAAE,QAAQ;YACnB,CAAC,EAAE,mBAAmB;SACvB,CAAC,CAAC;QAEH,OAAO;YACL,QAAQ,EAAE,MAAM;SACjB,CAAC;IACJ,CAAC;CACF;AA5FD,wBA4FC","sourcesContent":["import type {\n  INodeType,\n  INodeTypeDescription,\n  ISupplyDataFunctions,\n  SupplyData,\n} from 'n8n-workflow';\nimport { BufferWindowMemory } from 'langchain/memory';\nimport { BaseListChatMessageHistory } from '@langchain/core/chat_history';\nimport {\n  BaseMessage,\n  HumanMessage,\n  AIMessage,\n} from '@langchain/core/messages';\n\nclass ApiChatHistory extends BaseListChatMessageHistory {\n  lc_namespace = ['langchain', 'stores', 'message', 'api'];\n\n  constructor(\n    private apiUrl: string,\n    private sessionId: string,\n    private apiKey?: string,\n  ) {\n    super();\n  }\n\n  private getHeaders(): Record<string, string> {\n    const headers: Record<string, string> = {\n      'Content-Type': 'application/json',\n    };\n    if (this.apiKey) {\n      headers['Authorization'] = `Bearer ${this.apiKey}`;\n    }\n    return headers;\n  }\n\n  async getMessages(): Promise<BaseMessage[]> {\n    console.log('[ApiChatHistory] getMessages called for session:', this.sessionId);\n    try {\n      console.log('[ApiChatHistory] Fetching from:', this.apiUrl);\n      const response = await fetch(this.apiUrl, {\n        method: 'POST',\n        headers: this.getHeaders(),\n        body: JSON.stringify({\n          action: 'get',\n          sessionId: this.sessionId,\n        }),\n      });\n\n      if (!response.ok) {\n        console.error(`[ApiChatHistory] API error: ${response.status}`);\n        return [];\n      }\n\n      const data = await response.json() as { messages?: Array<{ type: string; content: string }> };\n      const messages = data?.messages ?? [];\n      console.log('[ApiChatHistory] Got messages:', messages.length);\n\n      return messages.map((m: { type: string; content: string }) => {\n        if (m.type === 'human') {\n          return new HumanMessage(m.content);\n        } else {\n          return new AIMessage(m.content);\n        }\n      });\n    } catch (error) {\n      console.error('[ApiChatHistory] getMessages error:', error);\n      return [];\n    }\n  }\n\n  async addMessage(message: BaseMessage): Promise<void> {\n    console.log('[ApiChatHistory] addMessage called for session:', this.sessionId);\n    try {\n      const type = message._getType() === 'human' ? 'human' : 'ai';\n\n      await fetch(this.apiUrl, {\n        method: 'POST',\n        headers: this.getHeaders(),\n        body: JSON.stringify({\n          action: 'add',\n          sessionId: this.sessionId,\n          message: {\n            type,\n            content: message.content,\n          },\n        }),\n      });\n      console.log('[ApiChatHistory] Message added successfully');\n    } catch (error) {\n      console.error('[ApiChatHistory] addMessage error:', error);\n    }\n  }\n\n  async addMessages(messages: BaseMessage[]): Promise<void> {\n    for (const message of messages) {\n      await this.addMessage(message);\n    }\n  }\n\n  async clear(): Promise<void> {\n    console.log('[ApiChatHistory] clear called for session:', this.sessionId);\n    try {\n      await fetch(this.apiUrl, {\n        method: 'POST',\n        headers: this.getHeaders(),\n        body: JSON.stringify({\n          action: 'clear',\n          sessionId: this.sessionId,\n        }),\n      });\n    } catch (error) {\n      console.error('[ApiChatHistory] clear error:', error);\n    }\n  }\n}\n\nexport class Memory implements INodeType {\n  description: INodeTypeDescription = {\n    displayName: 'Memory API',\n    name: 'memoryApi',\n    icon: 'fa:brain',\n    group: ['transform'],\n    version: 1,\n    subtitle: 'External API Memory',\n    description: 'Use an external API as chat memory storage',\n    defaults: {\n      name: 'Memory API',\n    },\n    codex: {\n      categories: ['AI'],\n      subcategories: {\n        AI: ['Memory'],\n      },\n      resources: {\n        primaryDocumentation: [\n          {\n            url: 'https://github.com/filipexyz/n8n-nodes-memory',\n          },\n        ],\n      },\n    },\n    inputs: [],\n    outputs: ['ai_memory' as const],\n    outputNames: ['Memory'],\n    properties: [\n      {\n        displayName: 'API URL',\n        name: 'apiUrl',\n        type: 'string',\n        default: '',\n        required: true,\n        description: 'URL of the memory API (e.g., n8n webhook URL)',\n        placeholder: 'https://your-n8n.com/webhook/memory',\n      },\n      {\n        displayName: 'Session ID',\n        name: 'sessionId',\n        type: 'string',\n        default: '={{ $json.sessionId }}',\n        required: true,\n        description: 'Unique identifier for the conversation session',\n      },\n      {\n        displayName: 'API Key',\n        name: 'apiKey',\n        type: 'string',\n        typeOptions: {\n          password: true,\n        },\n        default: '',\n        description: 'Optional API key for authentication',\n      },\n      {\n        displayName: 'Context Window Length',\n        name: 'contextWindowLength',\n        type: 'number',\n        default: 10,\n        description: 'Number of previous messages to include as context',\n      },\n    ],\n  };\n\n  async supplyData(\n    this: ISupplyDataFunctions,\n    itemIndex: number\n  ): Promise<SupplyData> {\n    const apiUrl = this.getNodeParameter('apiUrl', itemIndex) as string;\n    const sessionId = this.getNodeParameter('sessionId', itemIndex) as string;\n    const apiKey = (this.getNodeParameter('apiKey', itemIndex, '') as string) || undefined;\n    const contextWindowLength = this.getNodeParameter('contextWindowLength', itemIndex, 10) as number;\n\n    console.log('[Memory API] Creating memory for session:', sessionId);\n\n    const chatHistory = new ApiChatHistory(apiUrl, sessionId, apiKey);\n\n    const memory = new BufferWindowMemory({\n      memoryKey: 'chat_history',\n      chatHistory,\n      returnMessages: true,\n      inputKey: 'input',\n      outputKey: 'output',\n      k: contextWindowLength,\n    });\n\n    return {\n      response: memory,\n    };\n  }\n}\n"]}