n8n + Private KI: DSGVO-konforme Automatisierungs-Workflows mit JuiceFactory

n8n ist ein starkes Werkzeug zur Automatisierung von Geschäftsprozessen. Mit LLM-Fähigkeiten wird es noch deutlich mächtiger. Aber sobald deine Workflows sensible Daten verarbeiten — Kunden-E-Mails, Verträge, interne Dokumente — entsteht durch das Senden dieser Daten an öffentliche KI-Anbieter eine Compliance-Lücke, die du vermutlich nicht haben willst.

JuiceFactory löst dieses Problem. Es ist eine DSGVO-konforme Inferenz-API mit EU-Hosting, die das OpenAI-Protokoll spricht. Das bedeutet: Die eingebauten OpenAI-Nodes von n8n funktionieren ohne Anpassung. Du änderst eine URL und einen API-Key, und deine Workflow-Daten bleiben in der EU — mit Null-Speicherung auf der Inferenz-Seite.

Dieser Guide führt dich durch das komplette Setup: Credentials, dein erster Workflow, RAG-Patterns, produktionsreife Beispiele und die DSGVO-Details, die für Automatisierungs-Pipelines relevant sind.

Warum n8n + private Inferenz

Workflow-Daten in der EU halten

Wenn n8n Dokumente, Kundenkommunikation oder HR-Daten verarbeitet, musst du wissen, wohin diese Daten gehen. Mit JuiceFactory läuft der KI-Inferenz-Schritt auf EU-Infrastruktur. Keine transatlantischen Datentransfers, keine Diskussionen über Angemessenheitsbeschlüsse, keine ergänzenden Schutzmaßnahmen.

Null-Speicherung bei der Inferenz

Öffentliche KI-APIs empfangen deine Prompts und speichern sie — typischerweise 30 Tage zur Missbrauchsüberwachung. JuiceFactory arbeitet zustandslos: Dein Prompt geht rein, die Antwort kommt raus, nichts wird gespeichert. Der KI-Node in deinem Workflow wird nicht zur Datenspeicherungs-Altlast.

Vorhersagbare Latenz

Geteilte Infrastruktur bedeutet geteilte Ressourcen. Zu Spitzenzeiten bei öffentlichen APIs kann die Latenz von 200ms auf über 2 Sekunden springen. Dedizierte EU-Infrastruktur gibt dir konstante Antwortzeiten — das ist relevant, wenn deine n8n-Workflows SLAs oder Timeouts haben.

OpenAI-Kompatibilität = kein Migrationsaufwand

Falls du bereits n8n-Workflows mit OpenAI-Nodes betreibst, ist der Wechsel zu JuiceFactory eine Credential-Änderung. Gleiches Request-Format, gleiches Response-Format, gleiche Node-Konfiguration. Der einzige Unterschied ist, wo die Inferenz stattfindet.

Voraussetzungen

Bevor du loslegst, brauchst du drei Dinge:

1. Eine laufende n8n-Instanz

Entweder selbst gehostet oder n8n Cloud. Version 1.30+ empfohlen — ältere Versionen haben Eigenheiten mit benutzerdefinierten OpenAI-Base-URLs.

Wenn du selbst hostest, ist Docker der einfachste Weg:

docker run -d \
  --name n8n \
  -p 5678:5678 \
  -v n8n_data:/home/node/.n8n \
  n8nio/n8n

2. Ein JuiceFactory API-Key

Registriere dich unter portal.juicefactory.ai und generiere einen API-Key. Keys haben das Präfix jf_, damit sie in deinem Credential-Store leicht zu identifizieren sind.

3. API-Zugang verifizieren

Bevor du n8n anfasst, prüfe ob die API antwortet:

curl -s https://api.juicefactory.ai/v1/models \
  -H "Authorization: Bearer jf_your-api-key-here" | jq .

Du solltest eine Liste verfügbarer Modelle sehen. Bei einem 401 prüfe deinen Key. Bei einem Timeout prüfe dein Netzwerk — der Endpunkt muss von dort erreichbar sein, wo n8n läuft.

Du kannst auch einen schnellen Completion-Test machen:

curl -s https://api.juicefactory.ai/v1/chat/completions \
  -H "Authorization: Bearer jf_your-api-key-here" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "qwen3-30b-a3b",
    "messages": [{"role": "user", "content": "Say hello in Swedish"}],
    "max_tokens": 50
  }' | jq .choices[0].message.content

