Semantic Kernel & Azure AI Semantic Kernel & Azure AI

Tiefenreferenz für Kernel-Architektur, Plugins, Connectoren, Memory, Agents, Planner, Prompt Engineering, Azure OpenAI, Azure AI Services und Responsible AI. Deep reference for kernel architecture, plugins, connectors, memory, agents, planners, prompt engineering, Azure OpenAI, Azure AI Services, and responsible AI.

Semantic-Kernel-Architektur: Kernel, Plugins, Memory und Filter Semantic Kernel architecture: kernel, plugins, memory, and filters

Semantic Kernel strukturiert LLM-Anwendungen entlang klarer Bausteine: der Kernel verwaltet Dienste, Plugins kapseln Fähigkeiten, Memory liefert Kontext, und Filter erzwingen Governance an Ein- und Ausgängen. Semantic Kernel structures LLM applications around clear building blocks: the kernel manages services, plugins encapsulate capabilities, memory provides context, and filters enforce governance at inputs and outputs.

Diese Trennung ist essenziell für Enterprise-Anwendungen, weil sich Modelle, Prompts, Wissensspeicher und Sicherheitskontrollen unabhängig voneinander weiterentwickeln können. That separation is essential for enterprise applications because models, prompts, knowledge stores, and security controls can evolve independently.

• Kernel-Instanzen pro Request oder pro Session bewusst planen. Deliberately plan kernel instances per request or per session.
• Function- und Prompt-Filter für Audit und Guardrails zentralisieren. Centralize function and prompt filters for audit and guardrails.
• Memory nicht als Datenhalde nutzen; nur autoritativen Kontext einspeisen. Do not use memory as a data dump; feed only authoritative context.
• Modellwechsel entkoppeln, indem Connectors und Prompting sauber abstrahiert werden. Decouple model changes by abstracting connectors and prompting cleanly.

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Connectors.AzureOpenAI;

var builder = Kernel.CreateBuilder();
builder.AddAzureOpenAIChatCompletion(
    deploymentName: "gpt-4o-prod",
    endpoint: "https://aoai-contoso.openai.azure.com/",
    apiKey: Environment.GetEnvironmentVariable("AZURE_OPENAI_API_KEY")!);

Kernel kernel = builder.Build();
    

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion

kernel = Kernel()
kernel.add_service(
    AzureChatCompletion(
        deployment_name="gpt-4o-prod",
        endpoint="https://aoai-contoso.openai.azure.com/",
        api_key="<key>",
    )
)
    

Plugins: Native Functions, Prompt Functions und OpenAPI Plugins: native functions, prompt functions, and OpenAPI

Plugins sind die Domänenschnittstelle des Kernels. Native Functions kapseln Code, Prompt Functions kapseln wiederverwendbare Anweisungen, und OpenAPI-Importe öffnen bestehende APIs für Tool-Nutzung. Plugins are the domain interface of the kernel. Native functions encapsulate code, prompt functions encapsulate reusable instructions, and OpenAPI imports expose existing APIs for tool use.

Die wichtigste Qualitätsregel lautet: Kleine, klar benannte Funktionen mit eindeutigen Eingaben, deterministischem Verhalten und verständlichen Beschreibungen schlagen große generische Mega-Plugins. The most important quality rule is: small, clearly named functions with explicit inputs, deterministic behavior, and understandable descriptions beat large generic mega-plugins.

• Funktionsnamen verbenbasiert und fachlich verständlich wählen. Choose verb-based function names that are understandable to the business.
• Jede schreibende Funktion mit Validierung und Autorisierungsprüfung schützen. Protect every write function with validation and authorization checks.
• OpenAPI-Spezifikationen vor Import entschlacken. Trim OpenAPI specifications before import.
• Prompt Functions als austauschbare Bausteine statt als ganze Applikation behandeln. Treat prompt functions as replaceable building blocks, not the whole application.

using Microsoft.SemanticKernel;

public class TimePlugin
{
    [KernelFunction]
    public string GetUtcNow() => DateTime.UtcNow.ToString("O");
}

kernel.ImportPluginFromObject(new TimePlugin(), "time");
    

prompt = """
You summarize incidents for operations teams.
Input: {{$incident}}
Return: 3 bullet points and one recommended action.
"""

kernel.add_function(
    plugin_name="ops",
    function_name="summarize_incident",
    prompt=prompt,
)
    

