Grundlegendes zum Kernel

2025-04-21

Der Kernel ist die zentrale Komponente des semantischen Kernels. Am einfachsten ist der Kernel ein Dependency Injection-Container, der alle Dienste und Plug-Ins verwaltet, die zum Ausführen Ihrer KI-Anwendung erforderlich sind. Wenn Sie alle Ihre Dienste und Plug-Ins für den Kernel bereitstellen, werden sie von der KI bei Bedarf nahtlos verwendet.

Der Kernel befindet sich in der Mitte

Da der Kernel über alle Dienste und Plug-Ins verfügt, die zum Ausführen von systemeigenem Code und AI-Diensten erforderlich sind, wird er von fast jeder Komponente im Semantic Kernel SDK verwendet, um Ihre Agents zu aktivieren. Dies bedeutet, dass der Kernel immer verfügbar ist, wenn Sie eine Eingabeaufforderung oder Code im semantischen Kernel ausführen, um die erforderlichen Dienste und Plug-Ins abzurufen.

Der Kernel befindet sich im Mittelpunkt aller Elemente im semantischen Kernel.

Dies ist äußerst leistungsfähig, da es bedeutet, dass Sie als Entwickler einen einzigen Ort haben, an dem Sie Ihre KI-Agents konfigurieren und am wichtigsten überwachen können. Nehmen Sie beispielsweise an, wenn Sie eine Eingabeaufforderung aus dem Kernel aufrufen. Wenn Sie dies tun, wird der Kernel...

Wählen Sie den besten KI-Dienst aus, um die Eingabeaufforderung auszuführen.
Erstellen Sie die Eingabeaufforderung mithilfe der bereitgestellten Eingabeaufforderungsvorlage.
Senden Sie die Aufforderung an den KI-Dienst.
Empfangen und analysieren Sie die Antwort.
Und geben Sie schließlich die Antwort der LLM an Ihre Anwendung zurück.

Während dieses gesamten Prozesses können Sie Ereignisse und Middleware erstellen, die bei jedem dieser Schritte ausgelöst werden. Dies bedeutet, dass Sie Aktionen wie Protokollierung ausführen, Statusaktualisierungen für Benutzer bereitstellen und vor allem verantwortungsvolle KI bereitstellen können. Alles von einem einzigen Ort aus.

Erstellen eines Kernels mit Diensten und Plug-Ins

Bevor Sie einen Kernel erstellen, sollten Sie zunächst die beiden Typen von Komponenten verstehen, die vorhanden sind:

Komponente	Beschreibung
Services	Diese bestehen aus KI-Diensten (z. B. Chatabschluss) und anderen Diensten (z. B. Protokollierung und HTTP-Clients), die zum Ausführen Ihrer Anwendung erforderlich sind. Dies wurde nach dem Dienstanbietermuster in .NET modelliert, sodass die Abhängigkeitsinjektion in allen Sprachen unterstützt werden konnte.
Plug-Ins	Dies sind die Komponenten, die von Ihren KI-Diensten und Aufforderungsvorlagen zum Ausführen von Arbeiten verwendet werden. KI-Dienste können z. B. Plug-Ins verwenden, um Daten aus einer Datenbank abzurufen oder eine externe API aufzurufen, um Aktionen auszuführen.

Um mit dem Erstellen eines Kernels zu beginnen, importieren Sie die erforderlichen Pakete am Anfang der Datei:

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Plugins.Core;

Als Nächstes können Sie Dienste und Plug-Ins hinzufügen. Nachfolgend finden Sie ein Beispiel dafür, wie Sie einen Azure OpenAI-Chatabschluss, einen Logger und ein Zeit-Plug-In hinzufügen können.

// Create a kernel with a logger and Azure OpenAI chat completion service
var builder = Kernel.CreateBuilder();
builder.AddAzureOpenAIChatCompletion(modelId, endpoint, apiKey);
builder.Services.AddLogging(c => c.AddDebug().SetMinimumLevel(LogLevel.Trace));
builder.Plugins.AddFromType<TimePlugin>();
Kernel kernel = builder.Build();

Importieren Sie die erforderlichen Pakete:

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
from semantic_kernel.core_plugins.time_plugin import TimePlugin

Als Nächstes können Sie einen Kernel erstellen.

# Initialize the kernel
kernel = Kernel()

Schließlich können Sie die erforderlichen Dienste und Plug-Ins hinzufügen. Nachfolgend finden Sie ein Beispiel dafür, wie Sie einen Azure OpenAI-Chatabschluss, einen Logger und ein Zeit-Plug-In hinzufügen können.

# Add the Azure OpenAI chat completion service
kernel.add_service(AzureChatCompletion(model_id, endpoint, api_key))

# Add a plugin
kernel.add_plugin(
    TimePlugin(),
    plugin_name="TimePlugin",
)

Erstellen eines MCP-Servers aus Ihrem Kernel

Wir unterstützen jetzt das Erstellen eines MCP-Servers aus der Funktion, die Sie in Ihrer semantischen Kernelinstanz registriert haben.

Um dies zu tun, erstellen Sie Ihren Kernel wie gewohnt, und dann können Sie einen MCP-Server daraus erstellen.

from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import OpenAIChatCompletion
from semantic_kernel.functions import kernel_function
from semantic_kernel.prompt_template import InputVariable, PromptTemplateConfig

kernel = Kernel()

@kernel_function()
def echo_function(message: str, extra: str = "") -> str:
    """Echo a message as a function"""
    return f"Function echo: {message} {extra}"