Wenn eine Antwort zurückkommt, bist du startklar.

Schritt 1: JuiceFactory-Credentials in n8n konfigurieren

n8n nutzt den Credential-Typ "OpenAI" für jede OpenAI-kompatible API. So richtest du ihn ein.

Credential anlegen

1. Gehe in n8n zu Credentials in der linken Seitenleiste
2. Klicke auf Add Credential
3. Suche nach OpenAI API und wähle es aus
4. Fülle diese Felder aus:

5. Klicke auf Save

Das war's. Die Base-URL-Überschreibung sagt n8n, dass alle OpenAI-formatierten Requests an JuiceFactory statt an OpenAIs Server gehen sollen.

Credential klar benennen

Nenne es zum Beispiel JuiceFactory EU oder JuiceFactory Production. Wenn du mehrere Credentials hast (etwa einen Staging-Key und einen Production-Key), verhindert eine klare Benennung versehentliches Daten-Routing an den falschen Endpunkt.

Credential testen

Nach dem Speichern erstellst du einen schnellen Test-Workflow:

1. Füge einen Manual Trigger Node hinzu
2. Füge einen OpenAI Chat Model Node hinzu
3. Wähle dein neues JuiceFactory-Credential aus
4. Setze das Modell auf qwen3-30b-a3b
5. Gib im Prompt "Respond with OK" ein
6. Führe den Workflow aus

Wenn du "OK" zurückbekommst, funktioniert das Credential. Bei einem Fehler schau in den Troubleshooting-Abschnitt weiter unten.

Alternative: HTTP Header Auth

Für mehr Kontrolle (oder wenn du über Chat Completions hinaus Endpunkte ansprechen willst) kannst du den HTTP Request Node mit Header Auth verwenden:

1. Erstelle ein Header Auth Credential
2. Setze Name auf Authorization
3. Setze Value auf Bearer jf_your-api-key-here

Damit hast du Raw-Zugriff auf jeden JuiceFactory-Endpunkt über den HTTP Request Node.

Schritt 2: Dein erster KI-Workflow — Dokumenten-Zusammenfassung

Bauen wir etwas Nützliches. Dieser Workflow nimmt eine Dokument-URL, ruft den Inhalt ab und liefert eine KI-generierte Zusammenfassung zurück.

Workflow-Überblick

Manual Trigger → HTTP Request (fetch doc) → OpenAI Chat (summarize) → Set (format output)

Node-für-Node-Konfiguration

Node 1: Manual Trigger

Nichts zu konfigurieren. Das ist dein Einstiegspunkt. In der Produktion ersetzt du ihn durch einen Webhook, Zeitplan oder einen anderen Trigger.

Node 2: HTTP Request — Dokument abrufen

Zum Testen trägst du eine URL zu einem Klartext-Dokument oder einer einfachen Webseite fest ein.

Node 3: OpenAI Chat — Zusammenfassung erstellen

Node 4: Set — Ausgabe formatieren

Mappe die Antwort auf saubere Ausgabefelder:

Der Workflow als importierbares JSON

Kopiere das folgende JSON in n8n über Import from JSON:

{
  "nodes": [
    {
      "parameters": {},
      "id": "trigger",
      "name": "Manual Trigger",
      "type": "n8n-nodes-base.manualTrigger",
      "typeVersion": 1,
      "position": [240, 300]
    },
    {
      "parameters": {
        "url": "https://example.com/sample-document.txt",
        "options": {
          "response": {
            "response": {
              "responseFormat": "text"
            }
          }
        }
      },
      "id": "fetch-doc",
      "name": "Fetch Document",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 4,
      "position": [460, 300]
    },
    {
      "parameters": {
        "model": "qwen3-30b-a3b",
        "messages": {
          "values": [
            {
              "role": "system",
              "content": "You are a document summarizer. Create a concise summary. Focus on key facts, decisions, and action items. Return plain text, no markdown."
            },
            {
              "role": "user",
              "content": "={{ $json.data }}"
            }
          ]
        },
        "options": {
          "maxTokens": 500,
          "temperature": 0.3
        }
      },
      "id": "summarize",
      "name": "Summarize",
      "type": "@n8n/n8n-nodes-langchain.openAi",
      "typeVersion": 1,
      "position": [680, 300],
      "credentials": {
        "openAiApi": {
          "id": "your-credential-id",
          "name": "JuiceFactory EU"
        }
      }
    },
    {
      "parameters": {
        "assignments": {
          "assignments": [
            {
              "name": "summary",
              "value": "={{ $json.message.content }}"
            },
            {
              "name": "processed_at",
              "value": "={{ $now.toISO() }}"
            }
          ]
        }
      },
      "id": "format-output",
      "name": "Format Output",
      "type": "n8n-nodes-base.set",
      "typeVersion": 3,
      "position": [900, 300]
    }
  ],
  "connections": {
    "Manual Trigger": {
      "main": [[{"node": "Fetch Document", "type": "main", "index": 0}]]
    },
    "Fetch Document": {
      "main": [[{"node": "Summarize", "type": "main", "index": 0}]]
    },
    "Summarize": {
      "main": [[{"node": "Format Output", "type": "main", "index": 0}]]
    }
  }
}

