n8n-nodes-berget-mk 0.2.1 → 0.3.0

package/README.md

@@ -1,19 +1,13 @@
 # n8n-nodes-berget-mk
 
-n8n community nodes for [Berget AI](https://berget.ai), packaged as a single installable module. Maintained by Micke Kring.
+n8n community node for [Berget AI](https://berget.ai), packaged as a single installable module. Maintained by Micke Kring.
 
-Includes:
+Two nodes, two purposes:
 
-- **Berget AI Chat** — one-shot chat completions (action node)
-- **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** — a multi-resource action node with five resources: **Chat**, **Embeddings**, **OCR**, **Rerank**, **Speech to Text**. Use this for one-shot calls.
+- **Berget AI Chat Model** — a sub-node that plugs into n8n's built-in **AI Agent**, **Basic LLM Chain**, and any other LangChain-based node. Use this to drive an agent with Berget AI as the underlying LLM. Exposes `reasoning_effort` and the full standard LLM parameter set.
 
-> ⚠️ **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 the shape of nodes may change 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 +19,19 @@ n8n-nodes-berget-mk
 
 Then add a **Berget AI API** credential with your API key from [berget.ai](https://berget.ai).
 
+## Using the Berget AI action node
+
+1. Drop **Berget AI** onto the canvas.
+2. Select a **Resource** (Chat, Embeddings, OCR, Rerank, or Speech to Text).
+3. Fill in the resource-specific fields (model, input, options).
+4. Execute.
+
 ## Using Berget with n8n's AI Agent
 
-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.
+1. Add n8n's built-in **AI Agent** node.
+2. Add a **Berget AI Chat Model** node and connect it to the Agent's **Chat Model** socket.
+3. Pick a Berget AI chat model and optionally configure `reasoning_effort` for reasoning-capable models (GPT-OSS, DeepSeek R1).
+4. Add Memory and Tool sub-nodes as usual — they work with Berget as the underlying LLM.
 
 ## Changelog
 

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

@@ -0,0 +1,13 @@
+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[]>;
+            getEmbeddingsModels(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,144 @@
+"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 embeddings_1 = require("./embeddings");
+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, embeddings, document OCR, speech-to-text, and document reranking',
+            defaults: { name: 'Berget AI' },
+            codex: {
+                categories: ['AI'],
+                subcategories: {
+                    AI: ['Miscellaneous'],
+                },
+                alias: ['Berget', 'Berget AI', 'Swedish AI', 'LLM'],
+            },
+            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: 'Embeddings',
+                            value: 'embeddings',
+                            description: 'Generate vector embeddings from text',
+                        },
+                        {
+                            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,
+                ...embeddings_1.embeddingsProperties,
+                ...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 getEmbeddingsModels() {
+                    return (0, shared_1.loadModelOptions)(this, (m) => m.model_type === 'embedding');
+                },
+                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 'embeddings':
+                        result = await (0, embeddings_1.executeEmbeddings)(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/embeddings.d.ts

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

package/dist/nodes/BergetAi/embeddings.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.embeddingsProperties = void 0;
+exports.executeEmbeddings = executeEmbeddings;
+const n8n_workflow_1 = require("n8n-workflow");
+const shared_1 = require("./shared");
+const showForEmbeddings = {
+    displayOptions: {
+        show: {
+            resource: ['embeddings'],
+        },
+    },
+};
+exports.embeddingsProperties = [
+    {
+        displayName: 'Model',
+        name: 'embeddingsModel',
+        type: 'options',
+        typeOptions: { loadOptionsMethod: 'getEmbeddingsModels' },
+        default: '',
+        required: true,
+        description: 'The Berget AI embedding model to use',
+        ...showForEmbeddings,
+    },
+    {
+        displayName: 'Input Text',
+        name: 'embeddingsInput',
+        type: 'string',
+        typeOptions: { rows: 4 },
+        default: '',
+        required: true,
+        description: 'Text to convert into an embedding vector',
+        ...showForEmbeddings,
+    },
+    {
+        displayName: 'Options',
+        name: 'embeddingsOptions',
+        type: 'collection',
+        placeholder: 'Add Option',
+        default: {},
+        options: [
+            {
+                displayName: 'Encoding Format',
+                name: 'encoding_format',
+                type: 'options',
+                options: [
+                    { name: 'Float', value: 'float' },
+                    { name: 'Base64', value: 'base64' },
+                ],
+                default: 'float',
+                description: 'Format of the returned embedding data',
+            },
+        ],
+        ...showForEmbeddings,
+    },
+];
+async function executeEmbeddings(context, itemIndex) {
+    var _a, _b;
+    const credentials = await context.getCredentials('bergetAiApi');
+    const model = context.getNodeParameter('embeddingsModel', itemIndex);
+    const input = context.getNodeParameter('embeddingsInput', itemIndex);
+    const options = context.getNodeParameter('embeddingsOptions', itemIndex, {});
+    const { status, data } = await (0, shared_1.bergetRequest)(credentials.apiKey, 'POST', '/embeddings', { model, input, ...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 embeddings 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>;