Persistir una sesión de chat permite que su aplicación .NET sobreviva a reinicios, proporcione una copia de seguridad de la conversación y habilite mover la sesión entre máquinas. En esta guía recorreremos Persistir y reanudar una sesión de chat en C# usando Aspose.LLM, cubriendo cuándo usar el patrón, cómo guardar y cargar sesiones, qué datos se almacenan, consideraciones de portabilidad y mejores prácticas de seguridad.

Por qué persistir y reanudar una sesión de chat?

Los desarrolladores a menudo crean asistentes interactivos, bots de soporte o flujos de trabajo de análisis de datos de larga duración. En muchos escenarios, el contexto del chat debe sobrevivir más allá de la vida de un solo proceso:

  • Una herramienta de soporte de escritorio donde los usuarios esperan que sus consultas anteriores permanezcan disponibles después de cerrar la aplicación.
  • Automatización del lado del servidor que abarca varios pasos y puede reiniciarse debido al mantenimiento.
  • Requisitos de auditoría o cumplimiento que exigen una captura instantánea de toda la conversación.
  • Trasladar una sesión de solución de problemas desde el portátil de un desarrollador a un servidor de producción.

Al persistir la sesión en un archivo JSON, capturas el historial completo de mensajes y la caché KV interna necesaria para una continuación exacta, lo que hace que los casos de uso anteriores sean fáciles de implementar.

Comenzando con Aspose.LLM

Primero, agregue el paquete Aspose.LLM a su proyecto:

Install-Package Aspose.LLM

Puede encontrar más detalles del producto en la página del producto Aspose.LLM .NET. El SDK requiere una licencia válida, así que asegúrese de tener un archivo de licencia temporal o permanente listo.

Requisitos previos

  • Instale el paquete NuGet Aspose.LLM.
  • Aplique una licencia Aspose.LLM usando Aspose.LLM.License.
  • Cree una instancia de AsposeLLMApi (por ejemplo, con un Qwen25Preset).

Cuándo usar este patrón

Este patrón destaca cuando necesitas que la conversación persista más allá del proceso actual, o cuando deseas una instantánea fiable para copia de seguridad o migración. Los escenarios típicos incluyen:

  • Aplicaciones de escritorio o servidor donde los usuarios esperan que el chat persista entre lanzamientos.
  • Flujos de trabajo de larga duración que requieren que la conversación sobreviva al proceso.
  • Propósitos de copia de seguridad y auditoría mediante la captura de instantáneas de una conversación activa.
  • Migración del estado de la sesión entre máquinas con la misma versión del SDK y la misma configuración.

Requisitos previos

Antes de poder guardar o restaurar una sesión, asegúrese de que lo siguiente esté en su lugar:

  1. Aspose.LLM NuGet package – instalado mediante el comando mostrado anteriormente.
  2. Licencia – cree un objeto Aspose.LLM.License y llame a SetLicense con su archivo .lic.
  3. Instancia de API – instancie AsposeLLMApi con el preset deseado (p. ej., new Qwen25Preset()).

Estos pasos se demuestran en el ejemplo completo más adelante en el artículo.

Guardar una sesión

El SDK ofrece tres formas convenientes de mantener una sesión de chat. Siga los pasos a continuación y luego vea el ejemplo de código.

  1. Llama a SaveChatSession con una ruta de archivo explícita si necesitas el archivo en una ubicación conocida.
  2. Omite la ruta para que el SDK escriba <sessionId>.json junto al ejecutable.
  3. Construye una ruta temporal con Path.Combine, asegura que el directorio exista y guarda allí para escenarios aislados o en sandbox.

Ejemplo de código – Guardar una sesión

El siguiente ejemplo muestra los tres enfoques:

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") escribe el archivo JSON en la ubicación proporcionada.
Si llamas a SaveChatSession sin una ruta, el SDK crea un archivo con el nombre del ID de sesión en el directorio de trabajo actual.
Cuando necesites una ubicación determinista o temporal, combina Path.GetTempPath con tu propia estructura de carpetas y crea el directorio antes de guardar.

Nota: Estos fragmentos se reproducen de la documentación oficial de Aspose y no se han ejecutado en un sandbox. Verifíquelos en su entorno antes de usarlos en producción.

