Der Semantic Kernel Planner gehört zu den mächtigsten Komponenten im Microsoft-Ökosystem für die Entwicklung von KI-gesteuerten Anwendungen. In diesem Tutorial zeige ich Ihnen, wie Sie den Planner effektiv einsetzen, welche Stolperfallen es gibt und wie Sie mit HolySheep AI bis zu 85% bei den API-Kosten sparen können.

Was ist der Semantic Kernel Planner?

Der Semantic Kernel Planner ist eine Kernkomponente des Microsoft Semantic Kernel SDKs, die es ermöglicht, natürliche Sprachanweisungen in ausführbare Aktionspläne zu zerlegen. Der Planner analysiert Benutzeranfragen, identifiziert relevante Skills und erstellt eine Sequenz von Schritten zur Aufgabenerfüllung.

Architektur und Grundkonzepte

Bevor wir in die Implementierung einsteigen, ist es wichtig, die drei Hauptkomponenten zu verstehen:

Setup und Installation

Zunächst benötigen Sie das Semantic Kernel SDK. Die Installation erfolgt über NuGet:

dotnet add package Microsoft.SemanticKernel --version 1.24.0
dotnet add package Microsoft.SemanticKernel.Planners.Handlebars --version 1.24.0
dotnet add package Microsoft.SemanticKernel.Planners.Stepwise --version 1.24.0
dotnet add package Microsoft.SemanticKernel.Connectors.OpenAI --version 1.24.0

HolySheep AI API-Integration

Für die Nutzung des Semantic Kernel Planners empfehle ich HolySheep AI als API-Provider. Die Plattform bietet nicht nur kompatible Endpoints, sondern auch erhebliche Kostenvorteile:

Vollständige Implementierung mit HolySheep AI

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Plugins.Core;
using Microsoft.SemanticKernel.Planners.Handlebars;
using Microsoft.SemanticKernel.Connectors.OpenAI;

public class SemanticKernelPlannerDemo
{
    private const string HolySheepEndpoint = "https://api.holysheep.ai/v1";
    private const string YourApiKey = "YOUR_HOLYSHEEP_API_KEY";

    public static async Task Main(string[] args)
    {
        // Kernel mit HolySheep AI konfigurieren
        var kernel = Kernel.CreateBuilder()
            .AddOpenAIChatCompletion(
                modelId: "gpt-4.1",
                apiKey: YourApiKey,
                endpoint: new Uri(HolySheepEndpoint))
            .Build();

        // native Skills registrieren
        kernel.ImportPluginFromType<MathPlugin>();
        kernel.ImportPluginFromType<TextPlugin>();

        // Handlebars Planner initialisieren
        var planner = new HandlebarsPlanner(
            new HandlebarsPlannerOptions { MaxTokens = 2000 });

        // Benutzeranfrage analysieren
        var userRequest = "Berechne die Fakultät von 5 und konvertiere das Ergebnis in binär";
        
        var plan = await planner.CreatePlanAsync(kernel, userRequest);
        Console.WriteLine($"Erstellter Plan:\n{plan}");

        // Plan ausführen
        var result = await plan.InvokeAsync(kernel);
        Console.WriteLine($"Ergebnis: {result}");
    }
}

public class MathPlugin
{
    [KernelFunction]
    public int Fakultät(int n)
    {
        if (n <= 1) return 1;
        return n * Fakultät(n - 1);
    }

    [KernelFunction]
    public string DezimalZuBinär(int dezimal)
    {
        return Convert.ToString(dezimal, 2);
    }
}

public class TextPlugin
{
    [KernelFunction]
    public string Großbuchstaben(string text)
    {
        return text.ToUpperInvariant();
    }
}

Stepwise Planner für komplexe Aufgaben

Der Stepwise Planner eignet sich besonders für mehrstufige Problemlösungen, bei denen Zwischenresultate ausgewertet werden müssen:

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Planners.Stepwise;
using Microsoft.SemanticKernel.Connectors.OpenAI;

public class StepwisePlannerExample
{
    public static async Task<string> LöseMehrstufigeAufgabe()
    {
        var kernel = Kernel.CreateBuilder()
            .AddOpenAIChatCompletion(
                modelId: "gpt-4.1",
                apiKey: "YOUR_HOLYSHEEP_API_KEY",
                endpoint: new Uri("https://api.holysheep.ai/v1"))
            .Build();

        kernel.ImportPluginFromType<WebSearchPlugin>();
        kernel.ImportPluginFromType<CalculatorPlugin>();

        var planner = new StepwisePlanner(
            kernel,
            new StepwisePlannerConfig 
            { 
                MaxIterations = 10,
                MaxTokens = 4000
            });

        var problem = 
            "Recherchiere die aktuellen GPU-Preise und berechne, " +
            "wie viel ein Render-Cluster mit 8 RTX 4090 kosten würde.";

        var plan = planner.CreatePlan(problem);
        var result = await plan.InvokeAsync(kernel);
        
        return result.ToString();
    }
}

public class WebSearchPlugin
{
    [KernelFunction]
    public async Task<string> Suche(string query)
    {
        // Implementierung der Websuche
        await Task.Delay(100);
        return $"Ergebnisse für: {query}";
    }
}

public class CalculatorPlugin
{
    [KernelFunction]
    public double Addiere(double a, double b) => a + b;
    
    [KernelFunction]
    public double Multipliziere(double a, double b) => a * b;
}

Praxiserfahrung und Benchmarks

In meinen Tests mit verschiedenen Szenarien habe ich den Semantic Kernel Planner umfassend evaluiert. Hier meine Ergebnisse: