n8n + privat AI: Bygg GDPR-kompatibla automatiseringsflöden med JuiceFactory

n8n är kraftfullt för att automatisera affärsprocesser. Att lägga till LLM-funktioner gör det ännu kraftfullare. Men om dina arbetsflöden hanterar känsliga data — kundmail, kontrakt, interna dokument — skapar det ett complianceproblem att skicka den datan till publika AI-leverantörer. Ett problem du förmodligen vill slippa.

JuiceFactory löser det. Det är ett EU-hostat, GDPR-kompatibelt inferens-API som pratar OpenAI-protokollet. Det innebär att n8n:s inbyggda OpenAI-noder fungerar utan modifikation. Du byter en URL och en API-nyckel, och din arbetsflödesdata stannar i EU med noll datalagring på inferenssidan.

Den här guiden går igenom hela uppsättningen: credentials, ditt första arbetsflöde, RAG-mönster, produktionsfärdiga exempel och GDPR-detaljerna som spelar roll för automatiseringspipelines.

Varför n8n + privat inferens

Håll arbetsflödesdata i EU

När n8n bearbetar dokument, kundkommunikation eller HR-data behöver du veta vart den datan tar vägen. Med JuiceFactory körs AI-inferenssteget på EU-infrastruktur. Inga transatlantiska dataöverföringar, inga debatter om adekvansbeslutet, inga kompletterande skyddsåtgärder.

Noll datalagring vid inferens

Publika AI-API:er tar emot dina prompter och sparar dem — vanligtvis 30 dagar för missbruksövervakning. JuiceFactory fungerar tillståndslöst: din prompt kommer in, svaret går ut, inget lagras. AI-noden i ditt arbetsflöde blir inte en datalagringsrisk.

Förutsägbar latens

Delad infrastruktur innebär delade resurser. Under topptider på publika API:er kan latensen hoppa från 200ms till 2+ sekunder. Dedikerad EU-infrastruktur ger dig konsistenta svarstider, vilket spelar roll när dina n8n-arbetsflöden har SLA:er eller timeouts.

OpenAI-kompatibilitet = noll migrationsarbete

Om du redan har n8n-arbetsflöden som använder OpenAI-noder är bytet till JuiceFactory bara en ändring av credentials. Samma förfrågningsformat, samma svarsformat, samma nodkonfiguration. Enda skillnaden är var inferensen sker.

Förutsättningar

Innan du börjar behöver du tre saker:

1. En körande n8n-instans

Antingen självhostad eller n8n Cloud. Version 1.30+ rekommenderas — tidigare versioner har problem med anpassade OpenAI-bas-URL:er.

Om du självhostar är Docker enklaste vägen:

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

2. En JuiceFactory API-nyckel

Registrera dig på portal.juicefactory.ai och generera en API-nyckel. Nycklar har prefixet jf_ så de är lätta att identifiera i din credential-hantering.

3. Verifiera din API-åtkomst

Innan du rör n8n, bekräfta att API:et svarar:

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

Du bör se en lista med tillgängliga modeller. Får du en 401, kontrollera din nyckel. Får du timeout, kolla din nätverksanslutning — endpointen måste vara nåbar från var n8n körs.

Du kan också testa en snabb completion:

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

Får du ett svar tillbaka är du redo.

Steg 1: Konfigurera JuiceFactory-credentials i n8n

n8n använder credential-typen "OpenAI" för alla OpenAI-kompatibla API:er. Så här sätter du upp det.

Lägg till credentialen

1. I n8n, gå till Credentials i vänstra sidofältet
2. Klicka på Add Credential
3. Sök efter OpenAI API och välj det
4. Fyll i följande fält:

5. Klicka Save

Klart. Bas-URL:en talar om för n8n att skicka alla OpenAI-formaterade förfrågningar till JuiceFactory istället för OpenAI:s servrar.

Namnge credentialen tydligt

Kalla den något i stil med JuiceFactory EU eller JuiceFactory Production. När du har flera credentials (kanske en staging-nyckel och en produktionsnyckel) förhindrar tydlig namngivning oavsiktliga felrutningar av data.

Testa credentialen

Efter att du sparat, skapa ett snabbt testarbetsflöde:

1. Lägg till en Manual Trigger-nod
2. Lägg till en OpenAI Chat Model-nod
3. Välj din nya JuiceFactory-credential
4. Sätt modellen till qwen3-30b-a3b
5. Skriv "Respond with OK" i prompten
6. Kör arbetsflödet

Får du "OK" tillbaka fungerar credentialen. Får du ett felmeddelande, se felsökningssektionen nedan.

Alternativ: HTTP Header Auth

För mer kontroll (eller om du vill nå endpoints utöver chat completions) kan du använda HTTP Request-noden med Header Auth:

