Dela via

Förstå kerneln

Kärnan är den centrala komponenten i semantisk kernel. Kärnan är i sin enklaste form en container för beroendeinjicering som hanterar alla tjänster och plugins som krävs för att köra din AI-applikation. Om du tillhandahåller alla dina tjänster och plugin-program till kerneln används de sömlöst av AI:n efter behov.

Kerneln är i mitten

Eftersom kerneln har alla tjänster och plugin-program som krävs för att köra både intern kod och AI-tjänster används den av nästan alla komponenter i Semantic Kernel SDK för att driva dina agenter. Det innebär att om du kör någon fråga eller kod i semantisk kernel är kerneln alltid tillgänglig för att hämta nödvändiga tjänster och plugin-program.

Kärnan står i centrum för allt i semantisk kernel

Detta är mycket kraftfullt, eftersom det innebär att du som utvecklare har en enda plats där du kan konfigurera, och viktigast av allt övervaka, dina AI-agenter. Ta till exempel när du anropar en uppmaning från kerneln. När du gör det kommer kärnan...

  1. Välj den bästa AI-tjänsten för att köra uppmaningen.
  2. Skapa prompten med hjälp av den angivna promptmallen.
  3. Skicka uppmaningen till AI-tjänsten.
  4. Ta emot och parsa svaret.
  5. Och slutligen returnera svaret från LLM till din applikation.

Under hela den här processen kan du skapa händelser och mellanprogram som utlöses i vart och ett av dessa steg. Det innebär att du kan utföra åtgärder som loggning, tillhandahålla statusuppdateringar till användare och viktigast av allt ansvarsfull AI. Allt från en enda plats.

Skapa en kernel med tjänster och plugin-program

Innan du skapar en kernel bör du först förstå de två typer av komponenter som finns:

Komponent beskrivning
Tjänster Dessa består av både AI-tjänster (t.ex. chattavslut) och andra tjänster (t.ex. loggning och HTTP-klienter) som krävs för att köra ditt program. Detta modellerades efter mönstret för tjänstprovidern i .NET så att vi kunde stödja beroendeinmatning på alla språk.
Plugin Det här är de komponenter som används av dina AI-tjänster och promptmallar för att utföra arbete. AI-tjänster kan till exempel använda plugin-program för att hämta data från en databas eller anropa ett externt API för att utföra åtgärder.

Börja skapa en kernel genom att importera nödvändiga paket överst i filen:

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

Sedan kan du lägga till tjänster och plugin-program. Nedan visas ett exempel på hur du kan lägga till en Azure OpenAI-chattavslutning, en loggare och ett tidsplugin.

// 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();

Importera nödvändiga paket:

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

Sedan kan du skapa en kernel.

# Initialize the kernel
kernel = Kernel()

Slutligen kan du lägga till nödvändiga tjänster och plugin-program. Nedan visas ett exempel på hur du kan lägga till en Azure OpenAI-chattfärdigställande, en loggningsfunktion och ett tidsplugin.

# 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",
)

Skapa en MCP-server från kerneln

Nu har vi stöd för att skapa en MCP-server från den funktion som du har registrerat i din Semantic Kernel-instans.

För att göra detta skapar du din kernel som vanligt, och sedan kan du skapa en MCP-server från den.

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")

Objektet server som skapades ovan kommer från mcp-paketet. Du kan utöka det ytterligare till exempel genom att lägga till resurser eller andra funktioner i det. Och sedan kan du ta den online, till exempel för att användas med Stdio:

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)

Eller med 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)

Exponera promptmallar som MCP-prompt

Du kan också använda de olika semantiska kernel-promptmallarna genom att exponera dem som MCP-prompter, så här:

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])

Skapa en kernel

Kärnor kan skapas med hjälp av en Kernel.builder(). På så sätt kan du lägga till nödvändiga AI-tjänster och plugin-program.

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

Använda beroendeinjektion

I C# kan du använda beroendeinmatning för att skapa en kernel. Detta görs genom att skapa en ServiceCollection och lägga till tjänster och plugin-program i den. Nedan visas ett exempel på hur du kan skapa en kernel med hjälp av beroendeinmatning.

Dricks

Vi rekommenderar att du skapar en kernel som en tillfällig tjänst så att den tas bort efter varje användning eftersom plugin-samlingen kan ändras. Kerneln är extremt lätt (eftersom det bara är en container för tjänster och plugin-program), så att skapa en ny kernel för varje användning är inte ett prestandaproblem.

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);
});

Dricks

Fler exempel på hur du använder beroendeinmatning i C# finns i konceptexemplen.

Nästa steg

Nu när du förstår kerneln kan du lära dig mer om alla olika AI-tjänster som du kan lägga till i den.

Lär dig mer om AI-tjänster

  • Last updated on