Att spara en chattsession låter din .NET‑applikation överleva omstarter, ger en säkerhetskopia av konversationen och möjliggör att flytta sessionen mellan maskiner. I den här guiden går vi igenom Persist and Resume a Chat Session in C# med Aspose.LLM och täcker när man ska använda mönstret, hur man sparar och laddar sessioner, vilken data som lagras, portabilitetshänsyn samt bästa säkerhetspraxis.

Varför spara och återuppta en chattsession?

Utvecklare bygger ofta interaktiva assistenter, support‑botar eller lång‑variga data‑analysarbetsflöden. I många scenarier måste chattkontexten överleva bortom livslängden för en enskild process:

  • Ett skrivbordsstödverktyg där användarna förväntar sig att deras tidigare frågor ska förbli tillgängliga efter att appen har stängts.
  • Server‑sidig automatisering som omfattar flera steg och kan startas om på grund av underhåll.
  • Gransknings- eller efterlevnadskrav som kräver en ögonblicksbild av hela konversationen.
  • Att flytta en felsökningssession från en utvecklares bärbara dator till en produktionsserver.

Genom att spara sessionen i en JSON‑fil fångar du hela meddelandehistoriken och den interna KV‑cachen som behövs för en exakt fortsättning, vilket gör de ovanstående användningsfallen enkla att implementera.

Komma igång med Aspose.LLM

Först, lägg till Aspose.LLM-paketet i ditt projekt:

Install-Package Aspose.LLM

Du kan hitta mer produktinformation på Aspose.LLM .NET produktsida. SDK:n kräver en giltig licens, så se till att du har en tillfällig eller permanent licensfil redo.

Förutsättningar

  • Installera Aspose.LLM NuGet‑paketet.
  • Använd en Aspose.LLM‑licens med Aspose.LLM.License.
  • Skapa en AsposeLLMApi‑instans (till exempel med en Qwen25Preset).

När du ska använda detta mönster

Detta mönster glänser när du behöver att konversationen ska bestå bortom den aktuella processen, eller när du vill ha en pålitlig ögonblicksbild för backup eller migrering. Typiska scenarier inkluderar:

  • Desktop‑ eller serverapplikationer där användarna förväntar sig att chatten kvarstår mellan starter.
  • Långvariga arbetsflöden som kräver att konversationen lever längre än processen.
  • Säkerhetskopiering och revisionsändamål genom att ta en ögonblicksbild av en aktiv konversation.
  • Migrering av sessionsstatus mellan maskiner med samma SDK‑version och förinställning.

Förutsättningar

Innan du kan spara eller återställa en session, se till att följande är på plats:

  1. Aspose.LLM NuGet package – installerad via kommandot som visades tidigare.
  2. License – skapa ett Aspose.LLM.License-objekt och anropa SetLicense med din .lic-fil.
  3. API instance – skapa en instans av AsposeLLMApi med den önskade förinställningen (t.ex. new Qwen25Preset()).

Dessa steg demonstreras i det fullständiga exemplet senare i artikeln.

Spara en session

SDK:et erbjuder tre bekväma sätt att bevara en chattsession. Följ stegen nedan och se sedan kodexemplet.

  1. Anropa SaveChatSession med en explicit filsökväg om du behöver filen på en känd plats.
  2. Utelämna sökvägen så att SDK:n skriver <sessionId>.json bredvid den körbara filen.
  3. Bygg en temporär sökväg med Path.Combine, säkerställ att katalogen finns och spara där för isolerade eller sandlådescenarier.

Kodexempel – Spara en session

Följande exempel demonstrerar alla tre tillvägagångssätten:

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") skriver JSON-filen till den angivna platsen.
Om du anropar SaveChatSession utan en sökväg skapar SDK:n en fil med namn baserat på sessions‑ID:t i den aktuella arbetskatalogen.
När du behöver en bestämd eller tillfällig plats, kombinera Path.GetTempPath med din egen mappstruktur och skapa katalogen innan du sparar.

Obs: Dessa kodsnuttar är reproducerade från den officiella Aspose-dokumentationen och har inte körts i en sandlåda. Verifiera dem i din miljö innan du använder dem i produktion.

Återställ en session

