Lägg till stora språkmodeller i dina .NET-appar med Aspose.LLM

De flesta .NET‑team som lägger till AI‑funktioner idag slutar med att skriva samma infrastruktur: en HTTP‑klient, en återförsökspolicy, hemlig hantering för en API‑nyckel och en per‑token faktureringsrad på någons kreditkort. Aspose.LLM tar en annan väg. Det är ett NuGet‑paket som kör inferens av stora språkmodeller inuti din egen process – ingen tjänst att anropa, ingen nyckel att rotera och ingen begäran som lämnar maskinen.

Den här artikeln introducerar biblioteket, förklarar de tre koncept som dess API är byggt på och guidar dig genom en fungerande chattapplikation. Om du kan lägga till ett paketreferens kan du börja skicka prompts på några dussin rader.

Varför en lokal modell är viktig

Att köra modellen i processen förändrar vad du kan bygga.

• Data förblir på plats. Promptar lämnar aldrig värden, vilket är viktigt när du arbetar med kontrakt, medicinska anteckningar, källkod eller något annat som omfattas av en datalokaliseringspolicy.
• Ingen kostnad per token. När modellen väl finns på disk är inferens en CPU- eller GPU-kostnad du redan har, inte ett mätt API‑anrop.
• Ingen nätverksberoende vid körning. Desktopverktyg, lokala tjänster och luftgapade miljöer fungerar alla på samma sätt.
• Ett distributionsartefakt. Modellkonfigurationen levereras med din applikation istället för att finnas i en separat kontos instrumentpanel.

Avvägningen är ärlig och värd att säga från början: du tillhandahåller hårdvaran. En modell som körs lokalt behöver lokalt minne, och den första körningen måste ladda ner flera gigabyte.

Aspose.LLM for .NET i tre koncept

Ytarea är avsiktligt liten. Nästan allt du gör med Aspose.LLM involverar dessa tre typer.

En förinställning är den intressanta. Istället för att du ska koppla ihop modellvägar, tokeniseringsinställningar och samplingsvärden manuellt, paketerar en förinställning en beprövad kombination. Qwen25Preset är standardutgångspunkten, och du kan justera dess parametrar eller byta till en annan förinställning senare utan att röra resten av din kod.

Förutsättningar

Innan du skriver någon kod:

1. Installera paketet - Install-Package Aspose.LLM
2. Placera din licens - placera Aspose.LLM.lic någonstans som körprogrammet kan läsa vid körning.
3. Kontrollera din minnesbudget - Qwen25‑förinställningen kräver minst 8 GB ledigt RAM.

För produktdetaljer, se Aspose.LLM for .NET produktsida.

Din första chatt

Här är det kortaste programmet som håller en riktig konversation. Observera det andra och tredje anropet: API‑instansen spårar kontexten själv, så modellen vet fortfarande vem Alice är.

Vad koden gör

1. Skapar en License och pekar den på din licensfil.
2. Instansierar en Qwen25Preset med dess standardkonfiguration.
3. Skapar en AsposeLLMApi‑instans från den förinställningen.
4. Skickar flera prompts, alla delar samma konversation.

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) returnerar en sessionsmedveten klient. Varje SendMessageAsync-anrop lägger till prompten i den pågående konversationen, så du får beteende med flera turer utan att behöva hantera någon state själv. using-deklarationen är viktig – instansen äger inhemska resurser och måste avyttras.

Note: Dessa exempel följer den officiella Aspose-dokumentationen och har inte körts i en sandlåda. Verifiera dem i din egen miljö innan du levererar.

Finjustering av beteende för en enskild begäran

Konversationella svar drar nytta av viss slumpmässighet. Aritmetik gör det inte. Istället för att omkonfigurera instansen, bygg en andra förinställning och skicka den till det anrop som behöver den.

Vad koden gör

1. Skapar standardförinställningen och API‑instansen som vanligt.
2. Bygger strictPreset med en låg sampler‑temperatur.
3. Skickar den till SendMessageAsync via argumentet preset.
4. Låter senare anrop använda den ursprungliga standarden.

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 styr hur mycket slumpmässighet samplern introducerar. Värden nära 0.1 ger nästan deterministisk utdata; högre värden ger mer varierad formulering. Eftersom förinställningen är begränsad till anropet läcker inte överskrivningen till resten av konversationen.

Avbrytning och tidsgränser

