Node-RED KI-Integration

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über KI-Integration in Node-RED behandelt

• Wie Du Ollama und andere KI-Modelle in Node-RED einbindest.
• Wie Du mit Function-Nodes und dedizierten KI-Nodes arbeitest.
• Wie Event-getriebene KI-Flows aussehen (Sensor → KI → Aktion).
• Praxisbeispiele für Textverarbeitung, Klassifikation und Analyse.
• Best Practices für Performance, Fehlerbehandlung und Sicherheit.

Einleitung: KI in Node-RED verständlich erklärt

Node-RED ist ein visueller Flow-Editor. KI-Integration bedeutet: Ein Node empfängt Daten (Sensor, E-Mail, HTTP), ein Function-Node oder Ollama-Node verarbeitet sie mit KI, und ein weiterer Node führt eine Aktion aus. Das Ergebnis: Event-getriebene KI-Automatisierung ohne Code-Framework.

Dieser Artikel richtet sich an Anwender, die KI in Node-RED-Flows einbauen wollen. Grundlagen findest Du in Node-RED installieren und Ollama.

Warum brauche ich KI in Node-RED?

Stell Dir vor, ein Sensor meldet ungewöhnliche Temperaturwerte. Ein klassischer Flow sendet einen Alert. Mit KI analysiert der Flow die Daten, versteht den Kontext („Temperaturanstieg nach Wartung, wahrscheinlich normal”) und entscheidet intelligent, ob ein Alert nötig ist.

KI in Node-RED kurz erklärt

Du verbindest einen Input-Node (Trigger) mit einem Function-Node, der Ollama aufruft, und einem Output-Node (Aktion). Oder Du nutzt dedizierte Ollama-Nodes aus der Palette. Der Flow reagiert auf Events und verarbeitet sie mit KI.

Der Kerngedanke lautet: Event → KI-Verarbeitung → Aktion.

Für wen ist dieser Artikel gedacht?

• Node-RED-Nutzer, die KI-Funktionen einbauen wollen.
• IoT-Entwickler, die Sensordaten mit KI analysieren.
• Smart-Home-Bastler, die intelligente Automatisierung wollen.
• Self-Hoster, die KI-Flows lokal betreiben.

Vorkenntnisse in Node-RED und Ollama sind hilfreich.

Wichtige Begriffe

• Node-RED - Visueller Flow-Editor. Wann nützlich: die Plattform.
• Ollama - Lokaler Modellserver. Wann nützlich: das KI-Backend.
• Function Node - JavaScript-Node. Wann nützlich: für KI-Aufrufe.
• HTTP Request Node - HTTP-Node. Wann nützlich: für Ollama-API.
• node-red-contrib-ollama - Ollama-Nodes. Wann nützlich: für einfache Integration.
• Function Calling - Tool-Use. Wann nützlich: für strukturierte KI-Ausgaben.
• MQTT - IoT-Protokoll. Wann nützlich: für Sensor-Trigger.

Methode 1: Function Node mit fetch()

// Function Node: Ollama aufrufen
const response = await fetch("http://ollama:11434/api/chat", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
        model: "llama3.1",
        messages: [
            { role: "system", content: "Du bist ein Analyse-Assistent." },
            { role: "user", content: msg.payload }
        ],
        stream: false
    })
});

const data = await response.json();
msg.payload = data.message.content;
msg.ki_response = data;
return msg;

Methode 2: HTTP Request Node

[Inject/Trigger] → [HTTP Request: Ollama] → [Debug/Action]

HTTP Request Node:
  Method: POST
  URL: http://ollama:11434/api/chat
  Headers: Content-Type: application/json
  Body:
  {
    "model": "llama3.1",
    "messages": [{"role": "user", "content": "{{msg.payload}}"}],
    "stream": false
  }

Methode 3: Dedizierter Ollama-Node

# Installieren
cd /data
npm install node-red-contrib-ollama

# Oder über Palette Manager:
# Menu → Manage palette → Install → "ollama"

Der Node bietet fertige Konfigurationen für Chat, Embeddings und Completion.

Praxisbeispiel 1: Sensordaten analysieren

Flow: MQTT-Sensor → KI-Analyse → Alert bei Anomalie

[MQTT In: sensor/temperature]
    │
    ▼
[Function: Kontext aufbauen]
  msg.payload = `Temperatur: ${msg.payload}°C, Zeit: ${new Date()},
                 Sensor: Wohnzimmer, Grenze: 30°C`
    │
    ▼
[HTTP Request: Ollama]
  "Ist diese Temperatur kritisch? Antworte: ja/nein + Begründung"
    │
    ▼
[Switch: kritisch?]
    │
    ├─ ja → [Alert: Telegram/E-Mail]
    └─ nein → [Debug: OK]

Praxisbeispiel 2: E-Mail analysieren

Flow: E-Mail eingeht → KI klassifiziert → Ordner sortieren

[Email In]
    │
    ▼
[Function: E-Mail-Inhalt extrahieren]
    │
    ▼
[HTTP Request: Ollama]
  "Klassifiziere: rechnung, support, newsletter, spam, sonstiges"
    │
    ▼
