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.

Einführung in das 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.

Warum Prompt Engineering im RAG entscheidend ist

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

1. Kontextnutzung steuern: Dem LLM zeigen, wie es die abgerufenen Dokumente nutzen soll
2. Verhalten definieren: Tonalität, Stil, Detailgrad der Antworten
3. Halluzinationen verhindern: Das Modell zwingen, sich auf die Quellen zu stützen
4. Unsicherheit handhaben: Was tun, wenn die Information nicht im Kontext enthalten ist

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

# ❌ Basic-Prompt (problematisch)
basic_prompt = """
Du bist ein Assistent. Hier sind Dokumente:
{context}

Frage: {query}
"""

# ✅ Optimiertes Prompt
optimized_prompt = """
Du bist ein Experten-Assistent für {company_name}. Du hilfst Nutzern,
indem du dich AUSSCHLIESSLICH auf die bereitgestellten Dokumente stützt.

## Anweisungen
1. Antworte nur mit Informationen, die in den Dokumenten enthalten sind
2. Wenn die Information nicht verfügbar ist, sage es klar
3. Zitiere deine Quellen mit [Source: dokumentname]
4. Verwende einen professionellen, aber zugänglichen Ton

## Verfügbare Dokumente
{context}

## Frage des Nutzers
{query}

## Deine Antwort (nur basierend auf den obigen Dokumenten)
"""

Aufbau eines effizienten RAG-Prompts

Die 6 wesentlichen Komponenten

Ein gut strukturiertes RAG-Prompt enthält folgende Elemente:

Empfohlenes Basis-Template

DEVELOPERpython
RAG_PROMPT_TEMPLATE = """
# Rolle
Du bist {persona} für {company}. {personality_traits}

# Ziel
{primary_goal}

# Anweisungen
{numbered_instructions}

# Wichtige Einschränkungen
- {constraint_1}
- {constraint_2}
- {constraint_3}

# Antwortformat
{response_format}

---

# Referenzdokumente
Die folgenden Informationen stammen aus unserer Wissensdatenbank:

{context}

---

# Frage
{query}

# Antwort
"""

Fortgeschrittene Techniken des Prompt Engineering RAG

1. Instruction Hierarchy (Anweisungshierarchie)

Ordnen Sie Ihre Anweisungen nach Priorität. LLMs neigen dazu, Anweisungen am Anfang des Prompts besser zu befolgen.

DEVELOPERpython
def build_hierarchical_prompt(context, query, config):
    """Erstellt ein Prompt mit Anweisungshierarchie."""

    return f"""
# KRITISCHE REGELN (IMMER EINHALTEN)
1. NIEMALS Informationen erfinden, die nicht in den Dokumenten enthalten sind
2. Wenn du es nicht weißt, antworte "Ich habe diese Information nicht"
3. Immer deine Quellen zitieren

# WICHTIGE REGELN
1. Antworte ausschließlich auf Deutsch
2. Verwende einen {config.tone}-Ton
3. Begrenze deine Antwort auf {config.max_words} Wörter

# PRÄFERENZEN
1. Bevorzuge konkrete Beispiele
2. Strukturiere mit Aufzählungspunkten, wenn sinnvoll
3. Schlage ergänzende Ressourcen vor, sofern verfügbar

# DOKUMENTE
{context}

# FRAGE
{query}
"""

2. Few-Shot Examples (geführte Beispiele)

Integrieren Sie Beispiele guter Antworten, um das Verhalten des LLM zu lenken:

DEVELOPERpython
few_shot_prompt = """
Du bist ein Produktsupport-Assistent. So antwortest du:

## Beispiel 1
Frage: "Wie setze ich mein Passwort zurück?"
Dokumente: [Enthält das Verfahren zur Passwort-Zurücksetzung]
Antwort: "Um Ihr Passwort zurückzusetzen:
1. Klicken Sie auf der Anmeldeseite auf 'Passwort vergessen'
2. Geben Sie Ihre E-Mail-Adresse ein
3. Folgen Sie dem per E-Mail erhaltenen Link
[Source: Benutzerhandbuch, Abschnitt Authentifizierung]"

## Beispiel 2
Frage: "Was kostet das Enterprise-Paket?"
Dokumente: [Enthält keine Preisangaben]
Antwort: "Ich habe keinen Zugriff auf Preisinformationen in meiner
Wissensdatenbank. Ich empfehle Ihnen, sich an unser Vertriebsteam
unter [email protected] zu wenden, um ein individuelles Angebot zu erhalten."

## Beispiel 3
Frage: "Ist Ihr Produkt mit Linux kompatibel?"
Dokumente: [Erwähnt nur Windows und Mac]
Antwort: "Laut unserer Dokumentation ist das Produkt mit Windows und
macOS kompatibel. Die Linux-Kompatibilität wird nicht erwähnt. Ich
empfehle Ihnen, sich zur Überprüfung an den technischen Support zu wenden.
[Source: Installationsanleitung]"

---

Beantworte nun diese Frage mit den bereitgestellten Dokumenten:

Dokumente: {context}
Frage: {query}
"""

3. Chain-of-Thought RAG

