Custom Nodes

interface INodeType {
  description: INodeTypeDescription;
  execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]>;
  methods?: INodeTypeDescriptionMethods;
}

import {
  IExecuteFunctions,
  INodeExecutionData,
  INodeType,
  INodeTypeDescription,
  NodePropertyTypes,
} from 'n8n-workflow';

export class LocalmindAgent implements INodeType {
  description: INodeTypeDescription = {
    displayName: 'Localmind Agent',
    name: 'localmindAgent',
    icon: 'file:localmind.svg',
    group: ['transform'],
    version: 1,
    subtitle: '={{$parameter["operation"]}}',
    description: 'Ruft einen Localmind-Agenten auf',
    defaults: {
      name: 'Localmind Agent',
    },
    inputs: ['main'],
    outputs: ['main'],
    credentials: [
      {
        name: 'localmindApi',
        required: true,
      },
    ],
    properties: [
      {
        displayName: 'Agent ID',
        name: 'agentId',
        type: 'string',
        required: true,
        default: '',
        description: 'Die ID des Localmind-Agenten',
      },
      {
        displayName: 'Input',
        name: 'input',
        type: 'string',
        required: true,
        default: '',
        description: 'Der Input-Text für den Agenten',
      },
      {
        displayName: 'Temperature',
        name: 'temperature',
        type: 'number',
        typeOptions: {
          minValue: 0,
          maxValue: 2,
          numberStepSize: 0.1,
        },
        default: 0.7,
        description: 'Die Temperature für die Agent-Antwort',
      },
      {
        displayName: 'Max Tokens',
        name: 'maxTokens',
        type: 'number',
        typeOptions: {
          minValue: 1,
          maxValue: 4000,
        },
        default: 500,
        description: 'Maximale Anzahl von Tokens in der Antwort',
      },
    ],
  };

  async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
    const items = this.getInputData();
    const returnData: INodeExecutionData[] = [];

    for (let i = 0; i < items.length; i++) {
      const agentId = this.getNodeParameter('agentId', i) as string;
      const input = this.getNodeParameter('input', i) as string;
      const temperature = this.getNodeParameter('temperature', i) as number;
      const maxTokens = this.getNodeParameter('maxTokens', i) as number;

      const credentials = await this.getCredentials('localmindApi');
      const apiKey = credentials.apiKey as string;

      // API-Call zu Localmind (OpenAI-kompatibler /v1-Endpoint, model = agent_uuid)
      const response = await this.helpers.httpRequest({
        method: 'POST',
        url: `https://<deine-instanz>-api.localmind.ai/v1/chat/completions`,
        headers: {
          'Authorization': `Bearer ${apiKey}`,
          'Content-Type': 'application/json',
        },
        body: {
          model: agentId,
          messages: [{ role: 'user', content: input }],
          temperature,
          max_tokens: maxTokens,
        },
      });

      returnData.push({
        json: {
          agentId,
          input,
          response: response.choices[0].message.content,
          totalTokens: response.usage.total_tokens,
        },
      });
    }

    return [returnData];
  }
}

import {
  ICredentialType,
  INodeProperties,
} from 'n8n-workflow';

export class LocalmindApi implements ICredentialType {
  name = 'localmindApi';
  displayName = 'Localmind API';
  properties: INodeProperties[] = [
    {
      displayName: 'API Key',
      name: 'apiKey',
      type: 'string',
      typeOptions: {
        password: true,
      },
      default: '',
      required: true,
    },
    {
      displayName: 'Base URL',
      name: 'baseUrl',
      type: 'string',
      default: 'https://<deine-instanz>-api.localmind.ai/v1',
      required: true,
    },
  ];
}