Generationslängden är inte helt förutsägbar, och en förfrågan som kör länge kommer att blockera vad som än väntar på den. SendMessageAsync accepterar en CancellationToken, så ge den en.

Vad koden gör

1. Skapar en CancellationTokenSource med en budget på 30 sekunder.
2. Skickar cts.Token till SendMessageAsync.
3. Fångar OperationCanceledException och degraderar på ett smidigt sätt.

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

Avbokningen lämnar sessionstillståndet intakt, så konversationen fortsätter normalt vid nästa anrop. I en ASP.NET Core‑hanterare vidarebefordras begärans egna RequestAborted‑token här också – det finns ingen anledning att fortsätta generera för en klient som redan har kopplats bort.

En komplett konsolapplikation

Sätter ihop det: en REPL som håller en session levande under processens livstid och återhämtar sig från fel per meddelande.

Vad koden gör

1. Ställer in licensen och standardförinställningen en gång, vid start.
2. Skapar en enda AsposeLLMApi-instans för hela programmet.
3. Loopar på användarinmatning tills användaren skriver quit.
4. Skickar varje rad och skriver ut svaret.
5. Fångar undantag per meddelande så att ett fel inte avslutar sessionen.

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

Två designpunkter är värda att ta med i verkliga applikationer. För det första skapas instansen en gång och återanvänds – skapandet är dyrt och, som nästa avsnitt förklarar, är samtidiga instanser inte tillåtna. För det andra sitter try‑catch inuti loopen snarare än runt den, så ett enda dåligt meddelande kostar dig ett varv istället för hela sessionen.

Utvärdera biblioteket med en tillfällig licens från Aspose temporära licenssida.

Fel du sannolikt kommer att stöta på först

Den andra raden förtjänar betoning i tjänstescenarier. Om du kopplar in Aspose.LLM i en DI‑container, registrera AsposeLLMApi som en singleton och serialisera åtkomsten till den – en scoped‑ eller transient‑registrering kommer att misslyckas så snart två förfrågningar överlappar.

Ytterligare resurser

• Aspose.LLM Dokumentation
• API-referens
• Gratis online‑appar

Slutsats

Aspose.LLM reducerar “add an LLM to this .NET application” till tre typer och en metod. En licens aktiverar biblioteket, en förinställning definierar modellen och hur den genererar, och en AsposeLLMApi‑instans hanterar konversationen. Därefter hanterar SendMessageAsync en enskild fråga, en flervägsession, en per‑anrop‑parameteröverskrivning och en avbrytbar långvarig generering.

Börja med konsolprovet, bekräfta att modellen beter sig på det sätt som din funktion kräver, och gå sedan vidare till flersession‑ och beständighetsarbete när grunderna är solida.

Vanliga frågor

1. Vad är Aspose.LLM for .NET?

Ett NuGet‑bibliotek som kör inferens av stora språkmodeller i din egen .NET‑process. Du skapar en förinställning, skapar en API‑instans och skickar prompts – ingen extern tjänst, ingen API‑nyckel.

2. Behöver jag en internetanslutning för att använda den?

Endast för den första körningen. Det första Create-anropet laddar ner den inhemska motorn och modellfilerna som definieras av förinställningen, och resurserna cachas lokalt därefter.

3. Vad är förutsättningarna för kodexemplen?

Aspose.LLM NuGet‑paketet, en giltig Aspose.LLM.lic‑fil och tillräckligt med ledigt RAM för ditt valda förinställning – planera för minst 8 GB för Qwen25.

4. Hur ändrar jag modellens beteende för en enskild förfrågan?

Bygg en andra förinställning, justera dess parametrar (t.ex. SamplerParameters.Temperature), och skicka den till SendMessageAsync via argumentet preset. Senare anrop återgår till instansens standardförinställning.

5. Hur stoppar jag en generering som tar för lång tid?

Skicka en CancellationToken till SendMessageAsync och fånga OperationCanceledException. Sessionsstatus överlever avbrytandet, så konversationen fortsätter som vanligt.

6. Varför är det första svaret så långsamt?

Det första Create-anropet laddar ner inhemska binärer och modellvikter, vilket kan ta 5–15 minuter på en ren maskin. Värm upp instansen vid applikationsstart snarare än vid en användares första begäran.

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
• Bygg en enkel AI-chatt i C# med Aspose.LLM