Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Token, contesto e finestra di conversazione

Lezione 7 di 22 Aggiornata il 29 luglio 2026 Sviluppatore
In questa pagina
  1. Token, contesto e finestra di conversazione
  2. Che cos’è un token?
  3. La finestra di contesto
  4. Tre leve di ottimizzazione
  5. Il contesto si accumula durante la conversazione
  6. Punti chiave

Token, contesto e finestra di conversazione

Il token è l’unità che il modello manipola e quella su cui si basa la tua fatturazione. Finché questo concetto rimane confuso, lo saranno anche i tuoi costi e finirai per incappare in un errore di limite del contesto senza capirne il motivo. Questa lezione chiarisce entrambi gli aspetti.

Che cos’è un token?

Un token non è una parola. È un frammento di testo che il modello tratta come un’unità indivisibile. In italiano, un token rappresenta in media circa 0,7 parole. La libreria tiktoken ti permette di vedere esattamente come il testo viene suddiviso: nota come “andatevene” si spezza in due token mentre “oggi”, che appare più spesso nel corpus di addestramento, rientra in uno solo. Questo dettaglio spiega perché un testo in italiano consuma più token di un testo inglese di lunghezza comparabile.

from openai import OpenAI
client = OpenAI()

# Per stimare i token, usa la libreria tiktoken
import tiktoken

# cl200k_base è usato qui come esempio: ogni generazione di modello ha il proprio encoder.
# Verifica l'encoder per il modello che chiami prima di affidarti al conteggio.
enc = tiktoken.get_encoding("cl200k_base")

texte = "Bonjour, comment allez-vous aujourd'hui ?"
tokens = enc.encode(texte)
print(f"Text: {texte}")
print(f"Number of tokens: {len(tokens)}")
print(f"Tokens: {tokens}")
print(f"Decoded: {[enc.decode([t]) for t in tokens]}")

# Result:
# Text: Bonjour, comment allez-vous aujourd'hui ?
# Number of tokens: 9
# Tokens: [38025, 11, 4068, 67590, 5072, 76439, 30, ...]
# Decoded: ['Bonjour', ',', ' comment', ' allez', '-vous', " aujourd'hui", ' ?']

Verifica sempre quale encoder corrisponde al modello che chiami. Un conteggio eseguito con l’encoder sbagliato rimane un’approssimazione utile, ma non corrisponderà esattamente alla tua fattura.

La finestra di contesto

Ogni modello ha una finestra di contesto massima e la trappola per i principianti è che include sia l’input sia l’output. Non è un budget di input: è un budget totale. Se il tuo prompt occupa 190.000 token di una finestra da 200.000 token, ne rimangono solo 10.000 per la risposta. Il modello si interromperà a metà frase senza ulteriori avvisi.

# Generazione precedente, per riferimento:
# GPT-5.4: 1.000.000 di token di contesto
# GPT-5.3: 200.000 token di contesto
# gpt-5.6-sol  : 200.000 token di contesto
# gpt-5.6-terra : 200.000 token di contesto

# Esempio: se il tuo input è di 190.000 token in una finestra da 200.000 token,
# rimangono solo 10.000 token per la risposta

response = client.responses.create(
    model="gpt-5.6-terra",
    input="A very long text...",
    max_output_tokens=10000  # Limite esplicito
)

A posteriori, puoi leggere il conteggio esatto in response.usage, che distingue i token di input, i token di output e il totale:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain tokens in three sentences."
)

usage = response.usage
print(f"Input tokens: {usage.input_tokens}")
print(f"Output tokens: {usage.output_tokens}")
print(f"Total: {usage.total_tokens}")

# Result:
# Input tokens: 12
# Output tokens: 58
# Total: 70

Tre leve di ottimizzazione

La prima leva è la concisione del prompt. Le formule di cortesia e le precauzioni retoriche non migliorano la risposta e costano token fino all’ultimo: la prima versione sotto usa trentacinque token per un risultato identico alla seconda, che ne usa dieci. Alla scala di un servizio che gestisce un milione di richieste, la differenza non è più aneddotica.