Restaurar una sesión

Cargar una sesión guardada previamente es igualmente sencillo. La API lee el archivo JSON, vuelve a crear el estado interno y devuelve el identificador de la sesión para que pueda continuar enviando mensajes sin pasar manualmente el ID nuevamente.

  1. Llama a LoadChatSession con la ruta al archivo JSON.
  2. Guarda el sessionId devuelto.
  3. Usa SendMessageToSessionAsync con el ID restaurado para continuar la conversación.

Ejemplo de código – Restaurar una sesión

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

LoadChatSession lee el archivo y devuelve el ID de sesión restaurado.
La sesión restaurada se establece automáticamente como la activa, lo que permite llamadas inmediatas a SendMessageToSessionAsync.

Nota: Estos fragmentos se reproducen de la documentación oficial de Aspose y no se han ejecutado en un sandbox. Verifíquelos en su entorno antes de usarlos en producción.

Ejemplo completo — Guardar, reiniciar, reanudar

A continuación se muestra una demostración completa, de extremo a extremo. El primer bloque inicia un chat, envía algunos mensajes y guarda la sesión. El segundo bloque simula un nuevo proceso que carga el archivo guardado y continúa la conversación.

Ejemplo de código – Flujo de trabajo de extremo a extremo

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

El primer bloque crea una licencia, instancia la API con el Qwen25Preset, inicia un nuevo chat llamado support-ticket-1234, envía tres mensajes para construir el contexto y, finalmente, escribe la sesión en support-ticket-1234.json. El segundo bloque vuelve a crear la licencia y la API, carga el archivo JSON y continúa el diálogo, demostrando que el modelo conserva los mensajes anteriores.

Nota: Estos fragmentos se reproducen de la documentación oficial de Aspose y no se han ejecutado en un sandbox. Verifíquelos en su entorno antes de usarlos en producción.

¿Qué se guarda?

SaveChatSession produce un documento JSON con tres secciones esenciales:

  1. Identificador de sesión – el ID único que proporcionó al iniciar el chat.
  2. Historial de mensajes – una lista ordenada de todos los mensajes de usuario y asistente, incluyendo rol, contenido y cualquier metadato de medios.
  3. Metadatos de caché KV – posiciones internas y tamaños de la caché de clave‑valor para cada mensaje, lo que permite que el modelo continúe exactamente donde lo dejó.

Debido a que se incluyen los datos de caché, la sesión restaurada puede continuar la generación sin volver a calcular la atención previa, lo que hace que la operación de reanudación sea rápida y determinista.

Restricciones de portabilidad

Aunque el archivo JSON contiene todo lo necesario para una continuación perfecta, solo es portátil bajo ciertas condiciones:

  • Same SDK Major Version – el formato de archivo puede cambiar entre versiones mayores, por lo que ambos lados deben usar la misma versión mayor de Aspose.LLM.
  • Identical Model File – el modelo subyacente de Hugging Face (incluida la cuantización) debe coincidir exactamente; de lo contrario, la caché KV se vuelve incompatible.
  • Matching BinaryManagerParameters.ReleaseTag – la versión del runtime llama.cpp utilizada para cargar el modelo debe ser la misma, de lo contrario los diseños de tensores de bajo nivel difieren.

Un matiz conocido del tiempo de carga

Cuando llamas a LoadChatSession, el SDK reconstruye la conversación pero aplica predeterminados ContextParameters, ChatParameters y SamplerParameters. Cualquier configuración personalizada (p. ej., temperatura, número máximo de tokens, indicaciones del sistema) que utilizaste durante la sesión original no se restaura automáticamente. Para mantener el comportamiento exacto de generación, vuelve a aplicar tus parámetros personalizados después de cargar, o reproduce la conversación en una nueva sesión con la configuración deseada.

Errores comunes

A continuación se muestra una lista de verificación rápida de los problemas típicos que puede encontrar al cargar una sesión:

  • FileNotFoundException – Verifique la ruta del archivo; las rutas relativas se resuelven respecto al directorio de trabajo actual.
  • InvalidOperationException al cargar – Indica una versión del SDK incompatible o un archivo JSON corrupto.
  • Salida distorsionada después de cargar – Normalmente causado por un archivo de modelo no coincidente o ReleaseTag. Asegúrese de que el mismo binario del modelo esté presente en la máquina de carga.

