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 plug-ins necessários para executar seu aplicativo de IA. Se você fornecer todos os seus serviços e plug-ins ao 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 plug-ins necessários para executar o código nativo e os serviços de IA, ele é usado por quase todos os componentes 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 local onde pode configurar e, o mais importante, monitorar seus agentes de IA. Tomemos, 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, retorne a resposta do LLM para sua inscrição.
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 em 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 | Descrição | |
|---|---|---|
| 1 | 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) necessários para executar seu aplicativo. Isso foi modelado após o padrão do provedor de serviços no .NET para que pudéssemos dar suporte à ingestão de dependência em todas as linguagens. |
| 2 | Plugins | Esses são os componentes usados pelos serviços de IA e os modelos de prompt para executar o trabalho. Os serviços de IA, por exemplo, podem usar plug-ins 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 agente 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 agente 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(). Sobre isso, você pode adicionar serviços e plug-ins de IA necessários.
Kernel kernel = Kernel.builder()
.withAIService(ChatCompletionService.class, chatCompletionService)
.withPlugin(lightPlugin)
.build();
Usando injeção de dependência
Em C#, você pode usar a Injeção de Dependência para criar um kernel. Isso é feito criando e ServiceCollection 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.
Dica
Recomendamos que você crie um kernel como um serviço transitório para que ele seja descartado após cada uso, pois 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);
});
Dica
Para obter mais exemplos sobre como usar a injeção de dependência em C#, consulte os exemplos de conceito.
Próximas etapas
Agora que você entende o kernel, pode aprender sobre todos os diferentes serviços de IA que você pode adicionar a ele.