Contextcompressie
De context beperken tot wat ertoe doet
Contextcompressie is een gratis AI-promptengineering-les op CoddyKit. Dit is les 3 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject AI-promptengineering. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus AI-promptengineering bevat in totaal 4 lessen.
Waarom je context comprimeert
Opgehaalde fragmenten bevatten ruis: een relevant fragment kan grotendeels uit standaardtekst bestaan met slechts één zin die de kern bevat. Contextcompressie reduceert opgehaalde tekst tot wat de zoekopdracht daadwerkelijk beantwoordt voordat die tekst de generator bereikt.
De voordelen versterken elkaar: lagere tok kosten, minder latentie, minder afleiders en minder last van informatie die in het midden verloren gaat doordat de context waar het model doorheen moet gaan kleiner wordt.
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]Extractief versus abstractief
Extractieve compressie selecteert letterlijke tekstgedeelten (zinnen, passages) die relevant zijn voor de zoekopdracht, en behoudt zo de exacte formulering en herkomst. Abstractieve compressie parafraseert of vat samen. Daarmee bereik je een hogere compressie, maar loop je meer risico op informatieverlies en nieuwe fouten.
Geef bij feitelijke RAG met bronverwijzingen de voorkeur aan extractieve compressie, zodat beweringen naar de bron te herleiden zijn. Gebruik abstractieve compressie alleen wanneer je de getrouwheid kunt controleren.
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 emptyFilteren op zinsniveau
Dit is een lichte, robuuste techniek: beoordeel elke zin van elk fragment op overeenkomst met de zoekopdracht met een kleine cross-encoder of op basis van embeddingsovereenkomst, en verwijder zinnen met een lage score. Zo behoud je de zinnen met de meeste waarde en verwijder je opvulling.
Houd per fragment een minimale hoeveelheid context over, zodat je niet de omliggende zin verwijdert die een feit zijn betekenis geeft.
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 orderContextuele compressie op basis van een LLM
Een LLM kan elk fragment afzonderlijk comprimeren: geef de opdracht om alleen de delen van een passage te extraheren die relevant zijn voor de zoekopdracht, en laat het fragment letterlijk maar ingekort teruggeven, of een lege aanduiding als niets relevant is.
Dit is het patroon van LangChain ContextualCompressionRetriever. Het is nauwkeuriger dan filters op basis van embeddings, maar voegt per fragment een LLM-aanroep toe. Gebruik het daarom voor kritieke pijplijnen of verwerk meerdere fragmenten in één bundel.
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 outSnoeien op tokenniveau (LLMLingua)
Methoden zoals LLMLingua comprimeren op tokenniveau met een klein model dat inschat hoeveel informatie elk token bevat, en tokens met weinig informatie verwijdert. Ze kunnen hoge compressieverhoudingen bereiken en tegelijk het signaal behouden dat het grote model nodig heeft.
De keerzijde is dat de gecomprimeerde tekst minder leesbaar wordt voor mensen. Dit is daarom geschikt voor context die alleen door machines wordt gebruikt, niet voor weergave aan gebruikers.
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)Zoekopdrachtbewust versus zoekopdrachtagnostisch
Zoekopdrachtbewuste compressie behoudt wat relevant is voor deze zoekopdracht en levert de meest compacte context op, maar moet voor elk verzoek worden uitgevoerd. Zoekopdrachtagnostische compressie (vooraf berekende samenvattingen van fragmenten) is goedkoper tijdens een verzoek, maar kan zich niet richten op de specifieke vraag.
Een hybride aanpak slaat offline verkorte versies van fragmenten op en past online een lichte zoekopdrachtbewuste inkorting toe.
# 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]Bescherming tegen informatieverlies
Agressieve compressie kan de ene clausule verwijderen die ertoe deed. Bouw daarom een recallcontrole in: controleer of de gecomprimeerde context het antwoord nog ondersteunt, of houd een terugvaloptie naar het ongecomprimeerde fragment achter de hand wanneer de compressor verdacht weinig teruggeeft.
Laat compressie een fragment nooit volledig leegmaken wanneer de herordener het als zeer relevant heeft beoordeeld. Dat wijst op een fout in de compressor, niet op irrelevantie.
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.textHerkomst behouden
Bij compressie moet de bronvermelding intact blijven. Voorzie elk behouden tekstgedeelte van de ID van het fragment en het document, zodat de generator ernaar kan verwijzen. Als je de metagegevens wegcomprimeert, verlies je de controleerbaarheid en de mogelijkheid om hallucinaties te detecteren.
Geef ID's als gestructureerde velden door de hele pijplijn door, nooit als vrije tekst die door compressie kan worden verwijderd.
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 preservedCompressie en het tokenbudget
Dankzij compressie kun je meer kandidaten ophalen voor recall en toch de uiteindelijke prompt klein houden. Stel een tokenbudget in voor het contextvenster en vul dat hebzuchtig met de waardevolste gecomprimeerde tekstgedeelten totdat het budget is bereikt.
Zo ontkoppel je de hoeveelheid die je ophaalt van de hoeveelheid die je aan generatie besteedt. Dat is een belangrijke efficiëntieknop.
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 packedCompressiekwaliteit meten
Houd drie getallen bij: de compressieverhouding (bespaarde tokens), de antwoordnauwkeurigheid (bleef de kwaliteit behouden?) en de getrouwheid (veranderde de compressor geen feiten?). Het doel is de hoogste verhouding waarbij de antwoordnauwkeurigheid niet verandert.
Test verschillende niveaus van compressie en kies het Pareto-punt dat aan je kostendoel voldoet zonder kwaliteitsverlies.
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
}Een compressiebewuste pijplijn
Van begin tot eind: haal breed op, herorden, comprimeer elk overgebleven fragment (extractief of op basis van een LLM) met behoud van de herkomst, voorkom te vergaande inkorting, vul het tokenbudget en genereer met bronverwijzingen.
Compressie is de laag die ophalen met hoge recall betaalbaar maakt en ervoor zorgt dat de generator zich richt op wat ertoe doet.
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)Korte controle
Kies de juiste compressieaanpak voor een feitelijk RAG-systeem met bronverwijzingen.
Samenvatting
Belangrijkste punten:
- Compressie reduceert opgehaalde fragmenten tot inhoud die relevant is voor de zoekopdracht, en verlaagt kosten, latentie en het aantal afleiders.
- Geef bij feitelijke RAG met bronverwijzingen de voorkeur aan extractieve compressie (letterlijk en herleidbaar) boven abstractieve compressie; snoeien op tokenniveau is geschikt voor context die alleen door machines wordt gebruikt.
- Zoekopdrachtbewuste compressie levert de meest compacte context op, maar moet per verzoek worden uitgevoerd; combineer die voor efficiëntie met offline samenvattingen.
- Bescherm je tegen informatieverlies en behoud de herkomst van fragmenten en documenten voor bronverwijzingen.
- Gebruik compressie om breed op te halen en prompts toch klein te houden; stem de aanpak af op de maximale verhouding zonder verlies van antwoordnauwkeurigheid.
Leer AI-promptengineering met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 53
- Lessen
- 199
Veelgestelde vragen
Is de les “Contextcompressie” gratis?
Ja — je kunt hier op het web alle 3 lessen van het leerpad AI-promptengineering, waaronder “Contextcompressie”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus AI-promptengineering bevat in totaal 4 lessen.
Wat leer ik in “Contextcompressie”?
De context beperken tot wat ertoe doet Je oefent met AI-promptengineering door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met AI-promptengineering te beginnen?
Ervaring vooraf is niet nodig. AI-promptengineering op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Contextcompressie”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over AI-promptengineering?
Ja. Elke les over AI-promptengineering bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Verder dan naïeve RAG
- Opgehaalde chunks opnieuw rangschikken
- Contextcompressie
- Query herschrijven en HyDE