Créer un chat IA simple en C# avec Aspose.LLM

Vous avez besoin d’un moyen rapide d’ajouter une expérience d’IA conversationnelle à une application .NET ? Avec Aspose.LLM, vous pouvez créer un chat simple sans créer ou gérer explicitement des ID de session. SendMessageAsync utilise automatiquement la session en cours, permettant aux messages successifs de partager le contexte de la conversation.

Ce modèle est utile pour une conversation à la fois, y compris les outils CLI, les prototypes, les scripts et autres applications simples.

Quand le chat simple est le bon choix

Le modèle de session implicite convient bien à :

• Une seule question et réponse.
• Une courte conversation aller‑retour.
• Applications CLI et scripts.
• Prototypes.
• Applications où une seule conversation doit être active à la fois.

Si votre application nécessite plusieurs conversations indépendantes — par exemple, un chatbot servant plusieurs utilisateurs — vous devez utiliser les API de session explicites d’Aspose.LLM à la place.

Envoyer un message sans gérer une session

Le modèle de messagerie de base est délibérément petit :

string reply = await api.SendMessageAsync("What is 2 + 2?");
Console.WriteLine(reply);

Lorsque vous effectuez des appels ultérieurs sur la même instance AsposeLLMApi, ils appartiennent à la même conversation en cours :

await api.SendMessageAsync("My name is Alice.");

string reply = await api.SendMessageAsync("What is my name?");
Console.WriteLine(reply);

Vous ne créez pas d’ID de session, n’en transmettez pas entre les appels, et n’ajoutez pas explicitement l’historique de conversation. La même instance AsposeLLMApi maintient la conversation en cours pour vous. La source existante documente ce comportement comme une session implicite maintenue pendant toute la durée de vie de l’instance de l’API. fileciteturn0file0L29‑L34

La configuration complète nécessite toujours une instance d’API sous licence et un préréglage. L’exemple source utilise Aspose.LLM.License, Qwen25Preset et AsposeLLMApi.Create(preset). fileciteturn0file0L87-L122

Créer un chat console interactif

Une fois le modèle de messagerie de base compris, transformons‑le en une petite application console interactive.

L’essentiel est de créer l’API une fois, puis de la réutiliser pour chaque message :

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

Cet exemple garde le chat simple:

• L’instance de l’API est créée une fois.
• Chaque appel SendMessageAsync utilise la même session implicite.
• Les messages précédents restent disponibles pour le modèle.
• La boucle fournit une conversation naturelle aller‑retour.
• Les exceptions sont gérées par message afin qu’une requête échouée ne termine pas l’application.

L’exemple source utilise la même structure et indique que l’instance unique de l’API préserve le contexte à travers les itérations. fileciteturn0file0L192-L245

Pour l’exécuter, créez un projet console .NET, remplacez le fichier Program.cs généré, puis exécutez :

dotnet new console
dotnet run

Aspose.LLM fournit une classe de haut niveau AsposeLLMApi qui abstrait le chargement du modèle, la tokenisation et l’inférence. Pour commencer, installez le package NuGet :

Install-Package Aspose.LLM

Personnaliser un seul message avec un préréglage différent

Et si la plupart de votre conversation devait utiliser le comportement par défaut, mais qu’une question particulière nécessite une réponse plus déterministe ?

Vous pouvez passer un préréglage différent à SendMessageAsync pour cet appel :

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

Le remplacement ne s’applique qu’à cet appel. Le préréglage par défaut de l’API reste inchangé, et la session sous-jacente continue de fournir le contexte de la conversation. fileciteturn0file0L126-L159

Une température basse telle que 0.1f rend l’échantillonnage plus déterministe, ce qui peut être utile pour les questions où vous souhaitez moins de variation dans la réponse générée. fileciteturn0file0L155-L159

Protéger les requêtes de chat de longue durée avec l’annulation

L’inférence du modèle local peut prendre plus de temps pour de grandes invites ou des réponses plus longues. Vous pouvez empêcher qu’une requête individuelle s’exécute indéfiniment en transmettant un CancellationToken.

Par exemple, définissez un délai d’attente de 30 secondes :

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 source décrit le même schéma : créez un CancellationTokenSource avec un délai d’attente, transmettez son jeton à SendMessageAsync et interceptez OperationCanceledException lorsque la requête est annulée. fileciteturn0file0L161-L190

Dans une application ASP.NET Core, vous pouvez également transmettre le jeton d’annulation de la requête afin que la génération puisse s’arrêter lorsque le client se déconnecte.

Problèmes courants

La source document spécifiquement l’erreur de licence, le comportement d’instance unique active, et le chargement plus lent du premier modèle. fileciteturn0file0L249-L255

Chat simple vs. Sessions explicites

L’approche de session implicite est intentionnellement limitée : elle garde l’implémentation petite en maintenant une conversation en cours sur une instance AsposeLLMApi.

Utilisez la messagerie implicite lorsqu’une seule conversation suffit. Passez aux API de session explicites lorsque vous avez besoin de conversations indépendantes, d’utilisateurs concurrents, d’un état persistant ou d’un contrôle accru sur l’identité de la session. La source existante recommande les sessions explicites pour les conversations simultanées et l’état persistant. fileciteturn0file0L266-L274

Pour l’approche à session explicite, consultez la documentation Aspose.LLM et les API multi‑tour/session.

Obtenez une licence gratuite

Aspose propose des licences temporaires pour l’évaluation. Obtenez‑en une depuis la page de licence temporaire d’Aspose et placez le fichier Aspose.LLM.lic à l’endroit où votre application peut le charger.

Ressources supplémentaires gratuites

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

Conclusion

Créer un chat IA simple avec Aspose.LLM ne nécessite pas de gestion explicite de session. En créant une instance AsposeLLMApi et en appelant SendMessageAsync, vous pouvez créer une expérience conversationnelle où l’API maintient automatiquement la session en cours.

Pour les applications simples, les prototypes, les scripts et les expériences de chat à utilisateur unique, cela maintient l’implémentation minimale. Lorsque votre application se développe pour prendre en charge plusieurs conversations ou nécessite un contrôle de session explicite, vous pouvez passer aux API basées sur les sessions.

FAQ

1. Dois‑je gérer les sessions de chat manuellement avec Aspose.LLM ? Non. La méthode SendMessageAsync à session implicite suit automatiquement l’état de la conversation pendant la durée de vie de l’instance AsposeLLMApi.

2. Puis-je modifier le comportement du modèle pour une seule question ?
   Oui. Fournissez un préréglage différent (par exemple, avec une température plus basse) en tant qu’argument preset à SendMessageAsync. Seul cet appel utilise les nouveaux paramètres.

3. Comment arrêter une génération de longue durée ? Créez un CancellationTokenSource avec un délai d’expiration et transmettez son jeton à SendMessageAsync. Capturez OperationCanceledException pour gérer le délai d’expiration.

4. Quelles erreurs courantes dois-je surveiller ? Licence manquante, création de plusieurs instances d’API simultanément et un chargement initial lent du modèle sont les problèmes les plus fréquents. Suivez les étapes d’atténuation décrites ci‑dessus.

5. Le code d’exemple est‑il prêt pour la production ? Les extraits sont reproduits à partir de la documentation officielle d’Aspose et n’ont pas été testés en sandbox. Testez‑les dans votre propre environnement et ajoutez une gestion d’erreurs robuste avant le déploiement.

En savoir plus

• 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
• Ajoutez de grands modèles de langage à vos applications .NET avec Aspose.LLM
• Créez un chat multi‑tours en C# avec Aspose.LLM