Çekirdeği anlama

Çekirdek, AnlamSal Çekirdeğin merkezi bileşenidir. En basiti, çekirdek, yapay zeka uygulamanızı çalıştırmak için gereken tüm hizmetleri ve eklentileri yöneten bir Bağımlılık Ekleme kapsayıcısıdır. Çekirdekte tüm hizmetlerinizi ve eklentilerinizi sağlarsanız, bunlar gerektiğinde yapay zeka tarafından sorunsuz bir şekilde kullanılır.

Çekirdek ortada

Çekirdekte hem yerel kodu hem de yapay zeka hizmetlerini çalıştırmak için gereken tüm hizmetler ve eklentiler bulunduğundan, aracılarınızı desteklemek için Anlam Çekirdeği SDK'sı içindeki neredeyse tüm bileşenler tarafından kullanılır. Bu, Anlam Çekirdeği'nde herhangi bir istem veya kod çalıştırırsanız, çekirdeğin gerekli hizmetleri ve eklentileri almak için her zaman kullanılabilir olacağı anlamına gelir.

Bu son derece güçlüdür, çünkü bir geliştirici olarak yapay zeka aracılarınızı yapılandırabileceğiniz ve en önemlisi izleyebileceğiniz tek bir yere sahip olduğunuz anlamına gelir. Örneğin, çekirdekten bir istem çağırdığınızda. Bunu yaptığınızda çekirdek...

1. İstemi çalıştırmak için en iyi yapay zeka hizmetini seçin.
2. Sağlanan istem şablonunu kullanarak istemi oluşturun.
3. İstemi yapay zeka hizmetine gönderin.
4. Yanıtı alın ve ayrıştırın.
5. Ve son olarak LLM'den gelen yanıtı uygulamanıza döndürün.

Bu işlemin tamamında, bu adımların her birinde tetiklenen olaylar ve ara yazılım oluşturabilirsiniz. Bu, günlüğe kaydetme, kullanıcılara durum güncelleştirmeleri sağlama ve en önemli sorumlu yapay zeka gibi eylemleri gerçekleştirebileceğiniz anlamına gelir. Hepsi tek bir yerden.

Hizmetler ve eklentilerle çekirdek oluşturma

Çekirdek oluşturmadan önce mevcut olan iki bileşen türünü anlamanız gerekir:

Bileşen	Açıklama
Hizmetler	Bunlar hem yapay zeka hizmetlerinden (ör. sohbet tamamlama) hem de uygulamanızı çalıştırmak için gereken diğer hizmetlerden (örneğin, günlüğe kaydetme ve HTTP istemcileri) oluşur. Bu, tüm dillerde bağımlılık eklemeyi destekleyebilmemiz için .NET'teki Hizmet Sağlayıcısı düzeninden sonra modellendi.
Eklentiler	Bunlar, yapay zeka hizmetleriniz ve istem şablonlarınız tarafından iş gerçekleştirmek için kullanılan bileşenlerdir. Örneğin yapay zeka hizmetleri, bir veritabanından veri almak için eklentileri kullanabilir veya eylemleri gerçekleştirmek için dış API çağırabilir.

Çekirdek oluşturmaya başlamak için dosyanızın en üstündeki gerekli paketleri içeri aktarın:

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

Ardından, hizmetler ve eklentiler ekleyebilirsiniz. Aşağıda Azure OpenAI sohbet tamamlama, günlükçü ve zaman eklentisi eklemeye yönelik bir örnek verilmiştir.

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

Gerekli paketleri içeri aktarın:

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

Ardından bir çekirdek oluşturabilirsiniz.

# Initialize the kernel
kernel = Kernel()

Son olarak, gerekli hizmetleri ve eklentileri ekleyebilirsiniz. Aşağıda Azure OpenAI sohbet tamamlama, kayıt tutucu ve zaman eklentisi eklemeye yönelik bir örnek verilmiştir.

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

Çekirdeğinizden MCP Sunucusu Oluşturma

Artık Anlam Çekirdeği örneğinize kaydettiğiniz işlevden bir MCP sunucusu oluşturmayı destekliyoruz.

Bunu yapmak için, normalde yaptığınız gibi çekirdeğinizi oluşturursunuz ve ardından ondan bir MCP sunucusu oluşturabilirsiniz.

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

server Yukarıda oluşturulan nesne mcp paketinden gelir, örneğin kaynaklar veya başka özellikler ekleyerek daha da genişletebilirsiniz. Ardından, örneğin Stdio ile kullanılmak üzere çevrimiçi olarak getirebilirsiniz:

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)

Veya SSE ile:

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)

İstem şablonlarını MCP İstemi olarak görüntüleme

Ayrıca farklı AnlamSal Çekirdek istem şablonlarını MCP İstemleri olarak göstererek de kullanabilirsiniz:

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

Çekirdek oluşturma

Çekirdekler kullanılarak Kernel.builder()oluşturulabilir. Bunun üzerine gerekli yapay zeka hizmetlerini ve eklentilerini ekleyebilirsiniz.

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

Bağımlılık Enjekte Etme Kullanımı

C# dilinde, bir çekirdek oluşturmak için Bağımlılık Ekleme'yi kullanabilirsiniz. Bu, bir ServiceCollection oluşturup buna hizmet ve eklentiler ekleyerek yapılır. Aşağıda Bağımlılık Ekleme'yi kullanarak nasıl çekirdek oluşturabileceğinize bir örnek verilmiştir.

İpucu

Eklenti koleksiyonu değişebilir olduğundan, her kullanımdan sonra atılması için geçici bir hizmet olarak bir çekirdek oluşturmanızı öneririz. Çekirdek son derece hafiftir (yalnızca hizmetler ve eklentiler için bir kapsayıcı olduğundan), her kullanım için yeni bir çekirdek oluşturmak performansla ilgili bir sorun değildir.

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

İpucu

C# dilinde bağımlılık ekleme özelliğini kullanma hakkında daha fazla örnek için kavram örneklerine bakın.

Sonraki adımlar

Artık çekirdeği anladığınıza göre, buna ekleyebileceğiniz tüm farklı yapay zeka hizmetleri hakkında bilgi edinebilirsiniz.

Yapay zeka hizmetleri hakkında bilgi edinin