Conserver une session de chat permet à votre application .NET de survivre aux redémarrages, fournit une sauvegarde de la conversation et permet de déplacer la session entre les machines. Dans ce guide, nous parcourrons Persister et reprendre une session de chat en C# en utilisant Aspose.LLM, en couvrant quand utiliser ce modèle, comment enregistrer et charger les sessions, quelles données sont stockées, les considérations de portabilité et les meilleures pratiques de sécurité.

Pourquoi persister et reprendre une session de chat ?

Les développeurs créent souvent des assistants interactifs, des bots d’assistance ou des flux de travail d’analyse de données à long terme. Dans de nombreux scénarios, le contexte de la conversation doit survivre au-delà de la durée de vie d’un seul processus :

  • Un outil d’assistance de bureau où les utilisateurs s’attendent à ce que leurs requêtes précédentes restent disponibles après la fermeture de l’application.
  • Une automatisation côté serveur qui s’étend sur plusieurs étapes et peut être redémarrée en raison de la maintenance.
  • Des exigences d’audit ou de conformité qui exigent un instantané de l’ensemble de la conversation.
  • Le déplacement d’une session de dépannage d’un ordinateur portable de développeur vers un serveur de production.

En persistant la session dans un fichier JSON, vous capturez l’historique complet des messages ainsi que le cache KV interne nécessaire à une continuation exacte, ce qui rend les cas d’utilisation ci‑dessus simples à mettre en œuvre.

Démarrer avec Aspose.LLM

Tout d’abord, ajoutez le package Aspose.LLM à votre projet :

Install-Package Aspose.LLM

Vous pouvez trouver plus de détails sur le produit sur la page produit Aspose.LLM .NET. Le SDK nécessite une licence valide, assurez‑vous donc d’avoir un fichier de licence temporaire ou permanent prêt.

Prérequis

  • Installez le package NuGet Aspose.LLM.
  • Appliquez une licence Aspose.LLM en utilisant Aspose.LLM.License.
  • Créez une instance AsposeLLMApi (par exemple, avec un Qwen25Preset).

Quand utiliser ce modèle

Ce modèle excelle lorsque vous avez besoin que la conversation persiste au-delà du processus actuel, ou lorsque vous souhaitez un instantané fiable pour la sauvegarde ou la migration. Les scénarios typiques incluent :

  • Applications de bureau ou serveur où les utilisateurs s’attendent à ce que le chat persiste entre les lancements.
  • Flux de travail de longue durée qui nécessitent que la conversation survive au processus.
  • Sauvegarde et audit en créant un instantané d’une conversation active.
  • Migration de l’état de session entre machines avec la même version du SDK et le même préréglage.

Prérequis

Avant de pouvoir enregistrer ou restaurer une session, assurez‑vous que les éléments suivants sont en place :

  1. Aspose.LLM NuGet package – installé via la commande montrée précédemment.
  2. Licence – créez un objet Aspose.LLM.License et appelez SetLicense avec votre fichier .lic.
  3. Instance API – instanciez AsposeLLMApi avec le préréglage souhaité (par ex., new Qwen25Preset()).

Ces étapes sont démontrées dans l’exemple complet plus loin dans l’article.

Enregistrer une session

Le SDK propose trois méthodes pratiques pour persister une session de chat. Suivez les étapes ci‑dessous, puis consultez l’exemple de code.

  1. Appelez SaveChatSession avec un chemin de fichier explicite si vous avez besoin du fichier à un emplacement connu.
  2. Omettez le chemin pour laisser le SDK écrire <sessionId>.json à côté de l’exécutable.
  3. Construisez un chemin temporaire avec Path.Combine, assurez‑vous que le répertoire existe, et enregistrez‑y pour des scénarios isolés ou sandboxés.

Exemple de code – Enregistrement d’une session

L’exemple suivant montre les trois approches :

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") écrit le fichier JSON à l’emplacement fourni. Si vous appelez SaveChatSession sans chemin, le SDK crée un fichier nommé d’après l’ID de session dans le répertoire de travail actuel. Lorsque vous avez besoin d’un emplacement déterministe ou temporaire, combinez Path.GetTempPath avec votre propre structure de dossiers et créez le répertoire avant d’enregistrer.

Remarque : Ces extraits sont reproduits à partir de la documentation officielle d’Aspose et n’ont pas été exécutés dans un bac à sable. Vérifiez-les dans votre environnement avant de les utiliser en production.

