La mayoría de los equipos .NET que añaden funciones de IA hoy terminan escribiendo la misma infraestructura: un cliente HTTP, una política de reintentos, la gestión de secretos para una clave API y una línea de facturación por token en la tarjeta de crédito de alguien. Aspose.LLM toma una ruta diferente. Es un paquete NuGet que ejecuta la inferencia de modelos de lenguaje grande dentro de tu propio proceso - sin servicio al que llamar, sin clave que rotar y sin solicitudes que salgan de la máquina.

Este artículo presenta la biblioteca, explica los tres conceptos en los que se basa su API y le guía a través de una aplicación de chat funcional. Si puede agregar una referencia de paquete, podrá enviar indicaciones en unas pocas docenas de líneas.

Por qué un modelo local importa

Ejecutar el modelo en proceso cambia lo que puedes crear.

  • Los datos permanecen en su lugar. Los prompts nunca abandonan el host, lo cual es importante cuando trabajas con contratos, notas médicas, código fuente o cualquier otro elemento cubierto por una política de residencia de datos.
  • Sin costo por token. Una vez que el modelo está en disco, la inferencia es un costo de CPU o GPU que ya posees, no una llamada API medida.
  • Sin dependencia de red en tiempo de ejecución. Herramientas de escritorio, servicios locales y entornos aislados funcionan de la misma manera.
  • Un solo artefacto de implementación. La configuración del modelo se envía con tu aplicación en lugar de vivir en el panel de control de una cuenta separada.

El compromiso es honesto y vale la pena declararlo desde el principio: usted proporciona el hardware. Un modelo que se ejecuta localmente necesita memoria local, y la primera ejecución necesita descargar varios gigabytes.

Aspose.LLM for .NET en tres conceptos

El área superficial es deliberadamente pequeña. Casi todo lo que haces con Aspose.LLM involucra estos tres tipos.

ConceptoTipoRol
LicenciaAspose.LLM.LicenseActiva la biblioteca. Llame a SetLicense antes de cualquier otro uso de la API.
Preajustee.g. Qwen25PresetAgrupa los archivos del modelo con parámetros de generación como la temperatura del muestreador.
Instancia de APIAsposeLLMApiEl punto de entrada. Creada a partir de un preajuste, mantiene la conversación, expone SendMessageAsync.

Un preset es el interesante. En lugar de obligarte a configurar manualmente las rutas del modelo, los ajustes del tokenizador y los valores del muestreador, un preset empaqueta una combinación probada. Qwen25Preset es el punto de partida predeterminado, y puedes ajustar sus parámetros o cambiar a un preset diferente más tarde sin tocar el resto de tu código.

Requisitos previos

Antes de escribir cualquier código:

  1. Instalar el paquete - Install-Package Aspose.LLM
  2. Colocar su licencia - coloque Aspose.LLM.lic en algún lugar donde el ejecutable pueda leerla en tiempo de ejecución.
  3. Verificar su presupuesto de memoria - el preset Qwen25 requiere al menos 8 GB de RAM libre.

Para obtener detalles del producto, consulte la Aspose.LLM for .NET página del producto.

Tu primer chat

Aquí está el programa más corto que mantiene una conversación real. Observe las segunda y tercera llamadas: la instancia de la API rastrea el contexto por sí misma, por lo que el modelo aún sabe quién es Alice.

Qué hace el código

  1. Crea una License y la apunta a tu archivo de licencia.
  2. Instancia un Qwen25Preset con su configuración predeterminada.
  3. Crea una instancia de AsposeLLMApi a partir de ese preset.
  4. Envía varios prompts, todos compartiendo la misma conversación.
using Aspose.LLM;
using Aspose.LLM.Abstractions.Parameters.Presets;

var license = new Aspose.LLM.License();
license.SetLicense("Aspose.LLM.lic");

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

string reply = await api.SendMessageAsync("What is 2 + 2?");
Console.WriteLine(reply);
// Output: 2 + 2 equals 4.

