Mantenere una sessione di chat consente alla tua applicazione .NET di sopravvivere ai riavvii, fornisce un backup della conversazione e permette di spostare la sessione tra macchine. In questa guida vedremo Persisti e riprendi una sessione di chat in C# usando Aspose.LLM, coprendo quando utilizzare il pattern, come salvare e caricare le sessioni, quali dati vengono memorizzati, considerazioni sulla portabilità e le migliori pratiche di sicurezza.

Perché persistere e riprendere una sessione di chat?

Gli sviluppatori spesso creano assistenti interattivi, bot di supporto o flussi di lavoro di analisi dati a lungo termine. In molti scenari il contesto della chat deve sopravvivere oltre la durata di un singolo processo:

  • Uno strumento di supporto desktop in cui gli utenti si aspettano che le loro query precedenti rimangano disponibili dopo la chiusura dell’app.
  • Automazione lato server che comprende più passaggi e può essere riavviata a causa della manutenzione.
  • Requisiti di audit o conformità che richiedono uno snapshot dell’intera conversazione.
  • Spostare una sessione di risoluzione dei problemi dal laptop di uno sviluppatore a un server di produzione.

Persistendo la sessione in un file JSON, si cattura l’intera cronologia dei messaggi e la cache KV interna necessaria per una continuazione esatta, rendendo i casi d’uso sopra descritti semplici da implementare.

Iniziare con Aspose.LLM

Per prima cosa, aggiungi il pacchetto Aspose.LLM al tuo progetto:

Install-Package Aspose.LLM

Puoi trovare ulteriori dettagli sul prodotto nella pagina del prodotto Aspose.LLM .NET. L’SDK richiede una licenza valida, quindi assicurati di avere a disposizione un file di licenza temporaneo o permanente.

Prerequisiti

  • Installa il pacchetto NuGet Aspose.LLM.
  • Applica una licenza Aspose.LLM usando Aspose.LLM.License.
  • Crea un’istanza AsposeLLMApi (ad esempio, con un Qwen25Preset).

Quando utilizzare questo modello

Questo modello si distingue quando è necessario che la conversazione persista oltre il processo corrente, o quando si desidera uno snapshot affidabile per backup o migrazione. Gli scenari tipici includono:

  • Applicazioni desktop o server in cui gli utenti si aspettano che la chat persista tra le avvii.
  • Flussi di lavoro a lunga durata che richiedono che la conversazione sopravviva al processo.
  • Backup e scopi di audit mediante la creazione di snapshot di una conversazione attiva.
  • Migrazione dello stato della sessione tra macchine con la stessa versione SDK e impostazione predefinita.

Prerequisiti

Prima di poter salvare o ripristinare una sessione, assicurati che i seguenti requisiti siano soddisfatti:

  1. Aspose.LLM NuGet package – installato tramite il comando mostrato in precedenza.
  2. Licenza – crea un oggetto Aspose.LLM.License e chiama SetLicense con il tuo file .lic.
  3. Istanza API – istanzia AsposeLLMApi con il preset desiderato (ad esempio, new Qwen25Preset()).

Questi passaggi sono dimostrati nell’esempio completo più avanti nell’articolo.

Salva una sessione

L’SDK offre tre modi pratici per conservare una sessione di chat. Segui i passaggi seguenti, quindi consulta l’esempio di codice.

  1. Chiama SaveChatSession con un percorso file esplicito se hai bisogno del file in una posizione nota.
  2. Ometti il percorso per consentire al SDK di scrivere <sessionId>.json accanto all’eseguibile.
  3. Crea un percorso temporaneo con Path.Combine, assicurati che la directory esista e salva lì per scenari isolati o sandbox.

Esempio di codice – Salvataggio di una sessione

Il seguente esempio dimostra tutti e tre gli approcci:

api.SaveChatSession(sessionId, "session-42.json");

api.SaveChatSession(sessionId); // writes <sessionId>.json next to the executable

string path = Path.Combine(Path.GetTempPath(), "chats", $"{sessionId}.json");
Directory.CreateDirectory(Path.GetDirectoryName(path)!);
api.SaveChatSession(sessionId, path);

api.SaveChatSession(sessionId, "session-42.json") scrive il file JSON nella posizione fornita.
Se chiami SaveChatSession senza un percorso, l’SDK crea un file denominato con l’ID della sessione nella directory di lavoro corrente.
Quando hai bisogno di una posizione deterministica o temporanea, combina Path.GetTempPath con la tua struttura di cartelle e crea la directory prima di salvare.

Nota: Questi snippet sono riprodotti dalla documentazione ufficiale di Aspose e non sono stati eseguiti in un sandbox. Verificali nel tuo ambiente prima di usarli in produzione.

Ripristinare una sessione

