n8n + IA privée : créez des workflows d'automatisation conformes au RGPD avec JuiceFactory

n8n est un outil puissant pour automatiser vos processus métier. Y ajouter des capacités LLM le rend encore plus redoutable. Mais si vos workflows traitent des données sensibles — emails clients, contrats, documents internes — envoyer ces données vers des fournisseurs d'IA publics crée une faille de conformité dont vous pouvez vous passer.

JuiceFactory résout ce problème. C'est une API d'inférence hébergée dans l'UE, conforme au RGPD, qui parle le protocole OpenAI. Concrètement, les nœuds OpenAI natifs de n8n fonctionnent sans modification. Vous changez une URL et une clé API, et les données de votre workflow restent dans l'UE avec zéro rétention côté inférence.

Ce guide couvre l'intégralité du processus : credentials, votre premier workflow, les patterns RAG, des exemples prêts pour la production, et les aspects RGPD qui comptent pour vos pipelines d'automatisation.

Pourquoi n8n + inférence privée

Gardez les données de vos workflows dans l'UE

Quand n8n traite des documents, des communications clients ou des données RH, vous devez savoir où ces données transitent. Avec JuiceFactory, l'étape d'inférence IA tourne sur une infrastructure européenne. Pas de transfert transatlantique, pas de débats sur les décisions d'adéquation, pas de mesures supplémentaires à mettre en place.

Zéro rétention sur l'inférence

Les API d'IA publiques reçoivent vos prompts et les conservent — typiquement 30 jours pour la surveillance des abus. JuiceFactory fonctionne de manière stateless : votre prompt entre, la réponse sort, rien n'est stocké. Le nœud IA dans votre workflow ne devient pas un problème de rétention de données.

Latence prévisible

Infrastructure partagée signifie ressources partagées. Aux heures de pointe sur les API publiques, la latence peut passer de 200 ms à plus de 2 secondes. Une infrastructure dédiée dans l'UE vous garantit des temps de réponse constants, ce qui compte quand vos workflows n8n ont des SLA ou des timeouts.

Compatibilité OpenAI = zéro effort de migration

Si vous avez déjà des workflows n8n utilisant les nœuds OpenAI, passer à JuiceFactory se résume à un changement de credential. Même format de requête, même format de réponse, même configuration de nœud. La seule différence, c'est l'endroit où l'inférence s'exécute.

Prérequis

Avant de commencer, il vous faut trois choses :

1. Une instance n8n fonctionnelle

Auto-hébergée ou n8n Cloud. Version 1.30+ recommandée — les versions antérieures ont des comportements étranges avec les URL de base OpenAI personnalisées.

Si vous auto-hébergez, Docker est la voie la plus simple :

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

2. Une clé API JuiceFactory

Inscrivez-vous sur portal.juicefactory.ai et générez une clé API. Les clés sont préfixées par jf_ pour les identifier facilement dans votre gestionnaire de credentials.

3. Vérifiez votre accès API

Avant de toucher à n8n, confirmez que l'API répond :

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

Vous devriez voir une liste de modèles disponibles. Si vous obtenez une erreur 401, vérifiez votre clé. Si vous obtenez un timeout, vérifiez votre réseau — l'endpoint doit être accessible depuis la machine où n8n tourne.

Vous pouvez aussi tester une complétion rapide :

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

Si vous obtenez une réponse, vous êtes prêt.

Étape 1 : Configurer les credentials JuiceFactory dans n8n

n8n utilise le type de credential « OpenAI » pour toute API compatible OpenAI. Voici comment le mettre en place.

Ajouter le credential

1. Dans n8n, allez dans Credentials dans la barre latérale gauche
2. Cliquez sur Add Credential
3. Cherchez OpenAI API et sélectionnez-le
4. Remplissez les champs suivants :

5. Cliquez sur Save

C'est tout. Le remplacement de la base URL indique à n8n d'envoyer toutes les requêtes au format OpenAI vers JuiceFactory au lieu des serveurs d'OpenAI.

Nommez le credential clairement

Appelez-le quelque chose comme JuiceFactory EU ou JuiceFactory Production. Quand vous avez plusieurs credentials (peut-être une clé staging et une clé production), un nommage clair évite les erreurs de routage de données accidentelles.

Testez le credential

Après l'enregistrement, créez un workflow de test rapide :