await api.SendMessageAsync("My name is Alice.");
string reply2 = await api.SendMessageAsync("What is my name?");
Console.WriteLine(reply2);
// Output: Your name is Alice.

AsposeLLMApi.Create(preset) devuelve un cliente con conciencia de sesión. Cada llamada a SendMessageAsync agrega el mensaje a la conversación en curso, por lo que obtienes un comportamiento de varios turnos sin gestionar ningún estado tú mismo. La declaración using es importante: la instancia posee recursos nativos y necesita ser descartada.

Nota: Estas muestras siguen la documentación oficial de Aspose y no se han ejecutado en un sandbox. Verifíquelas en su propio entorno antes de enviarlas.

Ajuste del comportamiento para una sola solicitud

Las respuestas conversacionales se benefician de cierta aleatoriedad. La aritmética no. En lugar de reconfigurar la instancia, crea un segundo preset y pásalo a la única llamada que lo necesite.

Qué hace el código

  1. Crea el preset predeterminado y la instancia de la API como de costumbre.
  2. Construye strictPreset con una temperatura de muestreo baja.
  3. Lo pasa a SendMessageAsync a través del argumento preset.
  4. Deja las llamadas posteriores en el predeterminado original.
using Aspose.LLM.Abstractions.Parameters.Presets;

// Default preset used by the API instance
var defaultPreset = new Qwen25Preset();
using var api = AsposeLLMApi.Create(defaultPreset);

// A more deterministic preset, for this question only
var strictPreset = new Qwen25Preset();
strictPreset.SamplerParameters.Temperature = 0.1f;

string reply = await api.SendMessageAsync(
    "What is the square root of 144?",
    preset: strictPreset);

Console.WriteLine(reply);
// Output: The square root of 144 is 12.

SamplerParameters.Temperature controla cuánta aleatoriedad introduce el muestreador. Valores cercanos a 0.1 producen una salida casi determinista; valores más altos generan una redacción más variada. Debido a que el preset está limitado a la llamada, la sobrescritura no se filtra al resto de la conversación.

Cancelación y tiempos de espera

La longitud de generación no es totalmente predecible, y una solicitud que se ejecuta durante mucho tiempo bloqueará lo que la esté esperando. SendMessageAsync acepta un CancellationToken, así que proporciónale uno.

Qué hace el código

  1. Crea un CancellationTokenSource con un presupuesto de 30 segundos.
  2. Pasa cts.Token a SendMessageAsync.
  3. Captura OperationCanceledException y se degrada de manera elegante.
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(30));

try
{
    string reply = await api.SendMessageAsync(
        "Write a 500-word essay about migration patterns of the Arctic tern.",
        cancellationToken: cts.Token);
    Console.WriteLine(reply);
}
catch (OperationCanceledException)
{
    Console.WriteLine("Generation timed out.");
}

La cancelación deja el estado de la sesión intacto, por lo que la conversación continúa normalmente en la siguiente llamada. En un controlador ASP.NET Core, reenvíe aquí también el token RequestAborted de la propia solicitud; no hay razón para seguir generando para un cliente que ya se ha desconectado.

Una aplicación de consola completa

Juntándolo todo: un REPL que mantiene una sesión activa durante la vida del proceso y se recupera de fallas por mensaje.

Qué hace el código

  1. Configura la licencia y el preset predeterminado una sola vez, al iniciar.
  2. Crea una única instancia de AsposeLLMApi para todo el programa.
  3. Buclea la entrada del usuario hasta que el usuario escriba quit.
  4. Envía cada línea e imprime la respuesta.
  5. Captura excepciones por mensaje para que una falla no termine la sesión.
using Aspose.LLM;
using Aspose.LLM.Abstractions.Parameters.Presets;

internal class SimpleChatDemo
{
    public static async Task Main()
    {
        var license = new Aspose.LLM.License();
        license.SetLicense("Aspose.LLM.lic");

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

Console.WriteLine("Ask me anything. Type 'quit' to exit.");
        while (true)
        {
            Console.Write("> ");
            string? line = Console.ReadLine();
            if (line == null || line.Equals("quit", StringComparison.OrdinalIgnoreCase))
                break;

try
            {
                string reply = await api.SendMessageAsync(line);
                Console.WriteLine(reply);
            }
            catch (Exception ex)
            {
                Console.WriteLine($"Error: {ex.Message}");
            }
        }
    }
}

