AI-promptengineering · Les

Context behouden tussen chunks

Gebruik overlap, rolling context en metadata-injectie voor continuïteit.

Les 4 van 413 stappen

Context behouden tussen chunks is een gratis AI-promptengineering-les op CoddyKit. Dit is les 4 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.

Het probleem van context tussen stukken

Wanneer een document in stukken wordt verdeeld, kan informatie uit stuk N nodig zijn om stuk N+1 goed te interpreteren. Een term die in stuk 3 wordt gedefinieerd, kan bijvoorbeeld in stuk 7 worden gebruikt. Zonder een brug tussen de context weet het model dat stuk 7 verwerkt niet wat die definitie is.

Vier strategieën pakken dit aan: overlap, injectie van een doorlopende samenvatting, metadatalabels en verwijzingen naar paginanummers.

Strategie 1: overlap van tokens

Bij overlap worden de laatste N tokens van stuk N herhaald aan het begin van stuk N+1. Zo staat een zin of argument dat over een grens heen loopt in ten minste één stuk volledig.

Gebruikelijk is een overlap van 100–200 tokens (ongeveer 75–150 woorden). Te veel overlap verhoogt de herhaling en de kosten; te weinig overlap laat gaten op grenzen achter.

import tiktoken

enc = tiktoken.get_encoding('cl100k_base')

def chunk_with_overlap(text, max_tokens=1000, overlap=200):
    tokens = enc.encode(text)
    chunks = []
    step = max_tokens - overlap
    i = 0
    while i < len(tokens):
        chunk = tokens[i:i + max_tokens]
        chunks.append(enc.decode(chunk))
        i += step
    return chunks

chunks = chunk_with_overlap(document, max_tokens=1000, overlap=200)
print(f'{len(chunks)} chunks with 200-token overlap')

Overlap voor ophalen tegenover samenvatten

Overlap werkt verschillend per taak:

Ophalen: overlap helpt — een vraag komt in het overlappende gebied van een van beide aangrenzende stukken overeen, waardoor de volledigheid verbetert. Gebruik een overlap van 10–20% van de stukgrootte.
Samenvatten: overlap kan herhaling veroorzaken — dezelfde zin wordt twee keer samengevat. Gebruik een kleinere overlap (5–10%) of verwijder de overlap voordat je gaat samenvatten.

def strip_overlap(chunks, overlap_tokens=200):
    '''Remove the leading overlap from each chunk (except the first).'''
    cleaned = [chunks[0]]
    for chunk in chunks[1:]:
        tokens = enc.encode(chunk)
        trimmed = enc.decode(tokens[overlap_tokens:])
        cleaned.append(trimmed)
    return cleaned

Strategie 2: Doorlopende samenvatting invoegen

Een doorlopende samenvatting is een voortdurend bijgewerkt overzicht van alle blokken die tot nu toe zijn verwerkt. Voeg voordat je blok N verwerkt de doorlopende samenvatting als context aan de prompt toe. Zo krijgt het model kennis van eerdere inhoud zonder het contextvenster te overschrijden.

import openai
client = openai.OpenAI(api_key='sk-...')

def process_with_rolling_summary(chunks):
    rolling_summary = ''
    results = []

    for i, chunk in enumerate(chunks):
        context = ''
        if rolling_summary:
            context = f'Summary of previous sections:\n{rolling_summary}\n\n'

        prompt = context + f'Current section:\n{chunk}'
        resp = client.chat.completions.create(
            model='gpt-4o',
            messages=[
                {'role': 'system', 'content': 'Answer questions or summarize, using prior context.'},
                {'role': 'user', 'content': prompt}
            ]
        )
        result = resp.choices[0].message.content
        results.append(result)

        # Update rolling summary
        rolling_summary = update_rolling_summary(rolling_summary, chunk)

    return results

De doorlopende samenvatting bijwerken

