Oltre la finestra di contesto: i modelli linguistici ricorsivi in azione

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

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

Questo effetto è chiaramente dimostrato nel paper “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 valutare le prestazioni con 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 Llama 2–7B) è solo circa il 50% della finestra di contesto pubblicizzata, o anche meno.

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

Modelli linguistici ricorsivi

I modelli linguistici ricorsivi (RLM) sono stati introdotti per affrontare il degrado delle prestazioni all'aumentare della lunghezza del contesto e per consentire agli LLM di lavorare con contesti molto ampi (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 sintesi del contesto. 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 non è sufficiente: dettagli importanti e sottili sfumature dai passaggi precedenti tendono a perdersi man mano che il modello "dimentica" le vecchie informazioni per fare 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 poi a risolvere tali sotto-compiti chiamando ricorsivamente se stesso. Questo sposta l'onere dallo spremere tutto in un singolo prompt allo strutturare il problema in 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 appaiono estremamente promettenti. Gli RLM (con o senza sottochiamate) superano costantemente altri approcci in tutti i compiti. Vediamo come funziona questo nella pratica.

Utilizzo degli RLM nella pratica

Uno scenario comune in cui un contesto lungo si rivela davvero utile è 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 unico file Markdown. In modo alquanto sorprendente, ciò ammonta a quasi 1,5 MB di testo. Si spera che sia abbastanza per il modello da esplorare.

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.

Installazione di DSPy

pip install dspy --upgrade

Caricamento del dataset

Iniziamo caricando il dataset.

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

Successivamente, verifichiamo 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}")
# Output: 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 unico prompt non è fattibile. È esattamente qui che l'RLM diventa utile.

Configurazione del modello linguistico per DSPy

Per usare 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, userò Claude in questo esempio, poiché è noto per le sue buone prestazioni nei compiti legati al codice.

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

Inizializzazione dell'RLM

Successivamente, inizializziamo l'RLM specificando la sua "firma". 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 un elenco 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.

Esecuzione dell'RLM e analisi dell'output

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

output = rlm(
  articles = articles, 
  question = '''Quali sono state le principali tendenze dell'IA nel 2025 basate sugli articoli forniti? Presta attenzione al contenuto e non solo ai titoli.'''
)

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

L'output del modello, basato sull'analisi ricorsiva degli articoli, potrebbe essere simile al seguente elenco di tendenze:

• IA agentica e sistemi autonomi: modelli di auto-riflessione, miglioramento iterativo tramite cicli di feedback (Self-Refine, Reflexion, CRITIC) e LLM come motori di ragionamento in grado di pianificare ed eseguire autonomamente compiti.
• Sistemi IA multi-agente: evoluzione da singoli agenti a team collaborativi di agenti specializzati con ruoli distinti, utilizzando framework come LangGraph, CrewAI e AutoGen per l'orchestrazione.
• Ingegneria del contesto e RAG: andare oltre il prompting statico verso la generazione aumentata dal recupero dinamico (RAG), sistemi di memoria adattivi e contesti auto-miglioranti che apprendono dall'esperienza senza riaddestramento.
• Protocolli di standardizzazione: emergere 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à di integrazione.
• LLM con uso di strumenti e chiamata di funzioni: 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 IA 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 anziché prompting: passaggio verso lo sviluppo di IA dichiarativo e 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 anziché creare silos, consentendo architetture IA componibili che sfruttano le migliori caratteristiche di diversi ecosistemi.
• IA locale e costi-efficaci: tendenza all'ottimizzazione per l'esecuzione di modelli di grandi dimensioni localmente o con costi ridotti.

I modelli linguistici ricorsivi rappresentano un passo significativo nel superare i limiti di contesto degli LLM, offrendo una soluzione elegante e potente al problema del context rot. Integrando la capacità di scrivere codice e auto-invocarsi, gli RLM consentono agli LLM di affrontare contesti di dimensioni e complessità senza precedenti, aprendo nuove possibilità per applicazioni GenAI più intelligenti e autonome.