1. Ajoutez un nœud Manual Trigger
2. Ajoutez un nœud OpenAI Chat Model
3. Sélectionnez votre nouveau credential JuiceFactory
4. Définissez le modèle sur qwen3-30b-a3b
5. Dans le prompt, tapez "Respond with OK"
6. Exécutez le workflow

Si vous recevez « OK » en retour, le credential fonctionne. Sinon, consultez la section dépannage ci-dessous.

Alternative : HTTP Header Auth

Pour plus de contrôle (ou si vous souhaitez appeler des endpoints au-delà des chat completions), vous pouvez utiliser le nœud HTTP Request avec Header Auth :

1. Créez un credential Header Auth
2. Définissez Name sur Authorization
3. Définissez Value sur Bearer jf_your-api-key-here

Cela vous donne un accès brut à n'importe quel endpoint JuiceFactory depuis le nœud HTTP Request.

Étape 2 : Votre premier workflow IA — résumé de document

Construisons quelque chose d'utile. Ce workflow prend l'URL d'un document, récupère son contenu et renvoie un résumé généré par l'IA.

Vue d'ensemble du workflow

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

Configuration nœud par nœud

Nœud 1 : Manual Trigger

Rien à configurer. C'est votre point d'entrée. En production, vous le remplaceriez par un webhook, un schedule ou un autre déclencheur.

Nœud 2 : HTTP Request — récupérer le document

Pour les tests, utilisez en dur l'URL d'un document texte ou d'une page web simple.

Nœud 3 : OpenAI Chat — résumer

Nœud 4 : Set — formater la sortie

Mappez la réponse vers des champs de sortie propres :

Le workflow au format JSON importable

Copiez-le dans 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}]]
    }
  }
}

Remplacez your-credential-id par l'ID réel du credential dans votre instance n8n après l'import.

Étape 3 : Workflow RAG — récupération et génération

La génération augmentée par récupération (RAG) est l'endroit où n8n + IA privée devient véritablement utile. Au lieu de compter sur les données d'entraînement du modèle, vous lui fournissez du contexte pertinent issu de vos propres documents au moment de la requête.

Ce workflow accepte une question via webhook, récupère les passages pertinents depuis une base vectorielle, construit un prompt contextualisé et renvoie une réponse.

Architecture

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

Prérequis pour ce workflow

Vous avez besoin d'une base vectorielle avec vos documents déjà indexés. Cet exemple utilise Qdrant parce qu'il est open-source et facile à auto-héberger, mais n'importe quelle base vectorielle avec une API HTTP fait l'affaire.

Si vous n'avez pas encore de base vectorielle, consultez notre guide RAG without a vector database pour un point de départ plus simple.

Configuration des nœuds

Nœud 1 : Webhook

Le webhook attend un body JSON de cette forme :

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

Nœud 2 : Obtenir l'embedding de la question

Avant d'interroger la base vectorielle, il faut un embedding de la question. Utilisez un nœud HTTP Request pour appeler l'endpoint d'embedding de JuiceFactory :

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

Nœud 3 : HTTP Request — interroger Qdrant

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

Cela renvoie les 5 passages de documents les plus pertinents.

Nœud 4 : Code — construire le prompt

Utilisez un nœud Code pour assembler les passages récupérés en un 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
  }
}];

Nœud 5 : OpenAI Chat — générer la réponse

Une température basse maintient la réponse ancrée dans le contexte récupéré. Des valeurs plus élevées augmentent le risque d'hallucination.

Nœud 6 : Respond to Webhook

Retournez la réponse générée :

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

Tester le workflow RAG

Activez le workflow, puis testez depuis la ligne de commande :

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 .

Patterns avancés

Gestion d'erreurs avec retry et fallback

Les appels à une API d'IA peuvent échouer — limites de débit, timeouts, erreurs transitoires. La gestion d'erreurs de n8n est votre alliée ici.

Retry en cas d'échec :

Sur le nœud OpenAI Chat, activez Retry on Fail :

Cela gère les erreurs 500 transitoires et les réponses brèves de type rate limit (429).

Fallback avec Error Trigger :

Pour une gestion plus sophistiquée, utilisez un workflow Error Trigger :

Workflow principal :
  Webhook → OpenAI Chat → Respond to Webhook

