0Pricing
AI Prompt Engineering · Lektion

Kontextkomprimierung

Den Kontext auf das Wesentliche kürzen

Kontextkomprimierung ist eine kostenlose AI Prompt Engineering-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Prompt Engineering-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Warum Kontext komprimieren

Abgerufene Chunks sind verrauscht: Ein relevanter Chunk kann größtenteils aus Standardtext bestehen und nur einen einzigen entscheidenden Satz enthalten. Kontextkomprimierung kürzt den abgerufenen Text auf das, was die Query tatsächlich beantwortet, bevor er den Generator erreicht.

Die Vorteile verstärken sich gegenseitig: geringere Token-Kosten, kürzere Latenz, weniger Ablenkungen und eine Entlastung vom Lost-in-the-Middle-Effekt, weil der vom Modell zu verarbeitende Kontext kleiner wird.

def compress(query, chunks):
    # Goal: keep only spans that bear on the query,
    # dropping boilerplate, navigation, and off-topic sentences.
    return [extract_relevant(query, c) for c in chunks]

Extraktiv vs. abstraktiv

Extraktive Komprimierung wählt wörtliche Textstellen (Sätze, Passagen) aus, die für die Query relevant sind, und bewahrt dabei den exakten Wortlaut sowie die Provenienz. Abstraktive Komprimierung formuliert Inhalte um oder fasst sie zusammen. Dadurch wird eine stärkere Komprimierung erreicht, allerdings mit dem Risiko von Informationsverlust und eingeführten Fehlern.

Bevorzugen Sie bei faktischem RAG mit Zitaten die extraktive Variante, damit sich Aussagen zur Quelle zurückverfolgen lassen. Verwenden Sie die abstraktive Variante nur, wenn sich ihre Faktentreue überprüfen lässt.

def extractive(query, chunk):
    sents = split_sentences(chunk.text)
    scored = [(s, relevance(query, s)) for s in sents]
    kept = [s for s, r in scored if r > TAU]
    return ' '.join(kept) or top1(scored)   # never return empty

Filterung auf Satzebene

Eine leichtgewichtige, robuste Technik: Bewerten Sie jeden Satz jedes Chunks anhand seiner Übereinstimmung mit der Query, entweder mit einem kleinen Cross-Encoder oder anhand von Embedding-Ähnlichkeit, und entfernen Sie Sätze mit niedrigen Scores. So bleiben die wertvollen Sätze erhalten, während Fülltext entfernt wird.

Behalten Sie pro Chunk einen Mindestkontext bei, damit nicht der umgebende Satz entfernt wird, der einer Tatsache ihre Bedeutung gibt.

def sentence_filter(query, chunk, keep_ratio=0.4):
    sents = split_sentences(chunk.text)
    scores = embed_sim_batch(query, sents)
    n_keep = max(1, int(len(sents) * keep_ratio))
    idx = sorted(range(len(sents)), key=lambda i: -scores[i])[:n_keep]
    return ' '.join(sents[i] for i in sorted(idx))  # keep original order

LLM-basierte kontextuelle Komprimierung

Ein LLM kann jeden Chunk einzeln komprimieren: Geben Sie ihm die Anweisung, nur die für die Query relevanten Teile einer Passage zu extrahieren und entweder den Chunk wörtlich gekürzt oder eine leere Markierung zurückzugeben, wenn nichts relevant ist.

Dies ist das Muster des LangChain ContextualCompressionRetriever. Es ist genauer als Embedding-Filter, fügt aber pro Chunk einen LLM-Aufruf hinzu. Reservieren Sie es daher für Pipelines mit hohen Anforderungen oder bündeln Sie die Aufrufe.

def llm_compress(query, chunk):
    prompt = (
        'Extract ONLY sentences from the passage relevant to the query. '
        'If none are relevant, output NONE. Do not paraphrase.\n'
        'Query: ' + query + '\nPassage: ' + chunk.text
    )
    out = llm(prompt, temperature=0).strip()
    return None if out == 'NONE' else out

