# Gestione del contesto (/it/docs/verdent-for-vscode/best-practices/context)
> Gestire il contesto in modo efficace per ottenere risultati migliori
***
Una gestione efficace del contesto garantisce che Verdent disponga delle informazioni giuste al momento giusto, evitando il calo di prestazioni causato da un sovraccarico di contesto.
### Cosa imparerai [#cosa-imparerai]
* Comprendere le finestre di contesto e i loro limiti
* Selezionare i file in modo strategico per un contesto ottimale
* Riconoscere e reagire al sovraccarico di contesto
* Quando reimpostare il contesto per prestazioni migliori
* Come l'organizzazione del workspace influisce sul contesto
***
## Comprendere le finestre di contesto [#comprendere-le-finestre-di-contesto]
La dimensione della finestra di contesto di Verdent for VS Code dipende dal modello utilizzato.
La maggior parte dei modelli usa finestre di contesto standard da `200K`:
* **Claude 4.5 Sonnet** - Bilanciato per attività complesse
* **Claude 4.5 Haiku** - Veloce ed efficiente
* **GPT-5** - Eccellente per il ragionamento (Beta)
* **GPT-5-Codex** - Ottimizzato per la programmazione (Beta)
**Capacità:**
* \~`200,000` token di capacità di memoria totale
* Sufficiente per la maggior parte delle attività di sviluppo e per progetti di medie dimensioni
**Cosa è incluso:**
* Tutti i messaggi della conversazione
* I contenuti dei file caricati nel contesto
* Gli output e le risposte degli strumenti
* I prompt di sistema e le istruzioni
* Le definizioni dei server MCP
**Prestazioni:**
* Peggiorano in modo significativo quando ci si avvicina ai limiti
* Presta attenzione ai segnali di sovraccarico di contesto (risposte più lente, output meno accurati)
* Reimposta il contesto più spesso per prestazioni ottimali
Claude Sonnet 4.5 offre un contesto esteso (`1M` token) quando viene selezionato esplicitamente o quando l'input supera `200K` token.
**Capacità:**
* `1,000,000` token di memoria totale
* 5 volte più grande dei modelli standard
**Vantaggi:**
* Ideale per caricare interi codebase di grandi dimensioni senza suddividerli
* Elimina la maggior parte delle preoccupazioni sulla gestione del contesto per i progetti grandi
* Lavora più a lungo prima di raggiungere i limiti di contesto
* Servono meno reset delle sessioni
**Quando usarlo:**
* Codebase di grandi dimensioni con `1000+` file
* Refactoring complessi multi-file su interi progetti
* Lunghe sessioni di sviluppo che coprono più attività correlate
* Quando vuoi ridurre al minimo il sovraccarico della gestione del contesto
***
## Selezione strategica dei file [#selezione-strategica-dei-file]
Adotta un approccio strategico nella selezione dei file per ottimizzare l'uso del contesto ed evitare di raggiungere i limiti.
Inizia con meno file e aggiungine altri solo quando serve: Verdent può sempre leggere altri file durante la conversazione.
### Usa le @-menzioni per l'inclusione esplicita [#usa-le--menzioni-per-linclusione-esplicita]
```
@filename.js
```
Verdent carica automaticamente i file correlati, ma `@-mentions` garantisce un contesto preciso. Sii selettivo: includi solo i file direttamente rilevanti per l'attività in corso.
### Monitora l'uso del contesto [#monitora-luso-del-contesto]
* Presta attenzione al calo di prestazioni man mano che le sessioni si allungano
* Tieni presente la lunghezza della conversazione e il numero di file
* Rimuovi dal contesto i file non necessari quando possibile
### Evita il sovraccarico di contesto [#evita-il-sovraccarico-di-contesto]
* Suddividi le attività di grandi dimensioni in parti più piccole con meno file per attività
* Concentrati solo sui file correlati: non caricare l'intero codebase in una volta sola
* Usa la gestione dei server MCP per disattivare le integrazioni inutilizzate
### Buone pratiche [#buone-pratiche]
* Includi solo i file che devono essere modificati o consultati
* Fai riferimento ai pattern esistenti invece di caricare file di esempio
* Per i codebase di grandi dimensioni, lavora su un modulo alla volta
* Usa la documentazione del progetto (`AGENTS.md`) invece di caricare molti file
* Evita l'ultimo quinto della finestra di contesto per le attività che richiedono molta memoria
### Per il contesto esteso (1M token) [#per-il-contesto-esteso-1m-token]
La selezione dei file diventa molto meno critica: spesso puoi caricare interi repository di progetto senza raggiungere i limiti.
***
## Riconoscere il sovraccarico di contesto [#riconoscere-il-sovraccarico-di-contesto]
**Segnali:**
* Risposte meno accurate o incomplete
* Dettagli importanti mancanti rispetto alle prime fasi della conversazione
* Difficoltà a mantenere la coerenza nelle sessioni lunghe
* Confusione riguardo alle modifiche o al contesto recenti
**Esempi concreti:**
* Suggerisce soluzioni che avevi già rifiutato in precedenza nella sessione
* Ignora le convenzioni di programmazione che avevi stabilito `20` messaggi fa
* Genera codice in conflitto con modifiche fatte in precedenza nella conversazione
* Propone implementazioni che non corrispondono all'architettura del progetto discussa prima
**Segnale principale:** le risposte di Verdent diventano meno accurate o incoerenti
**Segnali:**
* Tempi di risposta notevolmente più lenti
* Ritardi di elaborazione più lunghi prima dell'inizio delle risposte
* Maggiore latenza tra i messaggi
**Esempi concreti:**
* Risposte che normalmente richiedono `5-10` secondi ora ne richiedono `30+`
* Ritardo visibile prima che compaia l'indicatore di digitazione dopo l'invio di un messaggio
* Le risposte in streaming iniziano molto più lentamente del solito
* L'esecuzione degli strumenti (letture di file, ricerche) richiede molto più tempo
**Segnale principale:** le risposte richiedono molto più tempo del solito
**Segnali:**
* Richieste di chiarire informazioni già fornite
* Dimenticanza di pattern o convenzioni stabiliti in precedenza
* Incapacità di fare riferimento a file o codice discussi in precedenza
* Domande ridondanti sulla struttura del progetto
**Esempi concreti:**
* Chiede "Quale framework stai usando?" quando avevi specificato React `30` messaggi fa
* Richiede percorsi di file che hai già `@-mentioned` più volte
* Non ricorda la convenzione di denominazione che avevi stabilito all'inizio della sessione
* Rispiega concetti o approcci che avevi già rifiutato con delle motivazioni
**Segnale principale:** Verdent chiede di cose già discusse
**Segnali:**
* Ci si avvicina all'ultimo quinto del limite di `200K` token (\~`160K+` token utilizzati)
* Conversazioni lunghe con molte letture di file e output di strumenti
* Più server MCP abilitati con definizioni di strumenti pesanti
* File di grandi dimensioni caricati ripetutamente nel contesto
**Esempi concreti:**
* La sessione è in corso da `2+` ore con `100+` messaggi
* Hai caricato `20+` file con `@-mentions` durante la conversazione
* Più file di grandi dimensioni (`>1000` righe ciascuno) sono nel contesto
* Hai `5+` server MCP abilitati con definizioni di strumenti estese
* La conversazione include molti risultati di grep/ricerca e letture di file
**Segnale principale:** sessioni molto lunghe con un uso intensivo di file/strumenti
**Quando intervenire:** il calo di prestazioni è il segnale principale. Se le risposte di Verdent diventano meno accurate, più lente o incoerenti, avvia una nuova sessione o applica le strategie di gestione del contesto.
Se le risposte di Verdent diventano vaghe o ripetitive, potrebbe essere in corso un sovraccarico di contesto. Reimposta la conversazione per ripristinare le prestazioni complete.
**Nota:** con il contesto da `1M` token (Claude Sonnet 4.5), questi problemi sono molto meno comuni.
***
## Quando reimpostare il contesto [#quando-reimpostare-il-contesto]
* Tempi di risposta notevolmente più lenti
* Risposte meno accurate o incoerenti
* Verdent dimentica il contesto o i pattern precedenti
* Ci si avvicina ai limiti della finestra di contesto (attenzione ai segnali di degrado)
**Azione:** avvia una nuova sessione quando la qualità peggiora
* Passaggio tra funzionalità o moduli non correlati
* Completamento di un elemento della to-do list e passaggio al successivo
* Dopo attività che richiedono molta memoria (refactoring di grandi dimensioni, lavoro architetturale)
* Passaggio dalla fase di ricerca a quella di implementazione
**Azione:** nuova sessione per ogni nuova attività importante
* Dopo aver eseguito il commit delle funzionalità completate nel controllo di versione
* Tra i checkpoint logici del flusso di lavoro di sviluppo
* Dopo i cicli di test-verifica-commit
**Azione:** commit → test → nuova sessione
* Prima di iniziare nuove funzionalità importanti
* Quando la cronologia della conversazione diventa molto lunga
* Dopo aver completato modifiche multi-file
* Tra diversi tipi di lavoro (debug → sviluppo di funzionalità)
**Azione:** avvia proattivamente una nuova sessione prima che il contesto si degradi
**Flusso di lavoro consigliato:** completa un'unità di lavoro atomica → test → commit → svuota il contesto → riparti da zero per l'attività successiva.
**Nota:** avvia una nuova sessione per reimpostare il contesto. Per i contesti da `1M` token, lo svuotamento è necessario molto meno spesso.
***
## Impatto dell'organizzazione del workspace [#impatto-dellorganizzazione-del-workspace]
L'organizzazione del workspace incide direttamente sull'efficienza con cui viene usato il contesto e sulla facilità con cui Verdent riesce a navigare nel tuo codebase.
**File più piccoli e mirati:**
* Molti file piccoli consumano il contesto in modo più efficiente rispetto a pochi file grandi
* È più facile caricare solo i moduli rilevanti
* Controllo più granulare su ciò che è nel contesto
* Riduce la necessità di caricare interi file di grandi dimensioni
**Struttura di directory chiara:**
* Un'organizzazione logica aiuta Verdent a localizzare i file correlati
* Un'organizzazione basata su funzionalità o moduli migliora la precisione del contesto
* Riduce la necessità di caricare codice non correlato
**`Documentation in AGENTS.md:`**
* La documentazione del progetto sostituisce la necessità di caricare molti file di esempio
* I pattern architetturali vengono descritti una volta e richiamati più volte
* Gli standard di programmazione documentati in modo centralizzato
* Riduce il sovraccarico di contesto dovuto alle letture esplorative dei file
**Vantaggi:**
* Lavora su moduli isolati senza caricare l'intero codebase
* Confini chiari consentono sessioni mirate
* Suddividere il lavoro diventa naturale lungo i confini dei moduli
**Problemi:**
* I file monolitici costringono a caricare interi contesti di grandi dimensioni
* Una struttura poco chiara richiede di caricare molti file per capire l'architettura
* Responsabilità miste negli stessi file sprecano contesto su codice irrilevante
**Impatto:**
* Frequenti problemi con i limiti di contesto
* Token sprecati su codice irrilevante
* Difficoltà a isolare il lavoro su moduli specifici
* Necessità più frequente di reimpostare le sessioni
**Anti-pattern comuni:**
* Singoli file di `5000+` righe con più responsabilità
* Struttura di directory piatta con `100+` file nella radice
* Nessuna separazione chiara tra funzionalità/moduli
* Mancanza di documentazione centralizzata
**Approcci di refactoring:**
* Suddividi i file di grandi dimensioni in moduli più piccoli e mirati
* Organizza per funzionalità o dominio (non per tipo di file)
* Crea una gerarchia di directory chiara
* Estrai il codice condiviso in moduli separati
**Documentazione:**
* Crea `AGENTS.md` con i pattern architetturali
* Documenta gli standard di programmazione in modo centralizzato
* Mantieni file `README` per ogni modulo
* Mantieni documentate le decisioni di progettazione
**Impatto sul contesto:** per i contesti standard da `200K` token, un workspace organizzato fa la differenza tra raggiungere i limiti spesso o raramente. Per i contesti da `1M` token, l'organizzazione conta meno ma migliora comunque l'efficienza.
***
## Strategie di ottimizzazione del contesto [#strategie-di-ottimizzazione-del-contesto]
Un'ottimizzazione efficace del contesto combina monitoraggio, pianificazione strategica e configurazione tecnica.
**Presta attenzione ai segnali di prestazioni:**
* Monitora la qualità e la velocità delle risposte durante le sessioni
* Nota quando le risposte diventano più lente o meno accurate
* Tieni traccia manualmente della lunghezza della conversazione e del numero di file
* Sii proattivo nell'avviare nuove sessioni
**Cosa monitorare:**
* Accuratezza e coerenza delle risposte
* Tempo alla prima risposta (ritardo dell'indicatore di digitazione)
* Tempo complessivo di completamento delle risposte
* Memoria dei dettagli delle prime fasi della conversazione
**Gestione dei sottoagenti:**
* Disattiva i sottoagenti personalizzati inutilizzati quando non servono
* Ogni sottoagente abilitato aggiunge definizioni al sovraccarico di sistema
* Mantieni abilitati solo i sottoagenti attivamente utilizzati
* Riabilitali quando servono per attività specifiche
**Soglia di intervento:** quando noti `2-3` segnali di degrado, è il momento di avviare una nuova sessione.
Monitora la qualità delle risposte come indicatore anticipatore dello stato del contesto: risposte degradate segnalano che è il momento di reimpostare.
**Approccio a suddivisione:**
* Suddividi le attività di grandi dimensioni in parti più piccole
* Completa il lavoro correlato in sessioni mirate
* Evita di mescolare tipi di attività diversi in conversazioni lunghe
* Evita l'ultimo quinto della finestra di contesto per il lavoro che richiede molta memoria
**Gestione delle sessioni:**
* Avvia nuove sessioni tra le attività importanti
* Svuota il contesto dopo i commit: test → verifica → commit → nuova sessione
* Usa le to-do list per la pianificazione multi-step
* Affronta gli elementi della to-do list in sessioni mirate separate
**Pattern consigliato:**
1. Pianifica l'attività in Plan Mode
2. Esegui un'implementazione mirata in una nuova sessione
3. Testa e verifica le modifiche
4. Esegui il commit nel controllo di versione
5. Avvia una nuova sessione per l'attività successiva
**Isolamento delle attività:** tieni separato il debug dallo sviluppo di funzionalità, e la ricerca dall'implementazione.
**Inclusione strategica:**
* Usa `@-mentions` per l'inclusione esplicita dei file solo quando necessario
* Sfrutta la documentazione `AGENTS.md` invece di caricare molti file
* Lavora su un modulo alla volta per i progetti di grandi dimensioni
* Suddividi i file di grandi dimensioni in componenti più piccoli e mirati
**Principi di selezione dei file:**
* Includi solo i file che necessitano di modifiche o di riferimento diretto
* Preferisci la documentazione al caricamento di file di esempio
* Rimuovi i file dal contesto quando non servono più
* Carica i file al momento del bisogno, non in anticipo
**Gestione dei file di grandi dimensioni:**
* Valuta di suddividere i file oltre `500` righe
* Estrai utility e helper in file separati
* Usa confini di modulo chiari
* Documenta le relazioni tra i file in `AGENTS.md`
**Flusso di lavoro di ottimizzazione:**
Monitora le prestazioni → Identifica il gonfiore delle sessioni → Disattiva i sottoagenti inutilizzati → Avvia proattivamente nuove sessioni → Concentrati sulla qualità delle attività
**Pratica quotidiana:**
* Inizia ogni funzionalità importante con un contesto pulito
* Esegui commit frequenti e reimposta tra un commit e l'altro
* Mantieni le sessioni concentrate su un unico obiettivo
* Rivedi l'uso del contesto nei punti di interruzione naturali
**`For Extended Context (1M tokens):`** Con la finestra di contesto più ampia di Claude Sonnet 4.5, l'ottimizzazione diventa meno critica: concentrati sulla qualità delle attività piuttosto che su una gestione aggressiva del contesto. Tuttavia, le buone pratiche migliorano comunque l'efficienza e l'organizzazione.
***
## Domande frequenti [#domande-frequenti]
I modelli standard (Claude 4.5 Sonnet, Haiku, GPT-5, GPT-5-Codex, MiniMax-M2) hanno finestre di contesto da `200K` token, sufficienti per la maggior parte delle attività. Claude Sonnet 4.5 offre un contesto esteso da `1M` token (5 volte più grande) per codebase di grandi dimensioni con `1000+` file, refactoring complessi multi-file o lunghe sessioni di sviluppo. Il contesto da `1M` si attiva automaticamente quando l'input supera `200K` token oppure può essere selezionato esplicitamente.
Devi avviare manualmente una nuova sessione per reimpostare il contesto: Verdent non lo svuota automaticamente. Buona pratica: reimposta dopo aver completato un'unità di lavoro atomica, averla testata ed eseguito il commit nel controllo di versione. Per i contesti da `1M` token, i reset sono necessari molto meno spesso.
Non esiste un limite fisso di file: dipende dalle dimensioni dei file e dal conteggio totale dei token. Per i contesti da `200K`, evita di caricare `20+` file di grandi dimensioni (`>1000` righe ciascuno). Concentrati sui file direttamente rilevanti per la tua attività in corso. Usa `@-mentions` in modo selettivo e sfrutta la documentazione `AGENTS.md` invece di caricare molti file di esempio. Con il contesto da `1M`, la selezione dei file diventa molto meno critica.
Tutto ciò che è presente nella tua sessione: tutti i messaggi della conversazione, i contenuti dei file caricati nel contesto, gli output degli strumenti (risultati di grep/ricerca, letture di file), i prompt di sistema e le istruzioni, e le definizioni dei server MCP. Ciascuno di questi elementi consuma token dalla tua capacità di contesto totale.
No: reimpostare il contesto svuota solo la cronologia della conversazione e i file caricati in memoria. Le tue modifiche effettive al codice, i commit e le modifiche ai file vengono conservati. Esegui sempre il commit del tuo lavoro nel controllo di versione prima di reimpostare il contesto, per sicurezza. Reimposta → avvia una nuova sessione → continua a lavorare sull'attività successiva.
***
## Vedi anche [#vedi-anche]
Buone pratiche per scrivere prompt efficaci
Comprendere le modalità di esecuzione e le loro implicazioni sulle risorse
Monitora l'uso dei token, i crediti e le prestazioni