Prompt Engineering RAG: System-Prompts für bessere Antworten optimieren

TL;DR

Das prompt engineering RAG ist die Kunst, die Anweisungen an das LLM so zu optimieren, dass die Qualität der aus dem abgerufenen Kontext generierten Antworten maximiert wird. Ein gutes System-Prompt kann die Relevanz um 40% verbessern, Halluzinationen um 60% reduzieren und konsistente Antworten im Einklang mit Ihrer Marke sicherstellen. Dieser Leitfaden zeigt fortgeschrittene Techniken, erprobte Templates und Fehler, die zu vermeiden sind.

Introduction au Prompt Engineering RAG

In einem RAG-System spielt das Prompt Engineering eine entscheidende, aber oft unterschätzte Rolle. Im Unterschied zum klassischen Prompt Engineering für LLM bringt der RAG-Kontext eine zusätzliche Komplexität: das Modell muss nicht nur die Benutzeranfrage verstehen, sondern auch die abgerufenen Dokumente effektiv nutzen.

Pourquoi le prompt engineering est critique en RAG

Das System-Prompt in einer RAG-Pipeline hat mehrere Verantwortlichkeiten :

1. Guider l'utilisation du contexte : Indiquer au LLM comment exploiter les documents récupérés
2. Définir le comportement : Ton, style, niveau de détail des réponses
3. Prévenir les hallucinations : Forcer le modèle à s'appuyer sur les sources
4. Gérer l'incertitude : Que faire quand l'information n'est pas dans le contexte

DEVELOPERpython
# Beispiel für ein einfaches vs. optimiertes RAG-Prompt

# ❌ Basic-Prompt (problematisch)
basic_prompt = """
Tu es un assistant. Voici des documents :
{context}

Question : {query}
"""

# ✅ Optimiertes Prompt
optimized_prompt = """
Tu es un assistant expert pour {company_name}. Tu aides les utilisateurs
en t'appuyant UNIQUEMENT sur les documents fournis.

## Instructions
1. Réponds uniquement avec les informations présentes dans les documents
2. Si l'information n'est pas disponible, dis-le clairement
3. Cite tes sources avec [Source: nom_du_document]
4. Utilise un ton professionnel mais accessible

## Documents disponibles
{context}

## Question de l'utilisateur
{query}

## Ta réponse (basée uniquement sur les documents ci-dessus)
"""

Architecture d'un prompt RAG efficace

Les 6 composants essentiels

Un prompt RAG bien structuré contient ces éléments :

Template de base recommandé

DEVELOPERpython
RAG_PROMPT_TEMPLATE = """
# Rôle
Tu es {persona} pour {company}. {personality_traits}

# Objectif
{primary_goal}

# Instructions
{numbered_instructions}

# Contraintes importantes
- {constraint_1}
- {constraint_2}
- {constraint_3}

# Format de réponse
{response_format}

---

# Documents de référence
Les informations suivantes proviennent de notre base de connaissances :

{context}

---

# Question
{query}

# Réponse
"""

Techniques avancées de prompt engineering RAG

