@ferchy/n8n-nodes-aimc-toolkit 0.1.7 → 0.1.9

package/README.md

@@ -5,12 +5,13 @@ AIMC Toolkit is a community node package for n8n with focused nodes:
 - **AIMC Code**: run JavaScript with a practical toolbox of libraries.
 - **AIMC Media**: FFmpeg-powered media operations without extra glue nodes.
 - **AIMC TTS**: CPU-friendly text-to-speech using Piper.
-- **AIMC Docling**: OCR/document extraction using Docling.
 
 ## Why I Built This
 
 n8n is powerful, but real workflows often need basic utilities (validation, parsing, HTTP) and media tasks (convert, compress, merge). I built AIMC Toolkit to remove the busywork and keep workflows short, readable, and fast.
 
+**Inspiration**: The original idea was sparked by Kenkaii’s SuperCode. I’m grateful for that work and built AIMC Toolkit as my own version, tailored to my needs and expanded with improvements over time.
+
 ## Who This Is For
 
 - Automation builders who want fewer nodes and faster iterations.
@@ -24,7 +25,6 @@ n8n is powerful, but real workflows often need basic utilities (validation, pars
 - **Media ready**: convert, compress, merge, and inspect media in one place.
 - **Practical libraries**: parsing, validation, dates, and web utilities built in.
 - **Local voice**: generate speech on a CPU server without paid APIs.
-- **Document extraction**: pull clean text/markdown from PDFs and scans.
 
 ## Installation
 
@@ -76,6 +76,7 @@ brew install ffmpeg
 - Run once for all items or once per item.
 - Access libraries as globals (`axios`, `_`, `zod`) or via `libs`.
 - Built-in helpers (`utils.now`, `utils.safeJson`, `utils.toArray`).
+- **AIMC Connect Mode**: optional AI connectors for LLMs, tools, memory, and more.
 
 **Example: normalize data**
 ```javascript
@@ -107,6 +108,20 @@ result = {
 }
 ```
 
+**AIMC Connect Mode (AI)**
+Enable **AIMC Connect Mode** to attach AI connectors. When enabled, your code can use:
+
+- `ai` (object with all connectors)
+- `aiModel`, `aiTools`, `aiMemory`, `aiVectorStore`, `aiChain`, `aiDocument`
+
+Example:
+```javascript
+if (aiModel) {
+  const response = await aiModel.invoke('Summarize this input.');
+  return { summary: response };
+}
+```
+
 ### AIMC Media
 
 **Operations**
@@ -175,34 +190,6 @@ Output Mode: Binary
 - Use **Output Mode = File Path** for large audio.
 - For custom voice storage, set **Data Dir**.
 
-### AIMC Docling (OCR + Document Parsing)
-
-**What it does**
-Extracts clean text/markdown from PDFs, images, and common document formats using Docling.
-
-**Requirements**
-- Python 3 installed
-- Docling installed: `pip install docling` (or enable Auto-install)
-
-**Input modes**
-- Binary (from n8n)
-- File Path (local file)
-- URL (public file URL)
-
-**Output formats**
-- Markdown (default)
-- JSON (structured output when available)
-- Plain Text (markdown stripped)
-
-**Auto-install**
-Turn on **Auto-install Docling** to run `pip install docling` the first time the node runs.
-Python must already be installed in your n8n environment.
-
-**Example**
-```
-Input Mode: Binary
-Output Format: Markdown
-```
 
 ## Library Reference (AIMC Code)
 

package/dist/nodes/AimcCode/AimcCode.node.js

@@ -147,6 +147,7 @@ function normalizeResult(result, fallbackItems) {
     ];
 }
 function buildSandbox(params) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j;
     const cache = {};
     const sandbox = {
         items: params.items,
@@ -161,6 +162,16 @@ function buildSandbox(params) {
                 : params.items.map((entry) => entry.json),
         },
         params: params.nodeParams,
+        ai: params.aiContext || {},
+        aiModel: (_a = params.aiContext) === null || _a === void 0 ? void 0 : _a.languageModel,
+        aiTools: (_b = params.aiContext) === null || _b === void 0 ? void 0 : _b.tools,
+        aiMemory: (_c = params.aiContext) === null || _c === void 0 ? void 0 : _c.memory,
+        aiChain: (_d = params.aiContext) === null || _d === void 0 ? void 0 : _d.chain,
+        aiDocument: (_e = params.aiContext) === null || _e === void 0 ? void 0 : _e.document,
+        aiEmbedding: (_f = params.aiContext) === null || _f === void 0 ? void 0 : _f.embedding,
+        aiOutputParser: (_g = params.aiContext) === null || _g === void 0 ? void 0 : _g.outputParser,
+        aiTextSplitter: (_h = params.aiContext) === null || _h === void 0 ? void 0 : _h.textSplitter,
+        aiVectorStore: (_j = params.aiContext) === null || _j === void 0 ? void 0 : _j.vectorStore,
         utils: {
             now: () => new Date().toISOString(),
             sleep: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
@@ -294,7 +305,32 @@ class AimcCode {
             defaults: {
                 name: 'AIMC Code',
             },
-            inputs: ['main'],
+            inputs: `={{ 
+			((values, aiMode) => {
+				const connectorTypes = {
+					'${"ai_chain"}': 'Chain',
+					'${"ai_document"}': 'Document',
+					'${"ai_embedding"}': 'Embedding',
+					'${"ai_languageModel"}': 'Language Model',
+					'${"ai_memory"}': 'Memory',
+					'${"ai_outputParser"}': 'Output Parser',
+					'${"ai_textSplitter"}': 'Text Splitter',
+					'${"ai_tool"}': 'Tool',
+					'${"ai_vectorStore"}': 'Vector Store',
+					'${"main"}': 'Main'
+				};
+				const baseInputs = [{ displayName: '', type: '${"main"}' }];
+				if (aiMode && values) {
+					return baseInputs.concat(values.map(value => ({
+						type: value.type,
+						required: value.required,
+						maxConnections: value.maxConnections === -1 ? undefined : value.maxConnections,
+						displayName: connectorTypes[value.type] !== 'Main' ? connectorTypes[value.type] : undefined
+					})));
+				}
+				return baseInputs;
+			})($parameter.aiConnections?.input, $parameter.aiConnectMode)
+		}}`,
             outputs: ['main'],
             properties: [
                 {
@@ -333,6 +369,67 @@ class AimcCode {
                         maxValue: 300,
                     },
                 },
+                {
+                    displayName: 'AIMC Connect Mode',
+                    name: 'aiConnectMode',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Enable AI connector inputs for models, tools, memory, and more.',
+                },
+                {
+                    displayName: 'AI Connections',
+                    name: 'aiConnections',
+                    placeholder: 'Add AI Connection',
+                    type: 'fixedCollection',
+                    displayOptions: {
+                        show: {
+                            aiConnectMode: [true],
+                        },
+                    },
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    default: {},
+                    options: [
+                        {
+                            name: 'input',
+                            displayName: 'Input',
+                            values: [
+                                {
+                                    displayName: 'Type',
+                                    name: 'type',
+                                    type: 'options',
+                                    options: [
+                                        { name: 'Chain', value: 'ai_chain' },
+                                        { name: 'Document', value: 'ai_document' },
+                                        { name: 'Embedding', value: 'ai_embedding' },
+                                        { name: 'Language Model', value: 'ai_languageModel' },
+                                        { name: 'Memory', value: 'ai_memory' },
+                                        { name: 'Output Parser', value: 'ai_outputParser' },
+                                        { name: 'Text Splitter', value: 'ai_textSplitter' },
+                                        { name: 'Tool', value: 'ai_tool' },
+                                        { name: 'Vector Store', value: 'ai_vectorStore' },
+                                    ],
+                                    default: 'ai_languageModel',
+                                },
+                                {
+                                    displayName: 'Max Connections',
+                                    name: 'maxConnections',
+                                    type: 'number',
+                                    default: 1,
+                                    description: 'Set -1 for unlimited connections',
+                                },
+                                {
+                                    displayName: 'Required',
+                                    name: 'required',
+                                    type: 'boolean',
+                                    default: false,
+                                    description: 'Whether this connection is required',
+                                },
+                            ],
+                        },
+                    ],
+                },
                 {
                     displayName: 'JavaScript Code',
                     name: 'code',
@@ -410,8 +507,38 @@ class AimcCode {
         const language = this.getNodeParameter('language', 0, 'javascript');
         const mode = this.getNodeParameter('mode', 0, 'runOnceForAllItems');
         const timeoutSeconds = this.getNodeParameter('timeoutSeconds', 0, 30);
+        const aiConnectMode = this.getNodeParameter('aiConnectMode', 0, false);
         const timeoutMs = Math.max(1, timeoutSeconds) * 1000;
         const nodeParams = this.getNode().parameters;
+        const aiContext = {};
+        const fetchAi = async (type) => {
+            if (!aiConnectMode) {
+                return undefined;
+            }
+            const getter = this
+                .getInputConnectionData;
+            if (!getter) {
+                return undefined;
+            }
+            try {
+                const value = await getter(type, 0);
+                return Array.isArray(value) ? value[0] : value;
+            }
+            catch {
+                return undefined;
+            }
+        };
+        if (aiConnectMode) {
+            aiContext.chain = await fetchAi('ai_chain');
+            aiContext.document = await fetchAi('ai_document');
+            aiContext.embedding = await fetchAi('ai_embedding');
+            aiContext.languageModel = await fetchAi('ai_languageModel');
+            aiContext.memory = await fetchAi('ai_memory');
+            aiContext.outputParser = await fetchAi('ai_outputParser');
+            aiContext.textSplitter = await fetchAi('ai_textSplitter');
+            aiContext.tools = await fetchAi('ai_tool');
+            aiContext.vectorStore = await fetchAi('ai_vectorStore');
+        }
         if (language === 'python') {
             const pythonCode = this.getNodeParameter('pythonCode', 0, '');
             if (!pythonCode.trim()) {
@@ -477,6 +604,7 @@ class AimcCode {
                         item,
                         mode,
                         nodeParams,
+                        aiContext,
                     });
                     const result = await runCode(sandbox);
                     const normalized = normalizeResult(result, [item]);
@@ -488,6 +616,7 @@ class AimcCode {
                 items,
                 mode,
                 nodeParams,
+                aiContext,
             });
             const result = await runCode(sandbox);
             const normalized = normalizeResult(result, items);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ferchy/n8n-nodes-aimc-toolkit",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "AIMC Toolkit nodes for n8n: code execution and media operations.",
   "license": "MIT",
   "author": "Ferchy",
@@ -29,8 +29,7 @@
     "nodes": [
       "dist/nodes/AimcCode/AimcCode.node.js",
       "dist/nodes/AimcMedia/AimcMedia.node.js",
-      "dist/nodes/AimcTts/AimcTts.node.js",
-      "dist/nodes/AimcDocling/AimcDocling.node.js"
+      "dist/nodes/AimcTts/AimcTts.node.js"
     ]
   },
   "dependencies": {

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

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

package/dist/nodes/AimcDocling/AimcDocling.node.js

@@ -1,317 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.AimcDocling = void 0;
-const n8n_workflow_1 = require("n8n-workflow");
-const fs = __importStar(require("fs"));
-const path = __importStar(require("path"));
-const os = __importStar(require("os"));
-const child_process_1 = require("child_process");
-const util_1 = require("util");
-const execFileAsync = (0, util_1.promisify)(child_process_1.execFile);
-let doclingChecked = null;
-async function ensureDoclingAvailable(pythonPath) {
-    if (doclingChecked) {
-        if (!doclingChecked.ok) {
-            throw new Error(doclingChecked.message || 'Docling not available');
-        }
-        return;
-    }
-    try {
-        await execFileAsync(pythonPath, ['-c', 'import docling'], {
-            timeout: 10000,
-            maxBuffer: 1024 * 1024,
-        });
-        doclingChecked = { ok: true };
-    }
-    catch (error) {
-        const message = error instanceof Error && error.message
-            ? error.message
-            : 'Docling not available';
-        doclingChecked = { ok: false, message };
-        throw new Error(message);
-    }
-}
-async function installDocling(pythonPath, packages, timeoutMs) {
-    const packageList = packages
-        .split(',')
-        .map((pkg) => pkg.trim())
-        .filter(Boolean);
-    if (!packageList.length) {
-        return;
-    }
-    const strategies = [
-        ['-m', 'pip', 'install', '--user', ...packageList],
-        ['-m', 'pip', 'install', '--user', '--break-system-packages', ...packageList],
-        ['-m', 'pip', 'install', '--user', '--force-reinstall', ...packageList],
-    ];
-    for (const args of strategies) {
-        try {
-            await execFileAsync(pythonPath, args, {
-                timeout: timeoutMs,
-                maxBuffer: 5 * 1024 * 1024,
-            });
-            doclingChecked = null;
-            return;
-        }
-        catch {
-            // Try next strategy.
-        }
-    }
-    throw new Error('Failed to install docling with pip.');
-}
-async function createTempDir() {
-    return fs.promises.mkdtemp(path.join(os.tmpdir(), 'aimc-docling-'));
-}
-function safeFileName(name) {
-    return name.replace(/[^a-zA-Z0-9._-]/g, '_');
-}
-class AimcDocling {
-    constructor() {
-        this.description = {
-            displayName: 'AIMC Docling',
-            name: 'aimcDocling',
-            icon: 'file:aimc-docling.svg',
-            group: ['transform'],
-            version: 1,
-            description: 'Document extraction using Docling (OCR, PDF, DOCX).',
-            defaults: {
-                name: 'AIMC Docling',
-            },
-            inputs: ['main'],
-            outputs: ['main'],
-            properties: [
-                {
-                    displayName: 'Input Mode',
-                    name: 'inputMode',
-                    type: 'options',
-                    options: [
-                        { name: 'Binary', value: 'binary' },
-                        { name: 'File Path', value: 'filePath' },
-                        { name: 'URL', value: 'url' },
-                    ],
-                    default: 'binary',
-                },
-                {
-                    displayName: 'Binary Property',
-                    name: 'binaryProperty',
-                    type: 'string',
-                    default: 'data',
-                    displayOptions: {
-                        show: {
-                            inputMode: ['binary'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'File Path',
-                    name: 'inputFilePath',
-                    type: 'string',
-                    default: '',
-                    placeholder: '/path/to/document.pdf',
-                    displayOptions: {
-                        show: {
-                            inputMode: ['filePath'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'URL',
-                    name: 'inputUrl',
-                    type: 'string',
-                    default: '',
-                    placeholder: 'https://example.com/file.pdf',
-                    displayOptions: {
-                        show: {
-                            inputMode: ['url'],
-                        },
-                    },
-                },
-                {
-                    displayName: 'Output Format',
-                    name: 'outputFormat',
-                    type: 'options',
-                    options: [
-                        { name: 'Markdown', value: 'markdown' },
-                        { name: 'JSON', value: 'json' },
-                        { name: 'Plain Text', value: 'text' },
-                    ],
-                    default: 'markdown',
-                },
-                {
-                    displayName: 'Python Path',
-                    name: 'pythonPath',
-                    type: 'string',
-                    default: 'python3',
-                    description: 'Path to Python binary with docling installed.',
-                },
-                {
-                    displayName: 'Auto-install Docling',
-                    name: 'autoInstall',
-                    type: 'boolean',
-                    default: false,
-                    description: 'Install docling with pip on first run if missing.',
-                },
-                {
-                    displayName: 'Python Packages',
-                    name: 'pythonPackages',
-                    type: 'string',
-                    default: 'docling',
-                    description: 'Comma-separated packages to install when auto-install is enabled.',
-                },
-                {
-                    displayName: 'Timeout (Seconds)',
-                    name: 'timeoutSeconds',
-                    type: 'number',
-                    default: 120,
-                    typeOptions: {
-                        minValue: 30,
-                        maxValue: 1800,
-                    },
-                },
-            ],
-        };
-    }
-    async execute() {
-        const items = this.getInputData();
-        const results = [];
-        for (let index = 0; index < items.length; index++) {
-            const item = items[index];
-            const inputMode = this.getNodeParameter('inputMode', index);
-            const binaryProperty = this.getNodeParameter('binaryProperty', index, 'data');
-            const inputFilePath = this.getNodeParameter('inputFilePath', index, '');
-            const inputUrl = this.getNodeParameter('inputUrl', index, '');
-            const outputFormat = this.getNodeParameter('outputFormat', index, 'markdown');
-            const pythonPath = this.getNodeParameter('pythonPath', index, 'python3');
-            const autoInstall = this.getNodeParameter('autoInstall', index, false);
-            const pythonPackages = this.getNodeParameter('pythonPackages', index, 'docling');
-            const timeoutSeconds = this.getNodeParameter('timeoutSeconds', index, 120);
-            let tempDir = null;
-            let source = '';
-            if (inputMode === 'binary') {
-                const binary = this.helpers.assertBinaryData(index, binaryProperty);
-                const buffer = await this.helpers.getBinaryDataBuffer(index, binaryProperty);
-                tempDir = await createTempDir();
-                const name = safeFileName(binary.fileName || `document.${binary.fileExtension || 'bin'}`);
-                const filePath = path.join(tempDir, name);
-                await fs.promises.writeFile(filePath, buffer);
-                source = filePath;
-            }
-            else if (inputMode === 'filePath') {
-                if (!inputFilePath) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'File Path is required.');
-                }
-                source = inputFilePath;
-            }
-            else {
-                if (!inputUrl) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'URL is required.');
-                }
-                source = inputUrl;
-            }
-            try {
-                if (autoInstall) {
-                    await installDocling(pythonPath, pythonPackages, Math.max(30, timeoutSeconds) * 1000);
-                }
-                await ensureDoclingAvailable(pythonPath);
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : 'Docling not available';
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Docling not found. Install with: pip install docling. ${message}`);
-            }
-            const script = `
-+import json
-+import sys
-+from docling.document_converter import DocumentConverter
-+
-+source = ${JSON.stringify(source)}
-+fmt = ${JSON.stringify(outputFormat)}
-+
-+converter = DocumentConverter()
-+result = converter.convert(source)
-+doc = result.document
-+
-+if fmt == 'markdown':
-+    content = doc.export_to_markdown()
-+elif fmt == 'text':
-+    content = doc.export_to_markdown()
-+    # naive text conversion
-+    content = content.replace('#', '').replace('*', '')
-+else:
-+    try:
-+        content = doc.model_dump()
-+    except Exception:
-+        content = {'text': doc.export_to_markdown()}
-+
-+payload = {"format": fmt, "content": content}
-+print("__AIMC_RESULT__" + json.dumps(payload, default=str))
-+`;
-            try {
-                const { stdout, stderr } = await execFileAsync(pythonPath, ['-c', script], {
-                    timeout: Math.max(30, timeoutSeconds) * 1000,
-                    maxBuffer: 20 * 1024 * 1024,
-                });
-                const combined = `${stdout}\n${stderr}`.trim();
-                const marker = '__AIMC_RESULT__';
-                const markerIndex = combined.lastIndexOf(marker);
-                if (markerIndex === -1) {
-                    throw new Error('Docling did not return a result.');
-                }
-                const jsonPayload = combined.slice(markerIndex + marker.length).trim();
-                const payload = JSON.parse(jsonPayload);
-                results.push({
-                    json: {
-                        ...item.json,
-                        docling: {
-                            format: payload.format,
-                            content: payload.content,
-                        },
-                    },
-                });
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : 'Unknown error';
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Docling failed: ${message}`);
-            }
-            finally {
-                if (tempDir) {
-                    await fs.promises.rm(tempDir, { recursive: true, force: true });
-                }
-            }
-        }
-        return [results];
-    }
-}
-exports.AimcDocling = AimcDocling;

package/dist/nodes/AimcDocling/aimc-docling.svg

@@ -1,20 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 64 64" width="64" height="64">
-  <defs>
-    <linearGradient id="aimc-docling-bg" x1="0" y1="0" x2="1" y2="1">
-      <stop offset="0%" stop-color="#0A1021"/>
-      <stop offset="100%" stop-color="#0B1B3A"/>
-    </linearGradient>
-    <linearGradient id="aimc-docling-glow" x1="0" y1="0" x2="1" y2="1">
-      <stop offset="0%" stop-color="#7DD3FC"/>
-      <stop offset="100%" stop-color="#0EA5E9"/>
-    </linearGradient>
-  </defs>
-  <rect x="6" y="6" width="52" height="52" rx="10" fill="url(#aimc-docling-bg)"/>
-  <path d="M22 16H38L44 22V48H22Z" fill="#0F172A" stroke="#1E3A8A" stroke-width="2"/>
-  <path d="M38 16V22H44" stroke="#1E3A8A" stroke-width="2" fill="none"/>
-  <rect x="24" y="26" width="16" height="3" rx="1.5" fill="url(#aimc-docling-glow)"/>
-  <rect x="24" y="32" width="12" height="3" rx="1.5" fill="url(#aimc-docling-glow)"/>
-  <rect x="24" y="38" width="18" height="3" rx="1.5" fill="url(#aimc-docling-glow)"/>
-  <circle cx="46" cy="44" r="6" fill="#0B1223" stroke="#38BDF8" stroke-width="2"/>
-  <path d="M46 40V44L49 46" stroke="#38BDF8" stroke-width="2" stroke-linecap="round"/>
-</svg>