Bygg en enkel AI-chatt i C# med Aspose.LLM

Behöver du ett snabbt sätt att lägga till en konversations‑AI‑upplevelse i en .NET‑applikation? Med Aspose.LLM kan du bygga en enkel chatt utan att explicit skapa eller hantera sessions‑ID:n. SendMessageAsync använder automatiskt den aktuella sessionen, vilket gör att efterföljande meddelanden kan dela konversationskontext.

Detta mönster är användbart för en konversation åt gången, inklusive CLI-verktyg, prototyper, skript och andra enkla applikationer.

När enkel chatt är det rätta valet

Det implicita sessionsmönstret passar bra för:

• En enda fråga och svar.
• En kort fram- och tillbaka-konversation.
• CLI‑applikationer och skript.
• Prototyper.
• Applikationer där endast en konversation behöver vara aktiv åt gången.

Om din applikation behöver flera oberoende konversationer — till exempel en chatbot som betjänar flera användare — bör du istället använda Aspose.LLM:s explicita sessions‑API:er.

Skicka ett meddelande utan att hantera en session

Det grundläggande meddelandemönstret är avsiktligt litet:

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

När du gör efterföljande anrop på samma AsposeLLMApi-instans tillhör de samma aktuella konversationen:

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

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

Du skapar inte ett sessions‑ID, skickar ett mellan anrop, eller lägger explicit till samtalshistorik. Samma AsposeLLMApi‑instans upprätthåller den aktuella konversationen åt dig. Den befintliga källan dokumenterar detta beteende som en implicit session som upprätthålls under hela API‑instansens livstid. fileciteturn0file0L29‑L34

Den fullständiga konfigurationen kräver fortfarande en licensierad API‑instans och en förinställning. Källexemplet använder Aspose.LLM.License, Qwen25Preset och AsposeLLMApi.Create(preset). fileciteturn0file0L87-L122

Bygg en interaktiv konsolchatt

När det grundläggande meddelandemönstret är förstått, låt oss omvandla det till en liten interaktiv konsolapplikation.

Det viktiga är att skapa API:et en gång och sedan återanvända det för varje meddelande:

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

Det här exemplet håller chatten enkel:

• API‑instansen skapas en gång.
• Varje SendMessageAsync‑anrop använder samma implicita session.
• Tidigare meddelanden förblir tillgängliga för modellen.
• Loopen ger en naturlig fram‑och‑tillbaka‑konversation.
• Undantag hanteras per meddelande så att en misslyckad begäran inte avslutar applikationen.

Källexemplet använder samma struktur och noterar att den enda API‑instansen bevarar kontexten över iterationer. fileciteturn0file0L192-L245

För att köra den, skapa ett .NET‑konsolprojekt, ersätt den genererade Program.cs och kör:

dotnet new console
dotnet run

Aspose.LLM tillhandahåller en hög‑nivå AsposeLLMApi‑klass som abstraherar modellinläsning, tokenisering och inferens. För att komma igång, installera NuGet‑paketet:

Install-Package Aspose.LLM

Anpassa ett enskilt meddelande med en annan förinställning

Tänk om det mesta av ditt samtal ska använda standardbeteendet, men en särskild fråga kräver ett mer deterministiskt svar?

Du kan skicka en annan förinställning till SendMessageAsync för det anropet:

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

Överskrivningen gäller endast för det anropet. API:ets standardinställning förblir oförändrad, och den underliggande sessionen fortsätter att tillhandahålla konversationssammanhang. fileciteturn0file0L126-L159

En låg temperatur som 0.1f gör sampling mer deterministisk, vilket kan vara användbart för frågor där du vill ha mindre variation i det genererade svaret. fileciteturn0file0L155-L159

Skydda långvariga chattförfrågningar med avbokning

Lokal modellinferens kan ta längre tid för stora promptar eller längre svar. Du kan förhindra att en enskild begäran körs oändligt genom att skicka en CancellationToken.

Till exempel, ange en timeout på 30 sekunder:

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

Källkoden beskriver samma mönster: skapa en CancellationTokenSource med en tidsgräns, skicka dess token till SendMessageAsync och fånga OperationCanceledException när begäran avbryts. fileciteturn0file0L161-L190

I en ASP.NET Core‑applikation kan du också skicka begärans avbrottstoken så att genereringen kan stoppas när klienten kopplar ner.

Vanliga problem

Källan dokumenterar specifikt licensfelet, beteendet med en enda aktiv instans och den långsammare första modellinläsningen. fileciteturn0file0L249-L255

Enkel chatt vs. explicita sessioner

Den implicita sessionsmetoden är avsiktligt begränsad: den håller implementationen liten genom att upprätthålla ett aktuellt samtal på en AsposeLLMApi-instans.

Använd implicit meddelandehantering när en konversation räcker.
Gå över till explicita sessions‑API:er när du behöver oberoende konversationer, samtidiga användare, bestående tillstånd eller mer kontroll över sessionsidentitet.
Den befintliga källan rekommenderar explicita sessioner för samtidiga konversationer och bestående tillstånd. fileciteturn0file0L266-L274

För den explicita sessionsmetoden, se Aspose.LLM-dokumentationen och multi-turn/session‑API:er.

Få en gratis licens

Aspose erbjuder tillfälliga licenser för utvärdering. Hämta en från den Aspose temporära licenssidan och placera filen Aspose.LLM.lic där din applikation kan läsa in den.

Gratis ytterligare resurser

• Aspose.LLM-dokumentation
• API-referens
• Gratis online-appar

Slutsats

Att bygga en enkel AI‑chatt med Aspose.LLM kräver inte explicit sessionshantering. Genom att skapa en AsposeLLMApi‑instans och anropa SendMessageAsync kan du skapa en konversationsupplevelse där API:et automatiskt upprätthåller den aktuella sessionen.

För enkla applikationer, prototyper, skript och chattupplevelser för en enda användare håller detta implementationen minimal. När din applikation växer för att stödja flera konversationer eller kräver explicit sessionskontroll kan du gå över till de sessionsbaserade API:erna.

FAQs

1. Behöver jag hantera chattsessioner manuellt med Aspose.LLM? Nej. Den implicita‑session SendMessageAsync‑metoden spårar automatiskt samtalstillståndet för hela livstiden för AsposeLLMApi‑instansen.

2. Kan jag ändra modellens beteende för bara en fråga? Ja. Tillhandahåll en annan förinställning (t.ex. med lägre temperatur) som preset-argumentet till SendMessageAsync. Endast det anropet använder de nya inställningarna.

3. Hur stoppar jag en långvarig generering? Skapa en CancellationTokenSource med en tidsgräns och skicka dess token till SendMessageAsync. Fånga OperationCanceledException för att hantera tidsgränsen.

4. Vilka vanliga fel bör jag hålla utkik efter? Saknad licens, att skapa flera API‑instanser samtidigt och en långsam första modellinläsning är de vanligaste problemen. Följ de mitigationssteg som beskrivits ovan.

5. Är exempel­koden klar för produktion? Kodsnuttarna är reproducerade från Asposes officiella dokumentation och har inte testats i en sandbox. Testa dem i din egen miljö och lägg till robust felhantering innan du distribuerar.

Läs mer

• Introduktion av AI-drivet sök i Aspose.Words för .NET-dokumentation
• Använd självhostade LLM-implementationer med Aspose.Words för .NET AI-funktionalitet
• Lägg till stora språkmodeller i dina .NET-appar med Aspose.LLM
• Bygg en flermålschatt i C# med Aspose.LLM