Face à un projet d'IA, la question revient toujours : faut-il fine-tuner un modèle, mettre en place du RAG, ou simplement mieux prompter ? La réponse n'est pas « ça dépend » — c'est « voici comment décider ». Ce guide vous donne un arbre de décision clair, avec les coûts, la complexité et les résultats attendus de chaque approche.
Que vous soyez développeur, product manager ou entrepreneur, vous saurez exactement quelle méthode choisir pour votre cas d'usage.
🌳 L'arbre de décision : par où commencer ?
Avant de plonger dans les détails techniques, voici la question fondamentale :
Le modèle de base donne-t-il déjà des résultats corrects avec un bon prompt ?
- Oui, mais pas assez précis → Améliorez votre prompting (Section 1)
- Non, il lui manque des connaissances spécifiques → Implémentez du RAG (Section 2)
- Non, il ne comprend pas le style/format/domaine → Envisagez le fine-tuning (Section 3)
┌─────────────────────┐
│ Votre cas d'usage │
└──────────┬──────────┘
│
┌──────────▼──────────┐
│ Le modèle de base │
│ comprend la tâche ? │
└──────────┬──────────┘
┌────┴────┐
OUI NON
│ │
┌────────▼───┐ ┌──▼─────────────┐
│ Résultats │ │ Il manque des │
│ suffisants?│ │ connaissances ? │
└─────┬──────┘ └──┬──────────────┘
┌────┴────┐ ┌───┴───┐
OUI NON OUI NON
│ │ │ │
┌───▼──┐ ┌───▼───▼┐ ┌───▼────────┐
│ STOP │ │ RAG │ │ FINE-TUNING│
│ │ │ │ │ │
└──────┘ └────────┘ └────────────┘
La règle d'or : commencez TOUJOURS par le prompting
Le prompting avancé est gratuit (en termes de développement), instantané et souvent suffisant. Ne sautez pas cette étape.
| Approche | Commencez ici si... |
|---|---|
| Prompting | Toujours. C'est votre point de départ. |
| RAG | Le modèle a besoin d'infos qu'il n'a pas (docs internes, données récentes) |
| Fine-tuning | Le modèle doit adopter un style/comportement spécifique à grande échelle |
🎯 Prompting avancé : l'art de bien demander
Pourquoi le prompting est sous-estimé
80% des projets qui pensent avoir besoin de fine-tuning ont en réalité besoin d'un meilleur prompt. Le prompting avancé, c'est bien plus que « pose ta question clairement ». C'est une discipline d'ingénierie à part entière.
System prompt : votre fondation
Le system prompt définit le comportement de base du modèle. C'est le levier le plus puissant et le plus sous-utilisé.
# ❌ System prompt faible
Tu es un assistant utile.
# ✅ System prompt structuré
Tu es un expert en droit fiscal français spécialisé dans les PME.
## 🎭 Ton rôle
- Répondre aux questions de fiscalité des PME françaises
- Citer les articles de loi pertinents (CGI, BOFiP)
- Signaler quand une question dépasse ton domaine
## 📝 Format de réponse
1. Réponse courte (2-3 phrases)
2. Base légale (articles de loi)
3. Points d'attention
4. Recommandation (consulter un expert si nécessaire)
## ⚠️ Règles strictes
- Ne JAMAIS inventer un article de loi
- Dire "je ne suis pas sûr" plutôt que deviner
- Toujours mentionner la date de dernière mise à jour de tes connaissances
Few-shot prompting : apprendre par l'exemple
Le few-shot consiste à donner des exemples de paires input/output pour guider le modèle :
# Tâche : classifier des tickets support
## 💡 Exemples
Ticket: "Mon paiement a été débité deux fois"
→ Catégorie: facturation
→ Priorité: haute
→ Sentiment: frustré
Ticket: "Comment changer mon mot de passe ?"
→ Catégorie: compte
→ Priorité: basse
→ Sentiment: neutre
Ticket: "Votre app plante à chaque ouverture depuis la MAJ"
→ Catégorie: bug
→ Priorité: critique
→ Sentiment: mécontent
## 🎫 Nouveau ticket à classifier
Ticket: "Je n'arrive pas à télécharger ma facture de janvier"
→
Chain-of-Thought (CoT) : faire réfléchir le modèle
# Sans CoT
Q: Si un train part à 14h30 et met 2h47, à quelle heure arrive-t-il ?
R: 17h17
# Avec CoT
Q: Si un train part à 14h30 et met 2h47, à quelle heure arrive-t-il ?
Réfléchis étape par étape avant de répondre.
R: Décomposons :
- Départ : 14h30
- Durée : 2h47
- 14h30 + 2h = 16h30
- 16h30 + 47min = 17h17
Le train arrive à 17h17.
Structured output : contrôler le format
Demander une sortie structurée (JSON, XML) améliore la fiabilité et réduit les tokens de sortie :
# Prompt pour extraction structurée
prompt = """Extrais les informations de cette facture au format JSON.
Facture:
Société ABC - Facture #2024-0892
Date: 15/01/2026
Client: Martin Dupont
Montant HT: 1 500,00 €
TVA (20%): 300,00 €
Total TTC: 1 800,00 €
Réponds UNIQUEMENT avec le JSON, sans texte avant/après.
Format attendu:
{
"numero": "string",
"date": "YYYY-MM-DD",
"client": "string",
"montant_ht": number,
"tva": number,
"total_ttc": number
}"""
Quand le prompting ne suffit plus
Le prompting atteint ses limites quand :
- Le modèle n'a tout simplement pas les connaissances nécessaires (données internes, infos post-training)
- Vous avez besoin d'un style très spécifique à grande échelle (milliers de requêtes)
- La latence du few-shot est trop élevée (trop d'exemples = trop de tokens)
- La cohérence sur des milliers de requêtes n'est pas suffisante
C'est là que RAG et fine-tuning entrent en jeu.
📚 RAG : donner des connaissances au modèle
Le principe du RAG
RAG (Retrieval-Augmented Generation) consiste à chercher des informations pertinentes dans une base de données, puis à les injecter dans le prompt avant de générer la réponse.
Question utilisateur
│
▼
┌───────────────┐
│ Retrieval │ ← Cherche dans vos documents
│ (recherche) │
└───────┬───────┘
│ Documents pertinents
▼
┌───────────────┐
│ Augmentation │ ← Ajoute au prompt
│ (contexte) │
└───────┬───────┘
│ Prompt enrichi
▼
┌───────────────┐
│ Generation │ ← Le LLM répond
│ (réponse) │
└───────────────┘
Les embeddings : transformer le texte en vecteurs
Pour chercher efficacement, on convertit les textes en vecteurs (embeddings) — des représentations numériques qui capturent le sens.
from openai import OpenAI
client = OpenAI()
# Créer un embedding
response = client.embeddings.create(
model="text-embedding-3-small",
input="Comment configurer OpenClaw sur un VPS ?"
)
vector = response.data[0].embedding
# → [0.0123, -0.0456, 0.0789, ...] (1536 dimensions)
# Deux textes proches sémantiquement
# auront des vecteurs proches (cosine similarity élevée)
Vector databases : stocker et chercher
Les bases de données vectorielles permettent de stocker des millions d'embeddings et de trouver les plus proches en millisecondes :
| Base vectorielle | Type | Prix | Idéal pour |
|---|---|---|---|
| Chroma | Open-source, local | Gratuit | Prototypage, petits projets |
| Pinecone | Cloud managé | $0.33/M vecteurs/mois | Production, scalabilité |
| Weaviate | Open-source + cloud | Gratuit → payant | Multimodal, flexible |
| pgvector | Extension PostgreSQL | Gratuit | Si vous avez déjà PostgreSQL |
| Qdrant | Open-source + cloud | Gratuit → payant | Performance, Rust-based |
| FAISS | Librairie Meta | Gratuit | Recherche brute, gros volumes |
Pipeline RAG complet
Pour aller plus loin sur ce sujet, consultez notre guide Claude, GPT, Gemini, Llama : quel modèle choisir en 2026 ?.
# Pipeline RAG simplifié
import chromadb
from openai import OpenAI
Pour aller plus loin sur ce sujet, consultez notre guide [Utiliser des modèles gratuits sans sacrifier la qualité](/article/modeles-ia-gratuits-openrouter-groq).
client = OpenAI()
chroma = chromadb.Client()
collection = chroma.create_collection("mes_docs")
# 1. INDEXATION (une seule fois)
documents = [
"OpenClaw est un agent IA autonome...",
"Pour installer OpenClaw sur un VPS...",
"La configuration se fait via config.yaml...",
]
for i, doc in enumerate(documents):
# Créer l'embedding
resp = client.embeddings.create(
model="text-embedding-3-small", input=doc
)
# Stocker dans ChromaDB
collection.add(
ids=[f"doc_{i}"],
embeddings=[resp.data[0].embedding],
documents=[doc]
)
# 2. RETRIEVAL (à chaque question)
question = "Comment installer OpenClaw ?"
q_embedding = client.embeddings.create(
model="text-embedding-3-small", input=question
).data[0].embedding
results = collection.query(
query_embeddings=[q_embedding],
n_results=3 # Top 3 documents pertinents
)
# 3. GENERATION (réponse augmentée)
contexte = "\n\n".join(results["documents"][0])
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": f"""Réponds en te basant
UNIQUEMENT sur le contexte fourni. Si l'info n'est pas
dans le contexte, dis-le.
Contexte:\n{contexte}"""},
{"role": "user", "content": question}
]
)
print(response.choices[0].message.content)
Chunking : découper intelligemment
La qualité du RAG dépend énormément du chunking (découpage des documents) :
# Stratégies de chunking
# 1. Par taille fixe (simple mais pas optimal)
def chunk_fixed(text, size=500, overlap=50):
chunks = []
for i in range(0, len(text), size - overlap):
chunks.append(text[i:i + size])
return chunks
# 2. Par paragraphes/sections (plus intelligent)
def chunk_by_sections(text):
sections = text.split("\n## ")
return [s.strip() for s in sections if len(s.strip()) > 50]
# 3. Sémantique (le meilleur, plus complexe)
# Utilise un modèle pour détecter les changements de sujet
| Méthode | Qualité | Complexité | Cas d'usage |
|---|---|---|---|
| Taille fixe | ⭐⭐ | Très simple | Prototypage |
| Par paragraphe | ⭐⭐⭐ | Simple | Documents structurés |
| Par section/titre | ⭐⭐⭐⭐ | Moyen | Documentation, articles |
| Sémantique | ⭐⭐⭐⭐⭐ | Complexe | Production, qualité max |
Quand utiliser le RAG
✅ RAG est idéal quand :
- Vos données changent fréquemment (actualités, docs produit)
- Vous avez besoin de citer vos sources (traçabilité)
- Vos documents sont trop volumineux pour le contexte
- Vous voulez garder le modèle de base (pas de fine-tuning)
❌ RAG n'est PAS idéal quand :
- Le problème est le style de réponse, pas les connaissances
- Vous avez besoin de latence ultra-faible
- Vos données sont simples et tiennent dans le prompt
🔧 Fine-tuning : customiser le modèle
Qu'est-ce que le fine-tuning ?
Le fine-tuning consiste à ré-entraîner un modèle pré-existant sur vos propres données pour qu'il adopte un comportement spécifique. C'est comme donner des cours particuliers au modèle.
Modèle de base (GPT-4o, Claude, Llama)
│
▼ + vos données d'entraînement
┌───────────────────┐
│ Fine-tuning │
│ (ré-entraînement)│
└───────┬───────────┘
│
▼
Modèle personnalisé
(comprend votre domaine/style)
Données nécessaires
Le fine-tuning nécessite des paires d'exemples (input → output attendu) :
{"messages": [{"role": "system", "content": "Tu es l'assistant de la boutique XYZ."}, {"role": "user", "content": "Quels sont vos délais de livraison ?"}, {"role": "assistant", "content": "Chez XYZ, nous livrons en 24-48h en France métropolitaine, et 3-5 jours pour les DOM-TOM. La livraison express (24h) est gratuite au-dessus de 50€ !"}]}
{"messages": [{"role": "system", "content": "Tu es l'assistant de la boutique XYZ."}, {"role": "user", "content": "Je veux retourner un article"}, {"role": "assistant", "content": "Bien sûr ! Chez XYZ, vous avez 30 jours pour retourner un article. Rendez-vous sur votre espace client > Mes commandes > Retour. Le retour est gratuit avec l'étiquette prépayée fournie."}]}
Combien de données faut-il ?
| Objectif | Données minimum | Données recommandées | Temps |
|---|---|---|---|
| Style de réponse | 50-100 exemples | 200-500 | 30 min - 2h |
| Domaine spécifique | 200-500 exemples | 1K-5K | 1h - 8h |
| Tâche complexe | 1K+ exemples | 5K-50K | 4h - 48h |
| Nouveau comportement | 5K+ exemples | 10K-100K | 24h+ |
Coûts du fine-tuning
# Coûts approximatifs (début 2026)
OpenAI GPT-4o mini fine-tuning :
- Entraînement : $3.00 / million tokens
- Inférence : $0.30 / M input, $1.20 / M output (2x le prix de base)
OpenAI GPT-4o fine-tuning :
- Entraînement : $25.00 / million tokens
- Inférence : $3.75 / M input, $15.00 / M output (1.5x le prix de base)
Llama 3 (self-hosted) :
- Entraînement : coût GPU ($1-5/h sur un A100)
- Inférence : coût GPU uniquement (pas de surcoût par token)
Cas d'usage réels du fine-tuning
- Tone of voice d'entreprise : votre chatbot parle exactement comme votre marque
- Classification ultra-rapide : fine-tuner un petit modèle pour classifier en 1 token
- Langue/dialecte spécifique : adapter au jargon médical, juridique, technique
- Réduction de coûts : un petit modèle fine-tuné peut remplacer un gros modèle generic
Les pièges du fine-tuning
⚠️ Attention aux erreurs courantes :
- Catastrophic forgetting : le modèle « oublie » ses capacités générales
- Overfitting : trop peu de données → le modèle mémorise au lieu d'apprendre
- Données biaisées : vos exemples transmettent vos biais au modèle
- Coût de maintenance : il faut re-fine-tuner à chaque mise à jour du modèle de base
- Pas magique : si le modèle de base ne sait pas faire la tâche, le fine-tuning n'aidera probablement pas
📊 Tableau comparatif : Prompting vs RAG vs Fine-tuning
| Critère | Prompting avancé | RAG | Fine-tuning |
|---|---|---|---|
| Coût initial | Quasi nul | Moyen (infra + embeddings) | Élevé (données + entraînement) |
| Coût par requête | Normal | Normal + recherche | Souvent réduit |
| Temps de mise en place | Minutes/heures | Jours/semaines | Semaines/mois |
| Connaissances fraîches | ❌ Limité au training | ✅ Temps réel | ❌ Figé au fine-tuning |
| Style personnalisé | ⭐⭐⭐ | ⭐⭐ | ⭐⭐⭐⭐⭐ |
| Précision domaine | ⭐⭐ | ⭐⭐⭐⭐ | ⭐⭐⭐⭐ |
| Traçabilité (sources) | ❌ | ✅ Citations possibles | ❌ |
| Maintenance | Faible | Moyenne (index à jour) | Élevée (re-training) |
| Complexité technique | Faible | Moyenne | Élevée |
| Scalabilité | ✅ Immédiate | ✅ Bonne | ⚠️ Modèle dédié |
Combiner les approches
La meilleure solution est souvent une combinaison :
┌─────────────────────────────────────────────┐
│ Architecture hybride │
│ │
│ System prompt optimisé (prompting) │
│ + │
│ Documents internes injectés (RAG) │
│ + │
│ Modèle fine-tuné sur le ton (fine-tuning) │
│ = │
│ 🏆 Meilleur résultat possible │
└─────────────────────────────────────────────┘
Exemple concret : un chatbot support client
1. Prompting : system prompt avec les règles de conversation
2. RAG : recherche dans la base de connaissances / FAQ
3. Fine-tuning : le modèle adopte le ton de la marque naturellement
🗺️ Guide pratique : quelle approche pour quel projet ?
| Projet | Recommandation | Pourquoi |
|---|---|---|
| Chatbot FAQ entreprise | RAG + Prompting | Connaissances internes + format contrôlé |
| Rédaction marketing | Prompting (few-shot) | Style contrôlable par exemples |
| Analyse de contrats | RAG + Prompting | Docs longs + extraction structurée |
| Assistant code interne | RAG (codebase) + Prompting | Connaît votre code, style de réponse flexible |
| Classification emails (volume) | Fine-tuning (petit modèle) | Volume élevé, coût réduit par requête |
| Traduction domaine spécifique | Fine-tuning | Jargon spécifique à apprendre |
| Veille actualités | RAG (flux RSS) | Données fraîches quotidiennes |
| Agent autonome | Prompting + RAG | Flexibilité max, accès à vos outils |
🚀 Par où commencer concrètement ?
Étape 1 : Optimisez vos prompts (Jour 1)
# Checklist prompting
☐ System prompt structuré avec rôle, règles, format
☐ 3-5 exemples few-shot pour les tâches récurrentes
☐ Instructions de format (JSON si possible)
☐ Guardrails ("ne fais PAS...", "si incertain, dis-le")
☐ Test sur 20+ cas variés
Étape 2 : Évaluez si vous avez besoin de plus (Semaine 1)
# Grille d'évaluation simple
questions = [
"Le modèle a-t-il les connaissances nécessaires ?", # Non → RAG
"Le style de réponse est-il acceptable ?", # Non → Fine-tuning
"Les réponses sont-elles assez précises ?", # Non → RAG ou Fine-tuning
"Le coût par requête est-il acceptable ?", # Non → Fine-tuning petit modèle
"La latence est-elle acceptable ?", # Non → Fine-tuning ou cache
]
Étape 3 : Implémentez progressivement (Semaines 2-4)
- RAG : commencez avec ChromaDB en local, migrez vers un service managé si ça marche
- Fine-tuning : commencez avec 100 exemples sur GPT-4o mini, itérez
📚 Articles liés
- Qu'est-ce qu'OpenClaw ? — L'agent IA qui combine prompting, RAG et outils automatiquement
- OpenRouter : le routeur multi-modèles — Tester différents modèles pour trouver le meilleur rapport qualité/prix
- Claude d'Anthropic — Modèles Claude : capacités, contexte et tarifs
- Configurer OpenClaw — Optimiser le system prompt et les paramètres de votre agent
- Automatiser sa vie avec l'IA — Applications concrètes de ces techniques au quotidien