Laddning av en tidigare sparad session är lika enkelt. API‑et läser JSON‑filen, återskapar det interna tillståndet och returnerar sessionsidentifieraren så att du kan fortsätta med meddelanden utan att manuellt ange ID‑t igen.

  1. Anropa LoadChatSession med sökvägen till JSON‑filen.
  2. Spara det returnerade sessionId.
  3. Använd SendMessageToSessionAsync med det återställda ID:t för att fortsätta konversationen.

Kodexempel – Återställa en session

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

LoadChatSession läser filen och returnerar det återställda sessions‑ID:t.
Den återställda sessionen sätts automatiskt som den aktiva, vilket möjliggör omedelbara anrop till SendMessageToSessionAsync.

Obs: Dessa kodsnuttar är reproducerade från den officiella Aspose-dokumentationen och har inte körts i en sandbox. Verifiera dem i din miljö innan du använder dem i produktion.

Fullt exempel — Spara, starta om, återuppta

Nedan följer en komplett, end‑to‑end‑demonstration. Det första blocket startar en chatt, skickar några meddelanden och sparar sessionen. Det andra blocket simulerar en ny process som laddar den sparade filen och fortsätter konversationen.

Kodexempel – End‑to‑‑Workflow

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);
}

Det första blocket skapar en licens, instansierar API:et med Qwen25Preset, startar en ny chatt med namnet support-ticket-1234, skickar tre meddelanden för att bygga kontext och skriver slutligen sessionen till support-ticket-1234.json. Det andra blocket återskapar licensen och API:et, laddar JSON-filen och fortsätter dialogen, vilket visar att modellen behåller de tidigare meddelandena.

Obs: Dessa kodsnuttar är reproducerade från den officiella Aspose-dokumentationen och har inte körts i en sandbox. Verifiera dem i din miljö innan du använder dem i produktion.

Vad sparas?

SaveChatSession skapar ett JSON-dokument med tre väsentliga sektioner:

  1. Session Identifier – det unika ID du angav när du startade chatten.
  2. Message History – en ordnad lista över alla användar‑ och assistentmeddelanden, inklusive roll, innehåll och eventuell mediametadata.
  3. KV Cache Metadata – interna positioner och storlekar för nyckel‑värde‑cachen för varje meddelande, vilket gör att modellen kan fortsätta exakt där den slutade.

Eftersom cachedata är inkluderad kan den återställda sessionen fortsätta genereringen utan att omberäkna tidigare uppmärksamhet, vilket gör återupptagningsoperationen snabb och deterministisk.

Portabilitetsbegränsningar

Även om JSON-filen innehåller allt som behövs för en perfekt fortsättning, är den endast portabel under vissa förhållanden:

  • Samma SDK huvudversion – filformatet kan förändras mellan huvudutgåvor, så båda parter måste använda samma huvudversion av Aspose.LLM.
  • Identisk modellfil – den underliggande Hugging Face-modellen (inklusive kvantisering) måste matcha exakt; annars blir KV-cachen inkompatibel.
  • Matchande BinaryManagerParameters.ReleaseTag – den llama.cpp-runtimeversion som används för att ladda modellen måste vara densamma, annars skiljer sig låg‑nivå tensorlayouter.

Om någon av dessa begränsningar bryts kan du se fel som InvalidOperationException eller förvrängd utdata.

En känd nyans vid laddningstid

När du anropar LoadChatSession rekonstruerar SDK:et konversationen men tillämpar standard ContextParameters, ChatParameters och SamplerParameters. Eventuella anpassade inställningar (t.ex. temperatur, max token, systemprompt) som du använde under den ursprungliga sessionen är inte återställda automatiskt. För att behålla exakt genereringsbeteende, återapplicera dina anpassade parametrar efter laddning, eller spela upp konversationen i en ny session med de önskade inställningarna.

Vanliga fel

Nedan är en snabb checklista för vanliga problem du kan stöta på när du laddar en session:

  • FileNotFoundException – Verifiera filvägen; relativa sökvägar löses upp mot den aktuella arbetskatalogen.
  • InvalidOperationException vid laddning – Indikerar en inkompatibel SDK-version eller en korrupt JSON‑fil.
  • Förvrängd utdata efter laddning – Orsakas vanligtvis av en felaktig modellfil eller ReleaseTag. Se till att exakt samma modellbinär finns på den maskin som laddar.

