n8n mit Ollama integrieren

Was dieser Artikel über n8n-Ollama-Integration behandelt

Wie Du n8n mit Ollama verbindest.
Wie HTTP-Request-Nodes für Ollama-API konfiguriert werden.
Praxisbeispiele: Klassifikation, Zusammenfassung, Übersetzung, Extraktion.
Wie Du RAG-Workflows mit Ollama-Embeddings baust.
Best Practices für Fehlerbehandlung, Caching und Performance.

Einleitung: n8n mit Ollama verständlich erklärt

n8n ist ein Workflow-Automatisierungstool, das Prozesse visuell verbindet. Ollama ist ein lokaler KI-Modellserver. Wenn Du beide verbindest, kannst Du Workflows bauen, die KI lokal nutzen: E-Mails klassifizieren, Dokumente zusammenfassen, Texte übersetzen, alles ohne Cloud, ohne API-Kosten, mit vollständiger Datenkontrolle.

Dieser Artikel richtet sich an Anwender, die n8n für Workflow-Automatisierung nutzen und Ollama für lokale KI integrieren wollen. Du solltest verstehen, wie n8n funktioniert und wie Ollama läuft.

Warum brauche ich n8n mit Ollama?

Stell Dir vor, Du willst E-Mails automatisch klassifizieren. Ohne KI brauchst Du Regeln: „Wenn Betreff X, dann Ordner Y”. Aber die Regeln sind starr. Mit Ollama in n8n versteht die KI den Inhalt und klassifiziert kontextabhängig. Alles lokal, ohne dass E-Mail-Inhalte in die Cloud gehen.

n8n mit Ollama kurz erklärt

n8n sendet HTTP-Requests an die Ollama-API. Die Antwort wird im Workflow weiterverarbeitet. Alles läuft lokal: n8n auf Deinem Server, Ollama auf Deinem Server, keine Daten verlassen Dein Netzwerk.

Der Kerngedanke lautet: n8n steuert den Workflow, Ollama liefert die KI.

Für wen ist dieser Artikel gedacht?

n8n-Nutzer, die KI in Workflows integrieren.
Ollama-Nutzer, die Workflows automatisieren.
Self-Hoster, die lokale KI nutzen wollen.
Automatisierer, die wiederkehrende Aufgaben mit KI lösen.

Vorkenntnisse in n8n und Ollama sind erforderlich.

Wichtige Begriffe

n8n - Workflow-Automatisierung. Wann nützlich: das Workflow-Tool.
Ollama - Lokaler Modellserver. Wann nützlich: das KI-Backend.
HTTP-Request-Node - n8n-Node für API-Aufrufe. Wann nützlich: um Ollama anzusprechen.
Ollama REST API - Ollama-Schnittstelle. Wann nützlich: wie n8n mit Ollama spricht.
Embeddings - Vektor-Repräsentationen. Wann nützlich: für RAG-Workflows.
RAG - Retrieval-Augmented Generation. Wann nützlich: für Wissens-Workflows.
Docker - Container. Wann nützlich: um n8n und Ollama zu betreiben.

Setup: n8n und Ollama verbinden

1. Ollama läuft

# Ollama läuft auf localhost:11434
ollama serve
ollama list  # Prüfe, ob Modelle geladen sind

2. n8n läuft

# n8n mit Docker starten
docker run -d \
  --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  --restart unless-stopped \
  n8nio/n8n:latest

3. Netzwerk

Wenn beide in Docker laufen, müssen sie im selben Netzwerk sein:

docker network create n8n-ollama

docker run -d --name ollama --network n8n-ollama -p 11434:11434 ollama/ollama
docker run -d --name n8n --network n8n-ollama -p 5678:5678 n8nio/n8n:latest

# In n8n: URL ist http://ollama:11434 statt http://localhost:11434

Siehe Docker Netzwerk für Details.

Ollama-API in n8n aufrufen

Basis-HTTP-Request

// n8n HTTP-Request-Node Konfiguration:
{
  "method": "POST",
  "url": "http://ollama:11434/api/chat",  // oder http://localhost:11434
  "headers": {
    "Content-Type": "application/json"
  },
  "body": {
    "model": "llama3.1",
    "messages": [
      {"role": "user", "content": "{{$json.prompt}}"}
    ],
    "stream": false
  }
}

Function-Node für Ollama

// In n8n Function-Node:
const response = await this.helpers.httpRequest({
  method: 'POST',
  url: 'http://ollama:11434/api/chat',
  body: {
    model: 'llama3.1',
    messages: [
      { role: 'system', content: 'Du bist ein hilfreicher Assistent.' },
      { role: 'user', content: $input.item.json.prompt }
    ],
    stream: false
  },
  json: true
});

return { response: response.message.content };

Praxisbeispiel 1: E-Mail-Klassifikation