Ersetze your-credential-id nach dem Import durch die tatsächliche Credential-ID aus deiner n8n-Instanz.

Schritt 3: RAG-Workflow — Retrieval und Generierung

Retrieval-Augmented Generation (RAG) ist der Punkt, an dem n8n + private KI richtig nützlich wird. Statt auf die Trainingsdaten des Modells angewiesen zu sein, fütterst du es zur Abfragezeit mit relevantem Kontext aus deinen eigenen Dokumenten.

Dieser Workflow nimmt eine Frage per Webhook entgegen, sucht relevante Textblöcke aus einer Vektordatenbank, baut einen fundierten Prompt und liefert eine Antwort zurück.

Architektur

Webhook (question) → HTTP Request (query vector DB) → Code (build prompt) → OpenAI Chat (generate) → Respond to Webhook

Voraussetzungen für diesen Workflow

Du brauchst eine Vektordatenbank, in der deine Dokumente bereits indexiert sind. Dieses Beispiel nutzt Qdrant, weil es Open Source und einfach selbst zu hosten ist — aber jede Vektordatenbank mit HTTP-API funktioniert.

Falls du noch keine Vektordatenbank hast, schau dir unseren Guide zu RAG ohne Vektordatenbank an — ein einfacherer Startpunkt.

Node-Konfiguration

Node 1: Webhook

Der Webhook erwartet einen JSON-Body wie:

{
  "question": "What is our refund policy for enterprise customers?"
}

Node 2: Embedding für die Frage generieren

Bevor du die Vektordatenbank abfragst, brauchst du ein Embedding der Frage. Nutze einen HTTP Request Node, um JuiceFactorys Embedding-Endpunkt aufzurufen:

{
  "model": "qwen3-embed",
  "input": "={{ $json.body.question }}"
}

Node 3: HTTP Request — Qdrant abfragen

{
  "vector": "={{ $json.data[0].embedding }}",
  "limit": 5,
  "with_payload": true
}

Das liefert die 5 relevantesten Dokumenten-Chunks zurück.

Node 4: Code — Prompt zusammenbauen

Nutze einen Code Node, um die abgerufenen Chunks zu einem Prompt zusammenzusetzen:

const results = $input.first().json.result;
const question = $('Webhook').first().json.body.question;

const context = results
  .map((r, i) => `[${i + 1}] ${r.payload.text}`)
  .join('\n\n');

const systemPrompt = `You are a helpful assistant. Answer the user's question based ONLY on the provided context. If the context doesn't contain enough information, say so. Cite sources using [1], [2], etc.`;

const userPrompt = `Context:\n${context}\n\nQuestion: ${question}`;

return [{
  json: {
    systemPrompt,
    userPrompt,
    sourceCount: results.length
  }
}];

Node 5: OpenAI Chat — Antwort generieren

Eine niedrige Temperature hält die Antwort nah am abgerufenen Kontext. Höhere Werte erhöhen die Wahrscheinlichkeit von Halluzinationen.

Node 6: Respond to Webhook

Gib die generierte Antwort zurück:

{
  "answer": "={{ $json.message.content }}",
  "sources_used": "={{ $('Build Prompt').first().json.sourceCount }}"
}

RAG-Workflow testen

Aktiviere den Workflow und teste von der Kommandozeile:

