n8n-nodes-vlm 1.0.2

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

@@ -0,0 +1,16 @@
+import { ISupplyDataFunctions, SupplyData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+/**
+ * VLM Complexity Classifier Provider
+ *
+ * A classifier sub-node that integrates with n8n's Vector Store and AI nodes.
+ * Uses VLM servers (like deposium-embeddings-turbov2) to classify document complexity.
+ */
+export declare class VLMComplexityClassifier implements INodeType {
+    description: INodeTypeDescription;
+    /**
+     * Supply Data Method
+     *
+     * Provider nodes use supplyData() to return a classifier provider object
+     */
+    supplyData(this: ISupplyDataFunctions, _itemIndex: number): Promise<SupplyData>;
+}

package/dist/nodes/VLMComplexityClassifier/VLMComplexityClassifier.node.js

@@ -0,0 +1,220 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VLMComplexityClassifier = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const vlm_logic_1 = require("../shared/vlm-logic");
+/**
+ * VLM Complexity Classifier Provider
+ *
+ * A classifier sub-node that integrates with n8n's Vector Store and AI nodes.
+ * Uses VLM servers (like deposium-embeddings-turbov2) to classify document complexity.
+ */
+class VLMComplexityClassifier {
+    constructor() {
+        this.description = {
+            displayName: 'VLM Complexity Classifier',
+            name: 'vlmComplexityClassifier',
+            icon: 'file:vlm.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: 'Document Complexity Classification',
+            description: 'Classify document complexity using Vision-Language Models (LOW/HIGH)',
+            defaults: {
+                name: 'VLM Complexity Classifier',
+            },
+            codex: {
+                categories: ['AI'],
+                subcategories: {
+                    AI: ['Chains', 'Root Nodes', 'Tools'],
+                },
+            },
+            inputs: [],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.AiTool],
+            outputNames: ['Classifier'],
+            credentials: [
+                {
+                    name: 'httpBasicAuth',
+                    required: false,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Server URL',
+                    name: 'serverUrl',
+                    type: 'string',
+                    default: 'http://localhost:8000',
+                    placeholder: 'http://localhost:8000',
+                    description: 'URL to your VLM classifier server (e.g., deposium-embeddings-turbov2)',
+                    required: true,
+                },
+                {
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'string',
+                    default: 'vl-classifier',
+                    description: 'VLM model to use for classification',
+                },
+                {
+                    displayName: 'Classification Strategy',
+                    name: 'classificationStrategy',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Add Metadata Only',
+                            value: 'metadata',
+                            description: 'Add complexity classification as document metadata',
+                        },
+                        {
+                            name: 'Filter Documents',
+                            value: 'filter',
+                            description: 'Filter documents based on complexity',
+                        },
+                        {
+                            name: 'Filter + Metadata',
+                            value: 'both',
+                            description: 'Both filter and add metadata',
+                        },
+                    ],
+                    default: 'metadata',
+                    description: 'How to use the classification results',
+                },
+                {
+                    displayName: 'Filter Complexity',
+                    name: 'filterComplexity',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Low Complexity Only',
+                            value: 'LOW',
+                            description: 'Keep only simple documents (good for OCR)',
+                        },
+                        {
+                            name: 'High Complexity Only',
+                            value: 'HIGH',
+                            description: 'Keep only complex documents (good for VLM)',
+                        },
+                        {
+                            name: 'Both',
+                            value: 'both',
+                            description: 'Keep all documents regardless of complexity',
+                        },
+                    ],
+                    default: 'both',
+                    description: 'Which complexity level to keep when filtering',
+                    displayOptions: {
+                        show: {
+                            classificationStrategy: ['filter', 'both'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Additional Options',
+                    name: 'additionalOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Request Timeout (ms)',
+                            name: 'timeout',
+                            type: 'number',
+                            default: 30000,
+                            typeOptions: {
+                                minValue: 1000,
+                                maxValue: 300000,
+                            },
+                            description: 'Maximum time per API request',
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    /**
+     * Supply Data Method
+     *
+     * Provider nodes use supplyData() to return a classifier provider object
+     */
+    async supplyData(_itemIndex) {
+        var _a;
+        this.logger.debug('Initializing VLM Complexity Classifier Provider');
+        const self = this;
+        // Get node parameters
+        const serverUrl = this.getNodeParameter('serverUrl', 0).replace(/\/$/, '');
+        const model = this.getNodeParameter('model', 0);
+        const classificationStrategy = this.getNodeParameter('classificationStrategy', 0);
+        const filterComplexity = this.getNodeParameter('filterComplexity', 0, 'both');
+        const additionalOptions = this.getNodeParameter('additionalOptions', 0, {});
+        const timeout = (_a = additionalOptions.timeout) !== null && _a !== void 0 ? _a : 30000;
+        // Verify server has classifier capability
+        const status = await (0, vlm_logic_1.checkServerStatus)(this, serverUrl, timeout);
+        if (!status.hasClassifier) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Server at ${serverUrl} does not support VLM classification.\nMake sure /api/status returns has_classifier: true`);
+        }
+        /**
+         * Classifier Provider Object
+         */
+        const provider = {
+            name: 'VLM Complexity Classifier Provider',
+            description: `Classifies document complexity using VLM model: ${model}`,
+            /**
+             * classify() - Main classification method
+             */
+            classify: async (input) => {
+                // Log input for n8n execution tracking
+                const { index } = self.addInputData(n8n_workflow_1.NodeConnectionTypes.AiTool, [
+                    [{ json: { documents: input.documents } }],
+                ]);
+                const { documents } = input || {};
+                // Validate inputs
+                const docs = Array.isArray(documents) ? documents : [];
+                if (docs.length === 0) {
+                    self.logger.debug('No documents to classify, returning empty array');
+                    return [];
+                }
+                // Convert documents to standard format
+                const processedDocs = docs.map((doc, docIndex) => {
+                    if (doc && typeof doc === 'object') {
+                        return {
+                            pageContent: doc.pageContent || doc.text || doc.content || doc.document || JSON.stringify(doc),
+                            metadata: doc.metadata || {},
+                            _originalIndex: docIndex,
+                            ...(doc.image ? { image: doc.image } : {}),
+                            ...(doc.base64Image ? { base64Image: doc.base64Image } : {}),
+                        };
+                    }
+                    return {
+                        pageContent: String(doc),
+                        metadata: {},
+                        _originalIndex: docIndex,
+                    };
+                });
+                self.logger.debug(`Classifying ${processedDocs.length} documents with model: ${model}`);
+                try {
+                    // Classify documents
+                    const classifiedDocs = await (0, vlm_logic_1.classifyDocuments)(self, {
+                        serverUrl,
+                        model,
+                        documents: processedDocs,
+                        timeout,
+                        classificationStrategy,
+                        filterComplexity,
+                    });
+                    self.logger.debug(`Classification complete: ${classifiedDocs.length} documents returned`);
+                    // Log output for n8n execution tracking
+                    self.addOutputData(n8n_workflow_1.NodeConnectionTypes.AiTool, index, [
+                        [{ json: { response: classifiedDocs } }],
+                    ]);
+                    return classifiedDocs;
+                }
+                catch (error) {
+                    throw new n8n_workflow_1.NodeOperationError(self.getNode(), `VLM classification failed: ${error.message}`);
+                }
+            },
+        };
+        return {
+            response: provider,
+        };
+    }
+}
+exports.VLMComplexityClassifier = VLMComplexityClassifier;

package/dist/nodes/VLMComplexityClassifier/index.d.ts

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

package/dist/nodes/VLMComplexityClassifier/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VLMComplexityClassifier = void 0;
+var VLMComplexityClassifier_node_1 = require("./VLMComplexityClassifier.node");
+Object.defineProperty(exports, "VLMComplexityClassifier", { enumerable: true, get: function () { return VLMComplexityClassifier_node_1.VLMComplexityClassifier; } });

package/dist/nodes/VLMComplexityClassifier/vlm.svg

@@ -0,0 +1,19 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <defs>
+    <linearGradient id="grad1" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#667eea;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#764ba2;stop-opacity:1" />
+    </linearGradient>
+  </defs>
+
+  <!-- Vision eye symbol -->
+  <ellipse cx="50" cy="40" rx="30" ry="20" fill="url(#grad1)" opacity="0.8"/>
+  <circle cx="50" cy="40" r="10" fill="white"/>
+  <circle cx="50" cy="40" r="5" fill="#667eea"/>
+
+  <!-- Document/Language symbol -->
+  <rect x="25" y="55" width="50" height="35" rx="3" fill="url(#grad1)"/>
+  <line x1="32" y1="65" x2="68" y2="65" stroke="white" stroke-width="2" stroke-linecap="round"/>
+  <line x1="32" y1="73" x2="68" y2="73" stroke="white" stroke-width="2" stroke-linecap="round"/>
+  <line x1="32" y1="81" x2="55" y2="81" stroke="white" stroke-width="2" stroke-linecap="round"/>
+</svg>

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

@@ -0,0 +1,16 @@
+import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+/**
+ * VLM Complexity Classifier Workflow Node
+ *
+ * A workflow node that classifies document complexity using Vision-Language Models.
+ * Can be used as a standalone tool or chained in workflows.
+ */
+export declare class VLMComplexityWorkflow implements INodeType {
+    description: INodeTypeDescription;
+    /**
+     * Execute Method
+     *
+     * Workflow nodes use execute() to process items through the workflow
+     */
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/VLMComplexityWorkflow/VLMComplexityWorkflow.node.js

@@ -0,0 +1,303 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VLMComplexityWorkflow = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const vlm_logic_1 = require("../shared/vlm-logic");
+/**
+ * VLM Complexity Classifier Workflow Node
+ *
+ * A workflow node that classifies document complexity using Vision-Language Models.
+ * Can be used as a standalone tool or chained in workflows.
+ */
+class VLMComplexityWorkflow {
+    constructor() {
+        this.description = {
+            displayName: 'VLM Complexity Workflow',
+            name: 'vlmComplexityWorkflow',
+            icon: 'file:vlm.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"]}}',
+            description: 'Classify document complexity using Vision-Language Models',
+            defaults: {
+                name: 'VLM Complexity Workflow',
+            },
+            usableAsTool: true,
+            codex: {
+                categories: ['AI'],
+                subcategories: {
+                    AI: ['Chains', 'Root Nodes', 'Tools'],
+                },
+            },
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            credentials: [
+                {
+                    name: 'httpBasicAuth',
+                    required: false,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Server URL',
+                    name: 'serverUrl',
+                    type: 'string',
+                    default: 'http://localhost:8000',
+                    placeholder: 'http://localhost:8000',
+                    description: 'URL to your VLM classifier server (e.g., deposium-embeddings-turbov2)',
+                    required: true,
+                },
+                {
+                    displayName: 'Model',
+                    name: 'model',
+                    type: 'string',
+                    default: 'vl-classifier',
+                    description: 'VLM model to use for classification',
+                },
+                {
+                    displayName: 'Document Source',
+                    name: 'documentSource',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'All Items',
+                            value: 'items',
+                            description: 'Process all items from input',
+                        },
+                        {
+                            name: 'From Field',
+                            value: 'field',
+                            description: 'Extract documents from a specific field',
+                        },
+                        {
+                            name: 'From Expression',
+                            value: 'expression',
+                            description: 'Define documents using an expression',
+                        },
+                    ],
+                    default: 'items',
+                    description: 'Where to get documents for classification',
+                },
+                {
+                    displayName: 'Field Name',
+                    name: 'fieldName',
+                    type: 'string',
+                    default: 'documents',
+                    description: 'Name of the field containing documents',
+                    displayOptions: {
+                        show: {
+                            documentSource: ['field'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Documents Expression',
+                    name: 'documentsExpression',
+                    type: 'string',
+                    default: '={{$json.documents}}',
+                    description: 'Expression to extract documents',
+                    displayOptions: {
+                        show: {
+                            documentSource: ['expression'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Classification Strategy',
+                    name: 'classificationStrategy',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Add Metadata Only',
+                            value: 'metadata',
+                            description: 'Add complexity classification as document metadata',
+                        },
+                        {
+                            name: 'Filter Documents',
+                            value: 'filter',
+                            description: 'Filter documents based on complexity',
+                        },
+                        {
+                            name: 'Filter + Metadata',
+                            value: 'both',
+                            description: 'Both filter and add metadata',
+                        },
+                    ],
+                    default: 'metadata',
+                    description: 'How to use the classification results',
+                },
+                {
+                    displayName: 'Filter Complexity',
+                    name: 'filterComplexity',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Low Complexity Only',
+                            value: 'LOW',
+                            description: 'Keep only simple documents (good for OCR)',
+                        },
+                        {
+                            name: 'High Complexity Only',
+                            value: 'HIGH',
+                            description: 'Keep only complex documents (good for VLM)',
+                        },
+                        {
+                            name: 'Both',
+                            value: 'both',
+                            description: 'Keep all documents regardless of complexity',
+                        },
+                    ],
+                    default: 'both',
+                    description: 'Which complexity level to keep when filtering',
+                    displayOptions: {
+                        show: {
+                            classificationStrategy: ['filter', 'both'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Additional Options',
+                    name: 'additionalOptions',
+                    type: 'collection',
+                    placeholder: 'Add Option',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Request Timeout (ms)',
+                            name: 'timeout',
+                            type: 'number',
+                            default: 30000,
+                            typeOptions: {
+                                minValue: 1000,
+                                maxValue: 300000,
+                            },
+                            description: 'Maximum time per API request',
+                        },
+                        {
+                            displayName: 'Output Format',
+                            name: 'outputFormat',
+                            type: 'options',
+                            options: [
+                                {
+                                    name: 'Documents Array',
+                                    value: 'documents',
+                                    description: 'Return classified documents in an array',
+                                },
+                                {
+                                    name: 'Separate Items',
+                                    value: 'items',
+                                    description: 'Return each document as a separate item',
+                                },
+                                {
+                                    name: 'Original Format',
+                                    value: 'original',
+                                    description: 'Maintain original input structure with classifications added',
+                                },
+                            ],
+                            default: 'documents',
+                            description: 'How to format the output',
+                        },
+                    ],
+                },
+            ],
+        };
+    }
+    /**
+     * Execute Method
+     *
+     * Workflow nodes use execute() to process items through the workflow
+     */
+    async execute() {
+        var _a, _b;
+        const items = this.getInputData();
+        this.logger.debug(`VLM Complexity Workflow: Processing ${items.length} input items`);
+        // Get node parameters
+        const serverUrl = this.getNodeParameter('serverUrl', 0).replace(/\/$/, '');
+        const model = this.getNodeParameter('model', 0);
+        const documentSource = this.getNodeParameter('documentSource', 0);
+        const classificationStrategy = this.getNodeParameter('classificationStrategy', 0);
+        const filterComplexity = this.getNodeParameter('filterComplexity', 0, 'both');
+        const additionalOptions = this.getNodeParameter('additionalOptions', 0, {});
+        const timeout = (_a = additionalOptions.timeout) !== null && _a !== void 0 ? _a : 30000;
+        const outputFormat = (_b = additionalOptions.outputFormat) !== null && _b !== void 0 ? _b : 'documents';
+        // Verify server has classifier capability
+        const status = await (0, vlm_logic_1.checkServerStatus)(this, serverUrl, timeout);
+        if (!status.hasClassifier) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Server at ${serverUrl} does not support VLM classification.\nMake sure /api/status returns has_classifier: true`);
+        }
+        // Extract documents based on source
+        let documents = [];
+        if (documentSource === 'items') {
+            // Use all items as documents
+            documents = items.map((item, index) => ({
+                pageContent: JSON.stringify(item.json),
+                metadata: { _itemIndex: index },
+            }));
+        }
+        else if (documentSource === 'field') {
+            // Extract from field
+            const fieldName = this.getNodeParameter('fieldName', 0);
+            for (let i = 0; i < items.length; i++) {
+                const fieldData = items[i].json[fieldName];
+                if (Array.isArray(fieldData)) {
+                    documents.push(...fieldData);
+                }
+                else if (fieldData) {
+                    documents.push(fieldData);
+                }
+            }
+        }
+        else if (documentSource === 'expression') {
+            // Extract from expression
+            for (let i = 0; i < items.length; i++) {
+                const expressionValue = this.getNodeParameter('documentsExpression', i);
+                if (Array.isArray(expressionValue)) {
+                    documents.push(...expressionValue);
+                }
+                else if (expressionValue) {
+                    documents.push(expressionValue);
+                }
+            }
+        }
+        if (documents.length === 0) {
+            this.logger.debug('No documents found to classify');
+            return [items];
+        }
+        this.logger.debug(`Classifying ${documents.length} documents with model: ${model}`);
+        try {
+            // Classify documents
+            const classifiedDocs = await (0, vlm_logic_1.classifyDocuments)(this, {
+                serverUrl,
+                model,
+                documents,
+                timeout,
+                classificationStrategy,
+                filterComplexity,
+            });
+            this.logger.debug(`Classification complete: ${classifiedDocs.length} documents returned`);
+            // Format output based on outputFormat option
+            if (outputFormat === 'items') {
+                // Return each document as a separate item
+                return [classifiedDocs.map((doc) => ({ json: doc }))];
+            }
+            else if (outputFormat === 'original') {
+                // Maintain original structure but add classifications
+                const outputItems = items.map((item) => ({
+                    json: {
+                        ...item.json,
+                        _classifications: classifiedDocs,
+                    },
+                }));
+                return [outputItems];
+            }
+            else {
+                // Default: return documents array
+                return [[{ json: { documents: classifiedDocs } }]];
+            }
+        }
+        catch (error) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `VLM classification failed: ${error.message}`);
+        }
+    }
+}
+exports.VLMComplexityWorkflow = VLMComplexityWorkflow;