Restaurer une session

Charger une session précédemment enregistrée est tout aussi simple. L’API lit le fichier JSON, recrée l’état interne et renvoie l’identifiant de session afin que vous puissiez continuer à envoyer des messages sans avoir à transmettre manuellement l’ID à nouveau.

  1. Appelez LoadChatSession avec le chemin du fichier JSON.
  2. Enregistrez le sessionId retourné.
  3. Utilisez SendMessageToSessionAsync avec l’ID restauré pour continuer la conversation.

Exemple de code – Restauration d’une session

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

LoadChatSession lit le fichier et renvoie l’ID de session restauré.
La session restaurée est automatiquement définie comme active, permettant des appels immédiats à SendMessageToSessionAsync.

Note : Ces extraits sont reproduits à partir de la documentation officielle d’Aspose et n’ont pas été exécutés dans un bac à sable. Vérifiez-les dans votre environnement avant de les utiliser en production.

Exemple complet — Enregistrer, redémarrer, reprendre

Voici une démonstration complète, de bout en bout. Le premier bloc démarre une conversation, envoie quelques messages et enregistre la session. Le deuxième bloc simule un nouveau processus qui charge le fichier enregistré et poursuit la conversation.

Exemple de code – Flux de travail de bout en bout

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

Le premier bloc crée une licence, instancie l’API avec le Qwen25Preset, démarre un nouveau chat nommé support-ticket-1234, envoie trois messages pour construire le contexte, puis écrit la session dans support-ticket-1234.json. Le deuxième bloc recrée la licence et l’API, charge le fichier JSON et continue le dialogue, démontrant que le modèle conserve les messages précédents.

Remarque : Ces extraits sont reproduits à partir de la documentation officielle d’Aspose et n’ont pas été exécutés dans un bac à sable. Vérifiez-les dans votre environnement avant de les utiliser en production.

Qu’est-ce qui est enregistré ?

SaveChatSession produit un document JSON contenant trois sections essentielles :

  1. Identifiant de session – l’ID unique que vous avez fourni lors du démarrage du chat.
  2. Historique des messages – une liste ordonnée de tous les messages utilisateur et assistant, incluant le rôle, le contenu et les métadonnées des médias.
  3. Métadonnées du cache KV – positions internes et tailles du cache clé‑valeur pour chaque message, ce qui permet au modèle de reprendre exactement là où il s’était arrêté.

Comme les données du cache sont incluses, la session restaurée peut poursuivre la génération sans recalculer l’attention précédente, rendant l’opération de reprise rapide et déterministe.

Contraintes de portabilité

Bien que le fichier JSON contienne tout ce qui est nécessaire pour une continuation parfaite, il n’est portable que sous certaines conditions :

  • Même version majeure du SDK – le format de fichier peut changer entre les versions majeures, donc les deux parties doivent utiliser la même version majeure d’Aspose.LLM.
  • Fichier de modèle identique – le modèle Hugging Face sous-jacent (y compris la quantisation) doit correspondre exactement ; sinon le cache KV devient incompatible.
  • Correspondance de BinaryManagerParameters.ReleaseTag – la version du runtime llama.cpp utilisée pour charger le modèle doit être la même, sinon les dispositions de tenseurs de bas niveau diffèrent.

Une nuance connue au moment du chargement

Lorsque vous appelez LoadChatSession, le SDK reconstruit la conversation mais applique les par défaut ContextParameters, ChatParameters et SamplerParameters. Tous les paramètres personnalisés (par ex., température, nombre maximal de jetons, invites système) que vous avez utilisés lors de la session originale ne sont pas restaurés automatiquement. Pour conserver le même comportement de génération, réappliquez vos paramètres personnalisés après le chargement, ou rejouez la conversation dans une nouvelle session avec les paramètres souhaités.

Erreurs courantes

Voici une liste de contrôle rapide des problèmes typiques que vous pourriez rencontrer lors du chargement d’une session :

  • FileNotFoundException – Vérifiez le chemin du fichier ; les chemins relatifs sont résolus par rapport au répertoire de travail actuel.
  • InvalidOperationException lors du chargement – Indique une version du SDK incompatible ou un fichier JSON corrompu.
  • Garbled output after load – Généralement causé par un fichier de modèle ou un ReleaseTag non concordant. Assurez-vous que le même binaire de modèle est présent sur la machine de chargement.

