n8n-nodes-ollama-reranker 1.3.2 → 1.4.0

package/README.md

@@ -3,13 +3,17 @@
 [![npm version](https://img.shields.io/npm/v/n8n-nodes-ollama-reranker)](https://www.npmjs.com/package/n8n-nodes-ollama-reranker)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-Ollama Reranker provider for n8n Vector Store nodes - rerank documents using local Ollama models.
+**Advanced Reranker Provider for n8n** - Supporting Ollama-compatible APIs, Custom Rerank servers, and VL Classifiers.
+
+> **⚠️ Important Note:** *Sorry folks, Ollama doesn't natively support reranker models! We're developing our own solution to bring powerful reranking capabilities to n8n. This package works with Ollama-compatible APIs that implement reranking through prompt-based scoring, custom rerank endpoints, and now Vision-Language classification servers.*
 
 ## Features
 
 - 🎯 **Integrates seamlessly** with n8n Vector Store nodes
-- 🚀 **Local inference** using Ollama (no API keys needed)
+- 🚀 **Multiple API types**: Ollama Generate, Custom Rerank, VL Classifier
+- 🤖 **Auto-detection** of server capabilities
 - 🔧 **Multiple models** supported (BGE Reranker, Qwen3 family)
+- 🎨 **VL Classification** for document complexity analysis (v1.4.0+)
 - ⚡ **Concurrent processing** with configurable batch sizes
 - 🔄 **Automatic retries** with exponential backoff
 - 📊 **Flexible scoring** with threshold and topK parameters
@@ -43,6 +47,9 @@ USER node
 
 ## Prerequisites
 
+Choose your server type:
+
+### Option 1: Ollama (Prompt-based reranking)
 1. **Ollama** must be running and accessible
 2. Pull a reranker model:
 
@@ -54,15 +61,41 @@ ollama pull bge-reranker-v2-m3
 ollama pull dengcao/Qwen3-Reranker-4B:Q5_K_M
 ```
 
+### Option 2: Custom Rerank API
+Use any service implementing `/api/rerank` endpoint (like deposium-embeddings-turbov2)
+
+### Option 3: VL Classifier Server (NEW in v1.4.0)
+Deploy a Vision-Language classifier server with:
+- `/api/status` - Server health and capabilities
+- `/api/classify` - Document complexity classification
+- Optional `/api/rerank` - Direct reranking support
+
+Example: `deposium_embeddings-turbov2` with ResNet18 ONNX INT8 model
+
 ## Usage
 
+### Basic Setup
 1. Add an **Ollama Reranker** node to your workflow
 2. Connect it to a Vector Store node (e.g., Pinecone, Qdrant, Supabase)
 3. Configure:
+   - **API Type**: Choose between:
+     - `Ollama Generate API` - Standard Ollama prompt-based
+     - `Custom Rerank API` - Direct reranking endpoint
+     - `VL Classifier + Reranker` - Vision-Language classification
+     - `Auto-Detect` - Automatically detect server type
    - **Model**: Select a reranker model
    - **Top K**: Number of documents to return
    - **Threshold**: Minimum relevance score (0-1)
-   - **Ollama Host**: URL to your Ollama instance
+   - **Base URL**: URL to your server
+
+### VL Classifier Options (v1.4.0+)
+When using VL Classifier:
+- **Enable VL Classification**: Use complexity analysis
+- **Classification Strategy**: 
+  - `Metadata` - Add complexity as document metadata
+  - `Filter` - Filter by complexity before reranking
+  - `Both` - Combine filtering and metadata
+- **Filter Complexity**: Keep LOW, HIGH, or both complexity documents
 
 ### Example Workflow
 
@@ -72,8 +105,9 @@ User Query → Vector Store (retrieve 50 docs)
            → Continue with top-ranked documents
 ```
 
-## Supported Models
+## Supported Configurations
 
+### Reranker Models (Ollama/Custom API)
 | Model | Size | Speed | Accuracy | Best For |
 |-------|------|-------|----------|----------|
 | `bge-reranker-v2-m3` | ~600MB | ⚡⚡⚡ | ⭐⭐⭐⭐ | General purpose (Recommended) |
@@ -81,6 +115,12 @@ User Query → Vector Store (retrieve 50 docs)
 | `Qwen3-Reranker-4B` | ~2.5GB | ⚡⚡ | ⭐⭐⭐⭐ | Balanced performance |
 | `Qwen3-Reranker-8B` | ~5GB | ⚡ | ⭐⭐⭐⭐⭐ | Maximum accuracy |
 
+### VL Classifier Models
+| Model | Size | Speed | Use Case |
+|-------|------|-------|----------|
+| `ResNet18-ONNX-INT8` | 11MB | ⚡⚡⚡⚡ | Document complexity classification |
+| Custom VL models | Varies | Varies | Vision-Language tasks |
+
 ## Development
 
 ### Setup
@@ -168,10 +208,27 @@ n8n_reranker/
         └── npm-publish.yml    # Automated publishing
 ```
 
+## How It Works
+
+### The Reranking Challenge
+Ollama doesn't natively support reranker models that output relevance scores. Instead, we implement three approaches:
+
+1. **Prompt-based Scoring**: Use Ollama's `/api/generate` with specially formatted prompts
+2. **Custom Rerank API**: Connect to servers with dedicated `/api/rerank` endpoints
+3. **VL Classification**: Pre-process with Vision-Language models for intelligent filtering
+
+### API Type Detection
+The node automatically detects your server type by checking:
+1. `/api/status` → VL Classifier server
+2. `/api/tags` → Ollama server
+3. `/api/rerank` → Custom rerank server
+4. Fallback → Ollama (default)
+
 ## Architecture
 
-This node follows n8n's **Sub-node Provider pattern**:
+This node implements two n8n patterns:
 
+### Provider Node (OllamaReranker)
 1. **No inputs** - Provider nodes don't receive workflow data
 2. **AiReranker output** - Connects to Vector Store nodes
 3. **supplyData()** - Returns a reranker provider object
@@ -179,6 +236,11 @@ This node follows n8n's **Sub-node Provider pattern**:
    - `rerank()` - Main reranking method
    - `compressDocuments()` - LangChain compatibility
 
+### Workflow Node (OllamaRerankerWorkflow)
+1. **Main inputs/outputs** - Processes workflow items
+2. **execute()** - Transforms documents in the workflow
+3. **usableAsTool** - Can be used as AI Agent tool
+
 ## Contributing
 
 1. Fork the repository
@@ -201,6 +263,7 @@ MIT © Gabriel BRUMENT
 
 - [GitHub Repository](https://github.com/theseedship/n8n_reranker)
 - [npm Package](https://www.npmjs.com/package/n8n-nodes-ollama-reranker)
+- [VL Classifier Integration Guide](./VL_CLASSIFIER_INTEGRATION.md)
 - [n8n Documentation](https://docs.n8n.io/)
 - [Ollama Documentation](https://ollama.ai/docs)
 

package/dist/nodes/OllamaReranker/OllamaReranker.node.js

@@ -1,4 +1,37 @@
 "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.OllamaReranker = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
@@ -182,6 +215,80 @@ class OllamaReranker {
                             },
                             description: 'Number of documents to process concurrently',
                         },
+                        // VL Classifier specific options
+                        {
+                            displayName: 'Enable VL Classification',
+                            name: 'enableClassification',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Use Vision-Language classifier to analyze document complexity',
+                            displayOptions: {
+                                show: {
+                                    '/apiType': ['vl-classifier'],
+                                },
+                            },
+                        },
+                        {
+                            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',
+                            displayOptions: {
+                                show: {
+                                    '/apiType': ['vl-classifier'],
+                                    'enableClassification': [true],
+                                },
+                            },
+                        },
+                        {
+                            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: {
+                                    '/apiType': ['vl-classifier'],
+                                    'enableClassification': [true],
+                                    'classificationStrategy': ['filter', 'both'],
+                                },
+                            },
+                        },
                     ],
                 },
             ],
@@ -194,7 +301,7 @@ class OllamaReranker {
      * that implements the standard rerank() and compressDocuments() interfaces.
      */
     async supplyData(_itemIndex) {
-        var _a, _b, _c;
+        var _a, _b, _c, _d, _e, _f;
         this.logger.debug('Initializing Ollama Reranker Provider');
         const self = this;
         // Get node parameters once (provider nodes use index 0)
@@ -202,18 +309,27 @@ class OllamaReranker {
         if (!(model === null || model === void 0 ? void 0 : model.trim())) {
             throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Model selection is required. Please select a model from the dropdown.');
         }
-        const apiType = this.getNodeParameter('apiType', 0, 'ollama');
+        // Get API type
+        let apiType = this.getNodeParameter('apiType', 0, 'ollama');
         const instruction = this.getNodeParameter('instruction', 0);
         const additionalOptions = this.getNodeParameter('additionalOptions', 0, {});
         const timeout = (_a = additionalOptions.timeout) !== null && _a !== void 0 ? _a : 30000;
         const batchSize = (_b = additionalOptions.batchSize) !== null && _b !== void 0 ? _b : 10;
         const includeOriginalScores = (_c = additionalOptions.includeOriginalScores) !== null && _c !== void 0 ? _c : false;
+        const enableClassification = (_d = additionalOptions.enableClassification) !== null && _d !== void 0 ? _d : true;
+        const classificationStrategy = (_e = additionalOptions.classificationStrategy) !== null && _e !== void 0 ? _e : 'metadata';
+        const filterComplexity = (_f = additionalOptions.filterComplexity) !== null && _f !== void 0 ? _f : 'both';
         // Get credentials (n8n's built-in ollamaApi)
         const credentials = await this.getCredentials('ollamaApi');
         if (!(credentials === null || credentials === void 0 ? void 0 : credentials.baseUrl)) {
             throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Ollama Base URL not configured. Please add Ollama API credentials with a valid Base URL.');
         }
         const ollamaHost = credentials.baseUrl.replace(/\/$/, '');
+        // Auto-detect server type if needed
+        if (apiType === 'auto') {
+            const { detectServerType } = await Promise.resolve().then(() => __importStar(require('../shared/reranker-logic')));
+            apiType = await detectServerType(this, ollamaHost);
+        }
         /**
          * Reranker Provider Object
          *
@@ -277,7 +393,7 @@ class OllamaReranker {
                 });
                 self.logger.debug(`Reranking ${processedDocs.length} documents with model: ${model}`);
                 try {
-                    // Rerank documents using Ollama or Custom API
+                    // Rerank documents using Ollama, Custom API, or VL Classifier
                     const rerankedDocs = await (0, reranker_logic_1.rerankDocuments)(self, {
                         ollamaHost,
                         model,
@@ -289,7 +405,10 @@ class OllamaReranker {
                         batchSize,
                         timeout,
                         includeOriginalScores,
-                        apiType,
+                        apiType: apiType,
+                        enableClassification,
+                        classificationStrategy,
+                        filterComplexity,
                     });
                     self.logger.debug(`Reranking complete: ${rerankedDocs.length} documents returned`);
                     // Log output for n8n execution tracking

package/dist/nodes/OllamaRerankerWorkflow/OllamaRerankerWorkflow.node.js

@@ -1,4 +1,37 @@
 "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.OllamaRerankerWorkflow = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
@@ -283,6 +316,80 @@ class OllamaRerankerWorkflow {
                             default: 'documents',
                             description: 'How to format output documents',
                         },
+                        // VL Classifier specific options
+                        {
+                            displayName: 'Enable VL Classification',
+                            name: 'enableClassification',
+                            type: 'boolean',
+                            default: true,
+                            description: 'Use Vision-Language classifier to analyze document complexity',
+                            displayOptions: {
+                                show: {
+                                    '/apiType': ['vl-classifier'],
+                                },
+                            },
+                        },
+                        {
+                            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',
+                            displayOptions: {
+                                show: {
+                                    '/apiType': ['vl-classifier'],
+                                    'enableClassification': [true],
+                                },
+                            },
+                        },
+                        {
+                            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: {
+                                    '/apiType': ['vl-classifier'],
+                                    'enableClassification': [true],
+                                    'classificationStrategy': ['filter', 'both'],
+                                },
+                            },
+                        },
                     ],
                 },
             ],
@@ -295,7 +402,7 @@ class OllamaRerankerWorkflow {
      * and return processed items to output connections.
      */
     async execute() {
-        var _a, _b, _c, _d;
+        var _a, _b, _c, _d, _e, _f, _g;
         const items = this.getInputData();
         const returnData = [];
         // Get credentials
@@ -309,8 +416,12 @@ class OllamaRerankerWorkflow {
         if (!(model === null || model === void 0 ? void 0 : model.trim())) {
             throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Model selection is required. Please select a model from the dropdown.');
         }
-        // Get API type
-        const apiType = this.getNodeParameter('apiType', 0, 'ollama');
+        // Get API type and auto-detect if needed
+        let apiType = this.getNodeParameter('apiType', 0, 'ollama');
+        if (apiType === 'auto') {
+            const { detectServerType } = await Promise.resolve().then(() => __importStar(require('../shared/reranker-logic')));
+            apiType = await detectServerType(this, ollamaHost);
+        }
         // Get common parameters
         const instruction = this.getNodeParameter('instruction', 0);
         const topK = this.getNodeParameter('topK', 0);
@@ -320,6 +431,9 @@ class OllamaRerankerWorkflow {
         const batchSize = (_b = additionalOptions.batchSize) !== null && _b !== void 0 ? _b : 10;
         const includeOriginalScores = (_c = additionalOptions.includeOriginalScores) !== null && _c !== void 0 ? _c : false;
         const outputFormat = (_d = additionalOptions.outputFormat) !== null && _d !== void 0 ? _d : 'documents';
+        const enableClassification = (_e = additionalOptions.enableClassification) !== null && _e !== void 0 ? _e : true;
+        const classificationStrategy = (_f = additionalOptions.classificationStrategy) !== null && _f !== void 0 ? _f : 'metadata';
+        const filterComplexity = (_g = additionalOptions.filterComplexity) !== null && _g !== void 0 ? _g : 'both';
         // Process each input item
         for (let itemIndex = 0; itemIndex < items.length; itemIndex++) {
             try {
@@ -397,7 +511,10 @@ class OllamaRerankerWorkflow {
                     batchSize,
                     timeout,
                     includeOriginalScores,
-                    apiType,
+                    apiType: apiType,
+                    enableClassification,
+                    classificationStrategy: classificationStrategy,
+                    filterComplexity: filterComplexity,
                 });
                 // Format output
                 let output;

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

@@ -11,10 +11,35 @@ export interface RerankConfig {
     batchSize: number;
     timeout: number;
     includeOriginalScores: boolean;
-    apiType?: 'ollama' | 'custom';
+    apiType?: 'ollama' | 'custom' | 'vl-classifier';
+    enableClassification?: boolean;
+    classificationStrategy?: 'filter' | 'metadata' | '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;
 }
 /**
  * Rerank documents using Ollama reranker model or Custom Rerank API
  */
 export declare function rerankDocuments(context: RerankerContext, config: RerankConfig): Promise<any[]>;
+/**
+ * Check server status to detect capabilities
+ */
+export declare function checkServerStatus(context: RerankerContext, serverUrl: string, timeout?: number): Promise<ServerStatus>;
+/**
+ * Detect server type automatically
+ */
+export declare function detectServerType(context: RerankerContext, serverUrl: string): Promise<'ollama' | 'custom' | 'vl-classifier'>;
 export {};

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

@@ -1,12 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.rerankDocuments = rerankDocuments;
+exports.checkServerStatus = checkServerStatus;
+exports.detectServerType = detectServerType;
 const n8n_workflow_1 = require("n8n-workflow");
 /**
  * Rerank documents using Ollama reranker model or Custom Rerank API
  */
 async function rerankDocuments(context, config) {
-    const { ollamaHost, model, query, documents, instruction, topK, threshold, batchSize, timeout, includeOriginalScores, apiType = 'ollama' } = config;
+    const { ollamaHost, model, query, documents, instruction, topK, threshold, batchSize, timeout, includeOriginalScores, apiType = 'ollama', enableClassification = false, classificationStrategy = 'metadata', filterComplexity = 'both' } = config;
+    // Handle VL Classifier API with reranking
+    if (apiType === 'vl-classifier' && enableClassification) {
+        return await rerankWithVLClassifier(context, config);
+    }
     // Use Custom Rerank API if specified
     if (apiType === 'custom') {
         return await rerankWithCustomAPI(context, config);
@@ -326,6 +332,188 @@ function parseGenericScore(output, outputLower) {
     // Default to neutral if completely ambiguous
     return 0.5;
 }
+/**
+ * Check server status to detect 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 || [],
+            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 VL classifier server
+        return {
+            status: 'error',
+            hasClassifier: false,
+            hasReranker: false,
+        };
+    }
+}
+/**
+ * Detect server type automatically
+ */
+async function detectServerType(context, serverUrl) {
+    // First check for VL classifier with /api/status
+    const status = await checkServerStatus(context, serverUrl);
+    if (status.hasClassifier) {
+        return 'vl-classifier';
+    }
+    // Check for Ollama with /api/tags
+    try {
+        await context.helpers.httpRequest({
+            method: 'GET',
+            url: `${serverUrl}/api/tags`,
+            timeout: 5000,
+        });
+        return 'ollama';
+    }
+    catch {
+        // Not Ollama
+    }
+    // Check for custom rerank API
+    try {
+        await context.helpers.httpRequest({
+            method: 'POST',
+            url: `${serverUrl}/api/rerank`,
+            headers: { 'Content-Type': 'application/json' },
+            body: {
+                model: 'test',
+                query: 'test',
+                documents: ['test'],
+            },
+            timeout: 5000,
+        });
+        return 'custom';
+    }
+    catch {
+        // Default to Ollama
+        return 'ollama';
+    }
+}
+/**
+ * Classify document complexity using VL Classifier API
+ */
+async function classifyDocumentComplexity(context, serverUrl, document, timeout) {
+    try {
+        // Prepare document content for classification
+        const content = document.pageContent || JSON.stringify(document);
+        // For VL classifier, we might need to handle base64 images
+        // 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,
+            modelUsed: response.model || 'ResNet18-ONNX',
+        };
+    }
+    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,
+        };
+    }
+}
+/**
+ * Rerank documents using VL Classifier + Reranking
+ */
+async function rerankWithVLClassifier(context, config) {
+    const { ollamaHost, model, query, documents, topK, threshold, timeout, includeOriginalScores, classificationStrategy = 'metadata', filterComplexity = 'both' } = config;
+    // Step 1: Classify all documents
+    const classificationPromises = documents.map(async (doc, index) => {
+        const classification = await classifyDocumentComplexity(context, ollamaHost, doc, timeout);
+        return { doc, index, classification };
+    });
+    const classifiedDocs = await Promise.all(classificationPromises);
+    // Step 2: Filter documents based on strategy
+    let docsToRerank = classifiedDocs;
+    if (classificationStrategy === 'filter' || classificationStrategy === 'both') {
+        if (filterComplexity !== 'both') {
+            docsToRerank = classifiedDocs.filter(item => item.classification.complexity === filterComplexity);
+        }
+    }
+    // If no documents pass the filter, return empty
+    if (docsToRerank.length === 0) {
+        return [];
+    }
+    // Step 3: Prepare documents for reranking
+    const rerankerDocs = docsToRerank.map(item => {
+        const enrichedDoc = { ...item.doc };
+        if (classificationStrategy === 'metadata' || classificationStrategy === 'both') {
+            enrichedDoc._complexityClass = item.classification.complexity;
+            enrichedDoc._complexityConfidence = item.classification.confidence;
+        }
+        return enrichedDoc;
+    });
+    // Step 4: Check if server has reranker capability
+    const status = await checkServerStatus(context, ollamaHost);
+    if (status.hasReranker) {
+        // Use the server's rerank endpoint if available
+        return await rerankWithCustomAPI(context, {
+            ...config,
+            documents: rerankerDocs,
+        });
+    }
+    else {
+        // Fall back to scoring-based reranking
+        // For VL classifier servers without reranker, we can still sort by complexity
+        const scoredDocs = rerankerDocs.map((doc, idx) => {
+            // Give higher scores to HIGH complexity documents for technical queries
+            const complexityScore = doc._complexityClass === 'HIGH' ? 0.8 : 0.2;
+            const confidenceBoost = (doc._complexityConfidence || 0) * 0.2;
+            return {
+                ...doc,
+                _rerankScore: complexityScore + confidenceBoost,
+                _originalIndex: classifiedDocs[idx].index,
+            };
+        });
+        // Sort and filter
+        return scoredDocs
+            .filter(doc => doc._rerankScore >= threshold)
+            .sort((a, b) => b._rerankScore - a._rerankScore)
+            .slice(0, topK)
+            .map(doc => {
+            if (!includeOriginalScores && doc._originalScore !== undefined) {
+                delete doc._originalScore;
+            }
+            return doc;
+        });
+    }
+}
 /**
  * Parse Ollama reranker response to extract relevance score
  * Uses model-specific parsing logic for better accuracy

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "n8n-nodes-ollama-reranker",
-  "version": "1.3.2",
-  "description": "Ollama Reranker for n8n - Dynamic model loading + Ollama/Custom API support (Vector Store provider + workflow node)",
+  "version": "1.4.0",
+  "description": "Ollama Reranker for n8n - VL Classifier integration + Auto-detect + Dynamic model loading (Vector Store provider + workflow node)",
   "main": "index.js",
   "author": "Gabriel BRUMENT",
   "license": "MIT",