AI-Connectoren: Azure OpenAI, OpenAI, Ollama und Gemini AI connectors: Azure OpenAI, OpenAI, Ollama, and Gemini

Semantic Kernel abstrahiert die Modellanbindung, sodass Teams je nach Datenschutz, Kosten, Latenz und Funktionsumfang zwischen mehreren Providern wechseln können. Semantic Kernel abstracts model connectivity so teams can switch between providers based on privacy, cost, latency, and feature coverage.

Trotz dieser Abstraktion bleiben Modellprofile unterschiedlich: Azure OpenAI liefert Enterprise-Governance, OpenAI deckt viele Features früh ab, Ollama erlaubt lokale Läufe, und Gemini kann für multimodale oder alternative Workflows interessant sein. Despite that abstraction, model profiles differ: Azure OpenAI delivers enterprise governance, OpenAI often exposes features early, Ollama enables local runs, and Gemini may be attractive for multimodal or alternative workflows.

• Providerwechsel nur über zentrale Konfiguration und nicht über verstreute Prompts steuern. Control provider switching through central configuration, not scattered prompts.
• Modelle je Anwendungsfall testen: Klassifikation, Tool-Calling, RAG, Reasoning. Test models per workload: classification, tool calling, RAG, reasoning.
• Lokale Modelle in derselben Evaluationspipeline wie Cloudmodelle messen. Measure local models in the same evaluation pipeline as cloud models.
• Telemetry pro Connector und Deployment erfassen. Capture telemetry per connector and deployment.

using Microsoft.SemanticKernel.Connectors.OpenAI;

builder.AddOpenAIChatCompletion(
    modelId: "gpt-4.1",
    apiKey: Environment.GetEnvironmentVariable("OPENAI_API_KEY")!);
    

from semantic_kernel.connectors.ai.ollama import OllamaChatCompletion

kernel.add_service(
    OllamaChatCompletion(
        service_id="local",
        host="http://localhost:11434",
        ai_model_id="llama3.1"
    )
)
    

Memory, Vector Stores, Agents und Planner Memory, vector stores, agents, and planners

Memory in Semantic Kernel sollte als Retrieval-Schicht verstanden werden, nicht als magischer Langzeitspeicher. Relevanz entsteht durch sauberes Chunking, Metadaten, Filterbarkeit und eindeutige Herkunft. Memory in Semantic Kernel should be understood as a retrieval layer, not a magical long-term memory. Relevance comes from clean chunking, metadata, filterability, and clear provenance.

Agents bündeln Ziel, Anweisungen, Tools und Verlauf. Planner entstehen heute oft aus Function Calling oder Handlebars-gesteuerten Schritten statt aus einer separaten magischen Komponente. Agents bundle goal, instructions, tools, and history. Planners today often emerge from function calling or Handlebars-driven steps rather than a separate magical component.

• Metadaten wie Quelle, Sprache, Sensitivität und Gültigkeit konsequent speichern. Persist metadata such as source, language, sensitivity, and validity consistently.
• Multi-Agent-Systeme mit Telemetrie pro Rolle instrumentieren. Instrument multi-agent systems with per-role telemetry.
• Plan-Ausgaben validieren, bevor Folgeaktionen freigegeben werden. Validate plan outputs before releasing follow-up actions.
• RAG ohne Zitate und Herkunftstracking nicht produktiv setzen. Do not put RAG into production without citations and provenance tracking.

using Microsoft.SemanticKernel.Memory;

var memory = new VolatileMemoryStore();
await memory.UpsertAsync(
    collectionName: "kb",
    record: MemoryRecord.LocalRecord(
        id: "doc-001",
        text: "Azure AI Search supports semantic, vector, and hybrid search.",
        description: "AI Search note",
        additionalMetadata: "source=architecture-guide"));
    

from semantic_kernel.memory.volatile_memory_store import VolatileMemoryStore

memory = VolatileMemoryStore()
await memory.upsert(
    collection_name="kb",
    record={
        "id": "doc-001",
        "text": "Qdrant is useful for containerized vector search workloads.",
        "description": "vector note"
    }
)
    

using Microsoft.SemanticKernel.Agents;

var agent = new ChatCompletionAgent
{
    Name = "support-analyst",
    Instructions = "Review incidents, call tools only when needed, and cite retrieved facts."
};
    

from semantic_kernel.agents import ChatCompletionAgent