package/dist/nodes/VLMComplexityWorkflow/index.d.ts

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

package/dist/nodes/VLMComplexityWorkflow/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VLMComplexityWorkflow = void 0;
+var VLMComplexityWorkflow_node_1 = require("./VLMComplexityWorkflow.node");
+Object.defineProperty(exports, "VLMComplexityWorkflow", { enumerable: true, get: function () { return VLMComplexityWorkflow_node_1.VLMComplexityWorkflow; } });

package/dist/nodes/VLMComplexityWorkflow/vlm.svg

@@ -0,0 +1,19 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <defs>
+    <linearGradient id="grad1" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#667eea;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#764ba2;stop-opacity:1" />
+    </linearGradient>
+  </defs>
+
+  <!-- Vision eye symbol -->
+  <ellipse cx="50" cy="40" rx="30" ry="20" fill="url(#grad1)" opacity="0.8"/>
+  <circle cx="50" cy="40" r="10" fill="white"/>
+  <circle cx="50" cy="40" r="5" fill="#667eea"/>
+
+  <!-- Document/Language symbol -->
+  <rect x="25" y="55" width="50" height="35" rx="3" fill="url(#grad1)"/>
+  <line x1="32" y1="65" x2="68" y2="65" stroke="white" stroke-width="2" stroke-linecap="round"/>
+  <line x1="32" y1="73" x2="68" y2="73" stroke="white" stroke-width="2" stroke-linecap="round"/>
+  <line x1="32" y1="81" x2="55" y2="81" stroke="white" stroke-width="2" stroke-linecap="round"/>
+</svg>