// Workflow:
// 1. IMAP-Trigger: Neue E-Mail
// 2. Function: Prompt bauen
// 3. HTTP-Request: Ollama klassifiziert
// 4. Switch: Basierend auf Kategorie
// 5. Verschiedene Aktionen

// Function-Node (Prompt bauen):
const email = $input.item.json;
return {
  prompt: `Klassifiziere diese E-Mail in eine der Kategorien: support, sales, billing, spam, other.

Betreff: ${email.subject}
Von: ${email.from}
Inhalt: ${email.body}

Antworte nur mit der Kategorie, nichts anderem.`
};

// HTTP-Request-Node:
{
  "method": "POST",
  "url": "http://ollama:11434/api/chat",
  "body": {
    "model": "llama3.1",
    "messages": [{"role": "user", "content": "{{$json.prompt}}"}],
    "stream": false
  }
}

// Function-Node (Ergebnis verarbeiten):
const category = $input.item.json.message.content.trim().toLowerCase();
return { category, email: $input.item.json.email };

Siehe E-Mail-Automatisierung für Details.

Praxisbeispiel 2: Dokumentenzusammenfassung

// Workflow:
// 1. Watch: Neuer Ordner
// 2. Read Binary File: PDF lesen
// 3. Function: Text extrahieren
// 4. HTTP-Request: Ollama fasst zusammen
// 5. Write File: Zusammenfassung speichern

// Function-Node:
const document = $input.item.json;
return {
  prompt: `Fasse das folgende Dokument in 5 Sätzen zusammen:\n\n${document.text}`
};

Praxisbeispiel 3: Übersetzung

// Function-Node:
return {
  prompt: `Übersetze ins Deutsche:\n\n${$input.item.json.text}`
};

// HTTP-Request-Node:
{
  "method": "POST",
  "url": "http://ollama:11434/api/chat",
  "body": {
    "model": "qwen2.5",  // Gutes Modell für Übersetzung
    "messages": [{"role": "user", "content": "{{$json.prompt}}"}],
    "stream": false
  }
}

Praxisbeispiel 4: RAG mit Ollama-Embeddings

// 1. Embeddings für Dokumente erstellen
const embedding = await this.helpers.httpRequest({
  method: 'POST',
  url: 'http://ollama:11434/api/embeddings',
  body: {
    model: 'nomic-embed-text',
    prompt: document.text
  },
  json: true
});

// 2. In Vektordatenbank speichern (z.B. Qdrant, Pinecone)
await this.helpers.httpRequest({
  method: 'PUT',
  url: 'http://qdrant:6333/collections/docs/points',
  body: {
    points: [{
      id: docId,
      vector: embedding.embedding,
      payload: { text: document.text }
    }]
  },
  json: true
});

// 3. Bei Frage: Ähnliche Dokumente suchen
const queryEmbedding = await this.helpers.httpRequest({
  method: 'POST',
  url: 'http://ollama:11434/api/embeddings',
  body: {
    model: 'nomic-embed-text',
    prompt: question
  },
  json: true
});

const similar = await this.helpers.httpRequest({
  method: 'POST',
  url: 'http://qdrant:6333/collections/docs/points/search',
  body: {
    vector: queryEmbedding.embedding,
    limit: 3
  },
  json: true
});

// 4. Antwort mit Kontext generieren
const context = similar.result.map(r => r.payload.text).join('\n');
const answer = await this.helpers.httpRequest({
  method: 'POST',
  url: 'http://ollama:11434/api/chat',
  body: {
    model: 'llama3.1',
    messages: [
      { role: 'system', content: 'Beantworte die Frage basierend auf dem Kontext.' },
      { role: 'user', content: `Kontext: ${context}\n\nFrage: ${question}` }
    ],
    stream: false
  },
  json: true
});

Siehe Lokales RAG für Details.

Praxisbeispiel 5: Datenextraktion

// Strukturierte Daten aus Text extrahieren
return {
  prompt: `Extrahiere aus dem folgenden Text: Name, E-Mail, Telefon.

Text: ${$input.item.json.text}

Antworte als JSON:
{"name": "...", "email": "...", "telefon": "..."}`
};

// Ollama mit format: json für strukturierte Ausgabe
{
  "model": "llama3.1",
  "messages": [{"role": "user", "content": "{{$json.prompt}}"}],
  "format": "json",
  "stream": false
}

Fehlerbehandlung

// Function-Node mit Error-Handling
try {
  const response = await this.helpers.httpRequest({
    method: 'POST',
    url: 'http://ollama:11434/api/chat',
    body: { model: 'llama3.1', messages: [...], stream: false },
    json: true,
    timeout: 30000  // 30 Sekunden Timeout
  });
  return { success: true, result: response.message.content };
} catch (error) {
  if (error.code === 'ECONNREFUSED') {
    return { success: false, error: 'Ollama nicht erreichbar' };
  }
  if (error.code === 'ETIMEDOUT') {
    return { success: false, error: 'Timeout' };
  }
  return { success: false, error: error.message };
}

