n8n-nodes-berget-mk 0.2.1 → 0.4.0

package/README.md

@@ -2,18 +2,13 @@
 
 n8n community nodes for [Berget AI](https://berget.ai), packaged as a single installable module. Maintained by Micke Kring.
 
-Includes:
+Three nodes:
 
-- **Berget AI Chat** — one-shot chat completions (action node)
+- **Berget AI** — multi-resource action node for one-shot calls: **Chat** (completions, classification), **OCR** (document text extraction), **Rerank** (document reranking), and **Speech to Text** (Swedish-tuned KB-Whisper). Can also be exposed as a tool to an AI Agent.
 - **Berget AI Chat Model** — sub-node that plugs into n8n's built-in **AI Agent**, **Basic LLM Chain**, and other LangChain-based nodes. Exposes `reasoning_effort` and the full standard LLM parameter set.
-- **Berget AI Embeddings** — create text embeddings
-- **Berget AI OCR** — document text extraction (PDF, DOCX, images)
-- **Berget AI Speech-to-Text** — audio transcription (KB-Whisper for Swedish)
-- **Berget AI Rerank** — document reranking
+- **Berget AI Embeddings Model** — sub-node that plugs into n8n's **Vector Store** nodes (Supabase, Qdrant, Pinecone, PGVector, etc.) and **Question and Answer Chain**.
 
-> ⚠️ **Experimental — actively developed.** This package is pre-1.0 and the shape of individual nodes may change between minor releases. Pin a specific version in production workflows until `1.0.0`.
->
-> **Breaking change in `0.2.0`:** the home-built `Berget AI Agent` node was removed and replaced with a `Berget AI Chat Model` sub-node that plugs into n8n's built-in **AI Agent**. See [CHANGELOG.md](CHANGELOG.md) for migration notes.
+> ⚠️ **Experimental — actively developed.** This package is pre-1.0 and may break between minor releases. Pin a specific version in production workflows until `1.0.0`. See [CHANGELOG.md](CHANGELOG.md) for breaking changes.
 
 ## Install
 
@@ -25,13 +20,31 @@ n8n-nodes-berget-mk
 
 Then add a **Berget AI API** credential with your API key from [berget.ai](https://berget.ai).
 
-## Using Berget with n8n's AI Agent
+## Typical workflows
 
-1. Add n8n's built-in **AI Agent** node to your workflow.
-2. Add a **Berget AI Chat Model** node and drag it onto the canvas below the Agent.
-3. Connect it to the Agent's **Chat Model** socket.
-4. Select a Berget AI chat model (the list loads live from the API).
-5. Optionally add Memory and Tool sub-nodes — they work as normal with Berget as the underlying LLM.
+### One-shot chat / classification
+
+1. Drop **Berget AI** onto the canvas, pick Resource = **Chat**, select a model, add a user message. Execute.
+
+### Agent with tools and memory
+
+1. Add n8n's built-in **AI Agent**.
+2. Add **Berget AI Chat Model** and connect it to the Agent's Chat Model socket.
+3. Add Memory and Tool sub-nodes as needed — they work with Berget as the underlying LLM.
+
+### RAG / vector search
+
+1. Add a Vector Store node (Supabase, Qdrant, etc.) or a Question and Answer Chain.
+2. Add **Berget AI Embeddings Model** and connect it to the Embedding socket.
+3. Index documents or query as usual.
+
+### Document extraction
+
+1. Drop **Berget AI** onto the canvas, pick Resource = **OCR**, provide a document URL or base64 data, and pick your output format (Markdown or JSON).
+
+### Swedish speech transcription
+
+1. Drop **Berget AI** onto the canvas, pick Resource = **Speech to Text**, pick a model (defaults to `KB-Whisper-Large`), and point at an audio file.
 
 ## Changelog
 

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

@@ -0,0 +1,12 @@
+import { type IExecuteFunctions, type ILoadOptionsFunctions, type INodeExecutionData, type INodePropertyOptions, type INodeType, type INodeTypeDescription } from 'n8n-workflow';
+export declare class BergetAi implements INodeType {
+    description: INodeTypeDescription;
+    methods: {
+        loadOptions: {
+            getChatModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getRerankModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+            getSpeechModels(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]>;
+        };
+    };
+    execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
+}

package/dist/nodes/BergetAi/BergetAi.node.js

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BergetAi = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const n8n_workflow_2 = require("n8n-workflow");
+const chat_1 = require("./chat");
+const ocr_1 = require("./ocr");
+const rerank_1 = require("./rerank");
+const speech_1 = require("./speech");
+const shared_1 = require("./shared");
+class BergetAi {
+    constructor() {
+        this.description = {
+            displayName: 'Berget AI',
+            name: 'bergetAi',
+            icon: 'file:bergetai.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["resource"]}}',
+            description: 'Use Berget AI for chat completions, document OCR, speech-to-text, and document reranking',
+            defaults: { name: 'Berget AI' },
+            usableAsTool: true,
+            codex: {
+                alias: ['Berget', 'Berget AI', 'Swedish AI', 'LLM', 'KB-Whisper'],
+                categories: ['AI'],
+                subcategories: {
+                    AI: ['Agents', 'Miscellaneous', 'Root Nodes'],
+                },
+            },
+            credentials: [
+                {
+                    name: 'bergetAiApi',
+                    required: true,
+                },
+            ],
+            inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    default: 'chat',
+                    options: [
+                        {
+                            name: 'Chat',
+                            value: 'chat',
+                            description: 'Create a chat completion',
+                        },
+                        {
+                            name: 'OCR',
+                            value: 'ocr',
+                            description: 'Extract text from a document (PDF, DOCX, images)',
+                        },
+                        {
+                            name: 'Rerank',
+                            value: 'rerank',
+                            description: 'Rerank documents by relevance to a query',
+                        },
+                        {
+                            name: 'Speech to Text',
+                            value: 'speech',
+                            description: 'Transcribe audio to text',
+                        },
+                    ],
+                },
+                ...chat_1.chatProperties,
+                ...ocr_1.ocrProperties,
+                ...rerank_1.rerankProperties,
+                ...speech_1.speechProperties,
+            ],
+        };
+        this.methods = {
+            loadOptions: {
+                async getChatModels() {
+                    return (0, shared_1.loadModelOptions)(this, (m) => m.model_type === 'text' || m.model_type === 'ocr');
+                },
+                async getRerankModels() {
+                    return (0, shared_1.loadModelOptions)(this, (m) => m.model_type === 'rerank');
+                },
+                async getSpeechModels() {
+                    return (0, shared_1.loadModelOptions)(this, (m) => m.model_type === 'speech-to-text');
+                },
+            },
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const resource = this.getNodeParameter('resource', i);
+                let result;
+                switch (resource) {
+                    case 'chat':
+                        result = await (0, chat_1.executeChat)(this, i);
+                        break;
+                    case 'ocr':
+                        result = await (0, ocr_1.executeOcr)(this, i);
+                        break;
+                    case 'rerank':
+                        result = await (0, rerank_1.executeRerank)(this, i);
+                        break;
+                    case 'speech':
+                        result = await (0, speech_1.executeSpeech)(this, i);
+                        break;
+                    default:
+                        throw new n8n_workflow_2.NodeOperationError(this.getNode(), `Unknown resource: ${resource}`, { itemIndex: i });
+                }
+                returnData.push({
+                    json: result,
+                    pairedItem: { item: i },
+                });
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            error: error instanceof Error ? error.message : String(error),
+                        },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.BergetAi = BergetAi;

package/dist/nodes/BergetAi/chat.d.ts

@@ -0,0 +1,3 @@
+import type { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+export declare const chatProperties: INodeProperties[];
+export declare function executeChat(context: IExecuteFunctions, itemIndex: number): Promise<IDataObject>;

package/dist/nodes/BergetAi/chat.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatProperties = void 0;
+exports.executeChat = executeChat;
+const n8n_workflow_1 = require("n8n-workflow");
+const shared_1 = require("./shared");
+const showForChat = {
+    displayOptions: {
+        show: {
+            resource: ['chat'],
+        },
+    },
+};
+exports.chatProperties = [
+    {
+        displayName: 'Model',
+        name: 'chatModel',
+        type: 'options',
+        typeOptions: { loadOptionsMethod: 'getChatModels' },
+        default: '',
+        required: true,
+        description: 'The Berget AI chat model to use',
+        ...showForChat,
+    },
+    {
+        displayName: 'Messages',
+        name: 'chatMessages',
+        type: 'fixedCollection',
+        typeOptions: { multipleValues: true },
+        default: {
+            values: [{ role: 'user', content: '' }],
+        },
+        options: [
+            {
+                displayName: 'Values',
+                name: 'values',
+                values: [
+                    {
+                        displayName: 'Role',
+                        name: 'role',
+                        type: 'options',
+                        options: [
+                            { name: 'System', value: 'system' },
+                            { name: 'User', value: 'user' },
+                            { name: 'Assistant', value: 'assistant' },
+                        ],
+                        default: 'user',
+                    },
+                    {
+                        displayName: 'Content',
+                        name: 'content',
+                        type: 'string',
+                        typeOptions: { rows: 2 },
+                        default: '',
+                        description: 'Message content',
+                    },
+                ],
+            },
+        ],
+        ...showForChat,
+    },
+    {
+        displayName: 'Options',
+        name: 'chatOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        options: [
+            {
+                displayName: 'Max Tokens',
+                name: 'max_tokens',
+                type: 'number',
+                typeOptions: { minValue: 1 },
+                default: 1024,
+                description: 'Maximum number of tokens to generate',
+            },
+            {
+                displayName: 'Response Format',
+                name: 'response_format',
+                type: 'options',
+                options: [
+                    { name: 'Text', value: 'text' },
+                    { name: 'JSON Object', value: 'json_object' },
+                ],
+                default: 'text',
+            },
+            {
+                displayName: 'Temperature',
+                name: 'temperature',
+                type: 'number',
+                typeOptions: { minValue: 0, maxValue: 2, numberPrecision: 2 },
+                default: 1,
+                description: 'Controls randomness. Lower is more deterministic.',
+            },
+            {
+                displayName: 'Top P',
+                name: 'top_p',
+                type: 'number',
+                typeOptions: { minValue: 0, maxValue: 1, numberPrecision: 2 },
+                default: 1,
+                description: 'Nucleus sampling cutoff',
+            },
+            {
+                displayName: 'User ID',
+                name: 'user',
+                type: 'string',
+                default: '',
+                description: 'Unique identifier for tracking and abuse prevention',
+            },
+        ],
+        ...showForChat,
+    },
+];
+async function executeChat(context, itemIndex) {
+    var _a, _b;
+    const credentials = await context.getCredentials('bergetAiApi');
+    const model = context.getNodeParameter('chatModel', itemIndex);
+    const messages = context.getNodeParameter('chatMessages.values', itemIndex, []);
+    const options = context.getNodeParameter('chatOptions', itemIndex, {});
+    const body = {
+        model,
+        messages,
+        ...options,
+    };
+    if (options.response_format === 'json_object') {
+        body.response_format = { type: 'json_object' };
+    }
+    else {
+        delete body.response_format;
+    }
+    const { status, data } = await (0, shared_1.bergetRequest)(credentials.apiKey, 'POST', '/chat/completions', body);
+    if (status !== 200) {
+        const message = (_b = (_a = data === null || data === void 0 ? void 0 : data.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : `HTTP ${status}`;
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Berget AI chat error: ${message}`, {
+            itemIndex,
+        });
+    }
+    return data;
+}

package/dist/nodes/BergetAi/ocr.d.ts

@@ -0,0 +1,3 @@
+import type { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+export declare const ocrProperties: INodeProperties[];
+export declare function executeOcr(context: IExecuteFunctions, itemIndex: number): Promise<IDataObject>;

package/dist/nodes/BergetAi/ocr.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ocrProperties = void 0;
+exports.executeOcr = executeOcr;
+const n8n_workflow_1 = require("n8n-workflow");
+const shared_1 = require("./shared");
+const showForOcr = {
+    displayOptions: {
+        show: {
+            resource: ['ocr'],
+        },
+    },
+};
+exports.ocrProperties = [
+    {
+        displayName: 'Document Type',
+        name: 'ocrDocumentType',
+        type: 'options',
+        options: [
+            { name: 'URL', value: 'url', description: 'Process a document from a URL' },
+            { name: 'Base64', value: 'base64', description: 'Process a base64-encoded document' },
+        ],
+        default: 'url',
+        description: 'How the document is provided',
+        ...showForOcr,
+    },
+    {
+        displayName: 'Document URL',
+        name: 'ocrDocumentUrl',
+        type: 'string',
+        default: '',
+        required: true,
+        description: 'URL of the document to process',
+        displayOptions: {
+            show: {
+                resource: ['ocr'],
+                ocrDocumentType: ['url'],
+            },
+        },
+    },
+    {
+        displayName: 'Document Data',
+        name: 'ocrDocumentData',
+        type: 'string',
+        typeOptions: { rows: 4 },
+        default: '',
+        required: true,
+        description: 'Base64-encoded document data',
+        displayOptions: {
+            show: {
+                resource: ['ocr'],
+                ocrDocumentType: ['base64'],
+            },
+        },
+    },
+    {
+        displayName: 'Processing Mode',
+        name: 'ocrAsync',
+        type: 'boolean',
+        default: false,
+        description: 'Whether to process the document asynchronously (recommended for large documents)',
+        ...showForOcr,
+    },
+    {
+        displayName: 'Options',
+        name: 'ocrOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        options: [
+            {
+                displayName: 'Output Format',
+                name: 'outputFormat',
+                type: 'options',
+                options: [
+                    { name: 'Markdown', value: 'md' },
+                    { name: 'JSON', value: 'json' },
+                ],
+                default: 'md',
+                description: 'Format for the extracted text',
+            },
+            {
+                displayName: 'Table Mode',
+                name: 'tableMode',
+                type: 'options',
+                options: [
+                    { name: 'Accurate', value: 'accurate' },
+                    { name: 'Fast', value: 'fast' },
+                ],
+                default: 'accurate',
+                description: 'Mode for table extraction',
+            },
+            {
+                displayName: 'OCR Method',
+                name: 'ocrMethod',
+                type: 'options',
+                options: [
+                    { name: 'EasyOCR', value: 'easyocr' },
+                    { name: 'Tesseract', value: 'tesseract' },
+                    { name: 'OCR Mac', value: 'ocrmac' },
+                    { name: 'RapidOCR', value: 'rapidocr' },
+                    { name: 'TesserOCR', value: 'tesserocr' },
+                ],
+                default: 'easyocr',
+                description: 'OCR engine to use',
+            },
+            {
+                displayName: 'Perform OCR',
+                name: 'doOcr',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to perform OCR on the document',
+            },
+            {
+                displayName: 'Extract Table Structure',
+                name: 'doTableStructure',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to extract table structure',
+            },
+            {
+                displayName: 'Include Images',
+                name: 'includeImages',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to include base64-encoded images in the output',
+            },
+            {
+                displayName: 'Input Formats',
+                name: 'inputFormat',
+                type: 'multiOptions',
+                options: [
+                    { name: 'PDF', value: 'pdf' },
+                    { name: 'HTML', value: 'html' },
+                    { name: 'DOCX', value: 'docx' },
+                    { name: 'PPTX', value: 'pptx' },
+                ],
+                default: ['pdf'],
+                description: 'Input formats to accept',
+            },
+        ],
+        ...showForOcr,
+    },
+];
+async function executeOcr(context, itemIndex) {
+    var _a, _b, _c, _d, _e, _f, _g;
+    const credentials = await context.getCredentials('bergetAiApi');
+    const documentType = context.getNodeParameter('ocrDocumentType', itemIndex);
+    const asyncMode = context.getNodeParameter('ocrAsync', itemIndex);
+    const options = context.getNodeParameter('ocrOptions', itemIndex, {});
+    let documentUrl;
+    if (documentType === 'url') {
+        documentUrl = context.getNodeParameter('ocrDocumentUrl', itemIndex);
+    }
+    else {
+        const documentData = context.getNodeParameter('ocrDocumentData', itemIndex);
+        documentUrl = `data:application/pdf;base64,${documentData}`;
+    }
+    const body = {
+        document: { url: documentUrl, type: 'document' },
+        async: asyncMode,
+        options: {
+            outputFormat: (_a = options.outputFormat) !== null && _a !== void 0 ? _a : 'md',
+            tableMode: (_b = options.tableMode) !== null && _b !== void 0 ? _b : 'accurate',
+            ocrMethod: (_c = options.ocrMethod) !== null && _c !== void 0 ? _c : 'easyocr',
+            doOcr: options.doOcr !== false,
+            doTableStructure: options.doTableStructure !== false,
+            includeImages: (_d = options.includeImages) !== null && _d !== void 0 ? _d : false,
+            inputFormat: (_e = options.inputFormat) !== null && _e !== void 0 ? _e : ['pdf'],
+        },
+    };
+    const { status, data } = await (0, shared_1.bergetRequest)(credentials.apiKey, 'POST', '/ocr', body);
+    if (status === 200) {
+        const d = data;
+        return {
+            content: d.content,
+            usage: d.usage,
+            metadata: d.metadata,
+            processing_mode: 'synchronous',
+        };
+    }
+    if (status === 202) {
+        const d = data;
+        return {
+            taskId: d.taskId,
+            status: d.status,
+            resultUrl: d.resultUrl,
+            processing_mode: 'asynchronous',
+            message: 'Document processing started. Use the taskId to check status.',
+        };
+    }
+    const message = (_g = (_f = data === null || data === void 0 ? void 0 : data.error) === null || _f === void 0 ? void 0 : _f.message) !== null && _g !== void 0 ? _g : `HTTP ${status}`;
+    throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Berget AI OCR error: ${message}`, {
+        itemIndex,
+    });
+}

package/dist/nodes/BergetAi/rerank.d.ts

@@ -0,0 +1,3 @@
+import type { IDataObject, IExecuteFunctions, INodeProperties } from 'n8n-workflow';
+export declare const rerankProperties: INodeProperties[];
+export declare function executeRerank(context: IExecuteFunctions, itemIndex: number): Promise<IDataObject>;

package/dist/nodes/BergetAi/rerank.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rerankProperties = void 0;
+exports.executeRerank = executeRerank;
+const n8n_workflow_1 = require("n8n-workflow");
+const shared_1 = require("./shared");
+const showForRerank = {
+    displayOptions: {
+        show: {
+            resource: ['rerank'],
+        },
+    },
+};
+exports.rerankProperties = [
+    {
+        displayName: 'Model',
+        name: 'rerankModel',
+        type: 'options',
+        typeOptions: { loadOptionsMethod: 'getRerankModels' },
+        default: '',
+        required: true,
+        description: 'The Berget AI reranker model to use',
+        ...showForRerank,
+    },
+    {
+        displayName: 'Query',
+        name: 'rerankQuery',
+        type: 'string',
+        typeOptions: { rows: 2 },
+        default: '',
+        required: true,
+        description: 'Query to rank documents against',
+        ...showForRerank,
+    },
+    {
+        displayName: 'Documents',
+        name: 'rerankDocuments',
+        type: 'fixedCollection',
+        typeOptions: { multipleValues: true },
+        default: {
+            values: [{ text: '' }],
+        },
+        options: [
+            {
+                displayName: 'Values',
+                name: 'values',
+                values: [
+                    {
+                        displayName: 'Document Text',
+                        name: 'text',
+                        type: 'string',
+                        typeOptions: { rows: 3 },
+                        default: '',
+                        description: 'A single document to rank against the query',
+                    },
+                ],
+            },
+        ],
+        description: 'Documents to rank',
+        ...showForRerank,
+    },
+    {
+        displayName: 'Options',
+        name: 'rerankOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        options: [
+            {
+                displayName: 'Top K',
+                name: 'top_k',
+                type: 'number',
+                typeOptions: { minValue: 1 },
+                default: 10,
+                description: 'Number of top-ranked documents to return',
+            },
+            {
+                displayName: 'Return Documents',
+                name: 'return_documents',
+                type: 'boolean',
+                default: true,
+                description: 'Whether to include the document text in the response',
+            },
+        ],
+        ...showForRerank,
+    },
+];
+async function executeRerank(context, itemIndex) {
+    var _a, _b;
+    const credentials = await context.getCredentials('bergetAiApi');
+    const model = context.getNodeParameter('rerankModel', itemIndex);
+    const query = context.getNodeParameter('rerankQuery', itemIndex);
+    const documents = context.getNodeParameter('rerankDocuments.values', itemIndex, []);
+    const options = context.getNodeParameter('rerankOptions', itemIndex, {});
+    const { status, data } = await (0, shared_1.bergetRequest)(credentials.apiKey, 'POST', '/rerank', {
+        model,
+        query,
+        documents: documents.map((doc) => doc.text),
+        ...options,
+    });
+    if (status !== 200) {
+        const message = (_b = (_a = data === null || data === void 0 ? void 0 : data.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : `HTTP ${status}`;
+        throw new n8n_workflow_1.NodeOperationError(context.getNode(), `Berget AI rerank error: ${message}`, {
+            itemIndex,
+        });
+    }
+    return data;
+}

package/dist/nodes/BergetAi/shared.d.ts

@@ -0,0 +1,17 @@
+import type { ILoadOptionsFunctions, INodePropertyOptions } from 'n8n-workflow';
+export declare const BERGET_API_BASE_URL = "https://api.berget.ai/v1";
+export interface BergetModel {
+    id: string;
+    name?: string;
+    model_type?: string;
+    owned_by?: string;
+    capabilities?: {
+        function_calling?: boolean;
+    };
+}
+export declare function fetchBergetModels(context: ILoadOptionsFunctions): Promise<BergetModel[]>;
+export declare function loadModelOptions(context: ILoadOptionsFunctions, filter: (model: BergetModel) => boolean): Promise<INodePropertyOptions[]>;
+export declare function bergetRequest(apiKey: string, method: 'GET' | 'POST', path: string, body?: unknown, extraHeaders?: Record<string, string>): Promise<{
+    status: number;
+    data: unknown;
+}>;