Visão geral do Semantic Kernel para .NET
Neste artigo, explore os principais conceitos e recursos do Semantic Kernel. O Kernel Semântico é uma opção avançada e recomendada para trabalhar com IA em aplicativos .NET. Nas próximas seções, você aprenderá:
- Como adicionar o Semantic Kernel ao seu projeto
- Conceitos centrais do Semantic Kernel
Este artigo apresenta uma visão geral introdutória do Kernel Semântico, especificamente no contexto do .NET. Para obter informações e treinamento mais abrangentes sobre o Semantic Kernel, consulte os recursos a seguir:
Adicionar o Semantic Kernel a um projeto .NET
O SDK do Semantic Kernel está disponível como um pacote NuGet para .NET e se integra às configurações de aplicativo padrão.
Instale o pacote Microsoft.SemanticKernel usando o seguinte comando:
dotnet add package Microsoft.SemanticKernel
Observação
Embora Microsoft.SemanticKernel forneça os principais recursos do Semantic Kernel, os recursos adicionais exigem a instalação de outros pacotes. Por exemplo, o pacote Microsoft.SemanticKernel.Plugins.Memory fornece recursos relacionados à memória de acesso. Para obter mais informações, consulte a documentação do Semantic Kernel.
Crie e configure uma instância Kernel usando a classe KernelBuilder para acessar e trabalhar com o Semantic Kernel. O Kernel contém serviços, dados e conexões para orquestrar as integrações entre seu código e os modelos de IA.
Configure o Kernel em um aplicativo de console .NET:
var builder = Kernel.CreateBuilder();
// Add builder configuration and services
var kernel = builder.Build();
Configure o Kernel em um aplicativo ASP.NET Core:
var builder = WebApplication.CreateBuilder();
builder.Services.AddKernel();
// Add builder configuration and services
var app = builder.Build();
Entenda o Semantic Kernel
Semantic Kernel é um SDK de código aberto que integra e orquestra modelos e serviços de IA como OpenAI, OpenAI do Azure e Hugging Face com linguagens de programação convencionais como C#, Python e Java.
O SDK do Semantic Kernel beneficia os desenvolvedores empresariais das seguintes maneiras:
- Simplifica a integração de recursos de IA em aplicativos existentes para permitir uma solução coesa para produtos empresariais.
- Minimiza a curva de aprendizado do trabalho com diferentes modelos ou serviços de IA, fornecendo abstrações que reduzem a complexidade.
- Aumenta a confiabilidade ao reduzir o comportamento imprevisível dos prompts e das respostas dos modelos de IA. É possível ajustar os prompts e planejar tarefas para criar uma experiência de usuário controlada e previsível.
O Semantic Kernel foi desenvolvido com base em vários conceitos fundamentais:
- Conexões: Interface com serviços externos de IA e fontes de dados.
- Plug-ins: encapsulam funções que os aplicativos podem usar.
- Planner: Orquestra planos e estratégias de execução com base no comportamento do usuário.
- Memória: Abstrai e simplifica o gerenciamento de contexto para aplicativos de IA.
Esses blocos de construção são explorados em mais detalhes nas seções a seguir.
conexões
O SDK do Semantic Kernel inclui um conjunto de conectores que permitem que os desenvolvedores integrem LLMs e outros serviços em seus aplicativos existentes. Esses conectores servem como ponte entre o código do aplicativo e os modelos ou serviços de IA. O Semantic Kernel lida com muitas preocupações e desafios comuns de conexão para que você possa se concentrar na criação de seus próprios fluxos de trabalho e recursos.
O trecho de código a seguir cria um Kernel e adiciona uma conexão a um modelo OpenAI do Azure:
using Microsoft.SemanticKernel;
// Create kernel
var builder = Kernel.CreateBuilder();
// Add a chat completion service:
builder.Services.AddAzureOpenAIChatCompletion(
"your-resource-name",
"your-endpoint",
"your-resource-key",
"deployment-model");
var kernel = builder.Build();
Plug-ins
Os plug-ins do Semantic Kernel encapsulam as funções de linguagem padrão para aplicativos e modelos de IA consumirem. Você pode criar seus próprios plug-ins ou confiar nos plug-ins fornecidos pelo SDK. Esses plug-ins simplificam as tarefas em que os modelos de IA são vantajosos e os combinam eficientemente com métodos C# mais tradicionais. As funções de plug-in geralmente são categorizadas em dois tipos: funções semânticas e funções nativas.
Funções semânticas
As funções semânticas são essencialmente prompts de IA definidos em seu código que o Semantic Kernel pode personalizar e chamar conforme necessário. Você pode modelar esses prompts para usar variáveis, formatação personalizada de prompts e conclusão, entre outros.
O trecho de código a seguir define e registra uma função semântica:
var userInput = Console.ReadLine();
// Define semantic function inline.
string skPrompt = @"Summarize the provided unstructured text in a sentence that is easy to understand.
Text to summarize: {{$userInput}}";
// Register the function
kernel.CreateSemanticFunction(
promptTemplate: skPrompt,
functionName: "SummarizeText",
pluginName: "SemanticFunctions"
);
Funções nativas
As funções nativas são métodos C# que o Semantic Kernel pode chamar diretamente para manipular ou recuperar dados. Elas executam operações que são mais adequadas para instruções de código tradicionais em vez de prompts LLM.
O trecho de código a seguir define e registra uma função nativa:
// Define native function
public class NativeFunctions {
[SKFunction, Description("Retrieve content from local file")]
public async Task<string> RetrieveLocalFile(string fileName, int maxSize = 5000)
{
string content = await File.ReadAllTextAsync(fileName);
if (content.Length <= maxSize) return content;
return content.Substring(0, maxSize);
}
}
//Import native function
string plugInName = "NativeFunction";
string functionName = "RetrieveLocalFile";
var nativeFunctions = new NativeFunctions();
kernel.ImportFunctions(nativeFunctions, plugInName);
Planner
O Planner é um componente central do Semantic Kernel que fornece orquestração de IA para gerenciar a integração perfeita entre modelos e plug-ins de IA. Essa camada cria estratégias de execução a partir de solicitações do usuário e orquestra dinamicamente os plug-ins para executar tarefas complexas com planejamento assistido por IA.
Considere o seguinte trecho do pseudocódigo:
// Native function definition and kernel configuration code omitted for brevity
// Configure and create the plan
string planDefinition = "Read content from a local file and summarize the content.";
SequentialPlanner sequentialPlanner = new SequentialPlanner(kernel);
string assetsFolder = @"../../assets";
string fileName = Path.Combine(assetsFolder,"docs","06_SemanticKernel", "aci_documentation.txt");
ContextVariables contextVariables = new ContextVariables();
contextVariables.Add("fileName", fileName);
var customPlan = await sequentialPlanner.CreatePlanAsync(planDefinition);
// Execute the plan
KernelResult kernelResult = await kernel.RunAsync(contextVariables, customPlan);
Console.WriteLine($"Summarization: {kernelResult.GetValue<string>()}");
O código anterior cria um plano executável e sequencial para ler o conteúdo de um arquivo local e resumir o conteúdo. O plano define instruções para ler o arquivo usando uma função nativa e, em seguida, analisá-lo usando um modelo de IA.
Memória
Os repositórios de vetor do Kernel Semântico fornecem abstrações sobre modelos de inserção, bancos de dados vetoriais e outros dados para simplificar o gerenciamento de contexto para aplicativos de IA. Os repositórios de vetor são agnósticos ao banco de dados LLM ou Vetor subjacente, proporcionando uma experiência de desenvolvedor uniforme. Você pode configurar recursos de memória para armazenar os dados em diversas fontes ou serviços, incluindo a Pesquisa de IA do Azure e Cache do Azure para Redis.
Considere o seguinte snippet de código:
var facts = new Dictionary<string,string>();
facts.Add(
"Azure Machine Learning; https://learn.microsoft.com/en-us/azure/machine-learning/",
@"Azure Machine Learning is a cloud service for accelerating and
managing the machine learning project lifecycle. Machine learning professionals,
data scientists, and engineers can use it in their day-to-day workflows"
);
facts.Add(
"Azure SQL Service; https://learn.microsoft.com/en-us/azure/azure-sql/",
@"Azure SQL is a family of managed, secure, and intelligent products
that use the SQL Server database engine in the Azure cloud."
);
string memoryCollectionName = "SummarizedAzureDocs";
foreach (var fact in facts) {
await memoryBuilder.SaveReferenceAsync(
collection: memoryCollectionName,
description: fact.Key.Split(";")[1].Trim(),
text: fact.Value,
externalId: fact.Key.Split(";")[2].Trim(),
externalSourceName: "Azure Documentation"
);
}
O código anterior carrega um conjunto de fatos na memória para que os dados estejam disponíveis para uso ao interagir com modelos de IA e orquestrar tarefas.
