n8n-nodes-ollama-reranker 1.1.0 → 1.3.0

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

@@ -1,4 +1,4 @@
-import { ISupplyDataFunctions, SupplyData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+import { ILoadOptionsFunctions, INodePropertyOptions, ISupplyDataFunctions, SupplyData, INodeType, INodeTypeDescription } from 'n8n-workflow';
 /**
  * Ollama Reranker Provider
  *
@@ -12,6 +12,15 @@ import { ISupplyDataFunctions, SupplyData, INodeType, INodeTypeDescription } fro
  */
 export declare class OllamaReranker implements INodeType {
     description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            /**
+             * Load models from Ollama/Custom Rerank API
+             * Dynamically fetches available models from /api/tags endpoint
+             */
+            getModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
     /**
      * Supply Data Method (NOT execute!)
      *

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

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OllamaReranker = void 0;
 const n8n_workflow_1 = require("n8n-workflow");
+const reranker_logic_1 = require("../shared/reranker-logic");
 /**
  * Ollama Reranker Provider
  *
@@ -55,48 +56,30 @@ class OllamaReranker {
                     displayName: 'Model',
                     name: 'model',
                     type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getModels',
+                    },
+                    default: '',
+                    description: 'The reranker model to use - models are loaded from your configured Ollama/Custom API',
+                },
+                {
+                    displayName: 'API Type',
+                    name: 'apiType',
+                    type: 'options',
                     options: [
                         {
-                            name: 'BGE Reranker v2-M3 (Recommended)',
-                            value: 'bge-reranker-v2-m3',
-                            description: 'Best general-purpose reranker, excellent balance of speed and accuracy',
-                        },
-                        {
-                            name: 'Qwen3-Reranker-0.6B (Fast)',
-                            value: 'dengcao/Qwen3-Reranker-0.6B:Q5_K_M',
-                            description: 'Fastest option, best for resource-limited environments',
-                        },
-                        {
-                            name: 'Qwen3-Reranker-4B (Balanced)',
-                            value: 'dengcao/Qwen3-Reranker-4B:Q5_K_M',
-                            description: 'Recommended for Qwen family - best balance of speed and accuracy',
+                            name: 'Ollama Generate API',
+                            value: 'ollama',
+                            description: 'Standard Ollama /api/generate endpoint (for BGE, Qwen prompt-based rerankers)',
                         },
                         {
-                            name: 'Qwen3-Reranker-8B (Most Accurate)',
-                            value: 'dengcao/Qwen3-Reranker-8B:Q5_K_M',
-                            description: 'Highest accuracy, requires more resources',
-                        },
-                        {
-                            name: 'Custom Model',
+                            name: 'Custom Rerank API',
                             value: 'custom',
-                            description: 'Specify your own Ollama reranker model',
+                            description: 'Custom /api/rerank endpoint (for deposium-embeddings-turbov2, etc.)',
                         },
                     ],
-                    default: 'bge-reranker-v2-m3',
-                    description: 'The Ollama reranker model to use',
-                },
-                {
-                    displayName: 'Custom Model Name',
-                    name: 'customModel',
-                    type: 'string',
-                    default: '',
-                    placeholder: 'your-reranker-model:tag',
-                    description: 'Name of your custom Ollama reranker model',
-                    displayOptions: {
-                        show: {
-                            model: ['custom'],
-                        },
-                    },
+                    default: 'ollama',
+                    description: 'Which API endpoint to use for reranking',
                 },
                 {
                     displayName: 'Top K',
@@ -168,6 +151,47 @@ class OllamaReranker {
                 },
             ],
         };
+        this.methods = {
+            loadOptions: {
+                /**
+                 * Load models from Ollama/Custom Rerank API
+                 * Dynamically fetches available models from /api/tags endpoint
+                 */
+                async getModels() {
+                    const credentials = await this.getCredentials('ollamaApi');
+                    if (!(credentials === null || credentials === void 0 ? void 0 : credentials.host)) {
+                        return [];
+                    }
+                    const baseUrl = credentials.host.replace(/\/$/, '');
+                    try {
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${baseUrl}/api/tags`,
+                            json: true,
+                            timeout: 5000,
+                        });
+                        if (!(response === null || response === void 0 ? void 0 : response.models) || !Array.isArray(response.models)) {
+                            return [];
+                        }
+                        // Sort models alphabetically
+                        const models = response.models.sort((a, b) => {
+                            const nameA = a.name || '';
+                            const nameB = b.name || '';
+                            return nameA.localeCompare(nameB);
+                        });
+                        return models.map((model) => ({
+                            name: model.name,
+                            value: model.name,
+                            description: model.details || `Size: ${Math.round((model.size || 0) / 1024 / 1024)}MB`,
+                        }));
+                    }
+                    catch (error) {
+                        // If API call fails, return empty array (user can still type model name manually)
+                        return [];
+                    }
+                },
+            },
+        };
     }
     /**
      * Supply Data Method (NOT execute!)
@@ -180,13 +204,11 @@ class OllamaReranker {
         this.logger.debug('Initializing Ollama Reranker Provider');
         const self = this;
         // Get node parameters once (provider nodes use index 0)
-        let model = this.getNodeParameter('model', 0);
-        if (model === 'custom') {
-            model = this.getNodeParameter('customModel', 0);
-            if (!(model === null || model === void 0 ? void 0 : model.trim())) {
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Custom model name is required when "Custom Model" is selected');
-            }
+        const model = this.getNodeParameter('model', 0);
+        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');
         const instruction = this.getNodeParameter('instruction', 0);
         const additionalOptions = this.getNodeParameter('additionalOptions', 0, {});
         const timeout = (_a = additionalOptions.timeout) !== null && _a !== void 0 ? _a : 30000;
@@ -261,8 +283,8 @@ class OllamaReranker {
                 });
                 self.logger.debug(`Reranking ${processedDocs.length} documents with model: ${model}`);
                 try {
-                    // Rerank documents using Ollama
-                    const rerankedDocs = await rerankDocuments(self, {
+                    // Rerank documents using Ollama or Custom API
+                    const rerankedDocs = await (0, reranker_logic_1.rerankDocuments)(self, {
                         ollamaHost,
                         model,
                         query,
@@ -273,6 +295,7 @@ class OllamaReranker {
                         batchSize,
                         timeout,
                         includeOriginalScores,
+                        apiType,
                     });
                     self.logger.debug(`Reranking complete: ${rerankedDocs.length} documents returned`);
                     // Log output for n8n execution tracking
@@ -310,277 +333,3 @@ class OllamaReranker {
     }
 }
 exports.OllamaReranker = OllamaReranker;
-/**
- * Rerank documents using Ollama reranker model
- */
-async function rerankDocuments(context, config) {
-    const { ollamaHost, model, query, documents, instruction, topK, threshold, batchSize, timeout, includeOriginalScores } = config;
-    const results = [];
-    // Process all documents concurrently with controlled concurrency
-    const promises = [];
-    for (let i = 0; i < documents.length; i++) {
-        const doc = documents[i];
-        const promise = scoreDocument(context, ollamaHost, model, query, doc.pageContent, instruction, timeout).then(score => ({
-            index: i,
-            score,
-        }));
-        promises.push(promise);
-        // Process in batches to avoid overwhelming the API
-        if (promises.length >= batchSize || i === documents.length - 1) {
-            const batchResults = await Promise.all(promises);
-            results.push(...batchResults);
-            promises.length = 0; // Clear the array
-        }
-    }
-    // Filter by threshold and sort by score (descending)
-    const filteredResults = results
-        .filter(r => r.score >= threshold)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, topK);
-    // Map back to original documents with scores
-    return filteredResults.map(result => {
-        const originalDoc = documents[result.index];
-        const rerankedDoc = {
-            ...originalDoc,
-            _rerankScore: result.score,
-            _originalIndex: result.index,
-        };
-        if (includeOriginalScores && originalDoc._originalScore !== undefined) {
-            rerankedDoc._originalScore = originalDoc._originalScore;
-        }
-        return rerankedDoc;
-    });
-}
-/**
- * Score a single document against the query using Ollama reranker model with retry logic
- */
-async function scoreDocument(context, ollamaHost, model, query, documentContent, instruction, timeout) {
-    var _a, _b, _c, _d;
-    // Format prompt based on model type
-    const prompt = formatRerankerPrompt(model, query, documentContent, instruction);
-    const maxRetries = 3;
-    let lastError;
-    for (let attempt = 0; attempt < maxRetries; attempt++) {
-        try {
-            // Use Ollama /api/generate endpoint for reranker models
-            const response = await context.helpers.httpRequest({
-                method: 'POST',
-                url: `${ollamaHost}/api/generate`,
-                headers: {
-                    'Content-Type': 'application/json',
-                    Accept: 'application/json',
-                },
-                body: {
-                    model,
-                    prompt,
-                    stream: false,
-                    options: {
-                        temperature: 0.0, // Deterministic scoring
-                    },
-                },
-                json: true,
-                timeout,
-            });
-            // Parse the response to extract relevance score
-            const score = parseRerankerResponse(model, response);
-            return score;
-        }
-        catch (error) {
-            lastError = error;
-            // Don't retry on permanent errors
-            if (((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.statusCode) === 404 || ((_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.statusCode) === 400) {
-                break;
-            }
-            // Retry on transient errors (timeout, 5xx, network issues)
-            if (attempt < maxRetries - 1) {
-                const isTransient = (error === null || error === void 0 ? void 0 : error.name) === 'AbortError' ||
-                    (error === null || error === void 0 ? void 0 : error.code) === 'ETIMEDOUT' ||
-                    ((_c = error === null || error === void 0 ? void 0 : error.response) === null || _c === void 0 ? void 0 : _c.statusCode) >= 500;
-                if (isTransient) {
-                    // Exponential backoff: 100ms, 200ms, 400ms
-                    await new Promise(resolve => setTimeout(resolve, 100 * Math.pow(2, attempt)));
-                    continue;
-                }
-            }
-            break;
-        }
-    }
-    // Handle final error after retries
-    const error = lastError;
-    if ((error === null || error === void 0 ? void 0 : error.name) === 'AbortError' || (error === null || error === void 0 ? void 0 : error.code) === 'ETIMEDOUT') {
-        throw new n8n_workflow_1.NodeApiError(context.getNode(), error, {
-            message: `Request timeout after ${timeout}ms (tried ${maxRetries} times)`,
-            description: `Model: ${model}\nEndpoint: ${ollamaHost}/api/generate`,
-        });
-    }
-    if ((_d = error === null || error === void 0 ? void 0 : error.response) === null || _d === void 0 ? void 0 : _d.body) {
-        throw new n8n_workflow_1.NodeApiError(context.getNode(), error, {
-            message: `Ollama API Error (${error.response.statusCode})`,
-            description: `Endpoint: ${ollamaHost}/api/generate\nModel: ${model}\nResponse: ${JSON.stringify(error.response.body, null, 2)}`,
-        });
-    }
-    throw new n8n_workflow_1.NodeApiError(context.getNode(), error, {
-        message: 'Ollama reranking request failed',
-        description: `Endpoint: ${ollamaHost}/api/generate\nModel: ${model}\nError: ${error.message}`,
-    });
-}
-/**
- * Format prompt based on reranker model type
- *
- * Different models expect different prompt formats:
- * - BGE Reranker: Simple query + document format
- * - Qwen3-Reranker: Structured chat format with system/user/assistant tags
- */
-function formatRerankerPrompt(model, query, documentContent, instruction) {
-    // Detect model type
-    const isBGE = model.toLowerCase().includes('bge');
-    const isQwen = model.toLowerCase().includes('qwen');
-    if (isBGE) {
-        // BGE Reranker uses a simple format
-        // See: https://huggingface.co/BAAI/bge-reranker-v2-m3
-        return `Instruction: ${instruction}
-
-Query: ${query}
-
-Document: ${documentContent}
-
-Relevance:`;
-    }
-    else if (isQwen) {
-        // Qwen3-Reranker uses structured chat format
-        // See: https://huggingface.co/dengcao/Qwen3-Reranker-4B
-        return `<|im_start|>system
-Judge whether the Document meets the requirements based on the Query and the Instruct provided. Note that the answer can only be "yes" or "no".<|im_end|>
-<|im_start|>user
-<Instruct>: ${instruction}
-<Query>: ${query}
-<Document>: ${documentContent}<|im_end|>
-<|im_start|>assistant
-<think>`;
-    }
-    // Default format for unknown models (similar to BGE)
-    return `Task: ${instruction}
-
-Query: ${query}
-
-Document: ${documentContent}
-
-Score:`;
-}
-/**
- * Parse BGE model response to extract relevance score
- */
-function parseBGEScore(output, outputLower) {
-    // Try to extract floating point number
-    const scoreRegex = /(\d*\.?\d+)/;
-    const scoreMatch = scoreRegex.exec(output);
-    if (scoreMatch) {
-        const score = parseFloat(scoreMatch[1]);
-        // BGE returns scores in various ranges, normalize to 0-1
-        if (score > 1 && score <= 10) {
-            return score / 10;
-        }
-        else if (score > 10) {
-            return score / 100;
-        }
-        return Math.min(Math.max(score, 0), 1); // Clamp to 0-1
-    }
-    // Fallback: check for keywords
-    if (outputLower.includes('high') || outputLower.includes('relevant')) {
-        return 0.8;
-    }
-    if (outputLower.includes('low') || outputLower.includes('irrelevant')) {
-        return 0.2;
-    }
-    return null;
-}
-/**
- * Parse Qwen model response to extract relevance score
- */
-function parseQwenScore(output, outputLower) {
-    // Look for explicit yes/no in the response
-    const yesRegex = /\b(yes|relevant|positive|match)\b/;
-    const noRegex = /\b(no|irrelevant|negative|not\s+relevant)\b/;
-    const yesMatch = yesRegex.exec(outputLower);
-    const noMatch = noRegex.exec(outputLower);
-    if (yesMatch && !noMatch) {
-        // Higher confidence for detailed explanations
-        const hasReasoning = output.length > 100;
-        const hasMultiplePositives = (output.match(/relevant|yes|match/gi) || []).length > 1;
-        if (hasReasoning && hasMultiplePositives)
-            return 0.95;
-        if (hasReasoning)
-            return 0.85;
-        return 0.75;
-    }
-    if (noMatch && !yesMatch) {
-        // Low scores for negative responses
-        const hasStrongNegative = outputLower.includes('completely') ||
-            outputLower.includes('totally') ||
-            outputLower.includes('not at all');
-        return hasStrongNegative ? 0.05 : 0.15;
-    }
-    // Mixed signals - check which appears first
-    if (yesMatch && noMatch) {
-        const yesIndex = output.toLowerCase().indexOf(yesMatch[0]);
-        const noIndex = output.toLowerCase().indexOf(noMatch[0]);
-        return yesIndex < noIndex ? 0.6 : 0.4;
-    }
-    return null;
-}
-/**
- * Parse generic model response with fallback logic
- */
-function parseGenericScore(output, outputLower) {
-    // Try numeric extraction first
-    const numericRegex = /(\d*\.?\d+)/;
-    const numericMatch = numericRegex.exec(output);
-    if (numericMatch) {
-        const score = parseFloat(numericMatch[1]);
-        if (score >= 0 && score <= 1)
-            return score;
-        if (score > 1 && score <= 10)
-            return score / 10;
-        if (score > 10 && score <= 100)
-            return score / 100;
-    }
-    // Keyword-based scoring
-    const positiveKeywords = ['relevant', 'yes', 'high', 'strong', 'good', 'match', 'related'];
-    const negativeKeywords = ['irrelevant', 'no', 'low', 'weak', 'poor', 'unrelated', 'different'];
-    const positiveCount = positiveKeywords.filter(kw => outputLower.includes(kw)).length;
-    const negativeCount = negativeKeywords.filter(kw => outputLower.includes(kw)).length;
-    if (positiveCount > negativeCount) {
-        return 0.5 + (positiveCount * 0.1);
-    }
-    else if (negativeCount > positiveCount) {
-        return 0.5 - (negativeCount * 0.1);
-    }
-    // Default to neutral if completely ambiguous
-    return 0.5;
-}
-/**
- * Parse Ollama reranker response to extract relevance score
- * Uses model-specific parsing logic for better accuracy
- */
-function parseRerankerResponse(model, response) {
-    if (!(response === null || response === void 0 ? void 0 : response.response)) {
-        return 0.0;
-    }
-    const output = response.response;
-    const outputLower = output.toLowerCase();
-    const isBGE = model.toLowerCase().includes('bge');
-    const isQwen = model.toLowerCase().includes('qwen');
-    // Try model-specific parsers
-    if (isBGE) {
-        const score = parseBGEScore(output, outputLower);
-        if (score !== null)
-            return score;
-    }
-    if (isQwen) {
-        const score = parseQwenScore(output, outputLower);
-        if (score !== null)
-            return score;
-    }
-    // Fallback to generic parsing
-    return parseGenericScore(output, outputLower);
-}

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

@@ -1,4 +1,4 @@
-import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription } from 'n8n-workflow';
+import { IExecuteFunctions, ILoadOptionsFunctions, INodeExecutionData, INodePropertyOptions, INodeType, INodeTypeDescription } from 'n8n-workflow';
 /**
  * Ollama Reranker Workflow Node
  *
@@ -13,6 +13,15 @@ import { IExecuteFunctions, INodeExecutionData, INodeType, INodeTypeDescription
  */
 export declare class OllamaRerankerWorkflow implements INodeType {
     description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            /**
+             * Load models from Ollama/Custom Rerank API
+             * Dynamically fetches available models from /api/tags endpoint
+             */
+            getModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
     /**
      * Execute Method (NOT supplyData!)
      *

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

@@ -53,53 +53,36 @@ class OllamaRerankerWorkflow {
                 },
             ],
             properties: [
-                // Model selection (same as provider node)
+                // Model selection with dynamic loading
                 {
                     displayName: 'Model',
                     name: 'model',
                     type: 'options',
+                    typeOptions: {
+                        loadOptionsMethod: 'getModels',
+                    },
+                    default: '',
+                    description: 'The reranker model to use - models are loaded from your configured Ollama/Custom API',
+                },
+                // API Type selection
+                {
+                    displayName: 'API Type',
+                    name: 'apiType',
+                    type: 'options',
                     options: [
                         {
-                            name: 'BGE Reranker v2-M3 (Recommended)',
-                            value: 'bge-reranker-v2-m3',
-                            description: 'Best general-purpose reranker',
-                        },
-                        {
-                            name: 'Qwen3-Reranker-0.6B (Fast)',
-                            value: 'dengcao/Qwen3-Reranker-0.6B:Q5_K_M',
-                            description: 'Fastest option',
-                        },
-                        {
-                            name: 'Qwen3-Reranker-4B (Balanced)',
-                            value: 'dengcao/Qwen3-Reranker-4B:Q5_K_M',
-                            description: 'Best balance',
+                            name: 'Ollama Generate API',
+                            value: 'ollama',
+                            description: 'Standard Ollama /api/generate endpoint (for BGE, Qwen prompt-based rerankers)',
                         },
                         {
-                            name: 'Qwen3-Reranker-8B (Most Accurate)',
-                            value: 'dengcao/Qwen3-Reranker-8B:Q5_K_M',
-                            description: 'Highest accuracy',
-                        },
-                        {
-                            name: 'Custom Model',
+                            name: 'Custom Rerank API',
                             value: 'custom',
-                            description: 'Specify your own model',
+                            description: 'Custom /api/rerank endpoint (for deposium-embeddings-turbov2, etc.)',
                         },
                     ],
-                    default: 'bge-reranker-v2-m3',
-                    description: 'Ollama reranker model to use',
-                },
-                {
-                    displayName: 'Custom Model Name',
-                    name: 'customModel',
-                    type: 'string',
-                    default: '',
-                    placeholder: 'your-reranker-model:tag',
-                    description: 'Name of your custom Ollama reranker model',
-                    displayOptions: {
-                        show: {
-                            model: ['custom'],
-                        },
-                    },
+                    default: 'ollama',
+                    description: 'Which API endpoint to use for reranking',
                 },
                 // Query input (flexible like n8n nodes)
                 {
@@ -269,6 +252,47 @@ class OllamaRerankerWorkflow {
                 },
             ],
         };
+        this.methods = {
+            loadOptions: {
+                /**
+                 * Load models from Ollama/Custom Rerank API
+                 * Dynamically fetches available models from /api/tags endpoint
+                 */
+                async getModels() {
+                    const credentials = await this.getCredentials('ollamaApi');
+                    if (!(credentials === null || credentials === void 0 ? void 0 : credentials.host)) {
+                        return [];
+                    }
+                    const baseUrl = credentials.host.replace(/\/$/, '');
+                    try {
+                        const response = await this.helpers.httpRequest({
+                            method: 'GET',
+                            url: `${baseUrl}/api/tags`,
+                            json: true,
+                            timeout: 5000,
+                        });
+                        if (!(response === null || response === void 0 ? void 0 : response.models) || !Array.isArray(response.models)) {
+                            return [];
+                        }
+                        // Sort models alphabetically
+                        const models = response.models.sort((a, b) => {
+                            const nameA = a.name || '';
+                            const nameB = b.name || '';
+                            return nameA.localeCompare(nameB);
+                        });
+                        return models.map((model) => ({
+                            name: model.name,
+                            value: model.name,
+                            description: model.details || `Size: ${Math.round((model.size || 0) / 1024 / 1024)}MB`,
+                        }));
+                    }
+                    catch (error) {
+                        // If API call fails, return empty array (user can still type model name manually)
+                        return [];
+                    }
+                },
+            },
+        };
     }
     /**
      * Execute Method (NOT supplyData!)
@@ -287,13 +311,12 @@ class OllamaRerankerWorkflow {
         }
         const ollamaHost = credentials.host.replace(/\/$/, '');
         // Get model
-        let model = this.getNodeParameter('model', 0);
-        if (model === 'custom') {
-            model = this.getNodeParameter('customModel', 0);
-            if (!(model === null || model === void 0 ? void 0 : model.trim())) {
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Custom model name is required');
-            }
+        const model = this.getNodeParameter('model', 0);
+        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 common parameters
         const instruction = this.getNodeParameter('instruction', 0);
         const topK = this.getNodeParameter('topK', 0);
@@ -380,6 +403,7 @@ class OllamaRerankerWorkflow {
                     batchSize,
                     timeout,
                     includeOriginalScores,
+                    apiType,
                 });
                 // Format output
                 let output;

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

@@ -11,9 +11,10 @@ export interface RerankConfig {
     batchSize: number;
     timeout: number;
     includeOriginalScores: boolean;
+    apiType?: 'ollama' | 'custom';
 }
 /**
- * Rerank documents using Ollama reranker model
+ * Rerank documents using Ollama reranker model or Custom Rerank API
  */
 export declare function rerankDocuments(context: RerankerContext, config: RerankConfig): Promise<any[]>;
 export {};

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

@@ -3,10 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.rerankDocuments = rerankDocuments;
 const n8n_workflow_1 = require("n8n-workflow");
 /**
- * Rerank documents using Ollama reranker model
+ * 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 } = config;
+    const { ollamaHost, model, query, documents, instruction, topK, threshold, batchSize, timeout, includeOriginalScores, apiType = 'ollama' } = config;
+    // Use Custom Rerank API if specified
+    if (apiType === 'custom') {
+        return await rerankWithCustomAPI(context, config);
+    }
+    // Otherwise use Ollama Generate API (original logic)
     const results = [];
     // Process all documents concurrently with controlled concurrency
     const promises = [];
@@ -43,6 +48,77 @@ async function rerankDocuments(context, config) {
         return rerankedDoc;
     });
 }
+/**
+ * Rerank documents using Custom Rerank API (/api/rerank endpoint)
+ * This is for services like deposium-embeddings-turbov2 that implement
+ * a custom /api/rerank endpoint with direct cosine similarity scoring
+ */
+async function rerankWithCustomAPI(context, config) {
+    var _a, _b;
+    const { ollamaHost, model, query, documents, topK, threshold, timeout, includeOriginalScores } = config;
+    try {
+        // Extract document content as strings
+        const documentStrings = documents.map(doc => doc.pageContent || JSON.stringify(doc));
+        // Call /api/rerank endpoint
+        const response = await context.helpers.httpRequest({
+            method: 'POST',
+            url: `${ollamaHost}/api/rerank`,
+            headers: {
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+            },
+            body: {
+                model,
+                query,
+                documents: documentStrings,
+                top_k: topK, // Custom API handles top_k filtering
+            },
+            json: true,
+            timeout,
+        });
+        // Parse response: { model: "...", results: [{index, document, relevance_score}] }
+        if (!(response === null || response === void 0 ? void 0 : response.results) || !Array.isArray(response.results)) {
+            throw new n8n_workflow_1.NodeApiError(context.getNode(), response, {
+                message: 'Invalid response from Custom Rerank API',
+                description: `Expected {results: [...]} but got: ${JSON.stringify(response)}`,
+            });
+        }
+        // Filter by threshold and map to our format
+        const filteredResults = response.results
+            .filter((r) => r.relevance_score >= threshold)
+            .map((result) => {
+            const originalDoc = documents[result.index];
+            const rerankedDoc = {
+                ...originalDoc,
+                _rerankScore: result.relevance_score,
+                _originalIndex: result.index,
+            };
+            if (includeOriginalScores && originalDoc._originalScore !== undefined) {
+                rerankedDoc._originalScore = originalDoc._originalScore;
+            }
+            return rerankedDoc;
+        });
+        return filteredResults;
+    }
+    catch (error) {
+        if (((_a = error === null || error === void 0 ? void 0 : error.response) === null || _a === void 0 ? void 0 : _a.statusCode) === 404) {
+            throw new n8n_workflow_1.NodeApiError(context.getNode(), error, {
+                message: 'Custom Rerank API endpoint not found',
+                description: `The /api/rerank endpoint was not found at ${ollamaHost}.\nMake sure you're using a service that supports this endpoint (like deposium-embeddings-turbov2).`,
+            });
+        }
+        if ((_b = error === null || error === void 0 ? void 0 : error.response) === null || _b === void 0 ? void 0 : _b.body) {
+            throw new n8n_workflow_1.NodeApiError(context.getNode(), error, {
+                message: `Custom Rerank API Error (${error.response.statusCode})`,
+                description: `Endpoint: ${ollamaHost}/api/rerank\nModel: ${model}\nResponse: ${JSON.stringify(error.response.body, null, 2)}`,
+            });
+        }
+        throw new n8n_workflow_1.NodeApiError(context.getNode(), error, {
+            message: 'Custom Rerank API request failed',
+            description: `Endpoint: ${ollamaHost}/api/rerank\nModel: ${model}\nError: ${error.message}`,
+        });
+    }
+}
 /**
  * Score a single document against the query using Ollama reranker model with retry logic
  */

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "n8n-nodes-ollama-reranker",
-  "version": "1.1.0",
-  "description": "Ollama Reranker for n8n - Vector Store provider + chainable workflow node with AI Agent tool support",
+  "version": "1.3.0",
+  "description": "Ollama Reranker for n8n - Dynamic model loading + Ollama/Custom API support (Vector Store provider + workflow node)",
   "main": "index.js",
   "author": "Gabriel BRUMENT",
   "license": "MIT",