n8n-nodes-memcontext 0.1.5

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# n8n-nodes-memcontext
+
+n8n custom nodes for a self-hosted memcontext API (Flask). Includes:
+- **Memory Add**: add text memories (`/init_memory` → `/import_conversations`)
+- **Memory Search**: search memories and get a reply (`/init_memory` → `/chat`)
+- **Memory Add Multimodal**: add multimodal memories (video/audio/image, `/init_memory` → `/add_multimodal_memory`), supports binary upload or local file path.
+
+## Installation
+
+### Local / private install
+```bash
+# in package root
+npm run build
+npm pack  # produces n8n-nodes-memcontext-<version>.tgz
+
+# in n8n custom nodes dir (example: C:\Users\<you>\.n8n\nodes)
+npm init -y
+npm install /path/to/n8n-nodes-memcontext-<version>.tgz
+```
+Restart n8n to load the nodes.
+
+### Publish to npm (optional)
+```bash
+# ensure version is bumped
+npm login
+npm publish   # if using a scope, rename to @your-scope/n8n-nodes-memcontext and add --access public
+```
+Target env: `npm install n8n-nodes-memcontext`, then restart n8n.
+
+## Backend requirements
+- Your Flask backend running (default `http://127.0.0.1:5019`).
+- Multimodal `video` converter needs:
+  - env vars: `LLM_API_KEY`, `LLM_BASE_URL`, `LLM_MODEL`
+  - `ffmpeg/ffprobe` in PATH
+- `videorag` converter is optional (imagebind/hnswlib, better on Linux/GPU). On Windows/CPU, use `video`.
+
+## Credentials (Memory API)
+- **Base URL**: backend URL (default `http://127.0.0.1:5019`)
+- **API Key**: optional; if backend requires auth, fill it (e.g. `Bearer xxx`, passed through as-is)
+
+## Nodes
+
+### Memory Add
+- Writes text memory.
+- Params: `userId`, `userInput`, `agentResponse`, `timestamp` (optional), `metaData` (JSON).
+- Routes: `/init_memory` → `/import_conversations`.
+
+### Memory Search
+- Searches memory and returns reply.
+- Params: `userId`, `query`.
+- Routes: `/init_memory` → `/chat`.
+
+### Memory Add Multimodal
+- Writes multimodal memory (video/audio/image).
+- Modes:
+  - `Upload File (Binary)`: binary from upstream node; set Binary Property Name.
+  - `Use Local File Path`: absolute path accessible by backend host.
+- Converters:
+  - `video` (recommended; requires ffmpeg + Ark SDK + LLM API env vars)
+  - `videorag` (optional; extra deps/models)
+- Routes: `/init_memory` → `/add_multimodal_memory`.
+
+## Example workflow
+```
+Manual Trigger
+  └─ Memory Add
+       └─ Memory Add Multimodal
+            └─ Memory Search
+```
+- Three nodes share the same Memory API credential and the same `userId`.
+- Base URL recommendation: `http://127.0.0.1:5019`.
+- For `Memory Add Multimodal` path mode: `File Path` must be an absolute path reachable by the backend machine; start with converter `video`.
+
+## FAQ
+- **ECONNREFUSED 127.0.0.1:5019**: backend not running or wrong port; `curl http://127.0.0.1:5019/` first.
+- **Video file missing / ingested_rounds=0**: path not reachable or ffmpeg/env vars missing; check backend logs.
+- **Backend 500**: inspect `python app.py` console stack; common causes are deps/env/path issues.
+- **Community nodes TLS errors**: unrelated to node execution; usually external network/proxy; ignore or configure network.
+
+## Development build
+- `npm run build` to generate `dist/`
+- `npm pack` to produce release `.tgz`
+- Before publishing, ensure `package.json` `n8n` field points to nodes/credentials under `dist`.
+

package/dist/credentials/MemoryApi.credential.d.ts

