A kernel ismertetése

A szemantikus kernel központi összetevője a kernel. Legegyszerűbben a kernel egy függőséginjektálási tároló, amely az AI-alkalmazás futtatásához szükséges összes szolgáltatást és beépülő modult kezeli. Ha az összes szolgáltatást és beépülő modult biztosítja a kernelhez, az AI szükség szerint zökkenőmentesen fogja használni őket.

A kernel a középpontban van

Mivel a kernel rendelkezik a natív kód- és AI-szolgáltatások futtatásához szükséges összes szolgáltatással és beépülő modulval, a Szemantic Kernel SDK szinte minden összetevője használja az ügynökök működtetéséhez. Ez azt jelenti, hogy ha bármilyen parancssort vagy kódot futtat a Szemantic Kernelben, a kernel mindig elérhető lesz a szükséges szolgáltatások és beépülő modulok lekéréséhez.

Ez rendkívül hatékony, mivel fejlesztőként egyetlen helyen konfigurálhatja és figyelheti az AI-ügynökeit. Vegyük például, amikor meghív egy parancssort a kernelből. Ha így tesz, a kernel...

1. Válassza ki a legjobb AI-szolgáltatást a parancssor futtatásához.
2. Hozza létre a parancssort a megadott parancssori sablonnal.
3. Küldje el a kérést az AI szolgáltatásnak.
4. A válasz fogadása és elemzése.
5. Végül adja vissza az LLM válaszát az alkalmazásnak.

A teljes folyamat során létrehozhat eseményeket és köztes szoftvereket, amelyek az egyes lépéseknél aktiválódnak. Ez azt jelenti, hogy olyan műveleteket hajthat végre, mint a naplózás, állapotfrissítések biztosítása a felhasználók számára, és ami a legfontosabb, a felelős AI. Mind egyetlen helyről.

Kernel létrehozása szolgáltatásokkal és beépülő modulokkal

A kernel létrehozása előtt először meg kell ismernie a két összetevőtípust:

Összetevő	Leírás
Szolgáltatások	Ezek mind az AI-szolgáltatásokból (például a csevegés befejezéséből) és az alkalmazás futtatásához szükséges egyéb szolgáltatásokból (például naplózásból és HTTP-ügyfelekből) állnak. Ezt a szolgáltatói minta után modelleztük a .NET-ben, hogy minden nyelven támogathassuk a függőséginjektálást.
Beépülő modulok	Ezek azok az összetevők, amelyeket az AI-szolgáltatások és a parancssori sablonok használnak a munka elvégzéséhez. Az AI-szolgáltatások például beépülő modulokkal lekérhetik az adatokat egy adatbázisból, vagy meghívhatnak egy külső API-t a műveletek végrehajtásához.

Kernel létrehozásához importálja a szükséges csomagokat a fájl tetején:

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

Ezután szolgáltatásokat és beépülő modulokat adhat hozzá. Az alábbiakban egy példa látható arra, hogyan adhat hozzá egy csevegés befejezést az Azure OpenAI használatával, egy naplózási eszközt és egy idő plugin-t.

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

Importálja a szükséges csomagokat:

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

Ezután létrehozhat egy kernelt.

# Initialize the kernel
kernel = Kernel()

Végül hozzáadhatja a szükséges szolgáltatásokat és beépülő modulokat. Az alábbiakban látható egy példa arra, hogyan adhat hozzá Azure OpenAI csevegés végrehajtását, egy naplózási rendszert és egy idő beépülő modult.

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

MCP-kiszolgáló létrehozása a kernelből

Mostantól támogatjuk az MCP-kiszolgáló létrehozását a szemantikai kernelpéldányban regisztrált függvényből.

Ehhez a szokásos módon hozza létre a kernelt, majd létrehozhat belőle egy MCP-kiszolgálót.

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

A server fent létrehozott objektum az mcp-csomagból származik, és még tovább bővítheti, például erőforrások vagy más funkciók hozzáadásával. Ezután online is elérhetővé teheti, például a Stdio használatával:

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)

Vagy az SSE-vel:

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)

Parancssori sablonok megjelenítése MCP-parancssorként

A különböző Szemantic Kernel-parancssori sablonokat is használhatja, ha MCP-parancssorként adja meg őket, például:

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

Kernel létrehozása

A kernelek egy Kernel.builder() segítségével építhetők. Ezen a felületen hozzáadhatja a szükséges AI-szolgáltatásokat és beépülő modulokat.

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

A függőség injektálásának használata

A C#-ban a Dependency Injection használatával hozhat létre kernelt. Ehhez létre kell hoznia egy ServiceCollection, és hozzá kell adnia a szolgáltatásokat és a beépülő modulokat. Az alábbi példa bemutatja, hogyan hozhat létre kernelt függőséginjektálással.

Tipp.

Javasoljuk, hogy átmeneti szolgáltatásként hozzon létre egy kernelt, hogy az minden használat után megsemmisüljön, mert a beépülő modulgyűjtemény változtatható. A kernel rendkívül egyszerű (mivel csak egy tároló a szolgáltatásokhoz és beépülő modulokhoz), ezért az új kernel létrehozása minden egyes használathoz nem jelent teljesítményproblémát.

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.

A függőséginjektálás C#-ban való használatával kapcsolatos további példákért tekintse meg a koncepciómintákat.

Következő lépések

Most, hogy megismerte a kernelt, megismerkedhet az összes olyan AI-szolgáltatással, amelyet hozzáadhat.

Tudnivalók az AI-szolgáltatásokról