Hur man använder Semantic Kernel: En praktisk guide med mönster, prompter och plugins
Har du någonsin försökt att koppla en LLM till din app och slutat med en skör röra av prompter, hjälpfunktioner och tillstånd? Semantic Kernel (SK) finns för att fixa just det. Det är ett lättviktigt, open source-orkestreringsramverk från Microsoft för att bygga AI-först-appar som blandar naturligt språk, verktyg och minne – utan att förvandla din kodbas till en prompt-spaghetti-röra.
I den här guiden kommer vi att ta en praktisk, lösningsorienterad tur i hur man använder Semantic Kernel från noll till produktionsmönster. Du kommer att lära dig hur man strukturerar prompter, kopplar in verktyg, lägger till minne, anropar flera modeller och distribuerar agenter som agerar konsekvent. Vi kommer att hålla exemplen jordnära och visa dig vad som är viktigt.
Vad är Semantic Kernel – och varför använda det?
Semantic Kernel är ett SDK som hjälper dig att:
- Sätta samman prompter och funktioner ("skills"/plugins) till pipelines.
- Anropa flera modeller (OpenAI, Azure OpenAI, lokala modeller) utbytbart.
- Lägga till minne för kontext och långsiktig återkallelse via inbäddningar.
- Planera och orkestrera flerstegsuppgifter med tillförlitligt tillstånd.
- Integrera verktyg (API:er, databaser, fil I/O) säkert och deterministiskt.
Tänk på SK som kontrollern som koordinerar LLM:er, din applogik och användardata. Istället för att hårdkoda långa prompter och ad hoc-verktygsanrop, definierar du återanvändbara semantiska funktioner och inbyggda funktioner med tydliga in-/utdata.
Vanliga användningsområden:
- Kundsupport-copiloter med hämtningsförstärkt generering (RAG)
- Arbetsflödesagenter (sammanfatta → klassificera → vidta åtgärder)
- Dokumentfrågor och svar med minne och citeringar
- Kreativa innehålls- och kodgenereringspipelines
Snabbstart: Din första Semantic Kernel-app
Nedan visas ett minimalt flöde för att visa hur man använder Semantic Kernel med en chattmodell och en enkel prompt. Vi använder C# för tydlighetens skull; du kan göra samma sak i Python eller Java.
1) Installera paket
# .NET
dotnet add package Microsoft.SemanticKernel
# Valfritt: anslutningar och planerare varierar beroende på version
2) Konfigurera kärnan och modellen
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Connectors.OpenAI;
var builder = Kernel.CreateBuilder;
// Välj din leverantör: OpenAI eller Azure OpenAI
builder.AddOpenAIChatCompletion(
modelId: "gpt-4o-mini", // eller din föredragna modell
apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")
);
var kernel = builder.Build;
3) Definiera en semantisk funktion (prompt)
using Microsoft.SemanticKernel.SemanticFunctions;
var prompt = @"Du är en koncis förklarare.
Förklara konceptet '{topic}' i 3 punkter för en nybörjare.";
var explainFunc = kernel.CreateFunctionFromPrompt(prompt);
var result = await explainFunc.InvokeAsync(kernel, new { ["topic"] = "vektorinbäddningar" });
Console.WriteLine(result);
Detta är kärnan: en kärna, en modell och en prompt som omvandlas till en återanvändbar funktion med indata.
Semantiska funktioner vs. Inbyggda funktioner
- Semantiska funktioner: Prompt-drivna. Du skapar dem från mallar, skickar variabler och får text eller strukturerade utdata.
- Inbyggda funktioner: Vanliga kodfunktioner som SK exponerar för LLM:en för verktygsanvändning.
Exempel på en inbyggd funktion som hämtar väder från ditt API och exponerar det för modellen:
public class WeatherPlugin
{
[KernelFunction, Description("Hämta väder för en stad")]
public async Task<string> GetWeatherAsync(
[Description("Stadsnamn")] string city)
{
// Anropa ditt väder-API här
var temp = 22; // platshållare
return $"Väder i {city}: {temp}°C och klart";
}
}
// Registrera plugin
var weather = new WeatherPlugin;
kernel.Plugins.AddFromObject(weather, pluginName: "weather");
Nu kan dina prompter anropa weather.GetWeatherAsync som ett verktyg, vilket gör att modellen kan basera svar på verkliga data.
Prompt-mönster som faktiskt fungerar
När du lär dig hur man använder Semantic Kernel kommer de snabbaste vinsterna från disciplinerade prompt-mönster:
- System-först: Använd ett starkt systemmeddelande för att låsa ton, persona, säkerhet och utdataformat.
- Variabla platser: Namnge platshållare tydligt (t.ex.
{topic}, {audience}) och validera indata.
- Utdataavtal: Be om strukturerade format som JSON; inkludera ett schema i prompten.
- Few-shot: Ge koncisa exempel på stil och format, inte innehållsmässigt överflöd.
- Skyddsräcken: Inkludera begränsningar ("Om data saknas, ställ en förtydligande fråga först").
Exempel på en strukturerad prompt inuti SK:
var prompt = @"
Du är en klassificeringsmotor.
Uppgift: Klassificera `meddelandet` i en av [Fakturering, Teknisk support, Försäljning].
Returnera strikt JSON: { \"label\": string, \"confidence\": number }
meddelande: {message}
";
var classify = kernel.CreateFunctionFromPrompt(prompt);
var output = await classify.InvokeAsync(kernel, new { ["message"] = "Jag kan inte logga in på mitt konto." });
Console.WriteLine(output); // {"label":"Teknisk support","confidence":0.89}
Lägga till minne: Inbäddningar, RAG och Kontextfönster
LLM:er glömmer. Minne gör dem användbara.
- Kortvarig kontext: Automatisk via konversationshistorik.
- Långtidsminne: Lagra inbäddningar av användarnoter, dokument eller händelser och hämta relevanta bitar för kontext.
- RAG: Innan du anropar en genereringsfunktion, fråga din vektorlagring och injicera resultat i prompten.
Exempel: lägg till textminne med inbäddningar och hämta kontext.
using Microsoft.SemanticKernel.Memory;
var memory = new MemoryBuilder
.WithMemoryStore(new VolatileMemoryStore) // byt ut mot en vektor-DB (Qdrant, Pinecone, Azure AI Search)
.WithTextEmbeddingGeneration(
new OpenAITextEmbeddingGeneration("text-embedding-3-small", Environment.GetEnvironmentVariable("OPENAI_API_KEY")))
.Build;
await memory.SaveInformationAsync(
collection: "policies", id: "refund-policy",
text: "Kunder kan begära en återbetalning inom 30 dagar efter köpet med bevis på kvitto."
);
// Senare: hämta och stoppa in i prompten
var results = memory.SearchAsync("återbetalningsfönster", collection: "policies", limit: 3, minRelevanceScore: 0.7);
await foreach (var item in results)
{
Console.WriteLine($"Relevant: {item.Metadata.Text}");
}
Mata sedan in de bästa matchningarna i din semantiska funktion som kontextvariabler. Tips: håll bitarna små (200–400 tokens) och deduplicera.
Verktygsanvändning och planering: Arbetsflöden i flera steg
Semantic Kernel stöder planerare som kan bryta ner ett användarmål i steg och välja vilka funktioner som ska anropas. Detta är perfekt när du har en verktygslåda med inbyggda och semantiska funktioner.
Mönster:
- Samla in mål och begränsningar från användaren.
- Utarbeta en plan (sekvens av funktionsanrop med argument).
- Utför steg för steg, verifiera utdata och återställ från fel.
Pseudokodexempel:
// 1) Definiera plugins (semantiska + inbyggda) som tidigare
// 2) Använd en planerare (API-yta kan variera beroende på version)
var goal = "Sammanfatta den bifogade policyn, klassificera risk och skicka en rapport via e-post";
// Anta att vi har plugins: filer, sammanfatta, klassificera, e-post
// Planeraren kommer att sätta ihop en plan: files.Load → summarize.Run → classify.Run → email.Send
// Utför planen sekventiellt, validera JSON-utdata mellan stegen
Bästa praxis:
- Gör stegen idempotenta och testbara.
- Ange explicita utdatascheman mellan stegen.
- Använd återförsök/backoff på nätverksanslutna verktyg.
- Logga indata/utdata för observerbarhet (men rensa PII).
Strategi för flera modeller: Välj rätt modell för jobbet
Med Semantic Kernel kan du dirigera uppgifter till olika modeller:
- Snabba utkast → små, billiga modeller
- Resonemangstunga steg → större modeller
- Inbäddningar → specialiserad inbäddningsmodell
- Kod → kodoptimerade modeller
I praktiken:
var kernel = Kernel.CreateBuilder
.AddOpenAIChatCompletion("gpt-4o-mini", apiKey)
.Build;
var fastKernel = Kernel.CreateBuilder
.AddOpenAIChatCompletion("gpt-4o-mini", apiKey) // hastighetsoptimerad
.Build;
// Dirigera enklare prompter till fastKernel; komplexa uppgifter till kernel
Eller konfigurera flera tjänster i samma kärna och välj per funktion.
Från prototyp till produktion: Skyddsräcken och testning
När du lär dig hur man använder Semantic Kernel i riktiga appar spelar tillförlitlighet roll:
- Schema-först-utdata: Använd JSON-scheman och
TryParse-grindar.
- Determinism när det behövs: Ställ in låg temperatur och begränsa utdata.
- Säkerhetsfilter: Lägg till innehållsfilter och red-team-prompter.
- Caching: Cachelagra RAG-resultat och stabila genereringar.
- Observerbarhet: Logga prompt-mallar, variabler, latens, token-användning.
- Enhetstester: Golden test-prompter med snapshot-jämförelser.
Exempel: validera JSON-utdata.
record Classification(string label, double confidence);
bool TryParseClassification(string text, out Classification cls)
{
try { cls = System.Text.Json.JsonSerializer.Deserialize<Classification>(text)!; return true; }
catch { cls = default!; return false; }
}
Verkliga mönster du kan återanvända
- RAG Chatbot:
hämta(kontext) → svara(fråga, kontext) med citeringar.
- Godkännandearbetsflöden: klassificera → generera utkast → mänsklig granskning → skicka.
- Innehållsoperationer: skissera → utkast → faktakontroll → tonjustering → publicera.
- Agent med verktyg: calendar.lookup, docs.search, email.send; med planering och minne.
Tips: Kapsla in varje steg som en funktion (semantisk eller inbyggd) och sätt samman dem till pipelines.
Exempel: Dokumentfrågor och svar med citeringar
Låt oss koppla en enkel Q&A-pipeline som citerar källor med hjälp av RAG.
// 1) Mata in dokument i minnet
await memory.SaveInformationAsync("handbook", "vacation-policy",
"Anställda samlar 1,5 dagars PTO per månad och kan överföra 5 dagar.");
// 2) Hämta kontext för en fråga
var top = memory.SearchAsync("överföra PTO", "handbook", limit: 3, minRelevanceScore: 0.75);
var contexts = new List<string>;
await foreach (var r in top) contexts.Add(r.Metadata.Text);
// 3) Fråga med kontext och begär citeringar
var qaPrompt = @"
Du svarar strikt från den angivna kontexten. Om det saknas, säg att du inte vet.
Inkludera inline-citeringar som [källa i] med hjälp av indexet för kontextobjekt som börjar på 1.
Kontext:
1) {{ctx1}}
2) {{ctx2}}
Fråga: {{q}}
";
var qa = kernel.CreateFunctionFromPrompt(qaPrompt);
var variables = new KernelArguments
{
["ctx1"] = contexts.ElementAtOrDefault(0) ?? "",
["ctx2"] = contexts.ElementAtOrDefault(1) ?? "",
["q"] = "Hur många PTO-dagar kan jag överföra?"
};
var answer = await qa.InvokeAsync(kernel, variables);
Console.WriteLine(answer);
Vanliga fallgropar (och hur man undviker dem)
- En enda jätteprompt: Dela upp i funktioner; skicka bara den kontext du behöver.
- Inga utdataavtal: Definiera alltid scheman för maskinläsbara steg.
- RAG utan hygien: Dela upp väl, deduplicera och rangordna efter relevans och aktualitet.
- Verktygsspret: Håll plugin-gränssnitten små och dokumenterade.
- Ingen människa-i-loopen: Lägg till godkännanden för högriskåtgärder.
Hur man använder Semantic Kernel med frontends
- Webbappar: Värd din SK-orkestrering i ett API-lager; strömma tokens till UI:t.
- Chatt-UI:er: Underhåll konversationsstatus på serversidan; rensa och sammanfatta.
- Autentisering: Personifieringssäkra anrop – låt aldrig modellen prägla tokens. Gate-verktygsanrop via din backend.
Distributionschecklista
- Miljövariabler för nycklar och slutpunkter
- Hastighetsbegränsning och återförsök för modell-/verktygsanrop
- Källkontroll för prompt-mallar
- Säkerhetskopiering av vektorlagring och PII-hantering
- Instrumentpaneler för observerbarhet (latens, kostnad, fel)
- A/B-testning för prompter och dirigering
Felsökning i FAQ-stil
- "Modellen hallucinerar även med RAG." Dra åt instruktionerna: "Svara bara från kontext" och inkludera ett vägransexempel. Öka hämtningsspecificiteten och minska temperaturen.
- "JSON går sönder hela tiden." Lägg till ett miniexempel på giltig JSON och förbjud kommentarer. Eftervalidera och omformulera vid fel.
- "Latensen är hög." Hämta färre, mer relevanta bitar; byt enkla steg till mindre modeller; parallellisera oberoende steg.
- "Kostnaderna skjuter i höjden." Cachelagra, komprimera kontext och dirigera enkla uppgifter till billigare modeller.
Värt att notera: Bygg snabbare med Sider.AI
Om du prototypar prompter, testar verktygsflöden eller jämför svar mellan modeller, kan en följeslagare som Sider.ai påskynda iterationen. Du kan utarbeta prompter, köra A/B-jämförelser och fånga återanvändbara kodsnuttar innan du flyttar dem till Semantic Kernel-mallar – perfekt för att vässa instruktioner och utdatascheman. Nästa steg: Förvandla detta till en fungerande agent
- Börja med en tydlig uppgift (t.ex. klassificera support-e-post).
- Definiera semantiska/inbyggda funktioner med strikta indata/utdata.
- Lägg bara till minne där det märkbart förbättrar svaren.
- Instrumentera allt; testa med verkliga exempel.
- Iterera på prompter med hjälp av en sandlåda och kodifiera sedan i SK.
Viktiga takeaways:
- Semantic Kernel hjälper dig att sätta samman prompter, verktyg och minne till tillförlitliga arbetsflöden.
- Använd utdatascheman, planerare och dirigering med flera modeller för robusthet och kostnadskontroll.
- RAG plus skyddsräcken slår jätteprompter varje gång.
När du väl behärskar hur man använder Semantic Kernel med dessa mönster kommer du att leverera AI-funktioner som inte bara är imponerande demos – utan pålitliga system.
FAQ
F1: Vad används Semantic Kernel till i AI-appar?
Semantic Kernel är ett orkestrerings-SDK för att bygga AI-arbetsflöden som kombinerar LLM-prompter, verktyg (inbyggda funktioner) och minne. Det hjälper dig att strukturera uppgifter, lägga till RAG och anropa flera modeller på ett tillförlitligt sätt.
F2: Hur använder jag Semantic Kernel för RAG med mina dokument?
Mata in dina dokument i en vektorlagring via SK:s minnes-API:er, hämta sedan de mest relevanta bitarna per fråga och injicera dem i din prompt. Detta förbättrar noggrannheten och minskar hallucinationer.
F3: Kan Semantic Kernel anropa externa API:er och tjänster?
Ja. Slå in API:er som inbyggda funktioner i ett plugin och registrera dem med kärnan så att modellen kan använda dem som verktyg. Håll gränssnitten små och tvinga igenom validering av indata/utdata.
F4: Vilka modeller fungerar med Semantic Kernel?
Semantic Kernel stöder OpenAI, Azure OpenAI och andra anslutningar. Du kan dirigera uppgifter till olika modeller – till exempel mindre modeller för utkast och större modeller för resonemangstunga steg.
F5: Hur gör jag Semantic Kernel-utdata konsekventa (t.ex. JSON)?
Använd strukturerade prompter som kräver strikt JSON och inkludera ett minimalt exempel eller schema. Ställ in låg temperatur, validera utdata efter anrop och försök igen eller reparera när parsningen misslyckas.