Ajoutez des modèles de langage de grande taille à vos applications .NET avec Aspose.LLM

La plupart des équipes .NET qui ajoutent des fonctionnalités d’IA aujourd’hui finissent par écrire la même plomberie : un client HTTP, une politique de nouvelle tentative, la gestion des secrets pour une clé d’API, et une ligne de facturation par jeton sur la carte de crédit de quelqu’un. Aspose.LLM prend une autre voie. C’est un package NuGet qui exécute l’inférence de grands modèles de langage dans votre propre processus – aucun service à appeler, aucune clé à faire pivoter, et aucune requête ne quitte la machine.

Cet article présente la bibliothèque, explique les trois concepts sur lesquels son API est construite, et vous guide à travers une application de chat fonctionnelle. Si vous pouvez ajouter une référence de package, vous pouvez envoyer des invites en quelques dizaines de lignes.

Pourquoi un modèle local compte

Exécuter le modèle en processus modifie ce que vous pouvez créer.

• Les données restent en place. Les invites ne quittent jamais l’hôte, ce qui est important lorsque vous travaillez avec des contrats, des notes médicales, du code source ou tout autre élément couvert par une politique de résidence des données.
• Pas de coût par jeton. Une fois le modèle sur le disque, l’inférence est un coût CPU ou GPU que vous possédez déjà, pas un appel d’API facturé.
• Pas de dépendance réseau à l’exécution. Les outils de bureau, les services sur site et les environnements isolés fonctionnent tous de la même manière.
• Un seul artefact de déploiement. La configuration du modèle est livrée avec votre application au lieu de vivre dans le tableau de bord d’un compte séparé.

Le compromis est honnête et mérite d’être indiqué dès le départ : vous fournissez le matériel. Un modèle qui s’exécute localement nécessite de la mémoire locale, et la première exécution doit télécharger plusieurs gigaoctets.

Aspose.LLM for .NET en trois concepts

La surface est délibérément petite. Presque tout ce que vous faites avec Aspose.LLM implique ces trois types.

Un preset est le plus intéressant. Plutôt que de vous obliger à configurer manuellement les chemins de modèle, les paramètres du tokenizer et les valeurs du sampler, un preset regroupe une combinaison éprouvée. Qwen25Preset est le point de départ par défaut, et vous pouvez ajuster ses paramètres ou remplacer le preset par un autre plus tard sans toucher au reste de votre code.

Prérequis

Avant d’écrire du code :

1. Installez le package - Install-Package Aspose.LLM
2. Placez votre licence - placez Aspose.LLM.lic quelque part où l’exécutable peut la lire au moment de l’exécution.
3. Vérifiez votre budget mémoire - le préréglage Qwen25 nécessite au moins 8 Go de RAM libre.

Pour les détails du produit, consultez la Aspose.LLM for .NET page du produit.

Votre premier chat

Voici le programme le plus court qui maintient une vraie conversation. Notez les deuxième et troisième appels : l’instance de l’API suit le contexte par elle‑même, de sorte que le modèle sait toujours qui est Alice.

Ce que fait le code

1. Crée une License et la pointe vers votre fichier de licence.
2. Instancie un Qwen25Preset avec sa configuration par défaut.
3. Crée une instance AsposeLLMApi à partir de ce préréglage.
4. Envoie plusieurs invites, toutes partageant la même conversation.

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) renvoie un client conscient de la session. Chaque appel SendMessageAsync ajoute l’invite à la conversation en cours, ce qui vous permet d’obtenir un comportement multi‑tour sans gérer vous‑même l’état. La déclaration using est importante — l’instance possède des ressources natives et doit être libérée.

Note: Ces exemples suivent la documentation officielle Aspose et n’ont pas été exécutés dans un bac à sable. Vérifiez-les dans votre propre environnement avant de les déployer.

Ajustement du comportement pour une seule requête

Les réponses conversationnelles bénéficient d’un certain degré d’aléatoire. L’arithmétique n’en bénéficie pas. Au lieu de reconfigurer l’instance, créez un deuxième préréglage et transmettez‑le à l’appel unique qui en a besoin.

Ce que fait le code

1. Crée le préréglage par défaut et l’instance API comme d’habitude.
2. Construit strictPreset avec une température d’échantillonnage basse.
3. Le transmet à SendMessageAsync via l’argument preset.
4. Laisse les appels ultérieurs sur le défaut 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 contrôle la quantité d’aléa introduite par le sampler. Les valeurs proches de 0.1 produisent une sortie quasi‑déterministe ; des valeurs plus élevées produisent des formulations plus variées. Comme le préréglage est limité à l’appel, la surcharge ne se propage pas au reste de la conversation.

Annulation et délais d’attente

La durée de génération n’est pas totalement prévisible, et une requête qui s’exécute longtemps bloquera tout ce qui l’attend. SendMessageAsync accepte un CancellationToken, alors fournissez‑en un.

Ce que fait le code

1. Crée un CancellationTokenSource avec un budget de 30 secondes.
2. Passe cts.Token à SendMessageAsync.
3. Capture OperationCanceledException et se dégrade gracieusement.

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

L’annulation laisse l’état de session intact, de sorte que la conversation se poursuit normalement lors de l’appel suivant. Dans un gestionnaire ASP.NET Core, transmettez également le jeton RequestAborted propre à la requête - il n’y a aucune raison de continuer à générer pour un client qui s’est déjà déconnecté.

Une application console complète

Mise en place : un REPL qui maintient une session active pendant toute la durée du processus et se remet des échecs par message.

Ce que fait le code

1. Configure la licence et le préréglage par défaut une fois, au démarrage.
2. Crée une seule instance AsposeLLMApi pour l’ensemble du programme.
3. Boucle sur l’entrée de l’utilisateur jusqu’à ce que l’utilisateur saisisse quit.
4. Envoie chaque ligne et affiche la réponse.
5. Capture les exceptions par message afin qu’une défaillance n’arrête pas la session.

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

Deux points de conception méritent d’être repris dans les applications réelles. Premièrement, l’instance est créée une fois et réutilisée – la création est coûteuse et, comme l’explique la section suivante, les instances concurrentes ne sont pas autorisées. Deuxièmement, le try-catch se trouve à l’intérieur de la boucle plutôt qu’autour, de sorte qu’un seul mauvais message vous coûte un tour au lieu de toute la session.

Évaluez la bibliothèque avec une licence temporaire depuis la page de licence temporaire d’Aspose.

Erreurs que vous êtes susceptible de rencontrer en premier

Cette deuxième ligne mérite une mise en évidence dans les scénarios de service. Si vous intégrez Aspose.LLM dans un conteneur DI, enregistrez AsposeLLMApi en tant que singleton et sérialisez l’accès à celui‑ci – un enregistrement scoped ou transient échouera dès que deux requêtes se chevauchent.

Ressources supplémentaires

• Documentation Aspose.LLM
• Référence API
• Applications en ligne gratuites

Conclusion

Aspose.LLM réduit “ajouter un LLM à cette application .NET” à trois types et une méthode. Une licence active la bibliothèque, un préréglage définit le modèle et la façon dont il génère, et une instance AsposeLLMApi porte la conversation. À partir de là, SendMessageAsync gère une question unique, une session à plusieurs tours, un remplacement de paramètre par appel, et une génération longue exécutable annulable.

Commencez par l’exemple de console, confirmez que le modèle se comporte comme votre fonctionnalité le nécessite, puis passez au travail multi‑session et de persistance une fois que les bases sont solides.

FAQs

1. Qu’est‑ce que Aspose.LLM for .NET ?

Une bibliothèque NuGet qui exécute l’inférence de grands modèles de langage dans votre propre processus .NET. Vous créez un préréglage, créez une instance d’API et envoyez des invites – aucun service externe, aucune clé API.

2. Ai‑je besoin d’une connexion Internet pour l’utiliser ?

Seulement pour la première exécution. L’appel initial Create télécharge le moteur natif et les fichiers de modèle définis par le préréglage, et les ressources sont ensuite mises en cache localement.

3. Quelles sont les conditions préalables aux exemples de code ?

Le package NuGet Aspose.LLM, un fichier Aspose.LLM.lic valide, et suffisamment de RAM libre pour le préréglage choisi - prévoyez au moins 8 Go pour Qwen25.

4. Comment modifier le comportement du modèle pour une seule requête ?

Créez un deuxième préréglage, ajustez ses paramètres (comme SamplerParameters.Temperature), et transmettez‑le à SendMessageAsync via l’argument preset. Les appels ultérieurs reviennent au préréglage par défaut de l’instance.

5. Comment arrêter une génération qui prend trop de temps ?

Passez un CancellationToken à SendMessageAsync et interceptez OperationCanceledException. L’état de session survit à l’annulation, de sorte que la conversation continue normalement.

6. Pourquoi la première réponse est‑elle si lente ?

Le premier appel Create télécharge les binaires natifs et les poids du modèle, ce qui peut prendre 5 à 15 minutes sur une machine propre. Réchauffez l’instance au démarrage de l’application plutôt que lors de la première requête d’un utilisateur.

Read More

• Présentation de la recherche alimentée par l’IA dans la documentation Aspose.Words for .NET
• Utilisez des implémentations LLM auto‑hébergées avec la fonctionnalité IA d’Aspose.Words for .NET
• Créez un chat IA simple en C# avec Aspose.LLM