Caricare una sessione precedentemente salvata è altrettanto semplice. L’API legge il file JSON, ricrea lo stato interno e restituisce l’identificatore della sessione in modo da poter continuare a inviare messaggi senza dover passare manualmente l’ID di nuovo.

  1. Chiama LoadChatSession con il percorso del file JSON.
  2. Memorizza l’sessionId restituito.
  3. Usa SendMessageToSessionAsync con l’ID ripristinato per continuare la conversazione.

Esempio di codice – Ripristino di una sessione

string sessionId = await api.LoadChatSession("session-42.json");
string reply = await api.SendMessageToSessionAsync(sessionId, "What did we discuss?");

LoadChatSession legge il file e restituisce l’ID della sessione ripristinata.
La sessione ripristinata viene impostata automaticamente come quella attiva, consentendo chiamate immediate a SendMessageToSessionAsync.

Nota: questi frammenti sono riprodotti dalla documentazione ufficiale di Aspose e non sono stati eseguiti in un sandbox. Verificali nel tuo ambiente prima di usarli in produzione.

Esempio completo — Salva, Riavvia, Riprendi

Di seguito è una dimostrazione completa, end‑to‑end. Il primo blocco avvia una chat, invia alcuni messaggi e salva la sessione. Il secondo blocco simula un nuovo processo che carica il file salvato e continua la conversazione.

Esempio di codice – Flusso di lavoro end‑to‑end

using Aspose.LLM;
using Aspose.LLM.Abstractions.Parameters.Presets;

// ---------- First run: save ----------
{
    var license = new Aspose.LLM.License();
    license.SetLicense("Aspose.LLM.lic");

using var api = AsposeLLMApi.Create(new Qwen25Preset());

string sessionId = await api.StartNewChatAsync(sessionId: "support-ticket-1234");

await api.SendMessageToSessionAsync(sessionId,
        "Customer reports that the migration from v25 to v26 broke their startup script.");
    await api.SendMessageToSessionAsync(sessionId,
        "Their environment: Windows Server 2022, .NET 8, CUDA 12.6.");
    await api.SendMessageToSessionAsync(sessionId,
        "What questions should I ask them next?");

api.SaveChatSession(sessionId, "support-ticket-1234.json");
    Console.WriteLine("Session saved.");
}

// ---------- Second run: resume ----------
{
    var license = new Aspose.LLM.License();
    license.SetLicense("Aspose.LLM.lic");

using var api = AsposeLLMApi.Create(new Qwen25Preset());

string sessionId = await api.LoadChatSession("support-ticket-1234.json");
    Console.WriteLine($"Resumed session: {sessionId}");

string reply = await api.SendMessageToSessionAsync(sessionId,
        "They replied that they use a custom build step that copies native DLLs. How should I proceed?");
    Console.WriteLine(reply);
}

Il primo blocco crea una licenza, istanzia l’API con il Qwen25Preset, avvia una nuova chat denominata support-ticket-1234, invia tre messaggi per costruire il contesto e infine scrive la sessione in support-ticket-1234.json. Il secondo blocco ricrea la licenza e l’API, carica il file JSON e continua il dialogo, dimostrando che il modello conserva i messaggi precedenti.

Nota: Questi frammenti sono riprodotti dalla documentazione ufficiale di Aspose e non sono stati eseguiti in un sandbox. Verificali nel tuo ambiente prima di usarli in produzione.

Cosa viene salvato?

SaveChatSession produce un documento JSON con tre sezioni essenziali:

  1. Identificatore di sessione – l’ID univoco fornito quando hai avviato la chat.
  2. Cronologia dei messaggi – un elenco ordinato di tutti i messaggi dell’utente e dell’assistente, includendo ruolo, contenuto e eventuali metadati dei media.
  3. Metadati della cache KV – posizioni e dimensioni interne della cache chiave‑valore per ogni messaggio, che consentono al modello di riprendere esattamente da dove si era interrotto.

Poiché i dati della cache sono inclusi, la sessione ripristinata può continuare la generazione senza ricalcolare l’attenzione precedente, rendendo l’operazione di ripresa veloce e deterministica.

Vincoli di Portabilità

Sebbene il file JSON contenga tutto il necessario per una continuazione perfetta, è portabile solo sotto certe condizioni:

  • Stessa versione principale SDK – il formato file può cambiare tra le versioni principali, quindi entrambe le parti devono utilizzare la stessa versione principale di Aspose.LLM.
  • File modello identico – il modello Hugging Face sottostante (inclusa la quantizzazione) deve corrispondere esattamente; altrimenti la cache KV diventa incompatibile.
  • Corrispondenza di BinaryManagerParameters.ReleaseTag – la versione del runtime llama.cpp usata per caricare il modello deve essere la stessa, altrimenti le disposizioni dei tensori a basso livello differiscono.

Una Nuance Conosciuta al Momento del Caricamento

Quando chiami LoadChatSession, l’SDK ricostruisce la conversazione ma applica i predefiniti ContextParameters, ChatParameters e SamplerParameters. Qualsiasi impostazione personalizzata (ad es., temperatura, max token, prompt di sistema) che hai usato durante la sessione originale non viene ripristinata automaticamente. Per mantenere esattamente lo stesso comportamento di generazione, riapplica i tuoi parametri personalizzati dopo il caricamento, oppure riproduci la conversazione in una nuova sessione con le impostazioni desiderate.