1. Skapa en Header Auth-credential
2. Sätt Name till Authorization
3. Sätt Value till Bearer jf_your-api-key-here

Det ger dig rå tillgång till vilken JuiceFactory-endpoint som helst via HTTP Request-noden.

Steg 2: Ditt första AI-arbetsflöde — dokumentsammanfattning

Låt oss bygga något användbart. Det här arbetsflödet tar en dokument-URL, hämtar innehållet och returnerar en AI-genererad sammanfattning.

Arbetsflödesöversikt

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

Nod-för-nod-konfiguration

Nod 1: Manual Trigger

Inget att konfigurera. Det här är din startpunkt. I produktion ersätter du den med en webhook, ett schema eller en annan trigger.

Nod 2: HTTP Request — hämta dokumentet

För testning, hårdkoda en URL till ett textdokument eller en enkel webbsida.

Nod 3: OpenAI Chat — sammanfatta

Nod 4: Set — formatera utdata

Mappa svaret till rena utdatafält:

Arbetsflödet som importerbar JSON

Kopiera det här i n8n via 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}]]
    }
  }
}

Ersätt your-credential-id med det faktiska credential-ID:t från din n8n-instans efter import.

Steg 3: RAG-arbetsflöde — hämta och generera

Retrieval-augmented generation (RAG) är där n8n + privat AI blir riktigt användbart. Istället för att förlita dig på modellens träningsdata matar du den med relevant kontext från dina egna dokument vid frågetillfället.

Det här arbetsflödet tar emot en fråga via webhook, hämtar relevanta textdelar från en vektordatabas, bygger en grundad prompt och returnerar ett svar.

Arkitektur

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

Förutsättningar för det här arbetsflödet

Du behöver en vektordatabas med dina dokument redan indexerade. Det här exemplet använder Qdrant eftersom det är open source och enkelt att självhosta, men vilken vektordatabas som helst med HTTP-API fungerar.

Om du inte har en vektordatabas ännu, se vår guide om RAG utan vektordatabas som utgångspunkt.

Nodkonfiguration

Nod 1: Webhook

Webhooken förväntar sig en JSON-body som:

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

Nod 2: Hämta embedding för frågan

Innan du frågar vektordatabasen behöver du en embedding av frågan. Använd en HTTP Request-nod för att anropa JuiceFactorys embedding-endpoint:

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

Nod 3: HTTP Request — fråga Qdrant

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

Det här returnerar de 5 mest relevanta dokumentdelarna.

Nod 4: Code — bygg prompten

Använd en Code-nod för att sätta ihop de hämtade textdelarna till en prompt:

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
  }
}];

Nod 5: OpenAI Chat — generera svar

Låg temperature håller svaret grundat i den hämtade kontexten. Högre värden ökar risken för hallucination.

Nod 6: Respond to Webhook

Returnera det genererade svaret:

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

Testa RAG-arbetsflödet

Aktivera arbetsflödet och testa från kommandoraden:

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 .

Avancerade mönster

Felhantering med retry och fallback

AI-API-anrop kan misslyckas — rate limits, timeouts, tillfälliga fel. n8n:s felhantering är din vän här.

Retry vid fel:

På OpenAI Chat-noden, aktivera Retry on Fail:

Det här hanterar tillfälliga 500-fel och kortvariga rate limit-svar (429).

Fallback med Error Trigger:

För mer sofistikerad hantering, använd ett Error Trigger-arbetsflöde:

Main 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
  ]

Tokenräkning för kostnadsuppföljning

JuiceFactory returnerar tokenanvändning i API-svaret, precis som OpenAI. Använd en Code-nod efter OpenAI Chat-noden för att extrahera och logga det:

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
  }
}];

Skicka dessa värden till ett Google Sheet, en databas eller ett övervakningsverktyg för att spåra användning över tid. Det här är särskilt användbart när flera team delar en och samma API-nyckel.

Batchbearbetning med SplitInBatches

När du behöver bearbeta en lista med objekt (e-post, dokument, rader från ett kalkylblad) förhindrar SplitInBatches-noden att du överbelastar API:et:

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

Konfiguration på SplitInBatches-noden:

Lägg till en Wait-nod efter OpenAI Chat-noden med 500ms fördröjning för att hålla dig väl inom rate limits. Det är långsammare men pålitligt — du slipper 429-fel klockan 3 på natten när ingen bevakar.

Streaming-svar — begränsningar i n8n

I nuvarande n8n 1.x stöder inte OpenAI Chat-noden streaming. Svaret kommer som ett helt block efter att genereringen är klar. Om du behöver streaming för ett användargränssnitt med chatt, använd en direkt WebSocket- eller SSE-anslutning från din frontend till JuiceFactory-API:et, inte n8n.

n8n passar bättre för backend-arbetsflöden där svarstiden mäts i "sekunder är helt OK" snarare än "latens till första token spelar roll."