[Switch: Kategorie]
    │
    ├─ rechnung → [Move to: Rechnungen]
    ├─ support → [Move to: Support]
    ├─ spam → [Delete]
    └─ sonstiges → [Move to: Allgemein]

Praxisbeispiel 3: Log-Monitoring mit KI

Flow: Log-Datei → KI analysiert → Bericht

[Watch: /var/log/app.log]
    │
    ▼
[Function: Neue Zeilen sammeln]
    │
    ▼
[HTTP Request: Ollama]
  "Analysiere diese Log-Einträge auf Fehler und Muster"
    │
    ▼
[Function: Bei kritischen Fehlern]
    │
    ▼
[Alert: Slack/E-Mail]

Praxisbeispiel 4: Sprachbefehl → KI → Aktion

Flow: Sprachbefehl verarbeiten

[HTTP In: /api/command]  ← von Rhasspy/Home Assistant
    │
    ▼
[HTTP Request: Ollama]
  "Interpretiere: '{{msg.payload.command}}'
   Verfügbare Aktionen: licht_an, licht_aus, temperatur_abfragen,
   musik_starten, musik_stoppen
   Antworte als JSON: {action: '...', params: {...}}"
    │
    ▼
[Switch: action]
    │
    ├─ licht_an → [call service: light.turn_on]
    ├─ temperatur_abfragen → [MQTT: sensor lesen] → [TTS: Antwort]
    └─ musik_starten → [call service: media_player.play]

Embeddings in Node-RED

// Function Node: Embedding erstellen
const response = await fetch("http://ollama:11434/api/embeddings", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
        model: "nomic-embed-text",
        prompt: msg.payload
    })
});

const data = await response.json();
msg.embedding = data.embedding;
return msg;

Fehlerbehandlung

// Function Node mit Error-Handling
try {
    const response = await fetch("http://ollama:11434/api/chat", {
        method: "POST",
        headers: { "Content-Type": "application/json" },
        body: JSON.stringify({
            model: "llama3.1",
            messages: [{ role: "user", content: msg.payload }],
            stream: false
        }),
        signal: AbortSignal.timeout(30000)  // 30s Timeout
    });

    if (!response.ok) throw new Error(`HTTP ${response.status}`);

    const data = await response.json();
    msg.payload = data.message.content;
    msg.success = true;
} catch (error) {
    msg.payload = "KI nicht erreichbar: " + error.message;
    msg.success = false;
    node.error("Ollama Fehler: " + error.message, msg);
}
return msg;

Performance-Optimierung

// Debounce: Nicht bei jedem Event Ollama aufrufen
// Nutze context für Caching

let cache = context.get("cache") || {};
const key = msg.payload;

if (cache[key] && (Date.now() - cache[key].time) < 60000) {
    // Cache: < 1 Minute alt
    msg.payload = cache[key].result;
    return msg;
}

// ... Ollama-Aufruf ...

cache[key] = { result: msg.payload, time: Date.now() };
context.set("cache", cache);
return msg;

Sicherheitshinweise

• Eingaben validieren: Sensor-Daten und E-Mails können Prompt Injection enthalten. Siehe Prompt Injection.
• Netzwerk-Isolation: Ollama nicht exponieren. Siehe Netzwerk-Isolation.
• Ausgaben validieren: KI-Ausgaben prüfen, bevor Aktionen ausgeführt werden.
• Kritische Aktionen: Für kritische Aktionen (Alarme, Löschen) menschliche Freigabe. Siehe Menschliche Freigabe.

Typische Stolpersteine

• Docker-Netzwerk: localhost im Flow ist der Node-RED-Container. Nutze http://ollama:11434.
• Timeout zu kurz: Große Modelle brauchen Zeit. Setze Timeout auf 60-120 Sekunden.
• Keine Fehlerbehandlung: Wenn Ollama ausfällt, sollte der Flow nicht abstürzen.
• Zu viele KI-Aufrufe: Bei hoher Event-Frequenz wird die KI zum Bottleneck. Cachen oder filtern.
• Context nicht persistent: Flow-Kontext geht bei Neustart verloren. Nutze persistentContext.

Weiterführende Links

• Node-RED Guide - Node-RED im Detail.
• Node-RED installieren - Installation.
• Node-RED Home Assistant - Home Assistant.
• Ollama REST API - API-Referenz.
• Function Calling - Tool-Calling.
• Workflow-Automatisierung - Grundlagen.
• Prompt Injection - Sicherheit.

Key Takeaways:

• KI in Node-RED: Function Node mit fetch(), HTTP Request Node oder dedizierte Ollama-Nodes.
• Event-getriebene KI: Sensor → Analyse → Aktion.
• Ollama lokal: keine API-Kosten, Daten bleiben lokal.
• Fehlerbehandlung und Timeout sind Pflicht.
• Caching bei hoher Event-Frequenz.

FAQ

Quellen und weiterführende Literatur

• Node-RED - Offizielle Website.
• node-red-contrib-ollama - Ollama-Node.
• Ollama API - API-Referenz.
• Node-RED Cookbook - Flow-Rezepte.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert