Erste Schritte mit Semantic Kernel: KI-Orchestrierung in C#

· 14 Min. Lesezeit
AI .NET Semantic Kernel Azure
Available in: Deutsch · English · Español · Français · Português · 한국어 · 日本語 · Русский · 中文 · العربية · हिन्दी · Polski · Türkçe · Bahasa Indonesia · Nederlands

Wenn Sie .NET-Anwendungen erstellt und die Entwicklung der KI-Landschaft beobachtet haben, haben Sie sich wahrscheinlich gefragt: Wie kann ich große Sprachmodelle am besten in meine C#-Projekte integrieren, ohne meine Codebasis in Spaghetti zu verwandeln? Das ist genau das Problem, das der Semantic Kernel von Microsoft löst, und nachdem ich das letzte Jahr damit verbracht habe, Produktionsanwendungen damit zu erstellen, kann ich Ihnen sagen, dass es zu einem der wichtigsten Tools in meinem Entwickler-Toolkit geworden ist.

In diesem Beitrag erkläre ich Ihnen alles, was Sie für den Einstieg in Semantic Kernel benötigen – vom Verständnis der Kernkonzepte bis zum Aufbau eines realen KI-Assistenten. Egal, ob Sie gerade erst in die KI-Entwicklung eintauchen oder nach einer strukturierten Möglichkeit suchen, LLM-Aufrufe in Ihren vorhandenen .NET-Anwendungen zu orchestrieren, dieser Leitfaden deckt alles ab.

Was ist ein semantischer Kernel?

Semantic Kernel (SK) ist ein Open-Source-SDK von Microsoft, das als Orchestrierungsschicht zwischen Ihrem Anwendungscode und großen Sprachmodellen wie GPT-4o, Azure OpenAI oder anderen KI-Diensten fungiert. Betrachten Sie es als eine leichtgewichtige Middleware, mit der Sie traditionellen C#-Code mit KI-Funktionen auf saubere, zusammensetzbare Weise kombinieren können.

Aber warum nicht einfach die OpenAI-API direkt aufrufen? Das ist absolut möglich – und für einfache Anwendungsfälle ist das auch in Ordnung. Aber in dem Moment müssen Sie:

  • Lassen Sie die KI basierend auf Benutzereingaben entscheiden, welche Funktionen aufgerufen werden sollen
  • Kombinieren Sie mehrere KI-Aufrufe mit herkömmlichem Code in einer Pipeline
  • Fügen Sie Speicher und Kontext hinzu, damit sich die KI an frühere Interaktionen erinnert
  • Erstellen Sie mehrstufige Agenten, die komplexe Aufgaben bewältigen

…Sie werden feststellen, dass Sie das Rad neu erfinden. Semantic Kernel bietet Ihnen all dies sofort einsatzbereit, mit erstklassiger .NET-Unterstützung, Abhängigkeitsinjektionsintegration und einer Plugin-Architektur, die für jeden C#-Entwickler selbstverständlich ist.

Das Projekt befindet sich auf GitHub im Repository microsoft/semantic-kernel und verfügt über SDKs für C#, Python und Java. Das C#-SDK ist das ausgereifteste und das, auf das wir uns hier konzentrieren werden.

Kernkonzepte

Bevor wir Code schreiben, wollen wir die Bausteine verstehen.

Der Kernel

Das Kernel ist das zentrale Objekt im Semantic Kernel. Es ist der Orchestrator – das, was Ihre KI-Dienste, Plugins und Konfigurationen miteinander verbindet. Sie erstellen eines, registrieren Ihre Dienste und Plugins darauf und verwenden es dann, um Eingabeaufforderungen auszuführen oder Funktionen aufzurufen. Wenn Sie mit der Abhängigkeitsinjektion in ASP.NET Core vertraut sind, wird Ihnen der Kernel sehr vertraut vorkommen – es handelt sich im Wesentlichen um einen Servicecontainer mit KI-Superkräften.

Plugins und Funktionen

Ein Plugin ist eine Sammlung verwandter Funktionen, die der Kernel aufrufen kann. Funktionen gibt es in zwei Varianten:

  • Eingabeaufforderungsfunktionen – definiert als Vorlagen in natürlicher Sprache, die an das LLM gesendet werden
  • Native Funktionen – reguläre C#-Methoden, die mit Attributen versehen sind, die der Kernel erkennen und aufrufen kann

Beispielsweise könnten Sie ein WeatherPlugin mit einer nativen Funktion GetCurrentWeather(string city) und einer Eingabeaufforderungsfunktion haben, die Wetterdaten auf benutzerfreundliche Weise zusammenfasst.### KI-Anschlüsse

Über Konnektoren kommuniziert der semantische Kernel mit KI-Diensten. Die häufigsten sind:

– AzureOpenAIChatCompletion – für Azure OpenAI Service

  • OpenAIChatCompletion – direkt für die OpenAI-API
  • Einbettung von Konnektoren für Vektorsuche und Speicher

Sie registrieren diese beim Start im Kernel und alles andere funktioniert einfach.

Einrichten Ihres Projekts

Machen wir uns die Hände schmutzig. Beginnen Sie mit der Erstellung einer neuen Konsolenanwendung:

dotnet new console -n SemanticKernelDemo
cd SemanticKernelDemo

Fügen Sie nun die Semantic Kernel NuGet-Pakete hinzu:

dotnet add package Microsoft.SemanticKernel
dotnet add package Microsoft.SemanticKernel.Connectors.AzureOpenAI

Wenn Sie OpenAI direkt anstelle von Azure OpenAI verwenden:

dotnet add package Microsoft.SemanticKernel.Connectors.OpenAI

Für Speicher- und Einbettungsunterstützung (wir werden dies später verwenden):

dotnet add package Microsoft.SemanticKernel.Plugins.Memory
dotnet add package Microsoft.Extensions.VectorData.Abstractions

Ihr .csproj sollte auf .NET 8 oder höher ausgerichtet sein. Die neuesten Versionen von Semantic Kernel nutzen alle Vorteile moderner .NET-Funktionen.

Ihr erster Kernel

Beginnen wir mit dem einfachsten möglichen Beispiel – einem Kernel erstellen, ihn mit einem KI-Dienst verbinden und ihm eine Frage stellen.

using Microsoft.SemanticKernel;

// Build the kernel with Azure OpenAI
var builder = Kernel.CreateBuilder();

builder.AddAzureOpenAIChatCompletion(
    deploymentName: "gpt-4o",
    endpoint: "https://your-resource.openai.azure.com/",
    apiKey: "your-api-key"
);

var kernel = builder.Build();

// Invoke a simple prompt
var result = await kernel.InvokePromptAsync(
    "Explain dependency injection in C# in three sentences."
);

Console.WriteLine(result);

Wenn Sie OpenAI direkt verwenden, tauschen Sie die Dienstregistrierung aus:

builder.AddOpenAIChatCompletion(
    modelId: "gpt-4o",
    apiKey: "your-openai-api-key"
);

Das ist es. Wenn Sie es ausführen, erhalten Sie eine kurze Erklärung der Abhängigkeitsinjektion. Aber das kratzt nur an der Oberfläche.

Verwendung von Eingabeaufforderungsvorlagen

Mit Eingabeaufforderungsvorlagen können Sie Ihre Eingabeaufforderungen mit Variablen unter Verwendung der Handlers-Syntax parametrisieren:

var prompt = """
    You are a technical writer. Write a brief summary of {{$topic}} 
    aimed at developers with {{$experienceLevel}} experience.
    Keep it under 200 words.
    """;

var function = kernel.CreateFunctionFromPrompt(prompt);

var arguments = new KernelArguments
{
    ["topic"] = "gRPC in .NET",
    ["experienceLevel"] = "intermediate"
};

var result = await kernel.InvokeAsync(function, arguments);
Console.WriteLine(result);

Hier beginnt Semantic Kernel zu glänzen – Sie können wiederverwendbare Eingabeaufforderungsvorlagen definieren, diese versionieren und in größeren Workflows zusammenstellen.

Plugins und native Funktionen

Mit Plugins schließt Semantic Kernel die Lücke zwischen KI und Ihrem vorhandenen C#-Code. Eine native Funktion ist lediglich eine reguläre Methode, die Sie dem Kernel zur Verfügung stellen.

using Microsoft.SemanticKernel;
using System.ComponentModel;

public class TimePlugin
{
    [KernelFunction("get_current_time")]
    [Description("Gets the current date and time in UTC")]
    public string GetCurrentTime()
    {
        return DateTime.UtcNow.ToString("yyyy-MM-dd HH:mm:ss UTC");
    }

    [KernelFunction("get_time_in_timezone")]
    [Description("Gets the current time in a specific timezone")]
    public string GetTimeInTimezone(
        [Description("The IANA timezone identifier, e.g. 'America/New_York'")] string timezone)
    {
        var tz = TimeZoneInfo.FindSystemTimeZoneById(timezone);
        var time = TimeZoneInfo.ConvertTimeFromUtc(DateTime.UtcNow, tz);
        return time.ToString("yyyy-MM-dd HH:mm:ss");
    }
}

Beachten Sie die Attribute [KernelFunction] und [Description]. Diese sind von entscheidender Bedeutung – die Beschreibungen sind das, was die KI liest, um zu verstehen, wann und wie Ihre Funktionen aufgerufen werden. Gute Beschreibungen machen den Unterschied zwischen einer KI, die Ihre Werkzeuge effektiv nutzt, und einer KI, die verwirrt ist.

Registrieren Sie das Plugin auf Ihrem Kernel:

var builder = Kernel.CreateBuilder();

builder.AddAzureOpenAIChatCompletion(
    deploymentName: "gpt-4o",
    endpoint: "https://your-resource.openai.azure.com/",
    apiKey: "your-api-key"
);

builder.Plugins.AddFromType<TimePlugin>();

var kernel = builder.Build();

Sie können auch komplexere Plugins erstellen, die Dienste einbinden. Da Semantic Kernel in Microsoft.Extensions.DependencyInjection integriert ist, können Ihre Plugins wie jeder andere Dienst Konstruktorabhängigkeiten empfangen:

public class OrderPlugin
{
    private readonly IOrderRepository _repository;

    public OrderPlugin(IOrderRepository repository)
    {
        _repository = repository;
    }

    [KernelFunction("get_order_status")]
    [Description("Retrieves the status of an order by its ID")]
    public async Task<string> GetOrderStatus(
        [Description("The order ID to look up")] string orderId)
    {
        var order = await _repository.GetByIdAsync(orderId);
        return order is null
            ? $"No order found with ID {orderId}"
            : $"Order {orderId}: {order.Status}, placed on {order.CreatedAt:d}";
    }
}

Funktionsaufruf und automatischer Aufruf

Hier wird es richtig interessant. Beim Funktionsaufruf (auch als Tool-Aufruf bezeichnet) lassen Sie das KI-Modell basierend auf dem Konversationskontext entscheiden, welche Ihrer registrierten Funktionen aufgerufen werden sollen. Das Modell führt keinen Code aus – es gibt eine strukturierte Anfrage mit der Meldung „Ich möchte Funktion X mit diesen Argumenten aufrufen“ zurück und der Kernel übernimmt den eigentlichen Aufruf.

So aktivieren Sie den automatischen Funktionsaufruf:

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Connectors.OpenAI;

var builder = Kernel.CreateBuilder();

builder.AddAzureOpenAIChatCompletion(
    deploymentName: "gpt-4o",
    endpoint: "https://your-resource.openai.azure.com/",
    apiKey: "your-api-key"
);

builder.Plugins.AddFromType<TimePlugin>();
builder.Plugins.AddFromType<WeatherPlugin>();

var kernel = builder.Build();

// Enable automatic function calling
var settings = new OpenAIPromptExecutionSettings
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};

var result = await kernel.InvokePromptAsync(
    "What time is it in Tokyo and what's the weather like there?",
    new KernelArguments(settings)
);

Console.WriteLine(result);