Errori comuni

Di seguito è una rapida lista di controllo per i problemi tipici che potresti incontrare durante il caricamento di una sessione:

  • FileNotFoundException – Verifica il percorso del file; i percorsi relativi vengono risolti rispetto alla directory di lavoro corrente.
  • InvalidOperationException durante il caricamento – Indica una versione SDK incompatibile o un file JSON corrotto.
  • Output distorto dopo il caricamento – Di solito è causato da un file modello non corrispondente o da un ReleaseTag. Assicurati che lo stesso binario del modello sia presente sulla macchina di caricamento.

Gestire queste eccezioni in modo elegante e registrare diagnosi dettagliate renderà la tua applicazione più robusta.

Sicurezza

Il file JSON persistente contiene copie plain‑text di ogni messaggio dell’utente e dell’assistente. Memorizzarlo in una posizione non protetta può esporre dati sensibili. Considera le seguenti mitigazioni:

  • Crittografa il file prima di scriverlo su disco (ad esempio, Windows DPAPI, Azure Key Vault o una libreria multipiattaforma come libsodium).
  • Limita i permessi del file system in modo che solo l’account di servizio che esegue l’applicazione possa leggere/scrivere il file.
  • Se il file deve viaggiare su una rete, utilizza canali crittografati TLS e considera la firma del file per rilevare manomissioni.

Cosa c’è dopo

Ora che puoi conservare e riprendere le chat, potresti esplorare le funzionalità correlate:

  • Casi d’uso di chat a più turni – mantieni dialoghi più lunghi attraverso molte interazioni.
  • Configurazione personalizzata del preset – adatta il preset del modello al tuo dominio prima di salvarlo.
  • Riferimento completo alla persistenza della sessione – consulta il riferimento API per una comprensione più approfondita della semantica di SaveChatSession e dei metadati correlati.

Scegliere l’approccio giusto

L’articolo ha presentato tre modi per salvare una sessione e un metodo di caricamento semplice. Scegli l’approccio che corrisponde al tuo scenario di distribuzione:

  • Percorso esplicito – ideale quando il file deve trovarsi in una posizione nota, come una cartella specifica per l’utente o un’unità di rete condivisa.
  • Nome file predefinito – comodo per prototipi rapidi o quando la sessione vive accanto all’eseguibile.
  • Percorso temporaneo con creazione della directory – ideale per ambienti sandbox, pipeline CI o quando si desidera che il sistema operativo gestisca la pulizia.

Tutti gli approcci utilizzano la stessa API di base; differiscono solo nel modo in cui gestisci il file system.

Ottieni una licenza gratuita

Se non hai ancora una licenza permanente, puoi ottenere una licenza di valutazione temporanea dalla pagina di licenza temporanea Aspose.

Risorse aggiuntive gratuite

Conclusione

La persistenza di una sessione di chat con Aspose.LLM ti offre durabilità, tracciabilità e la flessibilità di spostare le conversazioni tra processi o macchine. Hai imparato quando applicare questo modello, come salvare una sessione in tre modi diversi, come ripristinarla, cosa contiene il file JSON e le considerazioni di compatibilità e sicurezza da tenere presente. Con l’esempio completo, ora puoi integrare la persistenza della sessione in qualsiasi soluzione di chat .NET.

FAQ

  1. Quando è utile mantenere una sessione di chat?
    Il mantenimento è utile per applicazioni desktop o server che necessitano dello stato della conversazione tra avvii, flussi di lavoro a lungo termine, requisiti di audit o backup, e per la migrazione delle sessioni tra macchine con la stessa versione SDK.

  2. Come posso specificare un percorso file personalizzato durante il salvataggio di una sessione?
    Chiama api.SaveChatSession(sessionId, "myfolder\myfile.json"); o costruisci un percorso con Path.Combine e assicurati che la directory esista prima di salvare.

  3. Cosa restituisce LoadChatSession?
    Restituisce l’identificatore della sessione ripristinata, consentendoti di continuare a inviare messaggi senza fornire nuovamente l’ID.

  4. Posso spostare un file di sessione salvato su un’altra macchina?
    Sì, purché la macchina di destinazione utilizzi la stessa versione principale dell’SDK, lo stesso file modello e lo stesso ReleaseTag di llama.cpp.

  5. Il file JSON salvato è sicuro?
    Il file memorizza i dati della conversazione in chiaro, quindi dovresti crittografarlo prima di archiviarlo in posizioni non attendibili.

  6. Perché le mie impostazioni personalizzate di sampler o di contesto non vengono ripristinate dopo il caricamento?
    LoadChatSession applica i parametri predefiniti; riapplica le impostazioni personalizzate dopo il caricamento o riproduci la cronologia in una nuova sessione.

Leggi di più