Informacje o jądrze

Jądro jest centralnym składnikiem jądra semantycznego. W najprostszej postaci, jądro jest kontenerem wstrzykiwania zależności, który zarządza wszystkimi usługami i wtyczkami niezbędnymi dla działania aplikacji sztucznej inteligencji. Jeśli udostępnisz wszystkie usługi i wtyczki do jądra, będą one bezproblemowo używane przez sztuczną inteligencję zgodnie z potrzebami.

Jądro znajduje się w środku

Ponieważ jądro ma wszystkie usługi i wtyczki niezbędne do uruchamiania kodu natywnego i usług sztucznej inteligencji, jest on używany przez prawie każdy składnik w zestawie SDK jądra semantycznego do zasilania agentów. Oznacza to, że w przypadku uruchomienia dowolnego monitu lub kodu w jądrze semantycznym jądro będzie zawsze dostępne do pobrania niezbędnych usług i wtyczek.

Jest to niezwykle wydajne, ponieważ oznacza to, że jako deweloper masz jedno miejsce, w którym można skonfigurować i co najważniejsze monitorować agentów sztucznej inteligencji. Na przykład podczas wywoływania monitu z jądra. Gdy to zrobisz, jądro wykona...

1. Wybierz najlepszą usługę sztucznej inteligencji, aby uruchomić monit.
2. Skompiluj monit przy użyciu podanego szablonu monitu.
3. Wyślij monit do usługi sztucznej inteligencji.
4. Odbieranie i analizowanie odpowiedzi.
5. Na koniec zwróć odpowiedź usługi LLM do swojej aplikacji.

W całym tym procesie można tworzyć zdarzenia i oprogramowanie pośredniczące, które są wyzwalane w każdym z tych kroków. Oznacza to, że można wykonywać działania, takie jak rejestrowanie, udostępnianie użytkownikom aktualizacji statusu i, co najważniejsze, odpowiedzialne korzystanie ze sztucznej inteligencji. Wszystko z jednego miejsca.

Tworzenie jądra za pomocą usług i wtyczek

Przed utworzeniem jądra należy najpierw zrozumieć dwa typy składników, które istnieją:

Składnik	opis
Usługi	Składają się one zarówno z usług sztucznej inteligencji (np. ukończenia czatu) jak i innych usług (np. rejestrowania i klientów HTTP), które są niezbędne do uruchomienia aplikacji. Zostało to modelowane po wzorcu dostawcy usług na platformie .NET, aby umożliwić obsługę wstrzykiwania zależności we wszystkich językach.
Wtyczki	Są to składniki używane przez usługi sztucznej inteligencji oraz szablony monitów o wykonanie pracy. Na przykład usługi sztucznej inteligencji mogą używać wtyczek do pobierania danych z bazy danych lub wywoływania zewnętrznego interfejsu API w celu wykonywania akcji.

Aby rozpocząć tworzenie jądra, zaimportuj niezbędne pakiety w górnej części pliku:

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

Następnie możesz dodać usługi i wtyczki. Poniżej przedstawiono przykład sposobu dodawania uzupełniania czatu usługi Azure OpenAI, rejestratora i wtyczki czasu.

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

Zaimportuj niezbędne pakiety:

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

Następnie możesz utworzyć jądro.

# Initialize the kernel
kernel = Kernel()

Na koniec możesz dodać niezbędne usługi i wtyczki. Poniżej przedstawiono przykład, jak można dodać uzupełnienie czatu OpenAI w Azure, rejestrator i wtyczkę czasu.

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

Tworzenie serwera MCP na podstawie jądra

Teraz obsługujemy tworzenie serwera MCP z funkcji zarejestrowanej w Twoim wystąpieniu Semantic Kernel.

W tym celu należy utworzyć jądro tak, jak zwykle, a następnie utworzyć z niego serwer 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")

Utworzony server powyżej obiekt pochodzi z pakietu mcp, można go rozszerzyć jeszcze bardziej, dodając zasoby lub inne funkcje do niego. A następnie możesz przenieść go w tryb online, na przykład do użycia z 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)

Lub za pomocą funkcji 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)

Wyświetlanie szablonów monitów jako monitu MCP

Możesz również użyć różnych szablonów monitów jądra semantycznego, uwidaczniając je jako monity MCP, w następujący sposób:

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

Zbuduj jądro

Jądra można skompilować przy użyciu elementu Kernel.builder(). W tym celu można dodać wymagane usługi i wtyczki sztucznej inteligencji.

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

Korzystanie z wstrzykiwania zależności

W języku C# możesz użyć wstrzykiwania zależności, aby utworzyć jądro. W tym celu należy utworzyć ServiceCollection i dodać do niego usługi i wtyczki. Poniżej przedstawiono przykład tworzenia jądra przy użyciu wstrzykiwania zależności.

Napiwek

Zalecamy utworzenie jądra jako usługi przejściowej w celu usunięcia jej po każdym użyciu, ponieważ kolekcja wtyczek jest modyfikowalna. Jądro jest bardzo lekkie (ponieważ jest to tylko kontener dla usług i wtyczek), więc utworzenie nowego jądra dla każdego użycia nie jest problemem z wydajnością.

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

Napiwek

Aby uzyskać więcej przykładów dotyczących używania wstrzykiwania zależności w języku C#, zapoznaj się z przykładami pojęć.

Następne kroki

Teraz, gdy znasz jądro, możesz dowiedzieć się więcej o wszystkich różnych usługach sztucznej inteligencji, które można do niej dodać.

Dowiedz się więcej o usługach sztucznej inteligencji