Mit FunctionChoiceBehavior.Auto() wird der Kernel:

  1. Senden Sie Ihre Eingabeaufforderung zusammen mit Beschreibungen aller verfügbaren Funktionen an die KI
  2. Die KI entscheidet, dass sie get_time_in_timezone und get_weather aufrufen muss.
  3. Der Kernel führt diese Funktionen automatisch aus
  4. Die Ergebnisse werden an die KI zurückgesendet
  5. Die KI erstellt anhand der Funktionsergebnisse eine Antwort in natürlicher SpracheDiese Schleife kann in einem einzigen Aufruf mehrmals auftreten – die KI ruft möglicherweise mehrere Funktionen nacheinander auf, um alle benötigten Informationen zu sammeln. Sie können auch FunctionChoiceBehavior.Required() verwenden, um die KI zu zwingen, mindestens eine Funktion aufzurufen, oder eine bestimmte Liste von Funktionen bereitzustellen, die sie verwenden darf.

Chat-Abschluss mit Verlauf

Für Konversationsanwendungen sollten Sie ChatCompletionService direkt mit einem ChatHistory-Objekt verwenden:

using Microsoft.SemanticKernel.ChatCompletion;

var chatService = kernel.GetRequiredService<IChatCompletionService>();
var history = new ChatHistory();

history.AddSystemMessage("""
    You are a helpful developer assistant. You have access to tools 
    for checking the time and weather. Be concise and friendly.
    """);

while (true)
{
    Console.Write("You: ");
    var input = Console.ReadLine();
    if (string.IsNullOrWhiteSpace(input)) break;

    history.AddUserMessage(input);

    var response = await chatService.GetChatMessageContentAsync(
        history,
        executionSettings: settings,
        kernel: kernel
    );

    history.AddAssistantMessage(response.Content ?? "");
    Console.WriteLine($"Assistant: {response.Content}");
}

Dadurch erhalten Sie einen vollständig interaktiven Chatbot, der den Gesprächsverlauf verwaltet und Ihre Plugins bei Bedarf aufrufen kann.

Speicher und Einbettungen

Eines der leistungsstärksten Muster in KI-Anwendungen ist Retrieval-Augmented Generation (RAG) – es gibt der KI Zugriff auf Ihre eigenen Daten, indem es diese in den Vektorraum einbettet und relevante Blöcke zum Zeitpunkt der Abfrage abruft.

Semantic Kernel bietet Abstraktionen für die Arbeit mit Vektorspeichern und Einbettungen. So richten Sie einen In-Memory-Vektorspeicher für die Entwicklung ein:

using Microsoft.Extensions.VectorData;
using Microsoft.SemanticKernel.Connectors.AzureOpenAI;
using Microsoft.SemanticKernel.Embeddings;

#pragma warning disable SKEXP0010

// Create an embedding generation service
var builder = Kernel.CreateBuilder();

builder.AddAzureOpenAITextEmbeddingGeneration(
    deploymentName: "text-embedding-ada-002",
    endpoint: "https://your-resource.openai.azure.com/",
    apiKey: "your-api-key"
);

var kernel = builder.Build();
var embeddingService = kernel.GetRequiredService<ITextEmbeddingGenerationService>();

// Generate embeddings for your documents
var documents = new[]
{
    "Semantic Kernel is an open-source SDK for AI orchestration.",
    "Azure OpenAI provides enterprise-grade AI models.",
    "Plugins in SK allow you to expose C# methods to AI models."
};

var embeddings = await embeddingService.GenerateEmbeddingsAsync(documents);

Für Produktionsszenarien würden Sie diese Einbettungen in einer dedizierten Vektordatenbank wie Azure AI Search, Qdrant oder Pinecone speichern. Semantic Kernel verfügt über Konnektoren für all dies über die Microsoft.Extensions.VectorData-Abstraktionen.