Att hantera dessa undantag på ett smidigt sätt och logga detaljerad diagnostik gör din applikation mer robust.

Security

Den beständiga JSON-filen innehåller plain‑text kopior av varje användar‑ och assistentmeddelande. Att lagra den på en oskyddad plats kan exponera känslig data. Överväg följande åtgärder:

  • Kryptera filen innan den skrivs till disk (t.ex. Windows DPAPI, Azure Key Vault eller ett plattformsoberoende bibliotek som libsodium).
  • Begränsa filsystembehörigheter så att endast servicekontot som kör applikationen kan läsa/skriva filen.
  • Om filen måste överföras över ett nätverk, använd TLS‑krypterade kanaler och överväg att signera filen för att upptäcka manipulering.

Vad blir nästa

Nu när du kan spara och återuppta chattar, kan du utforska relaterade funktioner:

  • Multi‑turn chattusefall – upprätthålla längre dialoger över många interaktioner.
  • Anpassad förinställningskonfiguration – anpassa modellens förinställning till din domän innan den sparas.
  • Full referens för sessions‑persistens – granska API-referensen för djupare semantik kring SaveChatSession och relaterad metadata.

Välja rätt tillvägagångssätt

Artikeln presenterade tre sätt att spara en session och en enkel laddningsmetod. Välj det tillvägagångssätt som matchar ditt distributionsscenario:

  • Explicit path – bäst när filen måste finnas på en känd plats, till exempel en användarspecifik mapp eller en delad nätverksenhet.
  • Default filename – praktiskt för snabba prototyper eller när sessionen körs tillsammans med den körbara filen.
  • Temporary path with directory creation – idealiskt för sandlådemiljöer, CI‑pipelines eller när du vill att OS hanterar rensning.

Alla tillvägagångssätt använder samma underliggande API; de skiljer sig bara i hur du hanterar filsystemet.

Få en gratis licens

Om du ännu inte har en permanent licens kan du skaffa en tillfällig utvärderingslicens från Aspose temporära licenssida.

Gratis ytterligare resurser

Slutsats

Att spara en chattsession med Aspose.LLM ger dig hållbarhet, spårbarhet och flexibilitet att flytta konversationer mellan processer eller maskiner. Du lärde dig när du ska tillämpa detta mönster, hur du sparar en session på tre olika sätt, hur du återställer den, vad JSON‑filen innehåller samt vilka kompatibilitets‑ och säkerhetsaspekter du måste ha i åtanke. Beväpnad med hela exemplet kan du nu integrera sessionsbeständighet i vilken .NET‑chatlösning som helst.

Vanliga frågor

  1. När är det användbart att spara en chattsession?
    Att spara är användbart för skrivbords‑ eller serverapplikationer som behöver samtalsstatus mellan startar, långvariga arbetsflöden, revisions‑ eller säkerhetskopieringskrav samt för att migrera sessioner mellan maskiner med samma SDK‑version.

  2. Hur kan jag ange en anpassad filsökväg när jag sparar en session?
    Anropa api.SaveChatSession(sessionId, "myfolder\myfile.json"); eller bygg en sökväg med Path.Combine och se till att katalogen finns innan du sparar.

  3. Vad returnerar LoadChatSession?
    Den returnerar den återställda sessionsidentifieraren, vilket gör att du kan fortsätta skicka meddelanden utan att ange ID:t igen.

  4. Kan jag flytta en sparad sessionsfil till en annan maskin?
    Ja, så länge målmaskinen använder samma huvud‑SDK‑version, identisk modellfil och matchande llama.cpp ReleaseTag.

  5. Är den sparade JSON‑filen säker?
    Filen lagrar samtalsdata i klartext, så du bör kryptera den innan du lagrar den på opålitliga platser.

  6. Varför återställs inte mina anpassade sampler‑ eller kontextinställningar efter inläsning?
    LoadChatSession tillämpar standardparametrar; återapplicera eventuella anpassade inställningar efter inläsning eller spela upp historiken i en ny session.

Läs mer