Understanding the kernel in Semantic Kernel

Similar to operating system, the kernel is responsible for managing resources that are necessary to run "code" in an AI application. This includes managing the configuration, services, and plugins that are necessary for both native code and AI services to run together.

If you want to see the code demonstrated in this article in a complete solution, check out the following samples in the public documentation repository.

Language	Link to final solution
C#	Open solution in GitHub
Python	Open solution in GitHub

Using native and AI services together

Semantic Kernel makes it easy to run AI services alongside native code by treating calls to AI services as their own first-class citizens called "semantic functions."

Semantic functions are discussed more deeply in their own section, but for now, it is important to understand that both native and semantic functions behave the same way within Semantic Kernel. This is thanks to the fact that both are expressed as SKFunction objects. Because of this, they can each be triggered the same way by the kernel.

This is important because it means both semantic and native functions behave the same way within the kernel to maximize interoperability.

For example, you can see in the image below how the kernel is able to run both native and semantic functions together in a single pipeline. This allows the developer to use Semantic Kernel to 1) get the current time, 2) generate a poem about the time, before finally 3) translating it into a different language.

Running functions using the kernel

To run SKFunction objects, Semantic Kernel provides the RunAsync method within the Kernel class. This method takes one or more SKFunction objects and executes them sequentially. For example, the following code runs a single native function from the Time plugin and returns back the result:

C#

Import the necessary packages:

using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Plugins.Core;

Run the today function from the time plugin:

var kernel = Kernel.Builder
    .Build();
var time = kernel.ImportFunctions(new TimePlugin());
var result = await kernel.RunAsync(time["Today"]);

Console.WriteLine(result);

Python

Import the necessary packages:

import semantic_kernel as sk
from semantic_kernel.core_skills import TimeSkill

Run the today function from the time plugin:

kernel = sk.Kernel()

time = kernel.import_skill(TimeSkill())
result = await kernel.run_async(time["today"])

print(result)

After running this, you should see today's date printed to the console.

Creating the kernel runtime environment

To run anything more complex than a simple native function, however, you must ensure the kernel's runtime is appropriately configured. This is particularly important for semantic functions that require access to AI services.

Runtime properties managed by the kernel

By investigating the constructor of the Kernel class, you can see that you can configure multiple settings that are necessary to run both native and semantic functions. These include:

• The default AI service that will power your semantic functions.
• The template engine used to render prompt templates.
• The logger used to log messages from functions.
• The plugins available to be executed by the kernel
• Additional configuration used by the kernel via the KernelConfig class.

Configuring the kernel

Depending on your language of choice, you can configure the kernel in different ways. For example, in C#, you can use the Kernel.Builder class to create a kernel, whereas with Python, you can iteratively add properties to the Kernel object directly.

In the following examples, you can see how to add a chat completion service and a logger to the kernel.

C#

If you are using a Azure OpenAI, you can use the WithAzureChatCompletionService method.

var kernelWithConfiguration = Kernel.Builder
    .WithLoggerFactory(loggerFactory)
    .WithAzureChatCompletionService(
        AzureOpenAIDeploymentName,  // The name of your deployment (e.g., "gpt-35-turbo")
        AzureOpenAIEndpoint,        // The endpoint of your Azure OpenAI service
        AzureOpenAIApiKey           // The API key of your Azure OpenAI service
    )
    .Build();

If you are using OpenAI, you can use the WithOpenAIChatCompletionService method.

var kernelWithConfiguration = Kernel.Builder
    .WithLoggerFactory(loggerFactory)
    .WithOpenAIChatCompletionService(
        OpenAIModelId,              // The name of your deployment (e.g., "gpt-35-turbo")
        OpenAIApiKey,               // The API key of your Azure OpenAI service
        OpenAIOrgId                 // The endpoint of your Azure OpenAI service
    )
    .Build();

Python

If you are using a Azure OpenAI, you can use the AzureChatCompletion class.

kernel = sk.Kernel(log=sk.NullLogger())
kernel.add_chat_service(
    "chat_completion",
    AzureChatCompletion(
        config.get("AZURE_OPEN_AI__CHAT_COMPLETION_DEPLOYMENT_NAME", None),
        config.get("AZURE_OPEN_AI__ENDPOINT", None),
        config.get("AZURE_OPEN_AI__API_KEY", None),
    ),
)

If you are using OpenAI, you can use the OpenAIChatCompletion class.

kernel = sk.Kernel(log=sk.NullLogger())
kernel.add_chat_service(
    "chat_completion",
    OpenAIChatCompletion(
        config.get("OPEN_AI__CHAT_COMPLETION_MODEL_ID", None),
        config.get("OPEN_AI__API_KEY", None),
        config.get("OPEN_AI__ORG_ID", None),
    ),
)

Going further with the kernel

For more details on how to configure and leverage these properties, please refer to the following articles:

Article	Description
Adding services	Learn how to add services from OpenAI, Azure OpenAI, Hugging Face, and more to the kernel.
Adding telemetry and logs	Gain visibility into what Semantic Kernel is doing by adding telemetry to the kernel.

Next steps

Once you're done configuring the kernel, you can start creating custom functions by developing your own plugins.

Create a plugin for Semantic Kernel