curl -s -X POST https://your-n8n-instance.com/webhook/ask \
  -H "Content-Type: application/json" \
  -d '{"question": "What is our refund policy for enterprise customers?"}' | jq .

Fortgeschrittene Patterns

Fehlerbehandlung mit Retry und Fallback

KI-API-Aufrufe können fehlschlagen — Rate Limits, Timeouts, temporäre Fehler. Die Fehlerbehandlung von n8n ist hier dein Freund.

Retry bei Fehler:

Aktiviere am OpenAI Chat Node Retry on Fail:

Das fängt temporäre 500er-Fehler und kurzzeitige Rate-Limit-Antworten (429) ab.

Fallback mit Error Trigger:

Für ausgefeiltere Behandlung nutze einen Error-Trigger-Workflow:

Haupt-Workflow:
  Webhook → OpenAI Chat → Respond to Webhook

Error-Workflow:
  Error Trigger → IF (check error type) → [
    Rate Limit → Wait 10s → Retry via HTTP Request
    Timeout → Return cached/fallback response
    Auth Error → Send Slack alert to ops team
  ]

Token-Zählung für Kostentracking

JuiceFactory gibt den Token-Verbrauch in der API-Antwort zurück, genau wie OpenAI. Nutze einen Code Node nach dem OpenAI Chat Node, um die Werte zu extrahieren und zu loggen:

const response = $input.first().json;
const usage = response.usage || {};

return [{
  json: {
    content: response.message.content,
    tokens_prompt: usage.prompt_tokens || 0,
    tokens_completion: usage.completion_tokens || 0,
    tokens_total: usage.total_tokens || 0,
    estimated_cost_eur: ((usage.total_tokens || 0) / 1000) * 0.002
  }
}];

Leite diese Werte in ein Google Sheet, eine Datenbank oder ein Monitoring-Tool weiter, um den Verbrauch über die Zeit zu tracken. Das ist besonders nützlich, wenn mehrere Teams einen einzelnen API-Key teilen.

Batch-Verarbeitung mit SplitInBatches

Wenn du eine Liste von Elementen verarbeiten musst (E-Mails, Dokumente, Zeilen aus einer Tabellenkalkulation), verhindert der SplitInBatches-Node, dass du die API überlastest:

Read Spreadsheet → SplitInBatches (batch size: 5) → OpenAI Chat → Merge results

Konfiguration am SplitInBatches-Node:

Füge nach dem OpenAI Chat Node einen Wait Node mit 500ms Verzögerung ein, um sicher innerhalb der Rate Limits zu bleiben. Das ist langsamer, aber zuverlässig — du bekommst keine 429er um 3 Uhr nachts, wenn niemand hinschaut.

Streaming-Antworten — Einschränkungen in n8n

Stand n8n 1.x unterstützt der OpenAI Chat Node kein Streaming. Die Antwort kommt als einzelner Block, nachdem die Generierung abgeschlossen ist. Wenn du Streaming für eine nutzergerichtete Chat-Oberfläche brauchst, nutze eine direkte WebSocket- oder SSE-Verbindung von deinem Frontend zur JuiceFactory-API, nicht n8n.

n8n eignet sich besser für Backend-Workflows, bei denen die Antwortzeit eher in der Kategorie "ein paar Sekunden sind okay" liegt — und nicht "First-Token-Latency ist entscheidend".

Praxisbeispiele

1. Support-Triage — eingehende E-Mails klassifizieren

Problem: Dein Support-Postfach bekommt über 200 E-Mails am Tag. Du musst sie an das richtige Team weiterleiten und dringende Probleme kennzeichnen.

Workflow:

IMAP Trigger (new email) → OpenAI Chat (classify) → Switch (route by category) → [
  billing → Jira (create ticket in Billing queue)
  technical → Jira (create ticket in Engineering queue)
  urgent → Jira (create P1 ticket) + Slack (alert on-call)
  spam → Move to trash
]

Klassifizierungs-Prompt (System-Message):

Classify the following customer email into exactly one category:
- billing (invoices, payments, pricing, subscription changes)
- technical (bugs, errors, integration help, API issues)
- urgent (service down, data loss, security incident)
- spam (marketing, unrelated, automated)

Also extract:
- customer_name: the sender's name if identifiable
- sentiment: positive, neutral, or negative
- summary: one sentence

Respond in JSON only. No explanation.