Verkliga arbetsflödesexempel

1. Kundtjänsttriage — klassificera inkommande e-post

Problem: Er supportinkorg får 200+ mejl per dag. Ni behöver dirigera dem till rätt team och flagga brådskande ärenden.

Arbetsflöde:

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
]

Klassificeringsprompt (systemmeddelande):

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.

Switch-noden routar baserat på $json.message.content parsat som JSON:

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

Sedan kontrollerar Switch-noden {{ $json.category }} mot de fyra värdena.

Varför det här behöver privat AI: Kundmejl innehåller namn, kontodetaljer, avtalsvillkor och ibland personuppgifter. Att dirigera dem via ett USA-baserat AI-API innebär att den datan lämnar EU. Med JuiceFactory sker klassificeringen på EU-infrastruktur med noll datalagring.

2. Fakturaextraktion — PDF till strukturerad JSON

Problem: Ditt ekonomiteam tar emot fakturor som PDF-bilagor. Ni behöver extrahera nyckelfält till ert ERP-system.

Arbetsflöde:

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)

Extraktionsprompt:

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.

Valideringens Code-nod:

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
  }
}];

Dirigera valideringsfel till en kö för manuell granskning. Dirigera godkända extraheringar till ERP-API:et.

Varför det här behöver privat AI: Fakturor innehåller leverantörsnamn, bankkontonummer (IBAN), belopp och affärsrelationer. Det är kommersiellt känslig data som hör hemma i din infrastruktur, inte i ett träningsdataset.

3. Intern kunskapsbas Q&A — Slack till n8n till JuiceFactory till Slack

Problem: Ditt team ställer samma frågor om och om igen. Ni har dokumentation i Confluence/Notion/Google Drive men ingen läser den.

Arbetsflöde:

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:

Sätt upp en Slack-app med app_mentions:read-scope. Triggern aktiveras när någon @nämner boten.

Code-nod — extrahera frågan:

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 }
}];

Söknod — fråga ditt dokumentindex:

Det är samma vektordatabas-sökmönster som i RAG-arbetsflödet ovan. Anpassa det till din dokumentationskälla.

Slack-svar:

Att svara i tråden håller kanalen ren. Botens svar dyker upp direkt under frågan.

Varför det här behöver privat AI: Intern dokumentation innehåller ofta arkitekturdetaljer, säkerhetskonfigurationer, kundspecifik information och affärsstrategi. Att skicka den till ett publikt API som del av RAG-kontext exponerar proprietär information.

GDPR-överväganden för n8n-arbetsflöden

Att använda JuiceFactory gör AI-inferenssteget GDPR-kompatibelt. Men arbetsflödet i sig har egen datahantering som du behöver tänka på.

n8n:s exekveringsloggar innehåller personuppgifter

Varje arbetsflödeskörning i n8n loggas. Dessa loggar inkluderar indata, utdata och allt däremellan. Om ditt arbetsflöde bearbetar kundmejl finns hela mejltexten i exekveringsloggen.

Vad du bör göra:

• Sätt retentionstiden för exekveringsloggar till det minimum du behöver. I n8n-inställningar: Settings → Executions → Prune Executions
• I produktion, sätt retentionen till 7-30 dagar beroende på dina felsökningsbehov
• För arbetsflöden som hanterar känslig data, överväg att inaktivera exekveringsloggning helt (EXECUTIONS_DATA_SAVE_ON_ERROR=none och EXECUTIONS_DATA_SAVE_ON_SUCCESS=none som miljövariabler)

Självhostad kontra n8n Cloud — datalokaliserng

Starkast GDPR-ställning: självhosta n8n på EU-infrastruktur och anslut den till JuiceFactory. Hela pipelinen — trigger, bearbetning, inferens, svar — stannar inom EU.

JuiceFactorys noll-retention gör AI-steget rent

Ur GDPR artikel 28-perspektiv är AI-inferenssteget med JuiceFactory enkelt:

• Inget personuppgiftsbiträdesavtal behövs för lagrad data (det finns ingen lagrad data)
• Inga registerutdrag att hantera på inferenslagret
• Inga retentionsscheman att spåra
• Dataflödet är: prompt in → svar ut → inget bevarat

Det innebär att ditt GDPR-arbete fokuserar på n8n självt (exekveringsloggar, credential-lagring, arbetsflödesdata) snarare än på AI-leverantören.

Credential-säkerhet

Din JuiceFactory API-nyckel ger tillgång till inferens. Behandla den som ett databaslösenord:

• I självhostad n8n krypteras credentials i vila med N8N_ENCRYPTION_KEY. Se till att du har satt en stark nyckel.
• Committa aldrig credentials till versionshantering
• Rotera API-nycklar regelbundet via JuiceFactory-portalen
• Använd separata API-nycklar för utvecklings- och produktionsarbetsflöden

