n8n-nodes-memory 0.0.1 → 0.1.0

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,6 @@
+"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==

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

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,113 @@
+"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.d.ts

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

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Memory = void 0;
+const memory_1 = require("@langchain/classic/memory");
+const ApiMemoryHistory_1 = require("./ApiMemoryHistory");
+class Memory {
+    constructor() {
+        this.description = {
+            displayName: 'Memory',
+            name: 'memory',
+            icon: 'fa:brain',
+            group: ['transform'],
+            version: 1,
+            description: 'Custom memory node with external API support',
+            defaults: {
+                name: 'Memory',
+            },
+            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, '');
+        const contextWindowLength = this.getNodeParameter('contextWindowLength', itemIndex, 10);
+        const chatHistory = new ApiMemoryHistory_1.ApiMemoryHistory({
+            apiUrl,
+            sessionId,
+            apiKey: apiKey || undefined,
+        });
+        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,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

package/package.json

@@ -1,8 +1,47 @@
 {
   "name": "n8n-nodes-memory",
-  "version": "0.0.1",
-  "description": "Custom memory node for n8n AI Agent",
+  "version": "0.1.0",
+  "description": "Custom memory node for n8n AI Agent with external API support",
+  "keywords": [
+    "n8n-community-node-package",
+    "n8n",
+    "langchain",
+    "memory",
+    "ai"
+  ],
   "license": "MIT",
   "author": "Filipe Labs",
-  "repository": "https://github.com/filipexyz/n8n-nodes-memory"
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/filipexyz/n8n-nodes-memory"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/Memory/Memory.node.js"
+    ],
+    "credentials": []
+  },
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "typescript": "^5.9.3"
+  },
+  "peerDependencies": {
+    "n8n-workflow": "^2.2.1"
+  },
+  "dependencies": {
+    "@langchain/classic": "^1.0.7",
+    "@langchain/core": "^1.1.0",
+    "langchain": "^1.1.1"
+  }
 }