Der Switch-Node routet basierend auf $json.message.content, geparst als JSON:

// In a Code node before the Switch:
const classification = JSON.parse($json.message.content);
return [{ json: classification }];

Dann prüft der Switch-Node {{ $json.category }} gegen die vier Werte.

Warum das private KI braucht: Kunden-E-Mails enthalten Namen, Kontodaten, Vertragsbedingungen und manchmal personenbezogene Daten. Wenn du sie über eine US-basierte KI-API leitest, verlassen diese Daten die EU. Mit JuiceFactory findet die Klassifizierung auf EU-Infrastruktur mit Null-Speicherung statt.

2. Rechnungs-Datenextraktion — PDF zu strukturiertem JSON

Problem: Deine Buchhaltung bekommt Rechnungen als PDF-Anhänge. Du musst die Schlüsselfelder in dein ERP-System extrahieren.

Workflow:

IMAP Trigger (new email with attachment) → Extract Attachment → HTTP Request (convert PDF to text) → OpenAI Chat (extract fields) → Code (validate) → HTTP Request (POST to ERP API)

Extraktions-Prompt:

Extract the following fields from this invoice text. Return valid JSON only.

{
  "vendor_name": "",
  "invoice_number": "",
  "invoice_date": "YYYY-MM-DD",
  "due_date": "YYYY-MM-DD",
  "currency": "EUR/USD/SEK/etc",
  "line_items": [
    {"description": "", "quantity": 0, "unit_price": 0.00, "total": 0.00}
  ],
  "subtotal": 0.00,
  "vat_rate": 0.00,
  "vat_amount": 0.00,
  "total_amount": 0.00,
  "payment_reference": "",
  "iban": ""
}

If a field is not found, use null. Do not guess values.

Validierungs-Code-Node:

const extracted = JSON.parse($json.message.content);

// Basic validation
const errors = [];
if (!extracted.invoice_number) errors.push('Missing invoice number');
if (!extracted.total_amount) errors.push('Missing total amount');
if (extracted.total_amount < 0) errors.push('Negative total');

if (errors.length > 0) {
  return [{
    json: {
      status: 'validation_failed',
      errors,
      raw: extracted
    }
  }];
}

return [{
  json: {
    status: 'valid',
    ...extracted
  }
}];

Leite fehlgeschlagene Validierungen in eine manuelle Prüf-Queue weiter. Gültige Extraktionen gehen an die ERP-API.

Warum das private KI braucht: Rechnungen enthalten Lieferantennamen, Bankkontonummern (IBAN), Beträge und Geschäftsbeziehungen. Das sind geschäftskritische Daten, die in deiner Infrastruktur bleiben sollten — nicht in einem Trainings-Datensatz.

3. Interne Wissensdatenbank-Q&A — Slack zu n8n zu JuiceFactory zu Slack

Problem: Dein Team stellt immer wieder die gleichen Fragen. Ihr habt Dokumentation in Confluence/Notion/Google Drive, aber niemand liest sie.

Workflow:

Slack Trigger (app mention) → Code (extract question) → HTTP Request (search docs) → Code (build RAG prompt) → OpenAI Chat (generate answer) → Slack (reply in thread)

Slack Trigger Konfiguration:

Richte eine Slack-App mit dem Scope app_mentions:read ein. Der Trigger feuert, wenn jemand den Bot @erwähnt.

Code Node — Frage extrahieren:

const event = $json;
const question = event.event.text.replace(/<@[A-Z0-9]+>/g, '').trim();
const channel = event.event.channel;
const threadTs = event.event.ts;

return [{
  json: { question, channel, threadTs }
}];

Search-Node — Dokumenten-Index abfragen:

Das ist das gleiche Vektordatenbank-Suchmuster wie im RAG-Workflow oben. Passe es an deine Dokumentenquelle an.

Slack-Antwort:

Die Antwort im Thread hält den Kanal sauber. Die Bot-Antwort erscheint direkt unter der Frage.

Warum das private KI braucht: Interne Dokumentation enthält oft Architektur-Details, Sicherheitskonfigurationen, kundenspezifische Informationen und Geschäftsstrategie. All das als RAG-Kontext an eine öffentliche API zu senden, legt proprietäre Informationen offen.

DSGVO-Aspekte für n8n-Workflows