@@ -0,0 +1,6 @@
+import { ICredentialType, INodeProperties } from 'n8n-workflow';
+export declare class MemoryApi implements ICredentialType {
+    name: string;
+    displayName: string;
+    properties: INodeProperties[];
+}

package/dist/credentials/MemoryApi.credential.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryApi = void 0;
+class MemoryApi {
+    constructor() {
+        // n8n 会使用这个 name 来匹配节点中 credentials 的 name 属性
+        this.name = 'memoryApi';
+        // 在 n8n UI 中显示的名字
+        this.displayName = 'Memory API';
+        this.properties = [
+            {
+                displayName: 'Base URL',
+                name: 'baseUrl',
+                type: 'string',
+                default: 'http://localhost:5019',
+                required: true,
+                description: 'Memory API base URL, e.g. http://localhost:5019 or https://api.example.com',
+            },
+            {
+                displayName: 'API Key', // 在 Credential 配置界面显示的名称
+                name: 'apiKey', // 内部使用的属性名
+                type: 'string',
+                default: '',
+                required: false,
+                description: 'Your Memory API Key (e.g., "Bearer YOUR_KEY")',
+                typeOptions: {
+                    password: true,
+                },
+            },
+        ];
+    }
+}
+exports.MemoryApi = MemoryApi;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import { nodes } from './nodes';
+import { MemoryApi } from './credentials/MemoryApi.credential';
+export { nodes };
+export declare const credentials: MemoryApi[];

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.credentials = exports.nodes = void 0;
+const nodes_1 = require("./nodes");
+Object.defineProperty(exports, "nodes", { enumerable: true, get: function () { return nodes_1.nodes; } });
+const MemoryApi_credential_1 = require("./credentials/MemoryApi.credential");
+exports.credentials = [
+    new MemoryApi_credential_1.MemoryApi(),
+];

package/dist/nodes/MemoryAdd/MemoryAdd.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType } from 'n8n-workflow';
+export declare class MemoryAdd implements INodeType {
+    description: import("n8n-workflow").INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/MemoryAdd/MemoryAdd.node.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryAdd = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ui_1 = require("./ui");
+class MemoryAdd {
+    constructor() {
+        this.description = ui_1.MemoryAddUiDescription;
+    }
+    async execute() {
+        const userId = this.getNodeParameter('userId', 0);
+        const userInput = this.getNodeParameter('userInput', 0);
+        const agentResponse = this.getNodeParameter('agentResponse', 0);
+        const timestamp = this.getNodeParameter('timestamp', 0);
+        const metaData = this.getNodeParameter('metaData', 0);
+        const initPath = '/init_memory';
+        const apiPath = '/import_conversations';
+        let authorizationHeader = '';
+        let memoryApiBaseUrl = 'http://localhost:5019';
+        try {
+            const credentials = await this.getCredentials('memoryApi');
+            const apiKey = credentials.apiKey || '';
+            const baseUrl = credentials.baseUrl;
+            memoryApiBaseUrl = baseUrl || memoryApiBaseUrl;
+            authorizationHeader = apiKey;
+        }
+        catch {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Memory API credential is not configured.');
+        }
+        const baseHeaders = {
+            'Content-Type': 'application/json',
+        };
+        if (authorizationHeader) {
+            baseHeaders.Authorization = authorizationHeader;
+        }
+        // 先初始化 Flask session（后端依赖 cookie 来找到 memory_system）
+        const initResp = await this.helpers.request({
+            url: `${memoryApiBaseUrl}${initPath}`,
+            method: 'POST',
+            headers: baseHeaders,
+            body: {
+                user_id: userId,
+            },
+            json: true,
+            resolveWithFullResponse: true,
+        });
+        const setCookie = initResp.headers?.['set-cookie'];
+        const cookieHeader = Array.isArray(setCookie)
+            ? setCookie.map((c) => String(c).split(';')[0]).join('; ')
+            : '';
+        if (!cookieHeader) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to initialize session (no Set-Cookie returned from /init_memory).');
+        }
+        const response = await this.helpers.request({
+            url: `${memoryApiBaseUrl}${apiPath}`,
+            method: 'POST',
+            headers: {
+                ...baseHeaders,
+                Cookie: cookieHeader,
+            },
+            body: {
+                conversations: [
+                    {
+                        user_input: userInput,
+                        agent_response: agentResponse,
+                        ...(timestamp ? { timestamp } : {}),
+                        meta_data: metaData,
+                    },
+                ],
+            },
+            json: true,
+        });
+        return [this.helpers.returnJsonArray(response)];
+    }
+}
+exports.MemoryAdd = MemoryAdd;

