0Pricing
AI Prompt Engineering · Lezione

Mantenere il contesto tra i segmenti

Utilizzi sovrapposizione, contesto progressivo e inserimento di metadati per garantire la continuità

Mantenere il contesto tra i segmenti è una lezione AI Prompt Engineering gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Prompt Engineering, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Prompt Engineering include 4 lezioni in totale.

Il problema del contesto tra chunk

Quando un documento viene suddiviso in chunk, le informazioni del chunk N possono essere necessarie per interpretare correttamente il chunk N+1. Ad esempio, un termine definito nel chunk 3 viene utilizzato nel chunk 7. Senza un collegamento tra i contesti, il modello che elabora il chunk 7 non conosce quella definizione.

Quattro strategie risolvono questo problema: sovrapposizione, iniezione di un riepilogo progressivo, tag di metadati e riferimenti ai numeri di pagina.

Strategia 1: sovrapposizione di token

La sovrapposizione ripete gli ultimi N token del chunk N all'inizio del chunk N+1. In questo modo, una frase o un'argomentazione che attraversa un confine compare per intero in almeno uno dei chunk.

Sovrapposizione tipica: 100–200 token (circa 75–150 parole). Una sovrapposizione eccessiva aumenta la ridondanza e i costi; una troppo ridotta lascia lacune ai confini.

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')

Sovrapposizione per retrieval e riepilogo

La sovrapposizione si comporta in modo diverso a seconda dell'attività:

  • Retrieval: la sovrapposizione è utile: una query corrisponde alla regione sovrapposta in uno dei due chunk adiacenti, migliorando il richiamo. Utilizzi una sovrapposizione pari al 10–20% della dimensione del chunk.
  • Riepilogo: la sovrapposizione può causare ripetizioni: la stessa frase viene riepilogata due volte. Utilizzi una sovrapposizione inferiore (5–10%) oppure rimuova la sovrapposizione prima del riepilogo.
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

Strategia 2: inserimento del riepilogo progressivo

Un riepilogo progressivo è una sintesi aggiornata di tutti i blocchi elaborati finora. Prima di elaborare il blocco N, inserisca il riepilogo progressivo nel prompt come contesto. In questo modo il modello dispone delle informazioni sul contenuto precedente senza superare la finestra di contesto.

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

Aggiornamento del riepilogo progressivo

Il riepilogo progressivo dovrebbe crescere in modo incrementale. Dopo aver elaborato ogni blocco, chieda all'LLM di aggiornare il riepilogo incorporando le nuove informazioni di quel blocco. Mantenga il riepilogo progressivo breve — 200–400 token — per lasciare spazio al blocco corrente.

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

Strategia 3: tag di metadati

I tag di metadati associano informazioni strutturate a ogni blocco, così l'LLM sa che cosa sta elaborando e può mantenere la continuità logica.

Tag comuni: document_title, chapter, section, page, chunk_index, total_chunks. Li inserisca come intestazione nel prompt, non nel testo del blocco, per separare il contenuto dai metadati.

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
    }
)

Strategia 4: riferimenti ai numeri di pagina

Quando un blocco fa riferimento a qualcosa contenuto in una pagina precedente, il modello può citarlo se i numeri di pagina sono incorporati. Inserisca le interruzioni di pagina come marcatori nel testo prima di suddividerlo in blocchi, così rimarranno nei blocchi:

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)

Combinazione delle strategie

In produzione, combini tutte e quattro le strategie per ottenere la massima fedeltà del contesto:

  1. Aggiunga i marcatori di pagina prima di suddividere il documento in blocchi
  2. Suddivida il testo in blocchi con una sovrapposizione di 200 token
  3. Alleghi un'intestazione di metadati al prompt di ogni blocco
  4. Inserisca il riepilogo progressivo prima di ogni blocco

L'approccio combinato garantisce che il modello sappia sempre in quale punto del documento si trova, che cosa viene prima e in che modo il blocco corrente è collegato all'insieme.

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