Gérer ces exceptions de manière élégante et consigner des diagnostics détaillés rendra votre application plus robuste.

Sécurité

Le fichier JSON persistant contient des copies en texte brut de chaque message utilisateur et assistant. Le stocker dans un emplacement non protégé peut exposer des données sensibles. Envisagez les mesures d’atténuation suivantes :

  • Chiffrez le fichier avant de l’écrire sur le disque (par ex., Windows DPAPI, Azure Key Vault, ou une bibliothèque multiplateforme comme libsodium).
  • Restreignez les autorisations du système de fichiers afin que seul le compte de service exécutant l’application puisse lire/écrire le fichier.
  • Si le fichier doit être transmis sur un réseau, utilisez des canaux chiffrés TLS et envisagez de signer le fichier pour détecter toute altération.

Ce qui suit

Maintenant que vous pouvez enregistrer et reprendre les discussions, vous pourriez explorer les fonctionnalités connexes :

  • Cas d’utilisation de chat multi‑tours – maintenir des dialogues plus longs sur de nombreuses interactions.
  • Configuration de préréglage personnalisée – adapter le préréglage du modèle à votre domaine avant de le persister.
  • Référence complète de persistance de session – examiner la référence API pour une sémantique plus approfondie autour de SaveChatSession et des métadonnées associées.

Choisir la bonne approche

L’article présentait trois façons d’enregistrer une session ainsi qu’une méthode de chargement simple. Choisissez l’approche qui correspond à votre scénario de déploiement :

  • Chemin explicite – meilleur lorsque le fichier doit résider dans un emplacement connu, tel qu’un dossier spécifique à l’utilisateur ou un lecteur réseau partagé.
  • Nom de fichier par défaut – pratique pour les prototypes rapides ou lorsque la session vit à côté de l’exécutable.
  • Chemin temporaire avec création de répertoire – idéal pour les environnements sandbox, les pipelines CI, ou lorsque vous souhaitez que le système d’exploitation gère le nettoyage.

Toutes les approches utilisent la même API sous-jacente ; elles diffèrent uniquement dans la façon dont vous gérez le système de fichiers.

Obtenez une licence gratuite

Si vous n’avez pas encore de licence permanente, vous pouvez obtenir une licence d’évaluation temporaire depuis la page de licence temporaire Aspose.

Ressources supplémentaires gratuites

Conclusion

La persistance d’une session de chat avec Aspose.LLM vous offre durabilité, traçabilité et flexibilité pour déplacer les conversations entre processus ou machines. Vous avez appris quand appliquer ce modèle, comment enregistrer une session de trois manières différentes, comment la restaurer, ce que contient le fichier JSON, ainsi que les considérations de compatibilité et de sécurité à garder à l’esprit. Fort de l’exemple complet, vous pouvez désormais intégrer la persistance de session dans n’importe quelle solution de chat .NET.

FAQ

  1. Quand la persistance d’une session de chat est‑elle utile ?
    La persistance est utile pour les applications de bureau ou serveur qui ont besoin de conserver l’état de la conversation entre les lancements, les flux de travail de longue durée, les exigences d’audit ou de sauvegarde, et la migration des sessions entre machines avec la même version du SDK.

  2. Comment spécifier un chemin de fichier personnalisé lors de l’enregistrement d’une session ?
    Appelez api.SaveChatSession(sessionId, "myfolder\myfile.json"); ou construisez un chemin avec Path.Combine et assurez‑vous que le répertoire existe avant d’enregistrer.

  3. Que retourne LoadChatSession ?
    Elle retourne l’identifiant de session restauré, vous permettant de continuer à envoyer des messages sans fournir à nouveau l’ID.

  4. Puis‑je déplacer un fichier de session enregistré vers une autre machine ?
    Oui, tant que la machine cible utilise la même version majeure du SDK, le même fichier de modèle et le même ReleaseTag de llama.cpp.

  5. Le fichier JSON enregistré est‑il sécurisé ?
    Le fichier stocke les données de conversation en texte clair, il faut donc le chiffrer avant de le placer dans des emplacements non fiables.

  6. Pourquoi mes paramètres personnalisés de sampler ou de contexte ne sont pas restaurés après le chargement ?
    LoadChatSession applique les paramètres par défaut ; réappliquez vos paramètres personnalisés après le chargement ou rejouez l’historique dans une nouvelle session.

En savoir plus