De doorlopende samenvatting moet stapsgewijs groeien. Vraag de LLM na het verwerken van elk blok om de samenvatting bij te werken met de nieuwe informatie uit dat blok. Houd de doorlopende samenvatting kort — 200–400 tokens — zodat er ruimte overblijft voor het huidige blok.

def update_rolling_summary(current_summary, new_chunk, max_words=150):
    if not current_summary:
        prompt = f'Summarize the following in under {max_words} words:\n\n{new_chunk}'
    else:
        prompt = (
            f'Current running summary (under {max_words} words):\n{current_summary}\n\n'
            f'New section to incorporate:\n{new_chunk}\n\n'
            f'Update the summary to include the new section. Stay under {max_words} words.'
        )
    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}]
    )
    return resp.choices[0].message.content

Strategie 3: Metadatatags

Metadatatags koppelen gestructureerde informatie aan elk blok, zodat de LLM weet wat deze verwerkt en de logische samenhang kan behouden.

Veelgebruikte tags zijn: document_title, chapter, section, page, chunk_index, total_chunks. Voeg deze als kop aan de prompt toe, niet aan de bloktekst, zodat inhoud en metadata gescheiden blijven.

def build_prompt_with_metadata(chunk, metadata):
    header = (
        f'Document: {metadata["title"]}\n'
        f'Chapter: {metadata["chapter"]}\n'
        f'Section: {metadata["section"]}\n'
        f'Page: {metadata["page"]}\n'
        f'Chunk: {metadata["chunk_index"] + 1} of {metadata["total_chunks"]}\n'
        '---\n'
    )
    return header + chunk

prompt = build_prompt_with_metadata(
    chunk=chunks[5],
    metadata={
        'title': 'Annual Report 2024',
        'chapter': '3. Financial Results',
        'section': '3.2 Revenue Breakdown',
        'page': 42,
        'chunk_index': 5,
        'total_chunks': 120
    }
)

Strategie 4: Verwijzingen naar paginanummers

Wanneer een blok verwijst naar iets op een eerdere pagina, kan het model daarnaar verwijzen als de paginanummers zijn opgenomen. Voeg paginamarkeringen vóór het opdelen in blokken aan de tekst toe, zodat ze in de blokken behouden blijven:

def inject_page_markers(pages):
    '''pages: list of strings, one per page.'''
    marked = []
    for i, page_text in enumerate(pages):
        marked.append(f'[PAGE {i+1}]\n{page_text}')
    return '\n\n'.join(marked)

# When the model sees [PAGE 12] in context, it can say
# 'As defined on page 12...' in its output, enabling traceability.
document_with_markers = inject_page_markers(pdf_pages)
chunks = chunk_with_overlap(document_with_markers)

Strategieën combineren

Combineer in productie alle vier de strategieën voor een zo betrouwbaar mogelijke context:

Voeg paginamarkeringen toe voordat je de tekst in blokken opdeelt
Deel de tekst op in blokken met een overlap van 200 tokens
Voeg aan de prompt van elk blok een metadatakop toe
Voeg vóór elk blok de doorlopende samenvatting in

Dankzij deze gecombineerde aanpak weet het model altijd waar het zich in het document bevindt, wat eraan voorafging en hoe het huidige blok zich tot het geheel verhoudt.

def process_document(pages, doc_metadata):
    # Step 1: inject page markers
    full_text = inject_page_markers(pages)
    # Step 2: chunk with overlap
    chunks = chunk_with_overlap(full_text, max_tokens=900, overlap=150)
    total = len(chunks)
    rolling_summary = ''
    results = []

    for i, chunk in enumerate(chunks):
        meta = {**doc_metadata, 'chunk_index': i, 'total_chunks': total}
        prompt = build_prompt_with_metadata(chunk, meta)
        if rolling_summary:
            prompt = 'Prior context:\n' + rolling_summary + '\n\n' + prompt
        result = call_llm(prompt)
        results.append(result)
        rolling_summary = update_rolling_summary(rolling_summary, chunk)

    return results

Contextbehoud evalueren

