Informazioni sul kernel

Il kernel è il componente centrale del kernel semantico. In modo semplice, il kernel è un contenitore di Dependency Injection che gestisce tutti i servizi e i plugin necessari per eseguire l'applicazione di intelligenza artificiale. Se si forniscono tutti i servizi e i plug-in al kernel, questi verranno usati facilmente dall'IA in base alle esigenze.

Il kernel si trova al centro

Poiché il kernel ha tutti i servizi e i plug-in necessari per eseguire sia il codice nativo che i servizi di intelligenza artificiale, viene usato da quasi ogni componente all'interno di Semantic Kernel SDK per alimentare gli agenti. Ciò significa che se si esegue un prompt o codice nel kernel semantico, il kernel sarà sempre disponibile per recuperare i servizi e i plug-in necessari.

Questo è estremamente potente, perché significa che lo sviluppatore ha un'unica posizione in cui è possibile configurare e, soprattutto, monitorare gli agenti di intelligenza artificiale. Ad esempio, quando si richiama un prompt dal kernel. Quando lo fai, il kernel...

1. Selezionare il servizio di intelligenza artificiale migliore per eseguire il prompt.
2. Costruisci il prompt usando il modello di prompt fornito.
3. Inviare il prompt al servizio di intelligenza artificiale.
4. Ricevere e analizzare la risposta.
5. Infine, restituire la risposta dall'LLM all'applicazione.

In tutto questo processo è possibile creare eventi e middleware attivati in ognuno di questi passaggi. Ciò significa che è possibile eseguire azioni come la registrazione, fornire aggiornamenti di stato agli utenti e, soprattutto, utilizzare un'intelligenza artificiale responsabile. Tutto da un unico posto.

Creare un kernel con servizi e plug-in

Prima di compilare un kernel, è necessario comprendere i due tipi di componenti esistenti:

Componente	Descrizione
Servizi	Sono costituiti da entrambi i servizi di intelligenza artificiale (ad esempio, il completamento della chat) e altri servizi (ad esempio, la registrazione e i client HTTP) necessari per eseguire l'applicazione. Questo modello è stato modellato dopo il modello del provider di servizi in .NET in modo che sia possibile supportare l'inserimento delle dipendenze in tutti i linguaggi.
Plug-in	Questi sono i componenti usati dai servizi di intelligenza artificiale e richiedono ai modelli di eseguire il lavoro. I servizi di intelligenza artificiale, ad esempio, possono usare plug-in per recuperare dati da un database o chiamare un'API esterna per eseguire azioni.

Per iniziare a creare un kernel, importare i pacchetti necessari all'inizio del file:

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

Successivamente, è possibile aggiungere servizi e plug-in. Di seguito è riportato un esempio di come aggiungere un completamento della chat di Azure OpenAI, un logger e un plug-in per l'ora.

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

Importare i pacchetti necessari:

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

Successivamente, è possibile creare un kernel.

# Initialize the kernel
kernel = Kernel()

Infine, è possibile aggiungere i servizi e i plug-in necessari. Di seguito è riportato un esempio di come aggiungere un completamento chat di Azure OpenAI, un logger e un plugin dell'ora.

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

Creazione di un server MCP dal kernel

È ora supportata la creazione di un server MCP dalla funzione registrata nell'istanza del kernel semantico.

A tale scopo, si crea il kernel come si farebbe normalmente e quindi è possibile creare un server MCP da esso.

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

L'oggetto server creato in precedenza proviene dal pacchetto mcp, è possibile estenderlo ulteriormente, ad esempio aggiungendo risorse o altre funzionalità. E poi è possibile portarlo online, ad esempio per essere usato con 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)

Oppure con 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)

Presentazione dei modelli di prompt come Prompt MCP

È anche possibile sfruttare i diversi modelli di prompt del kernel semantico esponendoli come richieste MCP, come indicato di seguito:

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

Creare un kernel

I kernel possono essere compilati usando un oggetto Kernel.builder(). In questo modo è possibile aggiungere i servizi di intelligenza artificiale e i plug-in necessari.

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

Uso dell'inserimento delle dipendenze

In C#, è possibile usare la Dependency Injection per creare un kernel. Questa operazione viene eseguita creando un ServiceCollection e aggiungendo servizi e plug-in ad esso. Di seguito è riportato un esempio di come creare un kernel usando l'iniezione di dipendenze.

Suggerimento

È consigliabile creare un kernel come servizio temporaneo in modo che venga eliminato dopo ogni utilizzo perché la raccolta di plug-in è modificabile. Il kernel è estremamente leggero (poiché è solo un contenitore per servizi e plug-in), quindi la creazione di un nuovo kernel per ogni uso non è un problema di prestazioni.

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

Suggerimento

Per ulteriori esempi su come utilizzare il dependency injection in C#, consulta gli esempi relativi al concetto.

Passaggi successivi

Dopo aver compreso il kernel, è possibile ottenere informazioni su tutti i diversi servizi di intelligenza artificiale che è possibile aggiungere.

Informazioni sui servizi di intelligenza artificiale