JuiceFactory macht den KI-Inferenz-Schritt DSGVO-konform. Aber der Workflow selbst hat seinen eigenen Umgang mit Daten, den du bedenken musst.

n8n-Ausführungsprotokolle enthalten personenbezogene Daten

Jede Workflow-Ausführung in n8n wird protokolliert. Diese Logs enthalten die Eingabedaten, die Ausgabedaten und alles dazwischen. Wenn dein Workflow Kunden-E-Mails verarbeitet, steht der vollständige E-Mail-Text im Ausführungsprotokoll.

Was du tun solltest:

• Setze die Aufbewahrungsfrist für Ausführungsprotokolle auf das Minimum, das du brauchst. In den n8n-Einstellungen: Settings → Executions → Prune Executions
• Für Produktion setze die Aufbewahrung auf 7-30 Tage, je nach Debugging-Bedarf
• Für Workflows, die sensible Daten verarbeiten, erwäge das Speichern von Ausführungen ganz zu deaktivieren (EXECUTIONS_DATA_SAVE_ON_ERROR=none und EXECUTIONS_DATA_SAVE_ON_SUCCESS=none als Umgebungsvariablen)

Self-Hosted vs. n8n Cloud — Datenstandort

Für die stärkste DSGVO-Position: Hoste n8n selbst auf EU-Infrastruktur und verbinde es mit JuiceFactory. Die gesamte Pipeline — Trigger, Verarbeitung, Inferenz, Antwort — bleibt in der EU.

JuiceFactorys Null-Speicherung macht den KI-Schritt sauber

Aus Sicht von DSGVO Artikel 28 ist der KI-Inferenz-Schritt mit JuiceFactory unkompliziert:

• Kein Auftragsverarbeitungsvertrag für gespeicherte Daten nötig (es gibt keine gespeicherten Daten)
• Keine Auskunftsanfragen Betroffener auf Inferenz-Ebene zu erfüllen
• Keine Aufbewahrungsfristen zu tracken
• Der Datenfluss ist: Prompt rein → Antwort raus → nichts gespeichert

Das bedeutet, dein DSGVO-Aufwand konzentriert sich auf n8n selbst (Ausführungsprotokolle, Credential-Speicherung, Workflow-Daten) und nicht auf den KI-Anbieter.

Credential-Sicherheit

Dein JuiceFactory API-Key gibt Zugang zur Inferenz. Behandle ihn wie ein Datenbank-Passwort:

• Bei selbst gehostetem n8n werden Credentials im Ruhezustand mit N8N_ENCRYPTION_KEY verschlüsselt. Stelle sicher, dass du einen starken Key gesetzt hast.
• Committe Credentials niemals in die Versionskontrolle
• Rotiere API-Keys regelmäßig über das JuiceFactory-Portal
• Nutze separate API-Keys für Entwicklungs- und Produktions-Workflows

Fehlerbehebung

Häufige Fehler

401 Unauthorized

Error: Request failed with status code 401

Dein API-Key ist falsch oder abgelaufen. Prüfe:

• Der Key beginnt mit jf_
• Keine zusätzlichen Leerzeichen im Credential-Feld
• Der Key ist im JuiceFactory-Portal aktiv

429 Too Many Requests

Error: Request failed with status code 429

Du hast das Rate Limit erreicht. Optionen:

• Aktiviere Retry am Node (siehe Fortgeschrittene Patterns oben)
• Füge einen Wait-Node vor dem KI-Node in Batch-Workflows ein
• Prüfe die Rate Limits deines Plans im Portal

Timeout / ECONNREFUSED

Error: connect ECONNREFUSED

n8n kann die JuiceFactory-API nicht erreichen. Prüfe:

• Deine n8n-Instanz hat Internetzugang (oder Netzwerkzugang zur API bei privaten Endpunkten)
• Keine Firewall blockiert ausgehende HTTPS-Verbindungen auf Port 443
• DNS löst api.juicefactory.ai vom n8n-Host auf

Teste vom n8n-Host aus:

curl -v https://api.juicefactory.ai/v1/models \
  -H "Authorization: Bearer jf_your-key"

Model not found

Error: Model 'gpt-4' not found

JuiceFactory hostet eigene Modelle, nicht die von OpenAI. Prüfe die verfügbaren Modelle:

curl -s https://api.juicefactory.ai/v1/models \
  -H "Authorization: Bearer jf_your-key" | jq '.data[].id'

Verwende eine der zurückgegebenen Model-IDs in deiner n8n-Node-Konfiguration.

API-Verbindung von n8n aus testen

Wenn du unsicher bist, ob n8n JuiceFactory erreichen kann, füge einen temporären HTTP Request Node hinzu:

1. Erstelle einen neuen Workflow mit einem Manual Trigger
2. Füge einen HTTP Request Node hinzu
3. Method: GET
4. URL: https://api.juicefactory.ai/v1/models
5. Authentication: Header Auth mit deinem JuiceFactory-Credential
6. Ausführen

Wenn eine JSON-Liste von Modellen zurückkommt, funktioniert die Verbindung. Bei einem Fehler sagt dir die Fehlermeldung genau, was nicht stimmt (DNS, Firewall, Auth).

Debug-Modus in n8n

Wenn ein Workflow sich unerwartet verhält, nutze die eingebauten Debugging-Funktionen von n8n:

1. Ausführungsvorschau: Klicke auf eine vergangene Ausführung, um die Daten an jedem Node zu sehen. Die Input/Output-Panels zeigen genau, was an JuiceFactory gesendet und von dort empfangen wurde.

2. Pin Data: Pinne die Ausgabe von Nodes vor dem KI-Node fest und führe dann nur den KI-Schritt erneut aus. So vermeidest du beim Debuggen erneutes Abrufen von Dokumenten oder Datenbankabfragen.

3. Expression Editor: Nutze den Expression Editor am OpenAI Chat Node, um den exakten Prompt zu inspizieren, der gesendet wird. Wenn der Prompt leer oder fehlerhaft ist, siehst du es hier.

4. Workflow-Ausführungsliste: Filtere nach Status (Error, Success), um fehlgeschlagene Runs zu finden. Die Fehlermeldung am fehlerhaften Node reicht in der Regel zur Diagnose.

Performance-Tipps

Das richtige Modell für die Aufgabe wählen

Nicht jeder Workflow braucht das größte Modell. Für Klassifizierung und einfache Extraktion sind kleinere Modelle schneller und günstiger:

max_tokens passend setzen

Verwende nicht den Standard-max_tokens-Wert für jeden Workflow. Eine Klassifizierungsaufgabe braucht 50 Tokens. Eine Zusammenfassung braucht 500. Eine detaillierte Analyse vielleicht 2000. Richtig gesetzte Werte reduzieren Latenz und Kosten:

Classification prompt → max_tokens: 100
Summary prompt → max_tokens: 500
Full analysis → max_tokens: 2000

Wiederholte Abfragen cachen

Wenn dein Workflow häufig den gleichen Eingabetyp verarbeitet (z.B. E-Mails in Kategorien klassifizieren), denke über Caching nach. Nutze den Code-Node von n8n mit einer einfachen In-Memory-Map oder frage einen Redis-/Datenbank-Cache ab, bevor du die KI-API ansprichst.

Weiterführende Guides

• Von OpenAI zu einer EU-API migrieren — Zwei Zeilen Code-Änderung, um von OpenAI zu JuiceFactory zu wechseln
• Zustandslose LLM-APIs und DSGVO — Tiefgehender Blick darauf, warum Null-Speicherungs-Inferenz für Compliance wichtig ist
• RAG ohne Vektordatenbank — Eine minimale RAG-Pipeline in Python bauen, bevor du Infrastruktur hinzufügst
• BYOK AI — Bring Your Own Key — Nutze deine eigenen API-Keys mit JuiceFactorys EU-Infrastruktur

Nächste Schritte

Du hast die Bausteine: Credentials konfiguriert, einen funktionierenden Zusammenfassungs-Workflow, ein RAG-Pattern und drei produktionsreife Beispiele zum Anpassen.

Der schnellste Einstieg ist, das Beispiel auszuwählen, das deinem Anwendungsfall am nächsten kommt, das Workflow-JSON zu importieren, deine Credentials und dein Modell einzusetzen und mit echten Daten zu testen.

Wenn du n8n-Workflows betreibst, die personenbezogene EU-Daten verarbeiten, und der KI-Schritt konform sein muss, hol dir deinen JuiceFactory API-Key — dein erster privater KI-Workflow kann in unter 15 Minuten laufen.