Ein typischer RAG-Ablauf sieht so aus:

  1. Ingest: Teilen Sie Ihre Dokumente auf, generieren Sie Einbettungen und speichern Sie sie in einer Vektordatenbank
  2. Abrufen: Wenn ein Benutzer eine Frage stellt, betten Sie die Abfrage ein und finden Sie die ähnlichsten Dokumente
  3. Generieren: Übergeben Sie die abgerufenen Dokumente zusammen mit der Frage des Benutzers als Kontext an das LLM
[KernelFunction("search_knowledge_base")]
[Description("Searches the internal knowledge base for relevant information")]
public async Task<string> SearchKnowledgeBase(
    [Description("The search query")] string query)
{
    var queryEmbedding = await _embeddingService.GenerateEmbeddingAsync(query);

    var results = await _vectorStore.SearchAsync(queryEmbedding, limit: 3);

    return string.Join("\n\n", results.Select(r => r.Text));
}

Indem Sie Ihre RAG-Pipeline als Kernelfunktion verfügbar machen, kann die KI automatisch entscheiden, wann sie Ihre Wissensdatenbank durchsuchen muss – so bleibt die Orchestrierung sauber und das Modell kann das tun, was es am besten kann.

Planer und Agenten

Da Ihre KI-Anwendungen immer komplexer werden, benötigen Sie die KI, um mehrstufige Aufgaben zu planen und auszuführen. Hier kommt das Agent-Framework von Semantic Kernel ins Spiel.

Die Grundlagen: Chat Completion Agent

Der einfachste Agententyp umschließt ein Chat-Abschlussmodell mit Anweisungen und Plugins:

using Microsoft.SemanticKernel.Agents;

#pragma warning disable SKEXP0110

var agent = new ChatCompletionAgent
{
    Name = "DevAssistant",
    Instructions = """
        You are a senior .NET developer assistant. Help users with code 
        reviews, architecture decisions, and debugging. Always provide 
        code examples when relevant. Use your available tools to look up 
        current information when needed.
        """,
    Kernel = kernel,
    Arguments = new KernelArguments(settings)
};

var history = new ChatHistory();

history.AddUserMessage("How should I structure a clean architecture project in .NET 8?");

await foreach (var message in agent.InvokeAsync(history))
{
    Console.WriteLine(message.Content);
    history.Add(message);
}

Zusammenarbeit mehrerer Agenten

Richtig wirkungsvoll wird es, wenn mehrere Agenten zusammenarbeiten. Semantic Kernel unterstützt Gruppenchatmuster, bei denen Agenten mit unterschiedlichen Spezialisierungen zusammenarbeiten:

#pragma warning disable SKEXP0110

var codeReviewer = new ChatCompletionAgent
{
    Name = "CodeReviewer",
    Instructions = """
        You review C# code for bugs, performance issues, and best practices.
        Be specific about what you find and suggest concrete fixes.
        """,
    Kernel = kernel
};

var securityAuditor = new ChatCompletionAgent
{
    Name = "SecurityAuditor",
    Instructions = """
        You focus exclusively on security vulnerabilities in code.
        Look for injection attacks, authentication issues, data exposure,
        and OWASP Top 10 violations.
        """,
    Kernel = kernel
};

var groupChat = new AgentGroupChat(codeReviewer, securityAuditor)
{
    ExecutionSettings = new AgentGroupChatSettings
    {
        TerminationStrategy = new MaximumIterationTerminationStrategy(4)
    }
};

groupChat.AddChatMessage(
    new ChatMessageContent(AuthorRole.User, "Review this code: ...")
);

await foreach (var message in groupChat.InvokeAsync())
{
    Console.WriteLine($"[{message.AuthorName}]: {message.Content}");
}

Dieses Muster ist äußerst nützlich für komplexe Aufgaben, bei denen unterschiedliche Perspektiven oder Fachgebiete berücksichtigt werden müssen. Jeder Agent arbeitet mit seiner eigenen Systemaufforderung und kann über einen eigenen Satz von Plugins verfügen.

Praxisbeispiel: Erstellen eines Projektdokumentationsassistenten

Lassen Sie uns alles mit einem praktischen Beispiel verknüpfen – einem KI-Assistenten, der Entwicklern hilft, eine Codebasis zu verstehen, indem er Dateien liest und Fragen beantwortet.

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
using Microsoft.SemanticKernel.Connectors.OpenAI;
using System.ComponentModel;