package/dist/nodes/shared/vlm-logic.d.ts

@@ -0,0 +1,37 @@
+import { IExecuteFunctions, ISupplyDataFunctions } from 'n8n-workflow';
+type VLMContext = IExecuteFunctions | ISupplyDataFunctions;
+export interface VLMConfig {
+    serverUrl: string;
+    model?: string;
+    documents: any[];
+    timeout: number;
+    classificationStrategy?: 'metadata' | 'filter' | 'both';
+    filterComplexity?: 'LOW' | 'HIGH' | 'both';
+}
+export interface VLClassificationResult {
+    complexity: 'LOW' | 'HIGH';
+    confidence?: number;
+    processingTime?: number;
+    modelUsed?: string;
+}
+export interface ServerStatus {
+    status: 'healthy' | 'degraded' | 'error';
+    modelsLoaded?: string[];
+    vramUsage?: number;
+    hasClassifier?: boolean;
+    hasReranker?: boolean;
+    version?: string;
+}
+/**
+ * Check server status to detect VLM classifier capabilities
+ */
+export declare function checkServerStatus(context: VLMContext, serverUrl: string, timeout?: number): Promise<ServerStatus>;
+/**
+ * Classify documents using VLM Classifier
+ */
+export declare function classifyDocuments(context: VLMContext, config: VLMConfig): Promise<any[]>;
+/**
+ * List available VLM models from server
+ */
+export declare function listVLMModels(context: VLMContext, serverUrl: string, timeout?: number): Promise<any[]>;
+export {};