Workflow d'erreur :
  Error Trigger → IF (vérifier le type d'erreur) → [
    Rate Limit → Wait 10s → Retry via HTTP Request
    Timeout → Renvoyer une réponse en cache/fallback
    Auth Error → Envoyer une alerte Slack à l'équipe ops
  ]

Comptage de tokens pour le suivi des coûts

JuiceFactory renvoie l'utilisation de tokens dans la réponse API, exactement comme OpenAI. Utilisez un nœud Code après le nœud OpenAI Chat pour extraire et enregistrer ces données :

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

Envoyez ces valeurs vers un Google Sheet, une base de données ou un outil de monitoring pour suivre la consommation dans le temps. C'est particulièrement utile quand plusieurs équipes partagent la même clé API.

Traitement par lots avec SplitInBatches

Quand vous devez traiter une liste d'éléments (emails, documents, lignes d'un tableur), le nœud SplitInBatches vous évite de surcharger l'API :

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

Configuration du nœud SplitInBatches :

Ajoutez un nœud Wait après le nœud OpenAI Chat avec un délai de 500 ms pour rester largement dans les limites de débit. C'est plus lent mais fiable — pas de 429 à 3 h du matin quand personne ne surveille.

Réponses en streaming — limitations dans n8n

En l'état actuel de n8n 1.x, le nœud OpenAI Chat ne supporte pas le streaming. La réponse arrive en un seul bloc une fois la génération terminée. Si vous avez besoin du streaming pour une interface de chat utilisateur, utilisez une connexion WebSocket ou SSE directe depuis votre frontend vers l'API JuiceFactory, pas n8n.

n8n est mieux adapté aux workflows backend où le temps de réponse se mesure en « quelques secondes, c'est très bien » plutôt qu'en « la latence du premier token compte ».

Exemples de workflows concrets

1. Triage du support client — classifier les emails entrants

Problème : Votre boîte de support reçoit plus de 200 emails par jour. Vous devez les router vers la bonne équipe et signaler les problèmes urgents.

Workflow :

IMAP Trigger (nouvel email) → OpenAI Chat (classifier) → Switch (router par catégorie) → [
  billing → Jira (créer ticket dans la file Facturation)
  technical → Jira (créer ticket dans la file Ingénierie)
  urgent → Jira (créer ticket P1) + Slack (alerte astreinte)
  spam → Déplacer vers la corbeille
]

Prompt de classification (message système) :

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.

Le nœud Switch route en fonction de $json.message.content parsé en JSON :

// Dans un nœud Code avant le Switch :
const classification = JSON.parse($json.message.content);
return [{ json: classification }];

Le nœud Switch vérifie ensuite {{ $json.category }} par rapport aux quatre valeurs.

Pourquoi il faut de l'IA privée ici : Les emails clients contiennent des noms, des détails de comptes, des termes contractuels et parfois des données personnelles. Les router via une API d'IA basée aux États-Unis signifie que ces données quittent l'UE. Avec JuiceFactory, la classification s'effectue sur une infrastructure européenne avec zéro rétention.

2. Extraction de données de factures — du PDF au JSON structuré

Problème : Votre équipe comptable reçoit des factures en pièces jointes PDF. Vous devez extraire les champs clés vers votre ERP.

Workflow :

IMAP Trigger (nouvel email avec pièce jointe) → Extract Attachment → HTTP Request (convertir PDF en texte) → OpenAI Chat (extraire les champs) → Code (valider) → HTTP Request (POST vers l'API ERP)

Prompt d'extraction :

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.

Nœud Code de validation :

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

// Validation basique
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
  }
}];

Routez les échecs de validation vers une file de revue manuelle. Routez les extractions valides vers l'API ERP.

Pourquoi il faut de l'IA privée ici : Les factures contiennent des noms de fournisseurs, des numéros de comptes bancaires (IBAN), des montants et des relations commerciales. Ce sont des données commercialement sensibles qui doivent rester dans votre infrastructure, pas dans un jeu de données d'entraînement.

3. Q&A sur la base de connaissances interne — Slack vers n8n vers JuiceFactory vers Slack

Problème : Votre équipe pose les mêmes questions en boucle. Vous avez de la documentation dans Confluence/Notion/Google Drive, mais personne ne la lit.

Workflow :