Valutazione della conservazione del contesto

Per verificare che la strategia di contesto funzioni, crei domande di test che richiedano informazioni provenienti da più blocchi:

  • Definisca un termine introdotto nel blocco 2 e richiesto nel blocco 8
  • Calcoli un totale che si estende su più pagine
  • Individui una contraddizione tra il capitolo 1 e il capitolo 5

Esegua la pipeline e verifichi se le risposte fanno correttamente riferimento al contenuto precedente. In caso contrario, aumenti la sovrapposizione o la dimensione del riepilogo progressivo.

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"]}')

Riepilogo dei compromessi

Ogni strategia comporta costi e vantaggi:

  • Sovrapposizione: semplice, aumenta il numero di token della percentuale di sovrapposizione, può causare ripetizioni nella sintesi
  • Riepilogo progressivo: potente, aggiunge una chiamata all'LLM per ogni blocco, il riepilogo può diventare impreciso o perdere dettagli
  • Tag di metadati: gratuiti da aggiungere, aiutano il modello a orientarsi, non sostituiscono il contenuto
  • Marcatori di pagina: consentono la tracciabilità, aggiungono caratteri al testo ma comportano un sovraccarico minimo in termini di token

Inizi con sovrapposizione e metadati. Aggiunga il riepilogo progressivo solo quando nei test vengono osservati errori di contesto tra i blocchi.

Guida al dimensionamento nel mondo reale

Dimensioni pratiche per un documento di 100 pagine (media di 500 token per pagina = 50.000 token totali):

  • Dimensione del blocco: 800 token, sovrapposizione di 150 token → ~73 blocchi
  • Riepilogo progressivo: massimo 200 token (aggiornato dopo ogni blocco)
  • Intestazione di metadati: ~30 token per blocco
  • Input effettivo per chiamata API: 800 + 200 + 30 = 1030 token
  • Costo della fase Map (gpt-4o-mini a $0.15/1M): 73 × 1030 × $0.15/1M ≈ $0.011

Le strategie di contesto aggiungono costi minimi, migliorando notevolmente la coerenza.

Verifica delle conoscenze

Qual è lo scopo di un riepilogo progressivo nell'elaborazione di documenti blocco per blocco?

Riepilogo: contesto tra i blocchi

Quattro strategie per mantenere il contesto tra i blocchi:

  • Sovrapposizione: ripetere gli ultimi N token del blocco N all'inizio del blocco N+1
  • Riepilogo progressivo: inserire una breve sintesi aggiornata prima di ogni blocco
  • Tag di metadati: intestazione con informazioni sul documento, sul capitolo, sulla sezione e sulla pagina
  • Marcatori di pagina: incorporare i numeri di pagina nel testo prima di suddividerlo in blocchi

Combini tutte e quattro le strategie nelle pipeline di produzione. Verifichi la conservazione del contesto tra i blocchi usando domande che richiedono più blocchi. Con questo si conclude il corso 16 sulle strategie per la gestione di documenti lunghi.

Domande Frequenti

La lezione «Mantenere il contesto tra i segmenti» è gratuita?

Sì — il testo completo di «Mantenere il contesto tra i segmenti» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Prompt Engineering, passa a CoddyKit PRO. Il corso AI Prompt Engineering include 4 lezioni in totale.

Cosa imparerò in «Mantenere il contesto tra i segmenti»?

Utilizzi sovrapposizione, contesto progressivo e inserimento di metadati per garantire la continuità Eserciti AI Prompt Engineering con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare AI Prompt Engineering?

Non è richiesta alcuna esperienza precedente. AI Prompt Engineering su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Mantenere il contesto tra i segmenti»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione AI Prompt Engineering?

Sì. Ogni lezione AI Prompt Engineering include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Strategie di chunking per testi lunghi
  2. Schema di riepilogo Map-Reduce
  3. Riepilogo gerarchico
  4. Mantenere il contesto tra i segmenti
← Torna a AI Prompt Engineering