Manejar estas excepciones de forma elegante y registrar diagnósticos detallados hará que su aplicación sea más robusta.

Seguridad

El archivo JSON persistente contiene copias en texto sin formato de cada mensaje del usuario y del asistente. Almacenararlo en una ubicación no protegida puede exponer datos sensibles. Considere las siguientes mitigaciones:

  • Encripte el archivo antes de escribirlo en disco (p. ej., Windows DPAPI, Azure Key Vault o una biblioteca multiplataforma como libsodium).
  • Restrinja los permisos del sistema de archivos para que solo la cuenta de servicio que ejecuta la aplicación pueda leer/escribir el archivo.
  • Si el archivo debe transmitirse a través de una red, utilice canales cifrados con TLS y considere firmar el archivo para detectar manipulaciones.

Qué sigue

Ahora que puedes guardar y reanudar chats, podrías explorar capacidades relacionadas:

  • Casos de uso de chat de varios turnos – mantener diálogos más largos a lo largo de muchas interacciones.
  • Configuración de preset personalizada – adaptar el preset del modelo a su dominio antes de persistir.
  • Referencia completa de persistencia de sesión – revisar la referencia de la API para una semántica más profunda alrededor de SaveChatSession y los metadatos relacionados.

Elegir el Enfoque Correcto

El artículo presentó tres formas de guardar una sesión y un método de carga sencillo. Elija el enfoque que coincida con su escenario de implementación:

  • Ruta explícita – mejor cuando el archivo debe residir en una ubicación conocida, como una carpeta específica del usuario o una unidad de red compartida.
  • Nombre de archivo predeterminado – conveniente para prototipos rápidos o cuando la sesión vive junto al ejecutable.
  • Ruta temporal con creación de directorio – ideal para entornos aislados, pipelines de CI, o cuando deseas que el SO gestione la limpieza.

Todos los enfoques utilizan la misma API subyacente; solo difieren en cómo gestionas el sistema de archivos.

Obtén una licencia gratuita

Si aún no tienes una licencia permanente, puedes obtener una licencia de evaluación temporal desde la página de licencias temporales de Aspose.

Recursos adicionales gratuitos

Conclusión

Persistir una sesión de chat con Aspose.LLM le brinda durabilidad, auditabilidad y la flexibilidad para mover conversaciones entre procesos o máquinas. Aprendió cuándo aplicar este patrón, cómo guardar una sesión de tres maneras diferentes, cómo restaurarla, qué contiene el archivo JSON y las consideraciones de compatibilidad y seguridad que debe tener en cuenta. Con el ejemplo completo, ahora puede integrar la persistencia de sesiones en cualquier solución de chat .NET.

FAQs

  1. ¿Cuándo es útil persistir una sesión de chat?
    Persistir es útil para aplicaciones de escritorio o servidor que necesitan el estado de la conversación entre lanzamientos, flujos de trabajo de larga duración, requisitos de auditoría o copia de seguridad, y la migración de sesiones entre máquinas con la misma versión del SDK.

  2. ¿Cómo puedo especificar una ruta de archivo personalizada al guardar una sesión?
    Llame a api.SaveChatSession(sessionId, "myfolder\myfile.json"); o construya una ruta con Path.Combine y asegúrese de que el directorio exista antes de guardar.

  3. ¿Qué devuelve LoadChatSession?
    Devuelve el identificador de sesión restaurado, lo que le permite continuar enviando mensajes sin proporcionar nuevamente el ID.

  4. ¿Puedo mover un archivo de sesión guardado a otra máquina?
    Sí, siempre que la máquina de destino use la misma versión principal del SDK, el mismo archivo de modelo y una ReleaseTag de llama.cpp coincidente.

  5. ¿Es seguro el archivo JSON guardado?
    El archivo almacena datos de conversación en texto plano, por lo que debe encriptarlo antes de almacenarlo en ubicaciones no confiables.

  6. ¿Por qué mis configuraciones personalizadas de muestreador o contexto no se restauran después de cargar?
    LoadChatSession aplica parámetros predeterminados; vuelva a aplicar cualquier configuración personalizada después de cargar o reproduzca el historial en una sesión nueva.

Leer más