// Define our plugins
public class FileSystemPlugin
{
    private readonly string _rootPath;

    public FileSystemPlugin(string rootPath)
    {
        _rootPath = rootPath;
    }

    [KernelFunction("read_file")]
    [Description("Reads the contents of a file from the project directory")]
    public async Task<string> ReadFile(
        [Description("Relative path to the file")] string path)
    {
        var fullPath = Path.Combine(_rootPath, path);

        if (!File.Exists(fullPath))
            return $"File not found: {path}";

        var content = await File.ReadAllTextAsync(fullPath);

        // Truncate very large files
        if (content.Length > 8000)
            content = content[..8000] + "\n... [truncated]";

        return content;
    }

    [KernelFunction("list_files")]
    [Description("Lists files in a directory, optionally filtered by extension")]
    public string ListFiles(
        [Description("Relative directory path")] string directory,
        [Description("File extension filter like '.cs' or '.json'")] string? extension = null)
    {
        var fullPath = Path.Combine(_rootPath, directory);

        if (!Directory.Exists(fullPath))
            return $"Directory not found: {directory}";

        var files = Directory.GetFiles(fullPath, "*.*", SearchOption.AllDirectories)
            .Select(f => Path.GetRelativePath(_rootPath, f))
            .Where(f => extension is null || f.EndsWith(extension))
            .Take(50);

        return string.Join("\n", files);
    }
}

public class DocumentationPlugin
{
    [KernelFunction("generate_summary")]
    [Description("Generates a structured markdown summary for documentation")]
    public string GenerateSummaryTemplate(
        [Description("Name of the component")] string componentName,
        [Description("Brief description")] string description,
        [Description("Key responsibilities as comma-separated values")] string responsibilities)
    {
        var items = responsibilities.Split(',', StringSplitOptions.TrimEntries);
        var bullets = string.Join("\n", items.Select(r => $"- {r}"));

        return $"""
            ## {componentName}

            {description}

            ### Responsibilities
            {bullets}

            ---
            *Generated documentation — review and expand as needed.*
            """;
    }
}

// Wire it all up
var builder = Kernel.CreateBuilder();

builder.AddAzureOpenAIChatCompletion(
    deploymentName: "gpt-4o",
    endpoint: "https://your-resource.openai.azure.com/",
    apiKey: "your-api-key"
);

builder.Plugins.AddFromObject(new FileSystemPlugin("./src"));
builder.Plugins.AddFromType<DocumentationPlugin>();

var kernel = builder.Build();

var chatService = kernel.GetRequiredService<IChatCompletionService>();
var history = new ChatHistory();

history.AddSystemMessage("""
    You are a codebase documentation assistant. You help developers understand 
    projects by reading source files and explaining architecture, patterns, 
    and design decisions. 
    
    When asked about code, use your tools to read the actual files rather 
    than guessing. Be specific and reference actual code when possible.
    Generate documentation artifacts when asked.
    """);

var settings = new OpenAIPromptExecutionSettings
{
    FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};

Console.WriteLine("Documentation Assistant ready. Ask me about your codebase!");
Console.WriteLine("Type 'exit' to quit.\n");

while (true)
{
    Console.Write("You: ");
    var input = Console.ReadLine();

    if (string.IsNullOrWhiteSpace(input) || input.Equals("exit", StringComparison.OrdinalIgnoreCase))
        break;

    history.AddUserMessage(input);

    var response = await chatService.GetChatMessageContentAsync(
        history,
        executionSettings: settings,
        kernel: kernel
    );

    Console.WriteLine($"\nAssistant: {response.Content}\n");
    history.AddAssistantMessage(response.Content ?? "");
}

Dieser Assistent kann:- Dateien auflisten und lesen aus Ihrem Projektverzeichnis

  • Beantworten Sie Fragen zur Codebasis, indem Sie tatsächliche Quelldateien lesen
  • Dokumentation generieren im Markdown-Format
  • Konversationskontext beibehalten, damit Folgefragen natürlich funktionieren