Maak toetsvragen waarvoor informatie uit meerdere blokken nodig is om te controleren of je contextstrategie werkt:

Definieer een term die in blok 2 wordt geïntroduceerd en in blok 8 wordt opgevraagd
Bereken een totaal dat meerdere pagina's beslaat
Identificeer een tegenstrijdigheid tussen hoofdstuk 1 en hoofdstuk 5

Voer de verwerkingsketen uit en controleer of antwoorden correct naar eerdere inhoud verwijzen. Als dat niet lukt, vergroot je de overlap of de omvang van de doorlopende samenvatting.

test_questions = [
    {
        'question': 'What is the definition of "net recurring revenue" used in this report?',
        'defined_in_chunk': 2,
        'asked_in_chunk': 9,
        'expected_keywords': ['net recurring revenue', 'subscription', 'exclude']
    }
]

def evaluate_context_retention(pipeline_results, test_questions):
    for test in test_questions:
        answer = pipeline_results[test['asked_in_chunk']]
        for kw in test['expected_keywords']:
            if kw.lower() not in answer.lower():
                print(f'FAIL: missing "{kw}" in answer to chunk {test["asked_in_chunk"]}')

Samenvatting van de afwegingen

Elke strategie heeft kosten en voordelen:

Overlap: eenvoudig, verhoogt het aantal tokens met overlap%, kan herhaling in samenvattingen veroorzaken
Doorlopende samenvatting: krachtig, voegt één LLM-aanroep per blok toe, de samenvatting kan afwijken of details verliezen
Metadatatags: kost niets om toe te voegen, helpt het model zich te oriënteren, vervangt geen inhoud
Paginamarkeringen: maken traceerbaarheid mogelijk, voegen tekens aan de tekst toe maar zorgen voor minimale extra kosten in tokens

Begin met overlap en metadata. Voeg alleen een doorlopende samenvatting toe wanneer tijdens het toetsen fouten in de context tussen blokken worden waargenomen.

Praktische richtlijnen voor dimensionering

Praktische afmetingen voor een document van 100 pagina's (gemiddeld 500 tokens per pagina = in totaal 50.000 tokens):

Blokgrootte: 800 tokens, overlap van 150 tokens → ~73 blokken
Doorlopende samenvatting: maximaal 200 tokens (bijgewerkt na elk blok)
Metadatakop: ~30 tokens per blok
Effectieve invoer per API-aanroep: 800 + 200 + 30 = 1030 tokens
Kosten voor toewijzing (gpt-4o-mini voor $0.15/1M): 73 × 1030 × $0.15/1M ≈ $0.011

Contextstrategieën voegen minimale kosten toe en verbeteren de samenhang aanzienlijk.

Kennistoets

Wat is het doel van een doorlopende samenvatting bij het verwerken van documenten blok voor blok?

Beantwoord dit in de interactieve les

Samenvatting: context tussen blokken

Vier strategieën om de context tussen blokken te behouden:

Overlap: herhaal de laatste N tokens van blok N aan het begin van blok N+1
Doorlopende samenvatting: voeg vóór elk blok een kort, voortdurend bijgewerkt overzicht in
Metadatatags: kop met informatie over het document, hoofdstuk, sectie en pagina
Paginamarkeringen: neem paginanummers in de tekst op voordat je deze in blokken opdeelt

Combineer ze alle vier in verwerkingsketens voor productie. Controleer het contextbehoud tussen blokken met vragen waarvoor meerdere blokken nodig zijn. Hiermee wordt Cursus 16 over strategieën voor het verwerken van lange documenten afgesloten.

Gratis beginnen

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

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Context behouden tussen chunks” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad AI-promptengineering, waaronder “Context behouden tussen chunks”, 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 “Context behouden tussen chunks”?

Gebruik overlap, rolling context en metadata-injectie voor continuïteit. 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 4 van 4.

Hoe lang duurt de les “Context behouden tussen chunks”?

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

← Terug naar AI-promptengineering