Porozumění jádru

Jádro je ústřední součástí sémantického jádra. V nejjednodušším případě je jádro kontejner injektáže závislostí, který spravuje všechny služby a moduly plug-in potřebné ke spuštění aplikace AI. Pokud do jádra zadáte všechny služby a moduly plug-in, podle potřeby je bude AI bezproblémově používat.

Jádro je uprostřed.

Vzhledem k tomu, že jádro má všechny služby a moduly plug-in potřebné ke spouštění nativního kódu i služeb AI, používá ho téměř každá komponenta v sadě SDK sémantického jádra k napájení vašich agentů. To znamená, že pokud v sémantickém jádru spustíte jakýkoliv příkazový řádek nebo kód, bude jádro vždy k dispozici pro načtení potřebných služeb a modulů plug-in.

To je extrémně výkonné, protože to znamená, že jako vývojář máte jediné místo, kde můžete konfigurovat a nejdůležitější je monitorovat agenty AI. Například když vyvoláte výzvu z jádra. Když to uděláte, jádro...

1. Vyberte nejlepší službu AI pro spuštění výzvy.
2. Pomocí poskytnuté šablony výzvy vytvořte výzvu.
3. Odešlete výzvu službě AI.
4. Přijměte a analyzujte odpověď.
5. Nakonec systém předá zpět odpověď z LLM do vaší aplikace.

V celém tomto procesu můžete vytvořit události a middleware, které se aktivují v každém z těchto kroků. To znamená, že můžete provádět akce, jako je protokolování, poskytování aktualizací stavu uživatelům a nejdůležitější zodpovědná AI. Všechno z jednoho místa.

Vytvořte jádro se službami a moduly plug-in

Před vytvořením jádra byste měli nejprve porozumět dvěma typům komponent, které existují:

Součást	Popis
Služby	Ty se skládají ze služeb AI (např. dokončení chatu) a dalších služeb (např. protokolování a klientů HTTP), které jsou nezbytné ke spuštění aplikace. Tento model byl modelovaný podle vzoru poskytovatele služeb v .NET, abychom mohli podporovat injektáž závislostí napříč všemi jazyky.
Pluginy	Jedná se o komponenty, které používají vaše služby AI a šablony k iniciačnímu provádění práce. Například služby AI můžou pomocí modulů plug-in načítat data z databáze nebo volat externí rozhraní API k provádění akcí.

Pokud chcete začít vytvářet jádro, naimportujte potřebné balíčky v horní části souboru:

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

Dále můžete přidat služby a moduly plug-in. Níže je příklad, jak můžete přidat dokončení chatu Azure OpenAI, protokolovací modul a časový plug-in.

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

Naimportujte potřebné balíčky:

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

Dále můžete vytvořit jádro.

# Initialize the kernel
kernel = Kernel()

Nakonec můžete přidat potřebné služby a moduly plug-in. Níže je příklad, jak přidat chatové dokončení Azure OpenAI, protokolovací nástroj a časový plugin.

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

Vytvoření serveru MCP z jádra

Nyní podporujeme vytvoření serveru MCP z funkce, kterou jste zaregistrovali ve své instanci sémantického jádra.

Pokud to chcete udělat, vytvoříte jádro běžným způsobem a pak z něj můžete vytvořit server MCP.

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

Výše server vytvořený objekt pochází z balíčku mcp, můžete ho rozšířit ještě dál, například přidáním prostředků nebo dalších funkcí. A pak ji můžete přenést do režimu online, například použít s 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)

Nebo s 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)

Zveřejnění šablon podnětů jako MCP Prompt

Různé šablony výzvy k sémantickému jádru můžete využít také tak, že je zobrazíte jako výzvy MCP, například takto:

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

Vytvoření jádra

Jádra lze sestavit pomocí .Kernel.builder() Na tom můžete přidat požadované služby AI a pluginy.

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

Použití injekce závislostí

V jazyce C# můžete k vytvoření jádra použít injektáž závislostí. To se provádí vytvořením ServiceCollection a přidáním služeb a modulů plug-in do něj. Níže je příklad, jak vytvořit jádro pomocí injektáže závislostí.

Tip

Doporučujeme vytvořit jádro jako přechodnou službu, aby se po každém použití odstranilo, protože kolekce modulů plug-in je proměnlivá. Jádro je extrémně jednoduché (protože se jedná pouze o kontejner pro služby a moduly plug-in), takže vytvoření nového jádra pro každé použití není problém s výkonem.

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

Tip

Další ukázky použití injektáže závislostí v jazyce C# najdete v ukázkách konceptů.

Další kroky

Teď, když rozumíte jádru, se dozvíte o všech různých službách AI, které do něj můžete přidat.

Další informace o službách AI