Fordern Sie das LLM auf, Schritt für Schritt zu denken, bevor es antwortet:

DEVELOPERpython
cot_rag_prompt = """
Du bist ein Assistent, der die Dokumente analysiert, bevor er antwortet.

## Dokumente
{context}

## Frage
{query}

## Antwortprozess
Bevor du antwortest, folge diesen Schritten:

1. **Dokumentenanalyse**: Identifiziere die relevanten Passagen
2. **Abdeckungsprüfung**: Ist die angefragte Information vorhanden?
3. **Synthese**: Kombiniere die relevanten Informationen
4. **Formulierung**: Verfasse eine klare, mit Quellen belegte Antwort

## Deine Analyse (interne Überlegung)
<thinking>
[Analysiere die Dokumente hier]
</thinking>

## Deine endgültige Antwort
"""

4. Behandlung von Grenzfällen

Bereiten Sie Ihr Prompt auf schwierige Situationen vor:

DEVELOPERpython
edge_case_prompt = """
# Umgang mit Sonderfällen

## Wenn die Information nicht in den Dokumenten enthalten ist:
Antworte: "Ich habe diese Information in unserer Dokumentation nicht gefunden.
Hier ist, was ich Ihnen sagen kann: [verwandte Information, falls verfügbar].
Für weitere Details wenden Sie sich bitte an [geeigneter Kanal]."

## Wenn die Frage mehrdeutig ist:
Antworte: "Ihre Frage kann auf mehrere Arten interpretiert werden.
Könnten Sie präzisieren, ob Sie [Option A] oder [Option B] meinen?"

## Wenn sich die Dokumente widersprechen:
Antworte: "Ich habe Informationen gefunden, die sich zu unterscheiden scheinen.
Laut [Quelle 1] gilt [Info 1]. [Quelle 2] hingegen gibt [Info 2] an.
Ich empfehle, dies mit [zuständige Stelle] zu überprüfen."

## Wenn die Frage nicht zum Thema gehört:
Antworte: "Diese Frage liegt außerhalb meines Fachgebiets zu [Bereich].
Ich bin auf [Ihr Bereich] spezialisiert. Kann ich Ihnen bei einem
anderen Thema helfen?"
"""

Optimierung des injizierten Kontexts

Den Kontext für das LLM strukturieren

Die Art, wie Sie die abgerufenen Dokumente präsentieren, beeinflusst die Qualität erheblich:

DEVELOPERpython
def format_context(retrieved_docs, max_tokens=3000):
    """Formatiert die Dokumente für optimale Injektion."""

    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)

        # Strukturiertes Format
        chunk_text = f"""
### Dokument {i+1}: {source}
- Relevanz: {relevance:.2f}
- Datum: {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)

Reihenfolge der Dokumente

Die Reihenfolge der Dokumente im Kontext beeinflusst deren Nutzung:

DEVELOPERpython
def order_documents_strategically(docs, strategy="relevance_first"):
    """
    Sortierstrategien:
    - relevance_first: Relevanteste zuerst
    - relevance_sandwich: Relevante am Anfang und Ende
    - recency_first: Neueste zuerst
    """

    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 nach Anwendungsfall

Kundensupport

DEVELOPERpython
SUPPORT_PROMPT = """
Du bist ein Kundensupport-Mitarbeiter für {company}. Du hilfst Kunden
bei Fragen zu unseren Produkten und Dienstleistungen.

## Dein Stil
- Freundlich und professionell
- Einfühlsam bei Frustrationen
- Prägnant, aber vollständig

## Prioritäten
1. Das Problem des Kunden lösen
2. Klare, umsetzbare Schritte liefern
3. Alternativen vorschlagen, wenn die Hauptlösung nicht funktioniert

## Was du NICHT tun darfst
- Funktionen erfinden, die nicht existieren
- Fristen oder Ergebnisse versprechen
- Preisinformationen ohne Quelle angeben

## Wissensdatenbank
{context}

## Frage des Kunden
{query}

## Deine Antwort (beginne mit einer Begrüßung des Kunden)
"""

E-Commerce-Assistent

DEVELOPERpython
ECOMMERCE_PROMPT = """
Du bist ein Einkaufsberater für {store_name}. Du hilfst Kunden,
die perfekten Produkte für ihre Bedürfnisse zu finden.

## Dein Ziel
Den Kunden durch Verständnis seiner Bedürfnisse zum idealen Produkt führen.

## Gesprächsstil
- Begeistert, aber nicht aufdringlich
- Produktexperte, ohne zu technisch zu sein
- Lösungsorientiert

## Verfügbare Produktinformationen
{context}

## Wann ein Produkt empfohlen werden soll
- Erkläre, WARUM dieses Produkt zum Bedürfnis passt
- Nenne 2-3 wichtige Eigenschaften
- Gib den Preis an, falls verfügbar
- Schlage Alternativen vor, wenn sinnvoll

## Frage des Kunden
{query}

## Deine Empfehlung
"""

Interne Wissensdatenbank

DEVELOPERpython
KNOWLEDGE_BASE_PROMPT = """
Du bist der interne KI-Assistent von {company}. Du hilfst Mitarbeitenden,
Informationen in unserer Dokumentation zu finden.