Felsökning

Vanliga fel

401 Unauthorized

Error: Request failed with status code 401

Din API-nyckel är fel eller har gått ut. Kontrollera:

• Nyckeln börjar med jf_
• Inga extra mellanslag i credential-fältet
• Nyckeln är aktiv i JuiceFactory-portalen

429 Too Many Requests

Error: Request failed with status code 429

Du har nått rate limit. Alternativ:

• Aktivera retry på noden (se Avancerade mönster ovan)
• Lägg till en Wait-nod före AI-noden i batcharbetsflöden
• Kontrollera din plans rate limits i portalen

Timeout / ECONNREFUSED

Error: connect ECONNREFUSED

n8n kan inte nå JuiceFactory-API:et. Kontrollera:

• Din n8n-instans har internetåtkomst (eller nätverksåtkomst till API:et om du använder privata endpoints)
• Ingen brandvägg blockerar utgående HTTPS på port 443
• DNS löser upp api.juicefactory.ai från n8n-hosten

Testa från n8n-hosten:

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

Modellen hittades inte

Error: Model 'gpt-4' not found

JuiceFactory hostar sina egna modeller, inte OpenAI:s. Kontrollera tillgängliga modeller:

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

Använd ett av de returnerade modell-ID:na i din n8n-nodkonfiguration.

Hur du testar API-anslutningen från n8n

Om du är osäker på om n8n kan nå JuiceFactory, lägg till en tillfällig HTTP Request-nod:

1. Skapa ett nytt arbetsflöde med en Manual Trigger
2. Lägg till en HTTP Request-nod
3. Method: GET
4. URL: https://api.juicefactory.ai/v1/models
5. Authentication: Header Auth med din JuiceFactory-credential
6. Kör

Om det returnerar en JSON-lista med modeller fungerar anslutningen. Om det misslyckas berättar felmeddelandet exakt vad som är fel (DNS, brandvägg, auth).

Debug-läge i n8n

När ett arbetsflöde beter sig konstigt, använd n8n:s inbyggda debugging:

1. Exekveringsförhandsgranskning: Klicka på vilken tidigare exekvering som helst för att se datan vid varje nod. Input/output-panelerna visar exakt vad som skickades till och mottogs från JuiceFactory.

2. Pin data: Fäst utdatan från noder uppströms AI-noden, kör sedan bara AI-steget igen. Det slipper du hämta dokument eller fråga databaser på nytt under felsökning.

3. Expression editor: Använd expression-editorn på OpenAI Chat-noden för att inspektera exakt vilken prompt som skickas. Om prompten är tom eller felformaterad ser du det här.

4. Lista över arbetsflödeskörningar: Filtrera på status (error, success) för att hitta misslyckade körningar. Felmeddelandet på den felande noden räcker vanligtvis för att diagnostisera problemet.

Prestandatips

Välj rätt modell för uppgiften

Inte varje arbetsflöde behöver den största modellen. För klassificering och enkel extraktion är mindre modeller snabbare och billigare:

Ställ in max_tokens korrekt

Använd inte standard max_tokens för varje arbetsflöde. En klassificeringsuppgift behöver 50 tokens. En sammanfattning behöver 500. En detaljerad analys kan behöva 2000. Att ställa in det här rätt minskar latens och kostnad:

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

Cacha upprepade frågor

Om ditt arbetsflöde bearbetar samma typ av input ofta (t.ex. klassificering av e-post i kategorier), överväg att cacha resultat. Använd n8n:s Code-nod med en enkel in-memory map, eller fråga en Redis/databascache innan du anropar AI-API:et.

Relaterade guider

• Migrera från OpenAI till ett EU-API — Två raders kodändring för att byta från OpenAI till JuiceFactory i vilken applikation som helst
• Tillståndslösa LLM-API:er och GDPR — Djupdykning i varför noll-retention-inferens spelar roll för compliance
• RAG utan vektordatabas — Bygg en minimal RAG-pipeline i Python innan du lägger till infrastruktur
• BYOK AI — Bring Your Own Key — Använd dina egna API-nycklar med JuiceFactorys EU-infrastruktur

Nästa steg

Du har byggstenarna: credentials konfigurerade, ett fungerande sammanfattningsarbetsflöde, ett RAG-mönster och tre produktionsfärdiga exempel att anpassa.

Snabbaste sättet att komma igång är att välja det exempel som ligger närmast ditt användningsfall, importera arbetsflödets JSON, byta in dina credentials och modell, och testa med riktig data.

Om du kör n8n-arbetsflöden som hanterar personuppgifter inom EU och behöver att AI-steget är GDPR-kompatibelt, skaffa din JuiceFactory API-nyckel så kan du ha ditt första privata AI-arbetsflöde igång på under 15 minuter.