Die KI entscheidet automatisch, wann read_file, list_files oder generate_summary aufgerufen wird, je nachdem, was Sie fragen. Fragen Sie: „Was macht der OrderService?“ und es liest die Datei, analysiert sie und erklärt sie. Bitten Sie es um „Dokumentation für das Authentifizierungsmodul erstellen“ und es durchsucht die Dateien, versteht die Struktur und erstellt eine formatierte Zusammenfassung.

Tipps für die Produktion

Bevor Sie Ihre Semantic-Kernel-Anwendung versenden, habe ich einige Dinge auf die harte Tour gelernt:

Verwenden Sie die Abhängigkeitsinjektion ordnungsgemäß. Registrieren Sie in ASP.NET Core-Apps den Kernel und die Dienste in Ihrem DI-Container, anstatt sie inline zu erstellen:

builder.Services.AddKernel()
    .AddAzureOpenAIChatCompletion(
        deploymentName: "gpt-4o",
        endpoint: configuration["AzureOpenAI:Endpoint"]!,
        apiKey: configuration["AzureOpenAI:ApiKey"]!
    )
    .Plugins.AddFromType<TimePlugin>()
    .AddFromType<OrderPlugin>();

Behandeln Sie Fehler ordnungsgemäß. LLM-Aufrufe können fehlschlagen, eine Zeitüberschreitung verursachen oder unerwartete Ergebnisse zurückgeben. Wickeln Sie Ihre Aufrufe in Try-Catch-Blöcke ein und implementieren Sie Wiederholungsrichtlinien mit Polly oder den integrierten Resilienzfunktionen.

Token-Nutzung überwachen. Jede Eingabeaufforderung, jede Funktionsbeschreibung und jeder Teil des Chat-Verlaufs verbraucht Token. Verwenden Sie Filter, um die Nutzung zu protokollieren und zu verfolgen:

kernel.FunctionInvocationFilters.Add(new LoggingFilter());

Halten Sie Ihre Funktionsbeschreibungen präzise. Vage Beschreibungen führen dazu, dass die KI Funktionen falsch aufruft. Testen Sie Ihre Beschreibungen, indem Sie fragen: „Wenn ich nur die Beschreibung lesen würde, wüsste ich dann genau, wann und wie ich diese Funktion verwende?“

Fazit

Semantic Kernel ist eine dieser Bibliotheken, die Ihre Einstellung zum Erstellen von Anwendungen grundlegend verändert. Es handelt sich nicht nur um einen API-Wrapper, sondern um ein Orchestrierungs-Framework, mit dem Sie KI-Funktionen mit herkömmlichem Code auf eine wartbare, testbare und produktionsbereite Weise zusammenstellen können.

Was mir am meisten daran gefällt, ist, dass es das .NET-Ökosystem respektiert. Es verwendet Muster, die Sie bereits kennen – Abhängigkeitsinjektion, Attribute, Async/Await, Schnittstellen – und erweitert sie auf die KI-Welt. Sie müssen kein völlig neues Paradigma erlernen; Sie fügen einfach KI als weitere Fähigkeit zu Ihrem Toolkit hinzu.

Wenn Sie .NET-Anwendungen erstellen und Semantic Kernel noch nicht kennengelernt haben, ist jetzt der richtige Zeitpunkt dafür. Das SDK ist stabil, die Community ist aktiv und die Muster, die es ermöglicht – von einfacher prompter Orchestrierung bis hin zur Zusammenarbeit mit mehreren Agenten – werden für moderne Entwickler zu unverzichtbaren Fähigkeiten.

Fangen Sie klein an. Erstellen Sie einen Kernel, registrieren Sie ein Plugin und beobachten Sie, wie die KI Ihren Code aufruft. Sobald das Klick macht, werden Sie Möglichkeiten sehen, überall in Ihren Anwendungen Intelligenz hinzuzufügen.

Die offizielle Dokumentation und das GitHub-Repository sind hervorragende Ressourcen, um Ihre Reise fortzusetzen. Viel Spaß beim Bauen!