Descripción del kernel

El kernel es el componente central del kernel semántico. En su forma más sencilla, el kernel es un contenedor de inserción de dependencias que administra todos los servicios y complementos necesarios para ejecutar la aplicación de IA. Si proporciona todos los servicios y complementos al kernel, la inteligencia artificial los usará sin problemas según sea necesario.

El kernel está en el centro

Dado que el kernel tiene todos los servicios y complementos necesarios para ejecutar código nativo y servicios de IA, casi todos los componentes del SDK de kernel semántico usan para alimentar a los agentes. Esto significa que si ejecuta algún mensaje o código en kernel semántico, el kernel siempre estará disponible para recuperar los servicios y complementos necesarios.

Esto es extremadamente eficaz, ya que significa que usted como desarrollador tiene un único lugar donde puede configurar y, lo más importante, supervisar los agentes de IA. Por ejemplo, al invocar un mensaje desde el kernel. Al hacerlo, el kernel...

1. Seleccione el mejor servicio de IA para ejecutar el prompt.
2. Construye el mensaje utilizando la plantilla de mensaje proporcionada.
3. Envíe el mensaje al servicio de IA.
4. Reciba y analice la respuesta.
5. Finalmente, devuelve la respuesta del LLM a tu aplicación.

A lo largo de todo este proceso, puede crear eventos y middleware que se desencadenen en cada uno de estos pasos. Esto significa que puede realizar acciones como realizar registros, proporcionar actualizaciones de estado a los usuarios y, lo más importante, la inteligencia artificial responsable. Todo desde un solo lugar.

Creación de un kernel con servicios y complementos

Antes de compilar un kernel, primero debe comprender los dos tipos de componentes que existen:

Componente	Descripción
Servicios	Estos constan de servicios de inteligencia artificial (por ejemplo, finalización de chat) y otros servicios (por ejemplo, registro y clientes HTTP) necesarios para ejecutar la aplicación. Esto se modeló después del patrón de proveedor de servicios en .NET para poder admitir la inserción de dependencias en todos los lenguajes.
Complementos	Estos son los componentes que utilizan los servicios de inteligencia artificial y las plantillas de aviso para llevar a cabo el trabajo. Por ejemplo, los servicios de inteligencia artificial pueden usar complementos para recuperar datos de una base de datos o llamar a una API externa para realizar acciones.

Para empezar a crear un kernel, importe los paquetes necesarios en la parte superior del archivo:

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

A continuación, puede agregar servicios y complementos. A continuación se muestra un ejemplo de cómo puede agregar una finalización de chat de Azure OpenAI, un registrador y un complemento de hora.

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

Importe los paquetes necesarios:

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

A continuación, puede crear un kernel.

# Initialize the kernel
kernel = Kernel()

Por último, puede agregar los servicios y complementos necesarios. A continuación se muestra un ejemplo de cómo puede agregar una finalización de chat de Azure OpenAI, un registrador y un complemento de hora.

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

Creación de un servidor MCP desde el kernel

Ahora se admite la creación de un servidor MCP a partir de la función que ha registrado en la instancia del kernel semántico.

Para ello, cree el kernel como lo haría normalmente y, a continuación, puede crear un servidor MCP a partir de él.

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

El server objeto creado anteriormente procede del paquete mcp, puede ampliarlo aún más para agregar recursos u otras características a él. Y luego puede ponerla en línea, por ejemplo, para utilizarse 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)

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

Exponer plantillas de solicitud como mensaje de MCP

También puede aprovechar las distintas plantillas de solicitud de kernel semántico exponiendolas como mensajes de MCP, como se muestra a continuación:

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

Compilación de un kernel

Los núcleos se pueden compilar mediante un Kernel.builder(). En este caso, puede agregar complementos y servicios de INTELIGENCIA ARTIFICIAL necesarios.

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

Uso de la Inyección de Dependencias

En C#, puede usar la inserción de dependencias para crear un kernel. Esto se hace creando un ServiceCollection y añadiendo servicios y complementos a él. A continuación se muestra un ejemplo de cómo puede crear un kernel mediante la inserción de dependencias.

Sugerencia

Se recomienda crear un kernel como servicio transitorio para que se elimine después de cada uso porque la colección de complementos es mutable. El kernel es extremadamente ligero (ya que es solo un contenedor para servicios y complementos), por lo que la creación de un nuevo kernel para cada uso no es un problema de rendimiento.

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

Sugerencia

Para obtener más ejemplos sobre cómo usar la inserción de dependencias en C#, consulte los ejemplos de concepto.

Pasos siguientes

Ahora que comprende el kernel, puede obtener información sobre todos los diferentes servicios de inteligencia artificial que puede agregar a él.

Más información sobre los servicios de inteligencia artificial