# MALE — prompt verboso (35 token)
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Could you please give me a list "
          "of three fruits that are red in color, if that "
          "does not bother you of course?"
)

# BENE — prompt conciso (10 token)
response = client.responses.create(
    model="gpt-5.6-terra",
    input="List 3 red fruits."
)

La seconda leva mira all’output, che costa diverse volte più dell’input. Combina l’istruzione nel prompt con un tetto tecnico: la prima inquadra la scrittura, la seconda garantisce che il tuo budget regga anche se il modello ignora l’istruzione.

# Nessun limite — il modello può generare molti token
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain photosynthesis."
)

# Con limite — controllo dei costi
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Explain photosynthesis in 2 sentences maximum.",
    max_output_tokens=100
)

La terza leva è la stima del costo prima della chiamata, che diventa essenziale non appena elabori documenti di dimensioni variabili. Puoi così rifiutare o dividere una richiesta troppo pesante piuttosto che scoprirlo sulla tua fattura.

import tiktoken

def estimate_cost(text: str, model: str = "gpt-5.6-terra") -> dict:
    """Stima il costo di una chiamata API."""
    enc = tiktoken.get_encoding("cl200k_base")
    input_tokens = len(enc.encode(text))

    # Prezzi approssimativi per milione di token (verifica i prezzi attuali)
    prices = {
        "gpt-5.6-sol": {"input": 5.0, "output": 30.0},
        "gpt-5.6-terra": {"input": 2.0, "output": 12.0},
        "gpt-5.6-luna": {"input": 0.20, "output": 1.20},
    }

    input_cost = (input_tokens / 1_000_000) * prices[model]["input"]

    return {
        "input_tokens": input_tokens,
        "input_cost_usd": round(input_cost, 6),
        "model": model
    }

print(estimate_cost("Explain relativity in 3 sentences."))
# Result: {'input_tokens': 10, 'input_cost_usd': 2.5e-05, 'model': 'gpt-5.6-terra'}

Il contesto si accumula durante la conversazione

Quando concateni gli scambi usando previous_response_id, ogni turno riparte dalla totalità dei turni precedenti. I token di input continuano quindi a crescere: un dialogo che inizia a 50 token ne pesa 150 al secondo turno e molto di più al decimo. Questa è la causa più comune di fatture che lievitano senza un aumento del traffico, e il monitoraggio di response.usage.input_tokens è il tuo segnale di allarme.

# Turno 1: 50 token
r1 = client.responses.create(
    model="gpt-5.6-terra",
    input="Hello, I am a Python developer."
)

# Turno 2: 50 + 100 = 150 token (contesto cumulativo)
r2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Which web frameworks do you recommend?",
    previous_response_id=r1.id
)

# Turno 10: i token si accumulano!
# Monitora response.usage.input_tokens per evitare sorprese
print(f"Cumulative tokens at turn 2: {r2.usage.input_tokens}")

Per le conversazioni lunghe, la soluzione è troncare attivamente la cronologia: rimuovi i messaggi più vecchi finché non scendi sotto un limite scelto, mantenendo però il primo, che di solito porta il contesto fondante dello scambio.

def conversation_with_limit(messages: list, token_limit: int = 50000):
    """Mantieni la conversazione sotto un limite di token."""
    enc = tiktoken.get_encoding("cl200k_base")

    total = sum(len(enc.encode(m["content"])) for m in messages)

    # Rimuovi i messaggi più vecchi se necessario
    while total > token_limit and len(messages) > 2:
        removed = messages.pop(1)  # Mantieni il primo messaggio (contesto)
        total -= len(enc.encode(removed["content"]))

    return messages

Punti chiave

  • Un token equivale a circa 0,7 parole in italiano
  • La finestra di contesto include input E output
  • Le finestre variano in base al modello: nella generazione precedente, 1 milione di token per GPT-5.4 e 200.000 per GPT-5.3, o3-pro e o4-mini
  • Usa tiktoken per contare i token prima della chiamata
  • Monitora response.usage per controllare i tuoi costi
  • Gestisci attivamente il contesto nelle conversazioni lunghe