Slack Trigger (mention de l'app) → Code (extraire la question) → HTTP Request (rechercher dans les docs) → Code (construire le prompt RAG) → OpenAI Chat (générer la réponse) → Slack (répondre dans le thread)

Configuration du Slack Trigger :

Créez une application Slack avec le scope app_mentions:read. Le trigger se déclenche quand quelqu'un @mentionne le bot.

Nœud Code — extraire la question :

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

Nœud de recherche — interroger l'index documentaire :

C'est le même pattern de recherche vectorielle que dans le workflow RAG ci-dessus. Adaptez-le à votre source de documentation.

Réponse Slack :

Répondre dans le thread garde le canal propre. La réponse du bot apparaît directement sous la question.

Pourquoi il faut de l'IA privée ici : La documentation interne contient souvent des détails d'architecture, des configurations de sécurité, des informations spécifiques aux clients et de la stratégie d'entreprise. Envoyer tout ça à une API publique dans le cadre du contexte RAG expose des informations propriétaires.

Considérations RGPD pour les workflows n8n

Utiliser JuiceFactory rend l'étape d'inférence IA conforme au RGPD. Mais le workflow lui-même a sa propre gestion des données à laquelle il faut réfléchir.

Les logs d'exécution n8n contiennent des données personnelles

Chaque exécution de workflow dans n8n est journalisée. Ces logs incluent les données d'entrée, les données de sortie et tout ce qu'il y a entre les deux. Si votre workflow traite des emails clients, le texte complet de l'email se trouve dans le log d'exécution.

Que faire :

• Définissez la rétention des logs d'exécution au minimum nécessaire. Dans les paramètres n8n : Settings → Executions → Prune Executions
• En production, fixez la rétention entre 7 et 30 jours selon vos besoins de débogage
• Pour les workflows qui traitent des données sensibles, envisagez de désactiver complètement la sauvegarde des exécutions (EXECUTIONS_DATA_SAVE_ON_ERROR=none et EXECUTIONS_DATA_SAVE_ON_SUCCESS=none dans les variables d'environnement)

Auto-hébergement vs résidence des données n8n Cloud

Pour la posture RGPD la plus solide : auto-hébergez n8n sur une infrastructure européenne et connectez-le à JuiceFactory. L'ensemble du pipeline — déclencheur, traitement, inférence, réponse — reste dans l'UE.

Le zéro rétention de JuiceFactory rend l'étape IA propre

Du point de vue de l'article 28 du RGPD, l'étape d'inférence IA avec JuiceFactory est simple :

• Pas besoin de contrat de sous-traitance pour les données stockées (il n'y a pas de données stockées)
• Pas de demandes d'accès des personnes concernées à traiter au niveau de la couche d'inférence
• Pas de calendrier de rétention à suivre
• Le flux de données est : prompt entrant → réponse sortante → rien de conservé

Cela signifie que votre effort RGPD se concentre sur n8n lui-même (logs d'exécution, stockage des credentials, données de workflow) plutôt que sur le fournisseur d'IA.

Sécurité des credentials

Votre clé API JuiceFactory donne accès à l'inférence. Traitez-la comme un mot de passe de base de données :

• En auto-hébergement n8n, les credentials sont chiffrés au repos via N8N_ENCRYPTION_KEY. Assurez-vous d'avoir défini une clé robuste.
• Ne committez jamais vos credentials dans le contrôle de version
• Faites une rotation régulière des clés API via le portail JuiceFactory
• Utilisez des clés API distinctes pour les workflows de développement et de production

Dépannage

Erreurs courantes

401 Unauthorized

Error: Request failed with status code 401

Votre clé API est incorrecte ou expirée. Vérifiez :

• La clé commence par jf_
• Pas d'espace superflu dans le champ credential
• La clé est active dans le portail JuiceFactory

429 Too Many Requests

Error: Request failed with status code 429

Vous avez atteint la limite de débit. Options :

• Activez le retry sur le nœud (voir Patterns avancés ci-dessus)
• Ajoutez un nœud Wait avant le nœud IA dans les workflows par lots
• Vérifiez les limites de débit de votre plan dans le portail

Timeout / ECONNREFUSED

Error: connect ECONNREFUSED

n8n ne parvient pas à joindre l'API JuiceFactory. Vérifiez :

• Votre instance n8n a accès à Internet (ou un accès réseau vers l'API si vous utilisez des endpoints privés)
• Aucun pare-feu ne bloque le HTTPS sortant sur le port 443
• Le DNS résout api.juicefactory.ai depuis l'hôte n8n

Testez depuis l'hôte n8n :

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

Model not found

Error: Model 'gpt-4' not found

JuiceFactory héberge ses propres modèles, pas ceux d'OpenAI. Vérifiez les modèles disponibles :

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

Utilisez l'un des identifiants de modèle renvoyés dans la configuration de votre nœud n8n.

Comment tester la connexion API depuis n8n

Si vous n'êtes pas sûr que n8n puisse atteindre JuiceFactory, ajoutez un nœud HTTP Request temporaire :

1. Créez un nouveau workflow avec un Manual Trigger
2. Ajoutez un nœud HTTP Request
3. Method : GET
4. URL : https://api.juicefactory.ai/v1/models
5. Authentication : Header Auth avec votre credential JuiceFactory
6. Exécutez

Si cela renvoie une liste JSON de modèles, la connexion fonctionne. Si ça échoue, le message d'erreur vous dira exactement ce qui ne va pas (DNS, pare-feu, authentification).

Mode debug dans n8n

Quand un workflow dysfonctionne, utilisez le débogage intégré de n8n :

1. Aperçu d'exécution : Cliquez sur n'importe quelle exécution passée pour voir les données à chaque nœud. Les panneaux input/output montrent exactement ce qui a été envoyé à JuiceFactory et ce qui en est revenu.

2. Épingler les données : Épinglez la sortie des nœuds en amont du nœud IA, puis relancez uniquement l'étape IA. Cela évite de re-télécharger les documents ou de ré-interroger les bases de données pendant le débogage.

3. Éditeur d'expressions : Utilisez l'éditeur d'expressions sur le nœud OpenAI Chat pour inspecter le prompt exact qui est envoyé. Si le prompt est vide ou malformé, vous le verrez ici.

4. Liste des exécutions de workflow : Filtrez par statut (erreur, succès) pour trouver les exécutions en échec. Le message d'erreur sur le nœud défaillant est généralement suffisant pour diagnostiquer le problème.

Conseils de performance

Choisissez le bon modèle pour la tâche

Chaque workflow n'a pas besoin du plus gros modèle. Pour la classification et l'extraction simple, les modèles plus légers sont plus rapides et moins coûteux :

Définissez max_tokens correctement

N'utilisez pas la valeur max_tokens par défaut pour chaque workflow. Une tâche de classification nécessite 50 tokens. Un résumé en nécessite 500. Une analyse détaillée peut en demander 2000. Ajuster cette valeur correctement réduit la latence et le coût :

Prompt de classification → max_tokens: 100
Prompt de résumé → max_tokens: 500
Analyse complète → max_tokens: 2000

Mettez en cache les requêtes répétitives

Si votre workflow traite fréquemment le même type d'entrée (par exemple, classifier des emails par catégories), envisagez de mettre les résultats en cache. Utilisez le nœud Code de n8n avec une simple map en mémoire, ou interrogez un cache Redis ou une base de données avant de solliciter l'API d'IA.

Guides connexes

• Migrate from OpenAI to an EU API — Un changement de deux lignes de code pour passer d'OpenAI à JuiceFactory dans n'importe quelle application
• Stateless LLM APIs and GDPR — Plongée en profondeur sur l'importance de l'inférence zéro rétention pour la conformité
• RAG without a vector database — Construire un pipeline RAG minimal en Python avant d'ajouter de l'infrastructure
• BYOK AI — Bring Your Own Key — Utilisez vos propres clés API avec l'infrastructure européenne de JuiceFactory

Prochaines étapes

Vous avez tous les éléments : credentials configurés, un workflow de résumé fonctionnel, un pattern RAG et trois exemples prêts pour la production à adapter.

Le moyen le plus rapide de démarrer est de choisir l'exemple le plus proche de votre cas d'usage, importer le JSON du workflow, remplacer les credentials et le modèle par les vôtres, et tester avec des données réelles.

Si vous exécutez des workflows n8n qui traitent des données personnelles européennes et que l'étape IA doit être conforme, obtenez votre clé API JuiceFactory et vous pourrez avoir votre premier workflow d'IA privée en moins de 15 minutes.