Superare la Finestra di Contesto: I Modelli Linguistici Ricorsivi in Azione

Nel mondo delle applicazioni di intelligenza artificiale generativa (GenAI), il contesto è veramente tutto. La qualità dell'output di un modello linguistico di grandi dimensioni (LLM) è strettamente legata alla qualità e alla quantità di informazioni fornite. In pratica, molti casi d'uso reali comportano contesti massicci: generazione di codice su grandi codebase, interrogazione di sistemi di conoscenza complessi o persino lunghe e tortuose chat durante la ricerca della destinazione di vacanza perfetta (ci siamo passati tutti).

Sfortunatamente, gli LLM possono lavorare in modo efficiente solo con una quantità limitata di contesto. E questo non riguarda solo i limiti fisici della finestra di contesto, specialmente ora che i modelli di frontiera supportano centinaia di migliaia, o addirittura milioni, di token. E questi limiti continuano a crescere. La sfida più grande è un fenomeno noto come context rot, dove le prestazioni del modello si degradano all'aumentare della lunghezza del contesto.

Questo effetto è chiaramente dimostrato nel paper intitolato “RULER: What’s the Real Context Size of Your Long-Context Language Models?” di Hsieh et al. Gli autori introducono RULER, un nuovo benchmark per la valutazione delle prestazioni su contesti lunghi, e testano una serie di modelli. I risultati mostrano un modello coerente: all'aumentare della lunghezza del contesto, le prestazioni diminuiscono significativamente in tutti i modelli. In molti casi, la lunghezza effettiva del contesto (dove le prestazioni rimangono paragonabili a quelle di Llama 2–7B) è solo circa il 50% della finestra di contesto pubblicizzata, o anche meno.

Nel loro recente paper intitolato “Recursive Language Models”, Zhang et al. propongono un approccio promettente per affrontare il problema del context rot. In questo articolo, vorremmo esaminare più da vicino questa idea ed esplorare come funziona in pratica, sfruttando il supporto recentemente aggiunto da DSPy per questa strategia di inferenza.

I Modelli Linguistici Ricorsivi (RLM)

I Modelli Linguistici Ricorsivi (RLM) sono stati introdotti per affrontare la degradazione delle prestazioni all'aumentare della lunghezza del contesto e per consentire agli LLM di lavorare con contesti molto grandi (fino a due ordini di grandezza oltre la finestra di contesto nativa del modello). Questo sta diventando sempre più importante man mano che adottiamo gli LLM per compiti che implicano l'elaborazione di centinaia di milioni di token.

Esistono già diversi approcci per gestire compiti a lungo termine. Il più comune (qualcosa che probabilmente avete incontrato utilizzando agenti di codice come Cursor) è la contestualizzazione tramite riassunto. In questa configurazione, la conversazione o il contesto di lavoro viene ripetutamente riassunto una volta che si avvicina al limite di contesto del modello. In pratica, tuttavia, questo spesso si rivela insufficiente: dettagli importanti e sfumature sottili dei passaggi precedenti tendono a perdersi man mano che il modello "dimentica" le informazioni obsolete per far spazio a nuovi token.

I Modelli Linguistici Ricorsivi adottano un approccio diverso e sorprendentemente elegante. Invece di passare l'intero prompt all'LLM ogni volta, il prompt viene trattato come un insieme di variabili disponibili in un ambiente Python REPL (Read–Eval–Print Loop). Il modello è dotato di strumenti che gli consentono di ispezionare queste variabili o di invocare ricorsivamente se stesso su frammenti selezionati programmaticamente.

In altre parole, gli RLM incoraggiano l'LLM a scrivere codice che costruisce i propri sotto-compiti e quindi a risolvere tali sotto-compiti richiamando ricorsivamente se stesso. Questo sposta l'onere dallo spremere tutto in un singolo prompt allo strutturare il problema in un modo che il modello possa navigare in contesti ampi in modo più affidabile. Gli autori hanno valutato il loro approccio su diversi compiti a lungo termine, dove gli RLM hanno fornito risultati robusti sia sui modelli GPT-5 che Qwen-3.

I risultati sono estremamente promettenti. Gli RLM (con o senza sotto-chiamate) superano costantemente altri approcci in tutti i compiti. Vediamo come funziona questo in pratica.

Utilizzo degli RLM nella pratica

Uno scenario comune in cui il contesto lungo brilla davvero è la risposta a domande su una vasta base di conoscenza. Quindi è esattamente quello che proveremo qui. Ho preso tutti gli articoli che ho pubblicato su Towards Data Science e li ho caricati in un singolo file Markdown. In modo alquanto sorprendente, ciò ammonta a quasi 1,5 MB di testo. Si spera che sia abbastanza perché il modello possa scavare a fondo.

Fortunatamente, DSPy ha recentemente introdotto un'implementazione dell'approccio di inferenza dei Modelli Linguistici Ricorsivi. Ciò significa che non dobbiamo costruire nulla noi stessi; abbiamo solo bisogno della versione 3.1.2 o più recente di DSPy.

pip install dspy --upgrade

Iniziamo caricando il dataset.

with open('articles.md', 'r') as f:
    articles = f.read()

Successivamente, controlliamo quanti token contiene.

import anthropic

client = anthropic.Anthropic(api_key=config['ANTHROPIC_API_KEY'])

# Count tokens for messages
token_count = client.messages.count_tokens(
  model="claude-sonnet-4-5",
  messages=[
    {"role": "user", "content": articles}
  ]
)

print(f"Input tokens: {token_count.input_tokens}")
# Input tokens: 386768