agent = ChatCompletionAgent(
    service_id="default",
    name="risk-reviewer",
    instructions="Review proposed actions, flag policy violations, and request approval if needed."
)
    

Prompt Engineering, Azure OpenAI Service und Azure AI Services Prompt engineering, Azure OpenAI Service, and Azure AI Services

Prompt Engineering in Semantic Kernel sollte wiederholbar und versionierbar sein. Templates beschreiben Rollen, Variablen liefern Kontext, Few-Shot-Beispiele stabilisieren das Ausgabeformat und Grounding begrenzt Halluzinationen. Prompt engineering in Semantic Kernel should be repeatable and versionable. Templates describe roles, variables provide context, few-shot examples stabilize output format, and grounding limits hallucinations.

Azure OpenAI ergänzt diese Ebene mit Modell-Deployments, Content Filtering, PTU, Fine-Tuning und Embeddings. Azure AI Search, Vision, Language, Speech und Document Intelligence liefern die Fachsignale für RAG, multimodale und sprachbasierte Szenarien. Azure OpenAI complements that layer with model deployments, content filtering, PTU, fine-tuning, and embeddings. Azure AI Search, Vision, Language, Speech, and Document Intelligence provide the domain signals for RAG, multimodal, and speech-driven scenarios.

• Modelle pro Fähigkeit statt per Marketingname evaluieren. Evaluate models by capability, not marketing name alone.
• Deployments, Filter und PTU-Entscheidungen als Plattformprodukt behandeln. Treat deployments, filters, and PTU choices as a platform product.
• Grounding-Fehler gesondert von Modellfehlern messen. Measure grounding failures separately from model failures.
• Output-Formate streng validieren, bevor Automatisierung folgt. Strictly validate output formats before automation follows.

string template = """
You are an enterprise assistant.
Question: {{$question}}
Context: {{$context}}
Return JSON with fields answer, citations, confidence.
""";

var result = await kernel.InvokePromptAsync(template, new() {
    ["question"] = "How do I enable hybrid search?",
    ["context"] = "Azure AI Search supports vector, semantic, and hybrid retrieval."
});
    

template = """
You are a procurement copilot.
User request: {{$request}}
Approved vendors: {{$vendors}}
Return YAML with recommendation and justification.
"""

result = await kernel.invoke_prompt(
    prompt=template,
    arguments={
        "request": "Need a speech-to-text service for German meetings.",
        "vendors": "Azure AI Speech, Contoso Voice Archive"
    }
)
    

Responsible AI: Content Safety, Prompt Shields und Groundedness Responsible AI: content safety, prompt shields, and groundedness

Responsible AI ist kein nachgelagerter Freigabeschritt, sondern Teil der Laufzeitarchitektur. Sicherheitsfilter, Prompt Shields, Groundedness-Prüfungen, Evaluationssuiten und Human-in-the-Loop müssen zusammenwirken. Responsible AI is not a downstream approval step, but part of runtime architecture. Safety filters, prompt shields, groundedness checks, evaluation suites, and human-in-the-loop controls need to work together.

Gerade Agentensysteme mit Tool-Zugriff benötigen zusätzliche Kontrollen: Welche Prompts werden übernommen, welche Daten dürfen das Modell sehen, welche Aktionen dürfen ohne Bestätigung laufen und wie wird Missbrauch erkannt. Especially agent systems with tool access need additional controls: which prompts are accepted, which data the model may see, which actions may run without confirmation, and how abuse is detected.

• Keine Tool-Ausführung ohne klare Autorisierung, Schema und Ergebnisprüfung. Do not execute tools without clear authorization, schema, and result validation.
• Groundedness und Content Safety als eigene KPIs etablieren. Establish groundedness and content safety as separate KPIs.
• Prompt-Injection-Tests in CI/CD und Abnahmeprozesse aufnehmen. Include prompt injection tests in CI/CD and release sign-off.
• Fallback-Antworten definieren, wenn Unsicherheit, Safety oder Toolfehler auftreten. Define fallback responses for uncertainty, safety, or tool failures.

var ragPrompt = """
Answer only from the supplied passages.
Question: {{$question}}
Passages: {{$passages}}
Return citations with each claim.
""";
    

embeddings_model = {
    "deployment": "text-embedding-3-large",
    "usage": "semantic and vector retrieval for multilingual knowledge bases"
}