Token-Level-Pruning (LLMLingua)

Verfahren wie LLMLingua komprimieren auf Token-Ebene. Dabei wird ein kleines Modell verwendet, um die Informationsdichte von Tokens zu schätzen und Tokens mit geringem Informationsgehalt zu entfernen. So lassen sich hohe Komprimierungsraten erreichen, während das Signal erhalten bleibt, das das große Modell benötigt.

Der Nachteil: Der komprimierte Text wird weniger gut lesbar. Daher eignet sich dieses Verfahren für rein maschinell verarbeiteten Kontext, nicht für die Anzeige für Benutzer.

def token_prune(context, target_ratio=0.3):
    # small LM estimates per-token information (perplexity-based);
    # drop the least informative tokens down to target_ratio length
    scores = small_lm_token_importance(context)
    return keep_top_fraction(context, scores, target_ratio)

Query-abhängig vs. Query-unabhängig

Query-abhängige Komprimierung behält das für diese Query Relevante und erzeugt den knappsten Kontext, muss aber für jede Anfrage ausgeführt werden. Query-unabhängige Komprimierung (vorab berechnete Chunk-Zusammenfassungen) ist zum Anfragezeitpunkt günstiger, kann sich aber nicht auf die konkrete Frage konzentrieren.

Bei einem hybriden Ansatz werden komprimierte Chunk-Versionen offline gespeichert und online leicht Query-abhängig gekürzt.

# Offline: precompute a dense summary per chunk (query-agnostic)
chunk.summary = summarize(chunk.text)
# Online: query-aware trim over summaries (cheap) then verify on full
ctx = [sentence_filter(query, Chunk(c.summary)) for c in top_chunks]

Schutz vor Informationsverlust

Aggressive Komprimierung kann genau die eine Klausel entfernen, auf die es ankommt. Sichern Sie sich mit einer Recall-Prüfung ab: Überprüfen Sie, ob der komprimierte Kontext die Antwort weiterhin logisch stützt, oder behalten Sie einen Fallback auf den unkomprimierten Chunk bei, wenn der Komprimierer verdächtig wenig zurückgibt.

Lassen Sie niemals zu, dass die Komprimierung einen Chunk auf einen leeren Inhalt reduziert, wenn der Re-Ranker ihn als hochrelevant bewertet hat. Das deutet auf einen Fehler des Komprimierers hin, nicht auf Irrelevanz.

def safe_compress(query, chunk):
    out = llm_compress(query, chunk)
    if out is None and chunk.rerank_score > 0.7:
        return chunk.text          # trust re-ranker over compressor
    return out or chunk.text

Provenienz bewahren

Die Komprimierung muss die Quellenzuordnung erhalten. Kennzeichnen Sie jede beibehaltene Textstelle mit der ID ihres Chunks und Dokuments, damit der Generator sie zitieren kann. Wenn Sie die Metadaten wegkomprimieren, gehen die Überprüfbarkeit und die Möglichkeit verloren, Halluzinationen zu erkennen.

Führen Sie IDs als strukturierte Felder durch die Pipeline und niemals als Freitext, den die Komprimierung entfernen könnte.

def compress_with_ids(query, chunks):
    out = []
    for c in chunks:
        span = safe_compress(query, c)
        out.append({'id': c.id, 'doc': c.meta['doc_id'], 'text': span})
    return out   # generator cites id; provenance preserved

Komprimierung und Token-Budget

Durch Komprimierung können Sie für mehr Recall mehr Kandidaten abrufen und den endgültigen Prompt trotzdem klein halten. Legen Sie ein Tokenbudget für das Kontextfenster fest und packen Sie die wertvollsten komprimierten Textstellen nach dem Greedy-Prinzip hinein, bis das Budget erreicht ist.

So entkoppeln Sie die abgerufene Menge von den Kosten für die Generierung – ein wichtiger Hebel für die Effizienz.

