Visão geral do kernel semântico para .NET
Neste artigo, você explora os principais conceitos e recursos do Kernel Semântico . O Kernel Semântico é uma escolha poderosa e recomendada para trabalhar com IA em aplicativos .NET. Nas seções a seguir, você aprende:
- Como adicionar kernel semântico ao seu projeto
- Conceitos básicos do Kernel Semântico
Este artigo serve como 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 Kernel Semântico, consulte os seguintes recursos:
Adicionar kernel semântico a um projeto .NET
O SDK do Kernel Semântico está disponível como um pacote NuGet para .NET e integra-se com configurações de aplicativos padrão.
Instale o Microsoft.SemanticKernel pacote usando o seguinte comando:
dotnet add package Microsoft.SemanticKernel
Nota
Embora Microsoft.SemanticKernel forneça recursos principais do Kernel Semântico, recursos adicionais exigem que você instale pacotes adicionais. Por exemplo, o Microsoft.SemanticKernel.Plugins.Memory pacote fornece para acessar recursos relacionados à memória. Para obter mais informações, consulte a documentação do Semantic Kernel.
Crie e configure uma Kernel instância usando a classe para acessar e trabalhar com o KernelBuilder Semantic Kernel. O Kernel detém serviços, dados e conexões para orquestrar integrações entre seu código e 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();
Compreender o kernel semântico
O Semantic Kernel é um SDK de código aberto que integra e orquestra modelos e serviços de IA como OpenAI, Azure OpenAI e Hugging Face com linguagens de programação convencionais como C#, Python e Java.
O SDK do Kernel Semântico beneficia os desenvolvedores corporativos das seguintes maneiras:
- Simplifica a integração de recursos de IA em aplicativos existentes para permitir uma solução coesa para produtos corporativos.
- Minimiza a curva de aprendizado de trabalhar com diferentes modelos ou serviços de IA, fornecendo abstrações que reduzem a complexidade.
- Melhora a confiabilidade reduzindo o comportamento imprevisível de prompts e respostas de modelos de IA. Você pode ajustar prompts e planejar tarefas para criar uma experiência de usuário controlada e previsível.
O Kernel Semântico é construído em torno de vários conceitos centrais:
- Conexões: Interface com serviços externos de IA e fontes de dados.
- Plugins: encapsulam funções que os aplicativos podem usar.
- Planner: Orquestra planos de execução e estratégias 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.
Ligações
O SDK do Kernel Semântico inclui um conjunto de conectores que permitem aos desenvolvedores integrar LLMs e outros serviços em seus aplicativos existentes. Esses conectores servem como a ponte entre o código do aplicativo e os modelos ou serviços de IA. O Kernel Semântico 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 uma Kernel conexão 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 plugins do Kernel Semântico encapsulam funções de linguagem padrão para aplicações e modelos de IA consumirem. Você pode criar seus próprios plug-ins ou confiar em plug-ins fornecidos pelo SDK. Esses plugins simplificam tarefas onde os modelos de IA são vantajosos e os combinam eficientemente com métodos C# mais tradicionais. As funções do plugin são geralmente 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 Kernel Semântico pode personalizar e chamar conforme necessário. Você pode criar modelos desses prompts para usar variáveis, formatação personalizada de prompt e conclusão e muito mais.
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
Funções nativas são métodos C# que o Kernel Semântico pode chamar diretamente para manipular ou recuperar dados. Eles 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 planejador é um componente central do Semantic Kernel que fornece orquestração de IA para gerenciar a integração perfeita entre modelos de IA e plugins. Esta camada concebe estratégias de execução a partir de solicitações do usuário e orquestra dinamicamente Plugins para executar tarefas complexas com planejamento assistido por IA.
Considere o seguinte trecho de 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 configura 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 vetoriais do Semantic Kernel fornecem abstrações sobre modelos de incorporação, bancos de dados vetoriais e outros dados para simplificar o gerenciamento de contexto para aplicativos de IA. Os repositórios vetoriais são agnósticos ao LLM subjacente ou ao banco de dados vetorial, oferecendo uma experiência uniforme de desenvolvedor. Você pode configurar recursos de memória para armazenar dados em uma variedade de fontes ou serviços, incluindo a Pesquisa de IA do Azure e o Cache do Azure para Redis.
Considere o seguinte trecho 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.