Performance-Optimierung

1. Modell-Auswahl

// Für einfache Aufgaben: kleines Modell
model: 'llama3.1:8b'  // Schnell

// Für komplexe Aufgaben: großes Modell
model: 'qwen2.5:32b'  // Langsamer, aber besser

2. Caching

// Gleiche Anfragen cachen
const cache = new Map();
const cacheKey = JSON.stringify(prompt);

if (cache.has(cacheKey)) {
  return cache.get(cacheKey);
}

const result = await callOllama(prompt);
cache.set(cacheKey, result);
return result;

3. Batch-Verarbeitung

// Mehrere Anfragen bündeln
const batchPrompt = `Klassifiziere folgende Texte:
1. ${texts[0]}
2. ${texts[1]}
3. ${texts[2]}

Antworte als JSON-Array.`;

Sicherheitshinweise

Ollama absichern: Exponiere Ollama nicht ins Internet. Siehe API-Schlüssel.
Eingaben validieren: Prompt Injection verhindern. Siehe Prompt Injection.
Ausgaben validieren: Prüfe KI-Ausgaben, bevor sie verarbeitet werden.
Audit Logging: Protokolliere alle Ollama-Aufrufe. Siehe Protokollierung.
Netzwerk-Isolation: n8n und Ollama in eigenem Docker-Netzwerk. Siehe Docker Netzwerk-Isolation.

Typische Stolpersteine

Falsche URL: localhost in Docker ist der Container selbst, nicht der Host. Nutze http://ollama:11434 oder host.docker.internal.
Timeout zu kurz: Große Modelle brauchen Zeit. Setze Timeout auf 60-120 Sekunden.
Kein Error-Handling: Wenn Ollama nicht erreichbar ist, sollte der Workflow nicht abstürzen.
Modell nicht geladen: Prüfe mit ollama list, ob das Modell geladen ist.
Kontextlänge überschritten: Lange Dokumente müssen chunked werden.
Kein Streaming: Für lange Antworten ist Streaming besser, aber komplexer zu verarbeiten.

Key Takeaways:

n8n sendet HTTP-Requests an Ollama-API.
Lokale KI in Workflows ohne Cloud, ohne API-Kosten.
Anwendungen: Klassifikation, Zusammenfassung, Übersetzung, Extraktion, RAG.
Fehlerbehandlung und Caching sind wichtig.
Sicherheit: Ollama absichern, Eingaben validieren.

FAQ

Wie verbinde ich n8n mit Ollama?

Mit einem HTTP-Request-Node. URL: http://ollama:11434/api/chat, Method: POST, Body: JSON mit Modell und Messages. Wenn beide in Docker laufen, müssen sie im selben Netzwerk sein.

Welches Modell soll ich nutzen?

Für einfache Aufgaben: llama3.1:8b (schnell). Für komplexe: qwen2.5:32b (besser). Für Embeddings: nomic-embed-text. Für Übersetzung: qwen2.5.

Wie verbinde ich n8n und Ollama in Docker?

Erstelle ein Docker-Netzwerk (docker network create n8n-ollama), starte beide Container im selben Netzwerk, nutze http://ollama:11434 als URL in n8n.

Warum funktioniert localhost nicht?

In Docker ist localhost der Container selbst, nicht der Host. Nutze http://ollama:11434 (Container-Name) oder http://host.docker.internal:11434 (Host).

Wie lang sollte das Timeout sein?

Für kleine Modelle (8B): 30-60 Sekunden. Für große Modelle (32B+): 120-300 Sekunden. Für sehr lange Dokumente: länger.

Kann ich Streaming nutzen?

Ja, aber komplexer. Setze stream: true und verarbeite die Antwort inkrementell. Für einfache Workflows ist stream: false einfacher.

Was tun bei Fehlern?

Implementiere Error-Handling: try/catch, Timeout, Retry-Logik. Wenn Ollama nicht erreichbar ist, sollte der Workflow nicht abstürzen, sondern eine Fallback-Aktion ausführen.

Wie baue ich RAG in n8n?

Nutze Ollama-Embeddings (nomic-embed-text), speichere Vektoren in Qdrant oder Pinecone, suche ähnliche Dokumente bei Fragen, generiere Antwort mit Kontext.

Ist das sicher?

Ja, wenn lokal. Alle Daten bleiben auf Deinem Server. Aber prüfe Eingaben auf Prompt Injection und sichere Ollama ab (nicht ins Internet exponieren).

Was kostet das?

Nur Hardware-Kosten. n8n und Ollama sind Open Source. Du brauchst einen Rechner mit genug VRAM für das gewählte Modell. Keine API-Kosten.

Quellen und weiterführende Literatur

n8n Dokumentation - n8n-Docs.
Ollama API - API-Referenz.
Docker Networking - Docker-Netzwerke.
n8n Community - n8n-Forum.

Täglicher Artikel