package/dist/nodes/shared/vlm-logic.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkServerStatus = checkServerStatus;
+exports.classifyDocuments = classifyDocuments;
+exports.listVLMModels = listVLMModels;
+const n8n_workflow_1 = require("n8n-workflow");
+/**
+ * Check server status to detect VLM classifier capabilities
+ */
+async function checkServerStatus(context, serverUrl, timeout = 5000) {
+    try {
+        const response = await context.helpers.httpRequest({
+            method: 'GET',
+            url: `${serverUrl}/api/status`,
+            headers: {
+                Accept: 'application/json',
+            },
+            json: true,
+            timeout,
+        });
+        return {
+            status: response.status || 'healthy',
+            modelsLoaded: response.models_loaded || response.models || [],
+            vramUsage: response.vram_usage,
+            hasClassifier: response.has_classifier || false,
+            hasReranker: response.has_reranker || false,
+            version: response.version,
+        };
+    }
+    catch (error) {
+        // If /api/status doesn't exist, it's not a VLM classifier server
+        return {
+            status: 'error',
+            hasClassifier: false,
+            hasReranker: false,
+        };
+    }
+}
+/**
+ * Classify a single document's complexity using VLM Classifier API
+ */
+async function classifyDocumentComplexity(context, serverUrl, document, timeout) {
+    try {
+        // Prepare document content for classification
+        const content = document.pageContent || JSON.stringify(document);
+        // Check if document contains image data
+        const hasImage = document.image || document.base64Image;
+        let requestBody = {
+            text: content,
+        };
+        if (hasImage) {
+            requestBody.image = document.image || document.base64Image;
+        }
+        const response = await context.helpers.httpRequest({
+            method: 'POST',
+            url: `${serverUrl}/api/classify`,
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            body: requestBody,
+            json: true,
+            timeout,
+        });
+        return {
+            complexity: response.complexity || response.classification || 'LOW',
+            confidence: response.confidence,
+            processingTime: response.processing_time || response.processingTime,
+            modelUsed: response.model || 'VLM-Classifier',
+        };
+    }
+    catch (error) {
+        // On error, default to LOW complexity to not filter out documents
+        console.warn('Classification failed, defaulting to LOW complexity:', error.message);
+        return {
+            complexity: 'LOW',
+            confidence: 0,
+        };
+    }
+}
+/**
+ * Classify documents using VLM Classifier
+ */
+async function classifyDocuments(context, config) {
+    const { serverUrl, documents, timeout, classificationStrategy = 'metadata', filterComplexity = 'both' } = config;
+    // Step 1: Classify all documents
+    const classificationPromises = documents.map(async (doc, index) => {
+        const classification = await classifyDocumentComplexity(context, serverUrl, doc, timeout);
+        return { doc, index, classification };
+    });
+    const classifiedDocs = await Promise.all(classificationPromises);
+    // Step 2: Filter documents based on strategy
+    let docsToReturn = classifiedDocs;
+    if (classificationStrategy === 'filter' || classificationStrategy === 'both') {
+        if (filterComplexity !== 'both') {
+            docsToReturn = classifiedDocs.filter(item => item.classification.complexity === filterComplexity);
+        }
+    }
+    // If no documents pass the filter, return empty
+    if (docsToReturn.length === 0) {
+        return [];
+    }
+    // Step 3: Add metadata if requested
+    const finalDocs = docsToReturn.map(item => {
+        const enrichedDoc = { ...item.doc };
+        if (classificationStrategy === 'metadata' || classificationStrategy === 'both') {
+            enrichedDoc._complexityClass = item.classification.complexity;
+            enrichedDoc._complexityConfidence = item.classification.confidence;
+            enrichedDoc._processingTime = item.classification.processingTime;
+            enrichedDoc._modelUsed = item.classification.modelUsed;
+        }
+        enrichedDoc._originalIndex = item.index;
+        return enrichedDoc;
+    });
+    return finalDocs;
+}
+/**
+ * List available VLM models from server
+ */
+async function listVLMModels(context, serverUrl, timeout = 5000) {
+    try {
+        const response = await context.helpers.httpRequest({
+            method: 'GET',
+            url: `${serverUrl}/api/tags`,
+            headers: {
+                Accept: 'application/json',
+            },
+            json: true,
+            timeout,
+        });
+        return response.models || [];
+    }
+    catch (error) {
+        throw new n8n_workflow_1.NodeApiError(context.getNode(), error, {
+            message: 'Failed to fetch VLM models',
+            description: `Endpoint: ${serverUrl}/api/tags\nError: ${error.message}`,
+        });
+    }
+}

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "n8n-nodes-vlm",
+  "version": "1.0.2",
+  "description": "Vision-Language Models for n8n - Lightweight specialized VLMs for document analysis and classification",
+  "main": "index.js",
+  "author": "Gabriel BRUMENT",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/theseedship/n8n_vlm.git"
+  },
+  "bugs": {
+    "url": "https://github.com/theseedship/n8n_vlm/issues"
+  },
+  "homepage": "https://github.com/theseedship/n8n_vlm#readme",
+  "files": [
+    "dist/**/*",
+    "src/**/*.svg",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc && npm run copy-assets",
+    "copy-assets": "cp src/nodes/VLMComplexityClassifier/vlm.svg dist/nodes/VLMComplexityClassifier/ && cp src/nodes/VLMComplexityWorkflow/vlm.svg dist/nodes/VLMComplexityWorkflow/",
+    "dev": "tsc --watch",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "test": "jest",
+    "format": "prettier --write \"**/*.{ts,js,json,md}\"",
+    "format:check": "prettier --check \"**/*.{ts,js,json,md}\"",
+    "prepare": "cd .. && husky custom-nodes/.husky"
+  },
+  "keywords": [
+    "n8n",
+    "n8n-nodes",
+    "n8n-community-node-package",
+    "vlm",
+    "vision-language",
+    "classification",
+    "complexity",
+    "document-analysis",
+    "ai"
+  ],
+  "n8n": {
+    "n8nNodesApiVersion": 1,
+    "nodes": [
+      "dist/nodes/VLMComplexityClassifier/VLMComplexityClassifier.node.js",
+      "dist/nodes/VLMComplexityWorkflow/VLMComplexityWorkflow.node.js"
+    ],
+    "credentials": []
+  },
+  "devDependencies": {
+    "@types/jest": "^29.0.0",
+    "@types/node": "^18.0.0",
+    "@typescript-eslint/eslint-plugin": "^5.0.0",
+    "@typescript-eslint/parser": "^5.0.0",
+    "eslint": "^8.0.0",
+    "husky": "^9.1.7",
+    "jest": "^29.0.0",
+    "lint-staged": "^15.2.11",
+    "prettier": "^3.4.2",
+    "ts-jest": "^29.0.0",
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "n8n-workflow": "^1.0.0"
+  },
+  "lint-staged": {
+    "*.{ts,js}": [
+      "eslint --fix",
+      "prettier --write"
+    ],
+    "*.{json,md}": [
+      "prettier --write"
+    ]
+  },
+  "engines": {
+    "node": ">=18.0.0",
+    "npm": ">=9.0.0"
+  }
+}