Dos puntos de diseño valen la pena llevar a aplicaciones reales. Primero, la instancia se crea una vez y se reutiliza - la creación es costosa y, como explica la siguiente sección, no se permiten instancias concurrentes. Segundo, el try-catch se coloca dentro del bucle en lugar de alrededor de él, de modo que un solo mensaje incorrecto te cuesta un turno en lugar de toda la sesión.

Evalúe la biblioteca con una licencia temporal desde la página de licencia temporal de Aspose.

Errores que probablemente encuentres primero

ErrorCausa típicaSolución
Not licensed for this methodFalta el archivo de licencia o la ruta es incorrectaConfirme que Aspose.LLM.lic sea legible desde el directorio de trabajo y que SetLicense se ejecute antes de cualquier otra llamada a la API.
Only one AsposeLLMApi instance can be created at a timeDos instancias activas al mismo tiempo, a menudo provienen de una fábrica por solicitudRegistre la instancia como singleton, o libere la anterior antes de crear otra.
First response takes minutesEl motor está descargando binarios nativos y pesos del modeloEspere de 5 a 15 minutos en una máquina limpia. Active Create durante el inicio para que el costo no lo pague el usuario.

Esa segunda fila merece énfasis en escenarios de servicio. Si está integrando Aspose.LLM en un contenedor DI, registre AsposeLLMApi como singleton y serialice el acceso a él; un registro scoped o transient fallará tan pronto como dos solicitudes se superpongan.

Recursos adicionales

Conclusión

Aspose.LLM reduce “añadir un LLM a esta aplicación .NET” a tres tipos y un método. Una licencia activa la biblioteca, un preset define el modelo y cómo genera, y una instancia de AsposeLLMApi lleva la conversación. A partir de ahí, SendMessageAsync maneja una pregunta única, una sesión de varios turnos, una anulación de parámetros por llamada y una generación de larga duración cancelable.

Comience con el ejemplo de consola, confirme que el modelo se comporte de la manera que su característica necesita, y luego pase al trabajo de multi‑sesión y persistencia una vez que los fundamentos estén sólidos.

Preguntas frecuentes

1. ¿Qué es Aspose.LLM for .NET?

Una biblioteca NuGet que ejecuta inferencia de modelos de lenguaje grande dentro de tu propio proceso .NET. Creas un preset, creas una instancia de API y envías prompts, sin servicio externo, sin clave API.

2. ¿Necesito una conexión a Internet para usarlo?

Solo para la primera ejecución. La llamada inicial Create descarga el motor nativo y los archivos de modelo definidos por el preset, y los recursos se almacenan en caché localmente después.

3. ¿Cuáles son los requisitos previos para las muestras de código?

El paquete NuGet Aspose.LLM, un archivo Aspose.LLM.lic válido y suficiente RAM libre para el preset que elijas - planifica al menos 8 GB para Qwen25.

4. ¿Cómo cambio el comportamiento del modelo para una sola solicitud?

Cree un segundo preset, ajuste sus parámetros (como SamplerParameters.Temperature) y páselo a SendMessageAsync mediante el argumento preset. Las llamadas posteriores vuelven al preset predeterminado de la instancia.

5. ¿Cómo detengo una generación que está tardando demasiado?

Pase un CancellationToken a SendMessageAsync y capture OperationCanceledException. El estado de la sesión sobrevive a la cancelación, por lo que la conversación continúa normalmente.

6. ¿Por qué la primera respuesta es tan lenta?

La primera llamada Create descarga los binarios nativos y los pesos del modelo, lo que puede tardar de 5 a 15 minutos en una máquina limpia. Calienta la instancia al iniciar la aplicación en lugar de hacerlo en la primera solicitud del usuario.

Leer más