Entendendo o kernel
O kernel é o componente central do Kernel Semântico. Em sua forma mais simples, o kernel é um contêiner de injeção de dependência que gerencia todos os serviços e plugins necessários para executar seu aplicativo de IA. Se você fornecer todos os seus serviços e plugins para o kernel, eles serão usados perfeitamente pela IA conforme necessário.
O kernel está no centro
Como o kernel tem todos os serviços e plugins necessários para executar código nativo e serviços de IA, ele é usado por quase todos os componentes dentro do SDK do Kernel Semântico para alimentar seus agentes. Isso significa que, se você executar qualquer prompt ou código no Kernel Semântico, o kernel estará sempre disponível para recuperar os serviços e plug-ins necessários.
Isso é extremamente poderoso, porque significa que você, como desenvolvedor, tem um único lugar onde pode configurar e, mais importante, monitorar seus agentes de IA. Tome, por exemplo, quando você invoca um prompt do kernel. Quando você fizer isso, o kernel irá...
- Selecione o melhor serviço de IA para executar o prompt.
- Crie o prompt usando o modelo de prompt fornecido.
- Envie o prompt para o serviço de IA.
- Receba e analise a resposta.
- E, finalmente, devolva a resposta do LLM ao seu pedido.
Ao longo de todo esse processo, você pode criar eventos e middleware que são acionados em cada uma dessas etapas. Isso significa que você pode executar ações como registro, fornecer atualizações de status aos usuários e, o mais importante, IA responsável. Tudo a partir de um único lugar.
Construa um kernel com serviços e plugins
Antes de construir um kernel, você deve primeiro entender os dois tipos de componentes que existem:
| Componentes | Description | |
|---|---|---|
| 5 | Serviços | Eles consistem em serviços de IA (por exemplo, conclusão de bate-papo) e outros serviços (por exemplo, registro em log e clientes HTTP) que são necessários para executar seu aplicativo. Isso foi modelado de acordo com o padrão de provedor de serviços no .NET para que pudéssemos oferecer suporte à ingestão de dependência em todos os idiomas. |
| 2 | Plug-ins | Estes são os componentes que são usados por seus serviços de IA e modelos de prompt para executar o trabalho. Os serviços de IA, por exemplo, podem usar plugins para recuperar dados de um banco de dados ou chamar uma API externa para executar ações. |
Para começar a criar um kernel, importe os pacotes necessários na parte superior do seu arquivo:
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Plugins.Core;
Em seguida, você pode adicionar serviços e plugins. Abaixo está um exemplo de como você pode adicionar uma conclusão de chat do Azure OpenAI, um registrador e um plug-in de tempo.
// 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 os pacotes necessários:
from semantic_kernel import Kernel
from semantic_kernel.connectors.ai.open_ai import AzureChatCompletion
from semantic_kernel.core_plugins.time_plugin import TimePlugin
Em seguida, você pode criar um kernel.
# Initialize the kernel
kernel = Kernel()
Finalmente, você pode adicionar os serviços e plugins necessários. Abaixo está um exemplo de como você pode adicionar uma conclusão de chat do Azure OpenAI, um registrador e um plug-in de tempo.
# 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",
)
Construir um kernel
Os kernels podem ser construídos usando um Kernel.builder()arquivo . Nisso, você pode adicionar os serviços e plug-ins de IA necessários.
Kernel kernel = Kernel.builder()
.withAIService(ChatCompletionService.class, chatCompletionService)
.withPlugin(lightPlugin)
.build();
Usando a injeção de dependência
Em C#, você pode usar a injeção de dependência para criar um kernel. Isso é feito criando um ServiceCollection e adicionando serviços e plugins a ele. Abaixo está um exemplo de como você pode criar um kernel usando a injeção de dependência.
Gorjeta
Recomendamos que você crie um kernel como um serviço transitório para que ele seja descartado após cada uso, porque a coleção de plug-ins é mutável. O kernel é extremamente leve (já que é apenas um contêiner para serviços e plugins), portanto, criar um novo kernel para cada uso não é uma preocupação de desempenho.
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);
});
Gorjeta
Para obter mais exemplos sobre como usar a injeção de dependência em C#, consulte os exemplos de conceito.
Próximos passos
Agora que você entende o kernel, você pode aprender sobre todos os diferentes serviços de IA que você pode adicionar a ele.