1. Instruction Hierarchy (Hiérarchie d'instructions)

Organisez vos instructions par ordre de priorité. Les LLM ont tendance à mieux respecter les instructions en début de prompt.

DEVELOPERpython
def build_hierarchical_prompt(context, query, config):
    """Construit un prompt avec hiérarchie d'instructions."""

    return f"""
# RÈGLES CRITIQUES (TOUJOURS RESPECTER)
1. Ne JAMAIS inventer d'informations non présentes dans les documents
2. Si tu ne sais pas, réponds "Je n'ai pas cette information"
3. Toujours citer tes sources

# RÈGLES IMPORTANTES
1. Réponds en français uniquement
2. Utilise un ton {config.tone}
3. Limite ta réponse à {config.max_words} mots

# PRÉFÉRENCES
1. Privilégie les exemples concrets
2. Structure avec des bullet points si pertinent
3. Propose des ressources complémentaires si disponibles

# DOCUMENTS
{context}

# QUESTION
{query}
"""

2. Few-Shot Examples (Exemples guidés)

Incluez des exemples de bonnes réponses pour guider le comportement du LLM :

DEVELOPERpython
few_shot_prompt = """
Tu es un assistant support produit. Voici comment répondre :

## Exemple 1
Question : "Comment réinitialiser mon mot de passe ?"
Documents : [Contient la procédure de réinitialisation]
Réponse : "Pour réinitialiser votre mot de passe :
1. Cliquez sur 'Mot de passe oublié' sur la page de connexion
2. Entrez votre email
3. Suivez le lien reçu par email
[Source: Guide utilisateur, section Authentification]"

## Exemple 2
Question : "Quel est le prix du forfait Enterprise ?"
Documents : [Ne contient pas les tarifs]
Réponse : "Je n'ai pas accès aux informations tarifaires dans ma base
de connaissances. Je vous invite à contacter notre équipe commerciale
à [email protected] pour obtenir un devis personnalisé."

## Exemple 3
Question : "Votre produit est-il compatible avec Linux ?"
Documents : [Mentionne Windows et Mac uniquement]
Réponse : "D'après notre documentation, le produit est compatible avec
Windows et macOS. La compatibilité Linux n'est pas mentionnée. Je vous
recommande de contacter le support technique pour vérifier.
[Source: Guide d'installation]"

---

Maintenant, réponds à cette question avec les documents fournis :

Documents : {context}
Question : {query}
"""

3. Chain-of-Thought RAG

Demandez au LLM de raisonner étape par étape avant de répondre :

DEVELOPERpython
cot_rag_prompt = """
Tu es un assistant qui analyse les documents avant de répondre.

## Documents
{context}

## Question
{query}

## Processus de réponse
Avant de répondre, suis ces étapes :

1. **Analyse des documents** : Identifie les passages pertinents
2. **Vérification de couverture** : L'information demandée est-elle présente ?
3. **Synthèse** : Combine les informations pertinentes
4. **Formulation** : Rédige une réponse claire et sourcée

## Ton analyse (raisonnement interne)
<thinking>
[Analyse les documents ici]
</thinking>

## Ta réponse finale
"""

4. Gestion des cas limites

Préparez votre prompt pour les situations difficiles :

DEVELOPERpython
edge_case_prompt = """
# Gestion des cas particuliers

## Si l'information n'est pas dans les documents :
Réponds : "Je n'ai pas trouvé cette information dans notre documentation.
Voici ce que je peux vous dire : [information connexe si disponible].
Pour plus de détails, contactez [canal approprié]."

## Si la question est ambiguë :
Réponds : "Votre question peut être interprétée de plusieurs façons.
Pourriez-vous préciser si vous parlez de [option A] ou [option B] ?"

## Si les documents se contredisent :
Réponds : "J'ai trouvé des informations qui semblent différer.
Selon [source 1], [info 1]. Cependant, [source 2] indique [info 2].
Je recommande de vérifier avec [autorité]."

## Si la question est hors sujet :
Réponds : "Cette question sort du cadre de mon expertise sur [domaine].
Je suis spécialisé dans [votre domaine]. Puis-je vous aider sur un
autre sujet ?"
"""

Optimisation du contexte injecté

Structurer le contexte pour le LLM

La façon dont vous présentez les documents récupérés impacte fortement la qualité :

DEVELOPERpython
def format_context(retrieved_docs, max_tokens=3000):
    """Formate les documents pour injection optimale."""

    formatted_chunks = []
    current_tokens = 0

    for i, doc in enumerate(retrieved_docs):
        # Nützliche Metadaten
        source = doc.metadata.get('source', 'Document inconnu')
        date = doc.metadata.get('date', '')
        relevance = doc.metadata.get('score', 0)

        # Strukturierter Format
        chunk_text = f"""
### Document {i+1}: {source}
- Pertinence: {relevance:.2f}
- Date: {date}

{doc.page_content}

---
"""
        # Token-Kontrolle
        chunk_tokens = len(chunk_text.split()) * 1.3  # Schätzung
        if current_tokens + chunk_tokens > max_tokens:
            break

        formatted_chunks.append(chunk_text)
        current_tokens += chunk_tokens

    return "\n".join(formatted_chunks)

Ordre des documents

L'ordre des documents dans le contexte influence leur utilisation :

DEVELOPERpython
def order_documents_strategically(docs, strategy="relevance_first"):
    """
    Stratégies d'ordonnancement :
    - relevance_first: Plus pertinents en premier
    - relevance_sandwich: Pertinents au début et à la fin
    - recency_first: Plus récents en premier
    """

    if strategy == "relevance_first":
        return sorted(docs, key=lambda x: x.score, reverse=True)

    elif strategy == "relevance_sandwich":
        # LLM neigen dazu, den Anfang und das Ende besser zu nutzen
        sorted_docs = sorted(docs, key=lambda x: x.score, reverse=True)
        if len(sorted_docs) <= 2:
            return sorted_docs

        middle = sorted_docs[1:-1]
        return [sorted_docs[0]] + middle[::-1] + [sorted_docs[-1]]

    elif strategy == "recency_first":
        return sorted(docs, key=lambda x: x.metadata.get('date', ''), reverse=True)

    return docs

Templates par cas d'usage

Support client

DEVELOPERpython
SUPPORT_PROMPT = """
Tu es un agent de support client pour {company}. Tu aides les clients
avec leurs questions sur nos produits et services.

## Ton style
- Amical et professionnel
- Empathique face aux frustrations
- Concis mais complet

## Priorités
1. Résoudre le problème du client
2. Fournir des étapes claires et actionnables
3. Proposer des alternatives si la solution principale ne fonctionne pas

## Ce que tu NE DOIS PAS faire
- Inventer des fonctionnalités qui n'existent pas
- Promettre des délais ou des résultats
- Donner des informations sur les prix sans source

## Base de connaissances
{context}

## Question du client
{query}

## Ta réponse (commence par saluer le client)
"""

Assistant e-commerce

DEVELOPERpython
ECOMMERCE_PROMPT = """
Tu es un conseiller shopping pour {store_name}. Tu aides les clients
à trouver les produits parfaits pour leurs besoins.

## Ton objectif
Guider le client vers le produit idéal en comprenant ses besoins.

## Style de conversation
- Enthousiaste mais pas pushy
- Expert produit sans être technique
- Orienté solution

## Informations produits disponibles
{context}

## Quand recommander un produit
- Explique POURQUOI ce produit correspond au besoin
- Mentionne 2-3 caractéristiques clés
- Indique le prix si disponible
- Suggère des alternatives si pertinent

## Question du client
{query}

## Ta recommandation
"""

Base de connaissances interne

DEVELOPERpython
KNOWLEDGE_BASE_PROMPT = """
Tu es l'assistant IA interne de {company}. Tu aides les employés
à trouver des informations dans notre documentation.

## Ton rôle
- Répondre aux questions sur les processus internes
- Orienter vers les bons documents
- Clarifier les politiques de l'entreprise

## Règles strictes
- Réponds UNIQUEMENT avec les informations documentées
- Pour les questions RH sensibles, oriente vers le service RH
- Ne partage pas d'informations confidentielles hors contexte

## Documentation disponible
{context}

## Question de l'employé
{query}

## Ta réponse (cite toujours le document source)
"""

Mesurer et améliorer vos prompts

Métriques clés

A/B Testing de prompts

DEVELOPERpython
import random
from dataclasses import dataclass

@dataclass
class PromptVariant:
    name: str
    template: str
    metrics: dict = None

class PromptABTester:
    def __init__(self, variants: list[PromptVariant]):
        self.variants = variants
        self.results = {v.name: [] for v in variants}

    def get_prompt(self, context, query):
        """Sélectionne aléatoirement une variante."""
        variant = random.choice(self.variants)
        prompt = variant.template.format(context=context, query=query)
        return prompt, variant.name

    def record_feedback(self, variant_name, score):
        """Enregistre le feedback utilisateur."""
        self.results[variant_name].append(score)

    def get_winner(self):
        """Retourne la variante avec le meilleur score moyen."""
        averages = {
            name: sum(scores) / len(scores) if scores else 0
            for name, scores in self.results.items()
        }
        return max(averages, key=averages.get)

# Verwendung
tester = PromptABTester([
    PromptVariant("concise", CONCISE_PROMPT),
    PromptVariant("detailed", DETAILED_PROMPT),
    PromptVariant("structured", STRUCTURED_PROMPT),
])

# In deiner Pipeline
prompt, variant = tester.get_prompt(context, query)
response = llm.generate(prompt)
# ... Feedback sammeln ...
tester.record_feedback(variant, user_rating)

Itération continue

DEVELOPERpython
def analyze_failed_responses(responses, threshold=0.7):
    """Identifie les patterns dans les réponses de mauvaise qualité."""

    failed = [r for r in responses if r.quality_score < threshold]

    patterns = {
        "hallucination": 0,
        "incomplete": 0,
        "off_topic": 0,
        "wrong_format": 0,
        "too_long": 0,
        "too_short": 0,
    }

    for response in failed:
        # Automatische oder manuelle Analyse
        if response.has_unsourced_claims:
            patterns["hallucination"] += 1
        if response.missing_key_info:
            patterns["incomplete"] += 1
        # ... weitere Analysen

    # Hauptproblem identifizieren
    main_issue = max(patterns, key=patterns.get)

    # Vorschläge zur Verbesserung des Prompts
    suggestions = {
        "hallucination": "Renforcer les contraintes de sourcing",
        "incomplete": "Demander explicitement la couverture complète",
        "off_topic": "Ajouter des exemples de réponses hors sujet",
        "wrong_format": "Clarifier le format avec des exemples",
        "too_long": "Ajouter une limite de mots explicite",
        "too_short": "Demander des détails et exemples",
    }

    return main_issue, suggestions[main_issue]

Erreurs courantes à éviter

1. Prompts trop vagues

DEVELOPERpython
# ❌ Schlecht: zu vage
bad_prompt = "Réponds à la question avec les documents."

# ✅ Gut: präzise Anweisungen
good_prompt = """
Réponds à la question en suivant ces règles :
1. Utilise UNIQUEMENT les informations des documents fournis
2. Structure ta réponse avec des bullet points
3. Cite le document source entre crochets [Source: ...]
4. Si l'information n'est pas disponible, dis "Information non trouvée"
5. Limite ta réponse à 200 mots maximum
"""

2. Ignorer les cas d'échec

DEVELOPERpython
# ❌ Schlecht: keine Handhabung von Randfällen
bad_prompt = "Réponds à partir des documents : {context}"

# ✅ Gut: explizite Handhabung
good_prompt = """
Réponds à la question avec les documents.

SI l'information n'est pas dans les documents :
- Ne devine PAS la réponse
- Dis : "Cette information n'est pas dans ma base de connaissances"
- Suggère une source alternative si possible

SI la question est ambiguë :
- Demande une clarification
- Propose les interprétations possibles
"""

3. Contexte mal structuré

DEVELOPERpython
# ❌ Schlecht: unstrukturierter Kontext
bad_context = doc1.text + doc2.text + doc3.text

# ✅ Gut: strukturierter Kontext
good_context = f"""
Document 1 - {doc1.title} (pertinence: {doc1.score:.0%})
{doc1.text}

---

Document 2 - {doc2.title} (pertinence: {doc2.score:.0%})
{doc2.text}

---

Document 3 - {doc3.title} (pertinence: {doc3.score:.0%})
{doc3.text}
"""

Intégration avec Ailog

Ailog simplifie le prompt engineering RAG en proposant :

• Templates pré-optimisés par cas d'usage
• Variables dynamiques pour personnaliser sans coder
• A/B testing intégré pour optimiser vos prompts
• Analytics pour identifier les points d'amélioration

DEVELOPERpython
# Exemple avec l'API Ailog
from ailog import AilogClient

client = AilogClient(api_key="your-key")

# Verwende ein optimiertes Template
response = client.chat(
    channel_id="support-widget",
    message="Comment réinitialiser mon mot de passe ?",
    prompt_template="customer_support_v2",
    prompt_variables={
        "company": "Acme Corp",
        "tone": "friendly",
        "max_words": 150
    }
)

Conclusion

Le prompt engineering RAG est un levier puissant pour améliorer la qualité de vos chatbots. Les clés du succès :

1. Structure claire : Persona, instructions, contraintes, format
2. Gestion des cas limites : Prévoir l'absence d'information
3. Exemples guidés : Montrer le comportement attendu
4. Mesure continue : A/B testing et analyse des échecs
5. Itération : Améliorer progressivement basé sur les données

Ressources complémentaires

• Introduction au RAG - Comprendre les fondamentaux
• Génération LLM pour RAG - Guide parent sur la génération
• Chain-of-Thought RAG - Raisonnement étape par étape
• Streaming RAG - Réponses en temps réel

Prêt à optimiser vos prompts RAG ? Essayez Ailog gratuitement et bénéficiez de templates pré-optimisés pour votre cas d'usage.