package/src/nodes/VLMComplexityClassifier/vlm.svg

@@ -0,0 +1,19 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <defs>
+    <linearGradient id="grad1" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#667eea;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#764ba2;stop-opacity:1" />
+    </linearGradient>
+  </defs>
+
+  <!-- Vision eye symbol -->
+  <ellipse cx="50" cy="40" rx="30" ry="20" fill="url(#grad1)" opacity="0.8"/>
+  <circle cx="50" cy="40" r="10" fill="white"/>
+  <circle cx="50" cy="40" r="5" fill="#667eea"/>
+
+  <!-- Document/Language symbol -->
+  <rect x="25" y="55" width="50" height="35" rx="3" fill="url(#grad1)"/>
+  <line x1="32" y1="65" x2="68" y2="65" stroke="white" stroke-width="2" stroke-linecap="round"/>
+  <line x1="32" y1="73" x2="68" y2="73" stroke="white" stroke-width="2" stroke-linecap="round"/>
+  <line x1="32" y1="81" x2="55" y2="81" stroke="white" stroke-width="2" stroke-linecap="round"/>
+</svg>

package/src/nodes/VLMComplexityWorkflow/vlm.svg

@@ -0,0 +1,19 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 100 100">
+  <defs>
+    <linearGradient id="grad1" x1="0%" y1="0%" x2="100%" y2="100%">
+      <stop offset="0%" style="stop-color:#667eea;stop-opacity:1" />
+      <stop offset="100%" style="stop-color:#764ba2;stop-opacity:1" />
+    </linearGradient>
+  </defs>
+
+  <!-- Vision eye symbol -->
+  <ellipse cx="50" cy="40" rx="30" ry="20" fill="url(#grad1)" opacity="0.8"/>
+  <circle cx="50" cy="40" r="10" fill="white"/>
+  <circle cx="50" cy="40" r="5" fill="#667eea"/>
+
+  <!-- Document/Language symbol -->
+  <rect x="25" y="55" width="50" height="35" rx="3" fill="url(#grad1)"/>
+  <line x1="32" y1="65" x2="68" y2="65" stroke="white" stroke-width="2" stroke-linecap="round"/>
+  <line x1="32" y1="73" x2="68" y2="73" stroke="white" stroke-width="2" stroke-linecap="round"/>
+  <line x1="32" y1="81" x2="55" y2="81" stroke="white" stroke-width="2" stroke-linecap="round"/>
+</svg>