kernel.add_service(OpenAIChatCompletion(service_id="default"))
kernel.add_function("echo", echo_function, "echo_function")
kernel.add_function(
    plugin_name="prompt",
    function_name="prompt",
    prompt_template_config=PromptTemplateConfig(
        name="prompt",
        description="This is a prompt",
        template="Please repeat this: {{$message}} and this: {{$extra}}",
        input_variables=[
            InputVariable(
                name="message",
                description="This is the message.",
                is_required=True,
                json_schema='{ "type": "string", "description": "This is the message."}',
            ),
            InputVariable(
                name="extra",
                description="This is extra.",
                default="default",
                is_required=False,
                json_schema='{ "type": "string", "description": "This is the message."}',
            ),
        ],
    ),
)
server = kernel.as_mcp_server(server_name="sk")

Das server oben erstellte Objekt stammt aus dem mcp-Paket, Sie können es sogar noch weiter erweitern, indem Sie Ressourcen oder andere Features hinzufügen. Und dann können Sie es online bringen, z. B. mit Stdio zu verwenden:

import anyio
from mcp.server.stdio import stdio_server

async def handle_stdin(stdin: Any | None = None, stdout: Any | None = None) -> None:
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream, server.create_initialization_options())

anyio.run(handle_stdin)

Oder mit SSE:

import uvicorn
from mcp.server.sse import SseServerTransport
from starlette.applications import Starlette
from starlette.routing import Mount, Route

sse = SseServerTransport("/messages/")

async def handle_sse(request):
    async with sse.connect_sse(request.scope, request.receive, request._send) as (read_stream, write_stream):
        await server.run(read_stream, write_stream, server.create_initialization_options())

starlette_app = Starlette(
    debug=True,
    routes=[
        Route("/sse", endpoint=handle_sse),
        Mount("/messages/", app=sse.handle_post_message),
    ],
)

uvicorn.run(starlette_app, host="0.0.0.0", port=8000)

Verfügbarmachen von Eingabeaufforderungsvorlagen als MCP-Eingabeaufforderung

Sie können auch die verschiedenen Vorlagen für semantische Kernel-Eingabeaufforderungen nutzen, indem Sie sie wie folgt als MCP-Eingabeaufforderungen verfügbar geben:

from semantic_kernel.prompt_template import InputVariable, KernelPromptTemplate, PromptTemplateConfig

prompt = KernelPromptTemplate(
    prompt_template_config=PromptTemplateConfig(
        name="release_notes_prompt",
        description="This creates the prompts for a full set of release notes based on the PR messages given.",
        template=template,
        input_variables=[
            InputVariable(
                name="messages",
                description="These are the PR messages, they are a single string with new lines.",
                is_required=True,
                json_schema='{"type": "string"}',
            )
        ],
    )
)

server = kernel.as_mcp_server(server_name="sk_release_notes", prompts=[prompt])

Erstellen eines Kernels

Kernels können mit einem Kernel.builder() erstellt werden. Auf dieser Seite können Sie erforderliche KI-Dienste und Plug-Ins hinzufügen.

Kernel kernel = Kernel.builder()
    .withAIService(ChatCompletionService.class, chatCompletionService)
    .withPlugin(lightPlugin)
    .build();

Verwenden der Abhängigkeitsinjektion

In C# können Sie Dependency Injection verwenden, um einen Kernel zu erstellen. Dies wird durch die Erstellung eines ServiceCollection und das Hinzufügen von Diensten und Plug-Ins dazu erreicht. Im Folgenden finden Sie ein Beispiel für die Erstellung eines Kernels mithilfe der Abhängigkeitsinjektion.

Tipp

Es wird empfohlen, einen Kernel als vorübergehenden Dienst zu erstellen, damit er nach jeder Verwendung verworfen wird, da die Plug-In-Sammlung änderbar ist. Der Kernel ist extrem leicht (da es sich nur um einen Container für Dienste und Plug-Ins handelt), daher ist das Erstellen eines neuen Kernels für jede Verwendung kein Leistungsproblem.

using Microsoft.SemanticKernel;

var builder = Host.CreateApplicationBuilder(args);

// Add the OpenAI chat completion service as a singleton
builder.Services.AddOpenAIChatCompletion(
    modelId: "gpt-4",
    apiKey: "YOUR_API_KEY",
    orgId: "YOUR_ORG_ID", // Optional; for OpenAI deployment
    serviceId: "YOUR_SERVICE_ID" // Optional; for targeting specific services within Semantic Kernel
);

// Create singletons of your plugins
builder.Services.AddSingleton(() => new LightsPlugin());
builder.Services.AddSingleton(() => new SpeakerPlugin());

// Create the plugin collection (using the KernelPluginFactory to create plugins from objects)
builder.Services.AddSingleton<KernelPluginCollection>((serviceProvider) => 
    [
        KernelPluginFactory.CreateFromObject(serviceProvider.GetRequiredService<LightsPlugin>()),
        KernelPluginFactory.CreateFromObject(serviceProvider.GetRequiredService<SpeakerPlugin>())
    ]
);

// Finally, create the Kernel service with the service provider and plugin collection
builder.Services.AddTransient((serviceProvider)=> {
    KernelPluginCollection pluginCollection = serviceProvider.GetRequiredService<KernelPluginCollection>();

    return new Kernel(serviceProvider, pluginCollection);
});

Tipp

Weitere Beispiele zur Verwendung der Abhängigkeitsinjektion in C# finden Sie in den Konzeptbeispielen.

Nächste Schritte

Nachdem Sie den Kernel verstanden haben, können Sie sich über alle verschiedenen KI-Dienste informieren, die Sie hinzufügen können.

Informationen zu KI-Diensten

Freigeben über