Sådan bruges Semantic Kernel: En praktisk guide med mønstre, prompter og plugins
Har du nogensinde prøvet at koble en LLM til din app og endt med et skrøbeligt virvar af prompter, hjælpefunktioner og tilstand? Semantic Kernel (SK) er skabt til at løse netop det. Det er et letvægts, open-source orkestreringsframework fra Microsoft til at bygge AI-første apps, der blander naturligt sprog, værktøjer og hukommelse – uden at forvandle din kodebase til en prompt-spaghetti-ret.
I denne guide vil vi tage en praktisk, løsningsorienteret tur i, hvordan man bruger Semantic Kernel fra bunden til produktionsmønstre. Du lærer, hvordan du strukturerer prompter, tilslutter værktøjer, tilføjer hukommelse, kalder flere modeller og implementerer agenter, der handler konsekvent. Vi holder eksemplerne jordnære og viser dig, hvad der betyder noget.
Hvad er Semantic Kernel – og hvorfor bruge det?
Semantic Kernel er et SDK, der hjælper dig med at:
- Sammensætte prompter og funktioner ("skills"/plugins) i pipelines.
- Kalde flere modeller (OpenAI, Azure OpenAI, lokale modeller) udskifteligt.
- Tilføje hukommelse for kontekst og langsigtet genkaldelse via embeddings.
- Planlægge og orkestrere flertrinsopgaver med pålidelig tilstand.
- Integrere værktøjer (API'er, databaser, fil I/O) sikkert og deterministisk.
Tænk på SK som den controller, der koordinerer LLM'er, din app-logik og brugerdata. I stedet for at hårdkode lange prompter og ad hoc-værktøjskald definerer du genanvendelige semantiske funktioner og native funktioner med klare input/output.
Almindelige use cases:
- Kundesupport-copiloter med retrieval-augmented generation (RAG)
- Workflow-agenter (opsummer → klassificer → tag handling)
- Dokument Q&A med hukommelse og citater
- Kreative indholds- og kodegenereringspipelines
Hurtig start: Din første Semantic Kernel-app
Nedenfor er et minimalt flow for at vise, hvordan man bruger Semantic Kernel med en chatmodel og en simpel prompt. Vi bruger C# for klarhedens skyld; du kan gøre det samme i Python eller Java.
1) Installer pakker
# .NET
dotnet add package Microsoft.SemanticKernel
# Valgfrit: connectors og planners varierer efter version
2) Konfigurer kernen og modellen
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Connectors.OpenAI;
var builder = Kernel.CreateBuilder;
// Vælg din udbyder: OpenAI eller Azure OpenAI
builder.AddOpenAIChatCompletion(
modelId: "gpt-4o-mini", // eller din foretrukne model
apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")
);
var kernel = builder.Build;
3) Definer en semantisk funktion (prompt)
using Microsoft.SemanticKernel.SemanticFunctions;
var prompt = @"Du er en præcis forklarer.
Forklar konceptet '{topic}' i 3 punkter for en begynder.";
var explainFunc = kernel.CreateFunctionFromPrompt(prompt);
var result = await explainFunc.InvokeAsync(kernel, new { ["topic"] = "vector embeddings" });
Console.WriteLine(result);
Dette er kernen: en kernel, en model og en prompt, der er omdannet til en genanvendelig funktion med input.
Semantiske funktioner vs. Native funktioner
- Semantiske funktioner: Prompt-drevet. Du opretter dem fra skabeloner, sender variabler og får tekst eller strukturerede output.
- Native funktioner: Almindelige kodefunktioner, som SK eksponerer for LLM'en til værktøjsbrug.
Eksempel på en native funktion, der henter vejret fra din API og eksponerer det for modellen:
public class WeatherPlugin
{
[KernelFunction, Description("Get weather for a city")]
public async Task<string> GetWeatherAsync(
[Description("City name")] string city)
{
// Kald din vejr-API her
var temp = 22; // placeholder
return $"Weather in {city}: {temp}°C and clear";
}
}
// Registrer plugin
var weather = new WeatherPlugin;
kernel.Plugins.AddFromObject(weather, pluginName: "weather");
Nu kan dine prompter kalde weather.GetWeatherAsync som et værktøj, hvilket giver modellen mulighed for at basere svar på reelle data.
Prompt-mønstre, der faktisk virker
Når du lærer at bruge Semantic Kernel, kommer de hurtigste gevinster fra disciplinerede prompt-mønstre:
- System-first: Brug en stærk systembesked til at låse tone, persona, sikkerhed og outputformat.
- Variable slots: Navngiv pladsholdere tydeligt (f.eks.
{topic}, {audience}) og valider input.
- Output contracts: Bed om strukturerede formater som JSON; inkluder et skema i prompten.
- Few-shot: Giv præcise eksempler på stil og format, ikke indholds-bloat.
- Guardrails: Inkluder begrænsninger (“Hvis data mangler, stil først et afklarende spørgsmål”).
Eksempel på en struktureret prompt inde i SK:
var prompt = @"
Du er en klassifikationsmotor.
Opgave: Klassificer `message` i en af [Billing, Tech Support, Sales].
Returner streng JSON: { \"label\": string, \"confidence\": number }
message: {message}
";
var classify = kernel.CreateFunctionFromPrompt(prompt);
var output = await classify.InvokeAsync(kernel, new { ["message"] = "Jeg kan ikke logge ind på min konto." });
Console.WriteLine(output); // {"label":"Tech Support","confidence":0.89}
Tilføjelse af hukommelse: Embeddings, RAG og kontekstvinduer
LLM'er glemmer. Hukommelse gør dem nyttige.
- Kortvarig kontekst: Automatisk via samtalens historik.
- Langtidshukommelse: Gem embeddings af brugernotater, dokumenter eller begivenheder, og hent relevante bidder for kontekst.
- RAG: Før du kalder en genereringsfunktion, skal du forespørge din vektorlager og injicere resultater i prompten.
Eksempel: tilføj teksthukommelse med embeddings og hent kontekst.
using Microsoft.SemanticKernel.Memory;
var memory = new MemoryBuilder
.WithMemoryStore(new VolatileMemoryStore) // byt ud med 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 anmode om en refusion inden for 30 dage efter købet med bevis for kvittering."
);
// Senere: hent og stop ind i prompten
var results = memory.SearchAsync("refund window", collection: "policies", limit: 3, minRelevanceScore: 0.7);
await foreach (var item in results)
{
Console.WriteLine($"Relevant: {item.Metadata.Text}");
}
Fød derefter de bedste matches ind i din semantiske funktion som kontekstvariabler. Tip: hold bidderne små (200-400 tokens) og dedupliker.
Værktøjsbrug og planlægning: Flertrins-workflows
Semantic Kernel understøtter planners, der kan opdele et brugermål i trin og vælge, hvilke funktioner der skal kaldes. Dette er perfekt, når du har en værktøjskasse med native og semantiske funktioner.
Mønster:
- Indsaml mål og begrænsninger fra brugeren.
- Udarbejd en plan (sekvens af funktionskald med argumenter).
- Udfør trin for trin, bekræft output og gendan fra fejl.
Pseudokode-eksempel:
// 1) Definer plugins (semantiske + native) som før
// 2) Brug en planner (API-overfladen kan variere efter version)
var goal = "Opsummer den vedhæftede politik, klassificer risiko og e-mail en rapport";
// Antag, at vi har plugins: files, summarize, classify, email
// Planner vil samle en plan: files.Load → summarize.Run → classify.Run → email.Send
// Udfør planen sekventielt, valider JSON-outputs mellem trin
Best practices:
- Gør trinene idempotente og testbare.
- Indstil eksplicitte outputskemaer mellem trin.
- Brug retries/backoff på netværksværktøjer.
- Log input/output for observerbarhed (men scrub PII).
Multi-Model Strategy: Vælg den rigtige model til jobbet
Ved hjælp af Semantic Kernel kan du dirigere opgaver til forskellige modeller:
- Hurtige udkast → små, billige modeller
- Ræsonnements-tunge trin → større modeller
- Embeddings → specialiseret embedding-model
- Kode → kodeoptimerede modeller
I praksis:
var kernel = Kernel.CreateBuilder
.AddOpenAIChatCompletion("gpt-4o-mini", apiKey)
.Build;
var fastKernel = Kernel.CreateBuilder
.AddOpenAIChatCompletion("gpt-4o-mini", apiKey) // speed-optimized
.Build;
// Diriger simplere prompter til fastKernel; komplekse opgaver til kernel
Eller konfigurer flere tjenester i den samme kernel og vælg pr. funktion.
Fra prototype til produktion: Guardrails og test
Efterhånden som du lærer at bruge Semantic Kernel i virkelige apps, betyder pålidelighed noget:
- Skema-første outputs: Brug JSON-skemaer og
TryParse-gates.
- Determinisme når det er nødvendigt: Indstil temperaturen lavt og begræns output.
- Sikkerhedsfiltre: Tilføj indholdsfiltre og red-team prompter.
- Caching: Cache RAG-resultater og stabile generationer.
- Observerbarhed: Log prompt-skabeloner, variabler, latency, token-brug.
- Enhedstests: Golden test-prompter med snapshot-sammenligninger.
Eksempel: valider JSON-output.
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; }
}
Real-World Patterns You Can Reuse
- RAG Chatbot:
retrieve(context) → answer(question, context) med citater.
- Godkendelsesworkflows: klassificer → generer udkast → menneskelig gennemgang → send.
- Indholdsoperationer: disposition → udkast → faktatjek → tonejustering → publicer.
- Agent med værktøjer: calendar.lookup, docs.search, email.send; med planlægning og hukommelse.
Tip: Indkapsl hvert trin som en funktion (semantisk eller native) og sammensæt dem i pipelines.
Eksempel: Dokument Q&A med citater
Lad os koble en simpel Q&A-pipeline, der citerer kilder ved hjælp af RAG.
// 1) Indtag dokumenter i hukommelsen
await memory.SaveInformationAsync("handbook", "vacation-policy",
"Medarbejdere optjener 1,5 dages PTO pr. måned og kan overføre 5 dage.");
// 2) Hent kontekst for et spørgsmål
var top = memory.SearchAsync("carry over PTO", "handbook", limit: 3, minRelevanceScore: 0.75);
var contexts = new List<string>;
await foreach (var r in top) contexts.Add(r.Metadata.Text);
// 3) Spørg med kontekst og anmod om citater
var qaPrompt = @"
Du svarer udelukkende fra den angivne kontekst. Hvis den mangler, skal du sige, at du ikke ved det.
Inkluder inline-citater som [kilde i] ved hjælp af indekset for kontekstelementer, der starter ved 1.
Kontekst:
1) {{ctx1}}
2) {{ctx2}}
Spørgsmål: {{q}}
";
var qa = kernel.CreateFunctionFromPrompt(qaPrompt);
var variables = new KernelArguments
{
["ctx1"] = contexts.ElementAtOrDefault(0) ?? "",
["ctx2"] = contexts.ElementAtOrDefault(1) ?? "",
["q"] = "Hvor mange PTO-dage kan jeg overføre?"</a27>};
var answer = await qa.InvokeAsync(kernel, variables);
Console.WriteLine(answer);
Almindelige faldgruber (og hvordan man undgår dem)
- Enkelt kæmpe prompt: Opdel i funktioner; send kun den kontekst, du har brug for.
- Ingen outputkontrakter: Definer altid skemaer for maskinlæsbare trin.
- RAG uden hygiejne: Opdel godt, dedupliker og ranger efter relevans og aktualitet.
- Værktøjsspredning: Hold plugin-interfaces små og dokumenterede.
- Intet menneske-i-løkken: Tilføj godkendelser for handlinger med høj risiko.
Sådan bruges Semantic Kernel med frontends
- Webapps: Host din SK-orkestrering i et API-lag; stream tokens til UI'en.
- Chat UIs: Vedligehold samtalens tilstand på serversiden; beskær og opsummer.
- Auth: Impersoneringssikre kald – lad aldrig modellen udstede tokens. Gate-værktøjskald via din backend.
Implementerings-tjekliste
- Miljøvariabler for nøgler og endpoints
- Hastighedsbegrænsning og retries for model-/værktøjskald
- Prompt-skabelon kildekontrol
- Vektorlager-backups og PII-håndtering
- Observerbarheds-dashboards (latency, omkostninger, fejl)
- A/B-test for prompter og routing
Fejlfinding i FAQ-stil
- “Modellen hallucinerer selv med RAG.” Stram instruktionerne: "Svar kun fra kontekst", og inkluder et afvisningseksempel. Øg hentningsspecificiteten og reducer temperaturen.
- “JSON bliver ved med at gå i stykker.” Tilføj et mini-eksempel på gyldig JSON og forbyd kommentarer. Eftervalider og omformuler ved fejl.
- “Latency er høj.” Hent færre, mere relevante bidder; skift simple trin til mindre modeller; paralleliser uafhængige trin.
- “Omkostningerne stiger.” Cache, komprimer kontekst og diriger nemme opgaver til billigere modeller.
Værd at bemærke: Byg hurtigere med Sider.AI
Hvis du laver prototyper af prompter, tester værktøjsflows eller sammenligner svar på tværs af modeller, kan en ledsager som Sider.ai fremskynde iterationen. Du kan udarbejde prompter, køre A/B-sammenligninger og fange genanvendelige snippets, før du flytter dem ind i Semantic Kernel-skabeloner – fantastisk til at skærpe instruktioner og outputskemaer. Næste trin: Gør dette til en fungerende agent
- Start med en klar opgave (f.eks. klassificer support-e-mails).
- Definer semantiske/native funktioner med strenge input/output.
- Tilføj kun hukommelse, hvor det målbart forbedrer svarene.
- Instrumenter alt; test med virkelige eksempler.
- Iterer på prompter ved hjælp af en sandbox, og kodificer derefter i SK.
Vigtigste takeaways:
- Semantic Kernel hjælper dig med at sammensætte prompter, værktøjer og hukommelse til pålidelige workflows.
- Brug outputskemaer, planners og multi-model routing for robusthed og omkostningskontrol.
- RAG plus guardrails slår kæmpe prompter hver gang.
Når du mestrer, hvordan du bruger Semantic Kernel med disse mønstre, vil du levere AI-funktioner, der ikke kun er imponerende demoer – men pålidelige systemer.
FAQ
Q1:Hvad bruges Semantic Kernel til i AI-apps?
Semantic Kernel er et orkestrerings-SDK til opbygning af AI-workflows, der kombinerer LLM-prompter, værktøjer (native funktioner) og hukommelse. Det hjælper dig med at strukturere opgaver, tilføje RAG og kalde flere modeller pålideligt.
Q2:Hvordan bruger jeg Semantic Kernel til RAG med mine dokumenter?
Indtag dine dokumenter i en vektorlager via SK's hukommelses-API'er, og hent derefter de mest relevante bidder pr. forespørgsel og injicer dem i din prompt. Dette forbedrer nøjagtigheden og reducerer hallucinationer.
Q3:Kan Semantic Kernel kalde eksterne API'er og tjenester?
Ja. Pak API'er som native funktioner i et plugin, og registrer dem med kernen, så modellen kan bruge dem som værktøjer. Hold interfaces små og håndhæv input/output-validering.
Q4:Hvilke modeller fungerer med Semantic Kernel?
Semantic Kernel understøtter OpenAI, Azure OpenAI og andre connectors. Du kan dirigere opgaver til forskellige modeller – for eksempel mindre modeller til udkast og større modeller til ræsonnements-intensive trin.
Q5:Hvordan gør jeg Semantic Kernel-outputs konsistente (f.eks. JSON)?
Brug strukturerede prompter, der kræver streng JSON, og inkluder et minimalt eksempel eller skema. Indstil lav temperatur, valider outputs efter kald, og prøv igen eller reparer, når parsing mislykkes.