package/dist/nodes/MemoryAdd/ui.d.ts

@@ -0,0 +1,2 @@
+import { INodeTypeDescription } from 'n8n-workflow';
+export declare const MemoryAddUiDescription: INodeTypeDescription;

package/dist/nodes/MemoryAdd/ui.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryAddUiDescription = void 0;
+exports.MemoryAddUiDescription = {
+    displayName: 'Memory Add',
+    name: 'memoryAdd',
+    icon: 'fa:plus',
+    group: ['transform'],
+    version: 1,
+    description: 'Add memories to your Memory API backend.',
+    defaults: {
+        name: 'Add Memory',
+    },
+    inputs: ['main'],
+    outputs: ['main'],
+    credentials: [
+        {
+            name: 'memoryApi',
+            required: true,
+        },
+    ],
+    properties: [
+        {
+            displayName: 'User ID',
+            name: 'userId',
+            type: 'string',
+            default: '',
+            required: true,
+            placeholder: 'e.g., user123',
+            description: 'User ID for memory space.',
+        },
+        {
+            displayName: 'User Input',
+            name: 'userInput',
+            type: 'string',
+            default: '',
+            required: true,
+            typeOptions: {
+                rows: 3,
+            },
+            description: "The content of the user's input.",
+        },
+        {
+            displayName: 'Agent Response',
+            name: 'agentResponse',
+            type: 'string',
+            default: '',
+            required: true,
+            typeOptions: {
+                rows: 3,
+            },
+            description: "The content of the agent's response.",
+        },
+        {
+            displayName: 'Timestamp',
+            name: 'timestamp',
+            type: 'string',
+            default: '',
+            placeholder: 'e.g., 2024-01-01T12:00:00Z (ISO 8601)',
+            description: 'Timestamp in ISO 8601 format. If not provided, current time will be used.',
+        },
+        {
+            displayName: 'Meta Data',
+            name: 'metaData',
+            type: 'json',
+            default: {},
+            description: 'Additional metadata for the memory entry.',
+        },
+    ],
+};