def pack(spans, budget_tokens, tok):
    spans = sorted(spans, key=lambda s: -s['score'])
    used, packed = 0, []
    for s in spans:
        t = tok(s['text'])
        if used + t > budget_tokens:
            continue
        packed.append(s); used += t
    return packed

Qualität der Komprimierung messen

Verfolgen Sie drei Werte: das Komprimierungsverhältnis (eingesparte Tokens), die Antwortgenauigkeit (ist die Qualität erhalten geblieben?) und die Faktentreue (hat der Komprimierer Fakten unverändert gelassen?). Ziel ist das höchste Komprimierungsverhältnis, bei dem sich die Antwortgenauigkeit nicht verändert.

Variieren Sie die Aggressivität der Komprimierung und wählen Sie den Pareto-Punkt, der Ihr Kostenziel ohne Qualitätsverlust erfüllt.

def eval_compression(eval_set, levels):
    return {
        lvl: {
            'ratio': mean_ratio(eval_set, lvl),
            'acc':   answer_accuracy(eval_set, lvl),
            'faith': faithfulness(eval_set, lvl),
        } for lvl in levels
    }

Eine komprimierungsbewusste Pipeline

Ende zu Ende: Rufen Sie breit ab, führen Sie ein Re-Ranking durch, komprimieren Sie jeden verbleibenden Chunk (extraktiv oder LLM-basiert) unter Wahrung der Provenienz, schützen Sie sich vor übermäßiger Kürzung, packen Sie die Inhalte in ein Tokenbudget und generieren Sie Antworten mit Zitaten.

Die Komprimierung ist die Schicht, die Retrieval mit hohem Recall bezahlbar macht und den Generator auf das Wesentliche konzentriert.

def pipeline(query):
    top = rerank(query, hybrid_retrieve(query, 50))[:12]
    spans = compress_with_ids(query, top)
    spans = [s for s in spans if s['text']]
    packed = pack(spans, budget_tokens=2000, tok=count_tokens)
    return generate_with_citations(query, packed)

Schnelltest

Wählen Sie den richtigen Komprimierungsansatz für ein faktisches RAG-System mit Zitaten.

Zusammenfassung

Wichtigste Erkenntnisse:

  • Komprimierung kürzt abgerufene Chunks auf Query-relevante Inhalte und senkt Kosten, Latenz sowie die Zahl der Ablenkungen.
  • Bevorzugen Sie für faktisches RAG mit Zitaten die extraktive Variante (wörtlich, nachvollziehbar) gegenüber der abstraktiven Variante; Token-Level-Pruning eignet sich für rein maschinell verarbeiteten Kontext.
  • Query-abhängige Komprimierung ist am präzisesten, muss aber pro Anfrage ausgeführt werden. Kombinieren Sie sie für mehr Effizienz mit offline erstellten Zusammenfassungen.
  • Schützen Sie sich vor Informationsverlust und bewahren Sie die Provenienz von Chunk und Dokument für Zitate.
  • Nutzen Sie Komprimierung, um breit abzurufen und Prompts trotzdem klein zu halten. Stimmen Sie sie auf den maximalen Komprimierungsgrad ab, ohne die Antwortgenauigkeit zu verringern.

Häufig gestellte Fragen

Ist die Lektion „Kontextkomprimierung“ kostenlos?

Ja — der vollständige Text von „Kontextkomprimierung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Prompt Engineering-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Prompt Engineering-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Kontextkomprimierung“?

Den Kontext auf das Wesentliche kürzen Du übst AI Prompt Engineering mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Prompt Engineering zu starten?

Keine Vorkenntnisse erforderlich. AI Prompt Engineering auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Kontextkomprimierung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Prompt Engineering-Lektion Code schreiben und ausführen?

Ja. Jede AI Prompt Engineering-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Über naives RAG hinaus
  2. Abgerufene Chunks neu bewerten
  3. Kontextkomprimierung
  4. Query-Rewriting und HyDE
← Zurück zu AI Prompt Engineering