## Deine Rolle
- Fragen zu internen Prozessen beantworten
- Auf die richtigen Dokumente verweisen
- Unternehmensrichtlinien klären

## Strenge Regeln
- Antworte AUSSCHLIESSLICH mit dokumentierten Informationen
- Bei sensiblen HR-Fragen an die Personalabteilung verweisen
- Keine vertraulichen Informationen außerhalb des Kontexts teilen

## Verfügbare Dokumentation
{context}

## Frage des Mitarbeiters
{query}

## Deine Antwort (zitiere immer das Quelldokument)
"""

Prompts messen und verbessern

Wichtige Metriken

A/B-Testing von 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):
        """Wählt zufällig eine Variante aus."""
        variant = random.choice(self.variants)
        prompt = variant.template.format(context=context, query=query)
        return prompt, variant.name

    def record_feedback(self, variant_name, score):
        """Zeichnet das Benutzer-Feedback auf."""
        self.results[variant_name].append(score)

    def get_winner(self):
        """Gibt die Variante mit der besten Durchschnittsbewertung zurück."""
        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)

Kontinuierliche Iteration

DEVELOPERpython
def analyze_failed_responses(responses, threshold=0.7):
    """Identifiziert Muster in qualitativ schlechten Antworten."""

    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": "Quellenangabe-Einschränkungen verstärken",
        "incomplete": "Explizit vollständige Abdeckung verlangen",
        "off_topic": "Beispiele für themenabweichende Antworten hinzufügen",
        "wrong_format": "Format mit Beispielen verdeutlichen",
        "too_long": "Explizite Wortbegrenzung hinzufügen",
        "too_short": "Details und Beispiele einfordern",
    }

    return main_issue, suggestions[main_issue]

Häufige Fehler, die zu vermeiden sind

1. Zu vage Prompts

DEVELOPERpython
# ❌ Schlecht: zu vage
bad_prompt = "Beantworte die Frage mit den Dokumenten."

# ✅ Gut: präzise Anweisungen
good_prompt = """
Beantworte die Frage nach folgenden Regeln:
1. Verwende AUSSCHLIESSLICH die Informationen aus den bereitgestellten Dokumenten
2. Strukturiere deine Antwort mit Aufzählungspunkten
3. Zitiere das Quelldokument in eckigen Klammern [Source: ...]
4. Wenn die Information nicht verfügbar ist, sage "Information nicht gefunden"
5. Begrenze deine Antwort auf maximal 200 Wörter
"""

2. Fehlerfälle ignorieren

DEVELOPERpython
# ❌ Schlecht: keine Handhabung von Randfällen
bad_prompt = "Beantworte anhand der Dokumente: {context}"

# ✅ Gut: explizite Handhabung
good_prompt = """
Beantworte die Frage mit den Dokumenten.

WENN die Information nicht in den Dokumenten enthalten ist:
- Rate die Antwort NICHT
- Sage: "Diese Information ist nicht in meiner Wissensdatenbank"
- Schlage nach Möglichkeit eine alternative Quelle vor

WENN die Frage mehrdeutig ist:
- Bitte um Klärung
- Schlage mögliche Interpretationen vor
"""

3. Schlecht strukturierter Kontext

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

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

---

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

---

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

Integration mit Ailog

Ailog vereinfacht das RAG Prompt Engineering durch:

• Voroptimierte Templates nach Anwendungsfall
• Dynamische Variablen zur Personalisierung ohne Programmierung
• Integriertes A/B-Testing zur Optimierung Ihrer Prompts
• Analytics zur Identifizierung von Verbesserungsmöglichkeiten

DEVELOPERpython
# Beispiel mit der Ailog-API
from ailog import AilogClient

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

# Verwende ein optimiertes Template
response = client.chat(
    channel_id="support-widget",
    message="Wie setze ich mein Passwort zurück?",
    prompt_template="customer_support_v2",
    prompt_variables={
        "company": "Acme Corp",
        "tone": "friendly",
        "max_words": 150
    }
)

Fazit

Das RAG Prompt Engineering ist ein starker Hebel zur Verbesserung der Qualität Ihrer Chatbots. Die Erfolgsfaktoren:

1. Klare Struktur: Persona, Anweisungen, Einschränkungen, Format
2. Grenzfälle behandeln: Fehlende Informationen vorhersehen
3. Geführte Beispiele: Erwartetes Verhalten demonstrieren
4. Kontinuierliches Messen: A/B-Testing und Fehleranalyse
5. Iteration: Schrittweise Verbesserung auf Basis der Daten

Weiterführende Ressourcen

• Einführung in RAG - Die Grundlagen verstehen
• LLM-Generierung für RAG - Übergeordneter Leitfaden zur Generierung
• Chain-of-Thought RAG - Schrittweises Schlussfolgern
• Streaming RAG - Echtzeit-Antworten

Bereit, Ihre RAG-Prompts zu optimieren? Testen Sie Ailog kostenlos und profitieren Sie von voroptimieren Templates für Ihren Anwendungsfall.