package/dist/nodes/MemoryAddMultimodal/MemoryAddMultimodal.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType } from 'n8n-workflow';
+export declare class MemoryAddMultimodal implements INodeType {
+    description: import("n8n-workflow").INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/MemoryAddMultimodal/MemoryAddMultimodal.node.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryAddMultimodal = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ui_1 = require("./ui");
+class MemoryAddMultimodal {
+    constructor() {
+        this.description = ui_1.MemoryAddMultimodalUiDescription;
+    }
+    async execute() {
+        const formatRequestError = (error) => {
+            if (!error)
+                return 'Unknown error';
+            const e = error;
+            const parts = [];
+            if (e.statusCode)
+                parts.push(`statusCode=${e.statusCode}`);
+            if (e.message)
+                parts.push(`message=${e.message}`);
+            // n8n request helper often exposes response body as `response` or `responseBody`
+            const body = e.responseBody ?? e.response;
+            if (body !== undefined) {
+                try {
+                    parts.push(`response=${typeof body === 'string' ? body : JSON.stringify(body)}`);
+                }
+                catch {
+                    parts.push(`response=${String(body)}`);
+                }
+            }
+            if (!parts.length)
+                return String(error);
+            return parts.join(' | ');
+        };
+        const userId = this.getNodeParameter('userId', 0);
+        const agentResponse = this.getNodeParameter('agentResponse', 0, '');
+        const inputSource = this.getNodeParameter('inputSource', 0, 'upload');
+        const advancedOptions = this.getNodeParameter('advancedOptions', 0, {});
+        const initPath = '/init_memory';
+        const apiPath = '/add_multimodal_memory';
+        let authorizationHeader;
+        let memoryApiBaseUrl = 'http://localhost:5019';
+        try {
+            const credentials = await this.getCredentials('memoryApi');
+            const apiKey = credentials.apiKey || '';
+            const baseUrl = credentials.baseUrl;
+            memoryApiBaseUrl = baseUrl || memoryApiBaseUrl;
+            authorizationHeader = apiKey;
+        }
+        catch {
+            this.logger.error('Failed to get Memory API credentials');
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Memory API credential is not configured or invalid.');
+        }
+        const baseHeaders = {};
+        if (authorizationHeader) {
+            baseHeaders.Authorization = authorizationHeader;
+        }
+        // 先初始化 Flask session（后端依赖 cookie 来找到 memory_system）
+        const initResp = await this.helpers.request({
+            url: `${memoryApiBaseUrl}${initPath}`,
+            method: 'POST',
+            headers: {
+                ...baseHeaders,
+                'Content-Type': 'application/json',
+            },
+            body: {
+                user_id: userId,
+            },
+            json: true,
+            resolveWithFullResponse: true,
+        });
+        const setCookie = initResp.headers?.['set-cookie'];
+        const cookieHeader = Array.isArray(setCookie)
+            ? setCookie.map((c) => String(c).split(';')[0]).join('; ')
+            : '';
+        if (!cookieHeader) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to initialize session (no Set-Cookie returned from /init_memory).');
+        }
+        let response;
+        // ===== 上传文件（二进制） =====
+        if (inputSource === 'upload') {
+            const binaryPropertyName = this.getNodeParameter('file', 0, 'file');
+            const converterType = this.getNodeParameter('converterType', 0, 'videorag');
+            const binaryData = this.helpers.assertBinaryData(0, binaryPropertyName);
+            const formData = {
+                user_id: userId,
+                converter_type: converterType,
+                file: binaryData,
+                ...(agentResponse ? { agent_response: agentResponse } : {}),
+            };
+            if (advancedOptions?.converterKwargs) {
+                formData.converter_kwargs = JSON.stringify(advancedOptions.converterKwargs);
+            }
+            try {
+                response = await this.helpers.request({
+                    url: `${memoryApiBaseUrl}${apiPath}`,
+                    method: 'POST',
+                    headers: {
+                        ...baseHeaders,
+                        Cookie: cookieHeader,
+                    },
+                    formData,
+                });
+            }
+            catch (error) {
+                this.logger.error('Error calling Memory API (upload)', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to upload multimodal memory. ${formatRequestError(error)}`);
+            }
+            // ===== 使用本地路径 =====
+        }
+        else if (inputSource === 'path') {
+            const filePath = this.getNodeParameter('filePath', 0, '');
+            const converterType = this.getNodeParameter('converterType', 0, 'videorag');
+            if (!filePath) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'File path is required when input source is "path".');
+            }
+            const requestBody = {
+                user_id: userId,
+                file_path: filePath,
+                converter_type: converterType,
+                ...(agentResponse ? { agent_response: agentResponse } : {}),
+            };
+            if (advancedOptions?.converterKwargs) {
+                requestBody.converter_kwargs = advancedOptions.converterKwargs;
+            }
+            try {
+                response = await this.helpers.request({
+                    url: `${memoryApiBaseUrl}${apiPath}`,
+                    method: 'POST',
+                    headers: {
+                        ...baseHeaders,
+                        Cookie: cookieHeader,
+                        'Content-Type': 'application/json',
+                    },
+                    body: requestBody,
+                    json: true,
+                });
+            }
+            catch (error) {
+                this.logger.error('Error calling Memory API (path)', {
+                    error: error instanceof Error ? error.message : String(error),
+                });
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to add multimodal memory from path. ${formatRequestError(error)}`);
+            }
+        }
+        else {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Invalid input source: ${inputSource}`);
+        }
+        return [
+            this.helpers.returnJsonArray(response),
+        ];
+    }
+}
+exports.MemoryAddMultimodal = MemoryAddMultimodal;

package/dist/nodes/MemoryAddMultimodal/ui.d.ts

@@ -0,0 +1,2 @@
+import { INodeTypeDescription } from 'n8n-workflow';
+export declare const MemoryAddMultimodalUiDescription: INodeTypeDescription;

package/dist/nodes/MemoryAddMultimodal/ui.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryAddMultimodalUiDescription = void 0;
+exports.MemoryAddMultimodalUiDescription = {
+    displayName: 'Memory Add Multimodal',
+    name: 'memoryAddMultimodal',
+    icon: 'fa:file-video',
+    group: ['transform'],
+    version: 1,
+    description: 'Add multimodal memories (video, audio, image) to your Memory API backend.',
+    defaults: {
+        name: 'Add Multimodal Memory',
+    },
+    inputs: ['main'],
+    outputs: ['main'],
+    credentials: [
+        {
+            name: 'memoryApi',
+            required: true,
+        },
+    ],
+    properties: [
+        {
+            displayName: 'User ID',
+            name: 'userId',
+            type: 'string',
+            default: '',
+            required: true,
+            placeholder: 'e.g., user123',
+            description: 'User ID for memory space.',
+        },
+        {
+            displayName: 'Agent Response',
+            name: 'agentResponse',
+            type: 'string',
+            default: '',
+            placeholder: 'e.g., User uploaded a test video.',
+            typeOptions: {
+                rows: 2,
+            },
+            description: 'Associated agent response describing the multimodal content.',
+        },
+        {
+            displayName: 'Input Source',
+            name: 'inputSource',
+            type: 'options',
+            options: [
+                { name: 'Upload File (Binary)', value: 'upload' },
+                { name: 'Use Local File Path', value: 'path' },
+            ],
+            default: 'upload',
+            description: 'Choose how to provide the file.',
+        },
+        /* ===== 上传文件（binary input） ===== */
+        {
+            displayName: 'Binary Property Name',
+            name: 'file',
+            type: 'string',
+            default: 'file',
+            displayOptions: {
+                show: {
+                    inputSource: ['upload'],
+                },
+            },
+            description: 'Name of the binary property that contains the uploaded file (default: file).',
+        },
+        /* ===== 本地路径 ===== */
+        {
+            displayName: 'File Path',
+            name: 'filePath',
+            type: 'string',
+            default: '',
+            placeholder: '/path/to/your/video.mp4',
+            displayOptions: {
+                show: {
+                    inputSource: ['path'],
+                },
+            },
+            description: 'Server-accessible path to the local file when using "Use Local File Path".',
+        },
+        {
+            displayName: 'Converter Type',
+            name: 'converterType',
+            type: 'options',
+            options: [
+                { name: 'Video (default)', value: 'video' },
+                { name: 'Video RAG (recommended)', value: 'videorag' },
+                { name: 'Audio', value: 'audio' },
+                { name: 'Image', value: 'image' },
+            ],
+            default: 'videorag',
+            description: 'The type of converter to use for processing the multimodal data.',
+        },
+        {
+            displayName: 'Advanced Converter Options',
+            name: 'advancedOptions',
+            type: 'collection',
+            default: {},
+            placeholder: 'Add Options',
+            description: 'Additional parameters to configure the converter behavior.',
+            options: [
+                {
+                    displayName: 'Converter Kwargs (JSON)',
+                    name: 'converterKwargs',
+                    type: 'json',
+                    default: {},
+                    description: 'Custom arguments for the converter. Example: {"chunk_duration": 30}',
+                },
+            ],
+        },
+    ],
+};

package/dist/nodes/MemorySearch/MemorySearch.node.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType } from 'n8n-workflow';
+export declare class MemorySearch implements INodeType {
+    description: import("n8n-workflow").INodeTypeDescription;
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/MemorySearch/MemorySearch.node.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemorySearch = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ui_1 = require("./ui");
+class MemorySearch {
+    constructor() {
+        this.description = ui_1.MemorySearchUiDescription;
+    }
+    async execute() {
+        const userId = this.getNodeParameter('userId', 0);
+        const query = this.getNodeParameter('query', 0);
+        const relationshipWithUser = this.getNodeParameter('relationshipWithUser', 0);
+        const styleHint = this.getNodeParameter('styleHint', 0);
+        const userConversationMetaData = this.getNodeParameter('userConversationMetaData', 0);
+        const initPath = '/init_memory';
+        const apiPath = '/chat';
+        let authorizationHeader;
+        let memoryApiBaseUrl = 'http://localhost:5019';
+        try {
+            const credentials = await this.getCredentials('memoryApi');
+            const apiKey = credentials.apiKey || '';
+            const baseUrl = credentials.baseUrl;
+            memoryApiBaseUrl = baseUrl || memoryApiBaseUrl;
+            authorizationHeader = apiKey;
+        }
+        catch {
+            this.logger.error('Failed to get Memory API credentials');
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Memory API credential is not configured or invalid. Please configure it in the Credentials tab.');
+        }
+        const baseHeaders = {
+            'Content-Type': 'application/json',
+        };
+        if (authorizationHeader) {
+            baseHeaders.Authorization = authorizationHeader;
+        }
+        // 先初始化 Flask session（后端依赖 cookie 来找到 memory_system）
+        const initResp = await this.helpers.request({
+            url: `${memoryApiBaseUrl}${initPath}`,
+            method: 'POST',
+            headers: baseHeaders,
+            body: {
+                user_id: userId,
+                // 这些字段在当前 Flask demo 不使用，但保留在节点参数中，以后可扩展
+                relationship_with_user: relationshipWithUser,
+                style_hint: styleHint,
+                user_conversation_meta_data: userConversationMetaData,
+            },
+            json: true,
+            resolveWithFullResponse: true,
+        });
+        const setCookie = initResp.headers?.['set-cookie'];
+        const cookieHeader = Array.isArray(setCookie)
+            ? setCookie.map((c) => String(c).split(';')[0]).join('; ')
+            : '';
+        if (!cookieHeader) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to initialize session (no Set-Cookie returned from /init_memory).');
+        }
+        try {
+            const response = await this.helpers.request({
+                url: `${memoryApiBaseUrl}${apiPath}`,
+                method: 'POST',
+                headers: {
+                    ...baseHeaders,
+                    Cookie: cookieHeader,
+                },
+                body: {
+                    message: query,
+                },
+                json: true,
+            });
+            return [this.helpers.returnJsonArray(response)];
+        }
+        catch (error) {
+            this.logger.error('Error calling Memory API', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'An error occurred while calling the Memory API.');
+        }
+    }
+}
+exports.MemorySearch = MemorySearch;

package/dist/nodes/MemorySearch/ui.d.ts

@@ -0,0 +1,2 @@
+import { INodeTypeDescription } from 'n8n-workflow';
+export declare const MemorySearchUiDescription: INodeTypeDescription;

package/dist/nodes/MemorySearch/ui.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemorySearchUiDescription = void 0;
+exports.MemorySearchUiDescription = {
+    displayName: 'Memory Search',
+    name: 'memorySearch',
+    icon: 'fa:search',
+    group: ['transform'],
+    version: 1,
+    description: 'Search memories using your Memory API backend.',
+    defaults: {
+        name: 'Search Memory',
+    },
+    inputs: ['main'],
+    outputs: ['main'],
+    credentials: [
+        {
+            name: 'memoryApi',
+            required: true,
+        },
+    ],
+    properties: [
+        {
+            displayName: 'User ID',
+            name: 'userId',
+            type: 'string',
+            default: '',
+            required: true,
+            placeholder: 'e.g., user123',
+            description: "User ID for memory space. This identifies which user's memories to search.",
+        },
+        {
+            displayName: 'Query',
+            name: 'query',
+            type: 'string',
+            default: '',
+            required: true,
+            placeholder: 'e.g., What did I talk about before?',
+            typeOptions: {
+                rows: 3,
+            },
+            description: 'The query for retrieving relevant memories.',
+        },
+        {
+            displayName: 'Relationship with User',
+            name: 'relationshipWithUser',
+            type: 'options',
+            options: [
+                { name: 'Friend', value: 'friend' },
+                { name: 'Assistant', value: 'assistant' },
+                { name: 'Colleague', value: 'colleague' },
+                { name: 'Family', value: 'family' },
+                { name: 'Other', value: 'other' },
+            ],
+            default: 'friend',
+            description: "Relationship with the user, affects the LLM's response tone and style.",
+        },
+        {
+            displayName: 'Style Hint',
+            name: 'styleHint',
+            type: 'string',
+            default: '',
+            placeholder: 'e.g., Professional, Friendly, Concise, Detailed',
+            description: 'A hint to guide the LLM in generating a specific response style.',
+        },
+        {
+            displayName: 'User Conversation Meta Data',
+            name: 'userConversationMetaData',
+            type: 'json',
+            default: {},
+            description: 'Metadata for the current conversation context, for tracking or analysis.',
+        },
+    ],
+};

package/dist/nodes/index.d.ts

@@ -0,0 +1,2 @@
+import { MemoryAdd } from './MemoryAdd/MemoryAdd.node';
+export declare const nodes: (typeof MemoryAdd)[];

package/dist/nodes/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodes = void 0;
+const MemoryAdd_node_1 = require("./MemoryAdd/MemoryAdd.node");
+const MemorySearch_node_1 = require("./MemorySearch/MemorySearch.node");
+const MemoryAddMultimodal_node_1 = require("./MemoryAddMultimodal/MemoryAddMultimodal.node");
+exports.nodes = [
+    MemoryAdd_node_1.MemoryAdd,
+    MemorySearch_node_1.MemorySearch,
+    MemoryAddMultimodal_node_1.MemoryAddMultimodal,
+];

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "n8n-nodes-memcontext",
+  "version": "0.1.5",
+  "description": "Custom n8n nodes for memcontext API integration",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "credentials": [
+      "dist/credentials/MemoryApi.credential.js"
+    ],
+    "nodes": [
+      "dist/nodes/MemoryAdd/MemoryAdd.node.js",
+      "dist/nodes/MemorySearch/MemorySearch.node.js",
+      "dist/nodes/MemoryAddMultimodal/MemoryAddMultimodal.node.js"
+    ]
+  },
+
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "prepublishOnly": "npm run build",
+    "dev:build": "tsc -w"
+  },
+
+  "dependencies": {
+    "child-process-promise": "^2.2.1"
+  },
+
+  "peerDependencies": {
+    "n8n-workflow": "^2.1.4"
+  },
+
+  "devDependencies": {
+    "@types/node": "^20.19.27",
+    "typescript": "^5.9.3"
+  },
+
+  "keywords": [
+    "n8n",
+    "n8n-nodes",
+    "n8n-custom-nodes",
+    "n8n-community-node-package",
+    "memory",
+    "ai"
+  ],
+
+  "author": "Your Name <your.email@example.com>",
+  "license": "MIT",
+
+  "files": [
+    "dist"
+  ]
+}