Ci sono quasi 400.000 token nel nostro contesto. Claude Sonnet 4.5 supporta una finestra di contesto di 200.000 token, quindi elaborare l'intero dataset in un singolo prompt non è fattibile. Questo è esattamente dove l'RLM diventa utile.

Configurazione del modello linguistico e dell'RLM

Per utilizzare DSPy, dobbiamo prima configurare il modello linguistico. Come discusso in precedenza, l'RLM si basa sul codice per interagire con il prompt, quindi funziona meglio con modelli che hanno forti capacità di codifica. Per questo motivo, utilizzerò Claude in questo esempio, poiché è noto per le sue buone prestazioni nei compiti relativi al codice.

lm = dspy.LM('anthropic/claude-sonnet-4-5', api_key=config['ANTHROPIC_API_KEY'])
dspy.configure(lm=lm)

Successivamente, inizializziamo l'RLM specificando la sua "signature". In questo caso d'uso, passo l'intero set di articoli insieme a una domanda e mi aspetto che il modello estragga le tendenze chiave e le restituisca come una lista di stringhe.

rlm = dspy.RLM('articles, question -> trends: list[str]')

Qui, utilizzo Claude Sonnet 4.5 sia per il modello principale che per le sotto-chiamate ricorsive. DSPy consente anche di utilizzare un modello più piccolo per le sotto-chiamate tramite il parametro sub_lm, il che può aiutare a ridurre i costi.

Ora possiamo eseguire l'RLM e accedere al campo trends nell'output.

output = rlm(
  articles = articles, 
  question = '''What were the main AI trends of 2025 based on provided 
    articles? Pay attention to the content not only the titles.'''
)

print('\n'.join(output.trends))

Le tendenze AI identificate dall'RLM

L'output generato dal modello, basato sull'analisi dei 400.000 token, ha identificato le seguenti tendenze principali per il 2025:

• AI Agente e Sistemi Autonomi: Modelli di auto-riflessione, miglioramento iterativo attraverso cicli di feedback (Self-Refine, Reflexion, CRITIC) e LLM come motori di ragionamento in grado di pianificare ed eseguire compiti in modo autonomo.
• Sistemi AI Multi-Agente: Evoluzione da agenti singoli a team collaborativi di agenti specializzati con ruoli distinti, utilizzando framework come LangGraph, CrewAI e AutoGen per l'orchestrazione.
• Ingegneria del Contesto e RAG: Transizione dal prompting statico alla generazione aumentata dal recupero (RAG) dinamica, sistemi di memoria adattivi e contesti auto-miglioranti che apprendono dall'esperienza senza riaddestramento.
• Protocolli di Standardizzazione: Emergenza del Model Context Protocol (MCP) per la standardizzazione delle integrazioni LLM-tool e dell'Agent Communication Protocol (ACP) per la comunicazione inter-agente, riducendo la complessità dell'integrazione.
• LLM con Strumenti e Funzioni di Chiamata: LLM dotati della capacità di invocare strumenti esterni, eseguire query SQL, navigare sul web e interagire con le API tramite meccanismi strutturati di chiamata di funzioni.
• Framework AI Pronti per la Produzione: Ecosistema maturo che include LangGraph, DSPy, LangChain, NeMo Agent Toolkit, CrewAI e AutoGen, focalizzato sul passaggio dal prototipo alla produzione con osservabilità integrata.
• Valutazione e Osservabilità degli LLM: Modelli di valutazione "LLM-as-judge", framework di metriche complete (Ragas, DeepEval, Evidently), valutazione della traiettoria e monitoraggio continuo come infrastruttura di produzione essenziale.
• Programmazione al Posto del Prompting: Spostamento verso lo sviluppo AI dichiarativo, basato su codice con framework come DSPy e approcci basati sulla configurazione (basati su YAML) che sostituiscono l'ingegneria dei prompt.
• Interoperabilità dei Framework: Strumenti progettati per integrarsi tra più framework piuttosto che creare silos, consentendo architetture AI componibili che sfruttano le migliori caratteristiche di diversi ecosistemi.
• Local and Cost-Ef

Come si può notare, l'RLM è stato in grado di elaborare con successo un contesto di quasi 400.000 token, che era ben oltre il limite nativo della finestra di contesto del modello Claude Sonnet 4.5. Questo dimostra chiaramente il potenziale degli RLM nel superare le limitazioni di lunghezza del contesto degli LLM attuali, consentendo applicazioni GenAI molto più complesse e basate su dati di grandi dimensioni.

Conclusioni

Il problema del "context rot" e i limiti pratici delle finestre di contesto sono ostacoli significativi per l'adozione su larga scala degli LLM in contesti aziendali e di ricerca che richiedono l'elaborazione di vasti insiemi di dati. I Modelli Linguistici Ricorsivi (RLM) rappresentano una svolta promettente, offrendo una metodologia elegante per consentire agli LLM di gestire contesti che superano di gran lunga le loro capacità intrinseche.

L'approccio basato sulla ricorsione, dove l'LLM scrive codice per auto-organizzare e risolvere sotto-compiti, non solo migliora le prestazioni ma apre anche nuove strade per l'ingegneria del prompt e la costruzione di sistemi agentici. L'integrazione di questa strategia in framework come DSPy ne facilita l'implementazione pratica, rendendola accessibile a sviluppatori e ricercatori. Con gli RLM, stiamo assistendo a un passo avanti significativo nella capacità degli LLM di affrontare la complessità del mondo reale, spingendo i confini di ciò che è possibile con l'intelligenza artificiale generativa.