O que é o Semantic Kernel? – WPS Knowledge Solutions

Imagine o Semantic Kernel como um “Maestro”. Ele não é o modelo de IA em si (como o Gemini ou o GPT), mas sim a estrutura que permite que você conecte o seu código C# a esses modelos.

A grande vantagem é a abstração. Se amanhã você quiser trocar para o OpenAI, você mudaria poucas linhas de configuração, e o resto do seu “cérebro” (plugins e lógica) continuaria funcionando. Isso é o que chamamos de suporte a “n” modelos.

Por que usar o Semantic Kernel?

Orquestração de Plugins: Ele permite que a IA “saia da caixa” e interaja com o mundo real (como ler sua agenda ou enviar um e-mail).
Independência de Modelo: Você não fica “preso” a um único fornecedor. Pode usar Gemini, OpenAI, Mistral ou modelos locais (Llama).
Nativo para Desenvolvedores: Ele traz conceitos de engenharia de software (como injeção de dependência e interfaces) para o mundo da IA.

Exemplo Prático em C# e Gemini (google)

Abaixo temos um código em c# completo que iremos explicar passo a passo. A chave deve ser criada no Google AI Studio que existe opção free com limitações de acessos por minuto e por isso faremos os testes usando ele para que todos possam praticar

using System.ComponentModel;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.Connectors.Google;

// =========================================================================
// 1. CONFIGURAÇÃO DO KERNEL
// =========================================================================

var builder = Kernel.CreateBuilder();


builder.AddGoogleAIGeminiChatCompletion(
	modelId: "gemini-flash-latest",
	apiKey: "<Sua Chave da API>",
	apiVersion: GoogleAIVersion.V1_Beta 
);

// Adicionando nosso plugin de agenda
builder.Plugins.AddFromType<AgendaPlugin>();

var kernel = builder.Build();

// Configurando para a IA chamar as funções automaticamente
var settings = new PromptExecutionSettings
{
	FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()
};

// =========================================================================
// 2. LOOP DE EXECUCAO
// =========================================================================

Console.WriteLine("Assistente de Agenda Pronto!");
Console.WriteLine("(Digite 'sair' para encerrar)\n");

while (true)
{
	Console.Write("Você: ");
	string? input = Console.ReadLine();

	if (string.IsNullOrWhiteSpace(input) || input.ToLower() == "sair") break;

	try
	{
		// O Kernel gerencia a conversa e decide se precisa chamar o C#
		var resposta = await kernel.InvokePromptAsync(input, new(settings));
		Console.WriteLine($"\nGemini: {resposta}\n");
	}
	catch (Exception ex)
	{
		Console.WriteLine($"\nErro na execução: {ex.Message}");
	}
}

// =========================================================================
// 3. DEFINIÇÃO DOS PLUGINS
// =========================================================================

public class AgendaPlugin
{
	// Simulando dados de uma agenda
	private readonly List<string> _ocupados = ["14:00", "14:30", "16:00"];

	[KernelFunction, Description("Verifica se um horário (ex: 14:00) está livre ou ocupado.")]
	public string VerificarDisponibilidade(string horario)
	{
		Console.WriteLine($"   [LOG C#]: Verificando {horario}...");
		return _ocupados.Contains(horario) ? "Ocupado" : "Livre";
	}

	[KernelFunction, Description("Lista todos os horários que já têm compromisso hoje.")]
	public string ListarAgenda()
	{
		Console.WriteLine("   [LOG C#]: Consultando lista completa...");
		return "Horários ocupados: " + string.Join(", ", _ocupados);
	}
}

1. O Builder: A Fundação do seu Agente

No Semantic Kernel, tudo começa com o Kernel.CreateBuilder(). Pense nele como uma linha de montagem onde você escolhe quais “habilidades” e “conexões” seu assistente terá antes de ele começar a funcionar.

O trecho de código que resolve o nosso problema é este:

var builder = Kernel.CreateBuilder();

builder.AddGoogleAIGeminiChatCompletion(
    modelId: "gemini-flash-latest",
    apiKey: "SUA_CHAVE_AQUI",
    apiVersion: GoogleAIVersion.V1_Beta 
);

Por que esse trecho é vital?

Identidade do Modelo (modelId): Diferente de outras APIs, o Google AI Studio pode ter nomes específicos para os modelos (como o gemini-flash-latest que usamos). O Semantic Kernel usa isso para saber exatamente qual “cérebro” invocar.
Injeção de Dependência: O builder permite que você adicione plugins (como a nossa agenda) de forma modular. Isso significa que a lógica de negócio (C#) e a lógica de IA (Gemini) ficam organizadas e separadas.

2. O Poder dos Plugins: Transformando C# em Habilidades

No post, explicaremos que um Plugin no Semantic Kernel é basicamente uma classe C# comum, mas com “superpoderes” conferidos por atributos.

O que faz o código funcionar?

O trecho que define nosso plugin usa o atributo [KernelFunction]. Veja por que ele é especial:

[KernelFunction]: Este atributo sinaliza ao Kernel que este método específico está disponível para a IA. Sem isso, o Gemini nunca saberia que o método existe.
[Description]: Isso é fundamental. A IA não lê o seu código C#, ela lê as descrições que você escreve. É através dessas frases que o Gemini entende: “Ah, se o usuário perguntar sobre horários, eu devo chamar a função VerificarDisponibilidade”.
Tipagem Forte: O Semantic Kernel traduz automaticamente os tipos do C# (como string ou int) para que a IA saiba o que enviar como parâmetro.

A “Mágica” da Escolha Automática

No seu código, usamos esta configuração: FunctionChoiceBehavior = FunctionChoiceBehavior.Auto()

Isso diz ao Kernel: “Gemini, analise o que o usuário pediu. Se você achar que uma das minhas funções C# pode ajudar a responder, execute-a automaticamente e use o resultado para formular sua resposta final”.

Chegámos à parte onde tudo ganha vida: o Loop de Execução!

3. O Loop de Execução: Onde a Conversa Acontece

Depois de configurarmos o Kernel e carregarmos os Plugins, precisamos de criar um espaço para o utilizador falar com a IA. É aqui que entra o ciclo while.

O que este trecho faz?

while (true)
{
    var resposta = await kernel.InvokePromptAsync(input, new(settings));
    Console.WriteLine($"\nGemini: {resposta}\n");
}

Interação Contínua 🔁: O while (true) garante que o programa não feche após a primeira resposta. Ele mantém o assistente “acordado” até que o utilizador decida sair.
Processamento Inteligente (InvokePromptAsync) : Este é o comando principal. Ele envia o texto do utilizador para o Gemini. Graças às settings que configurámos antes, o Kernel não apenas gera texto, mas também verifica se precisa de “chamar” alguma função do C# antes de responder.
Tratamento de Erros : O bloco try-catch é essencial. Se a internet falhar ou se a API atingir um limite, o programa não vai simplesmente “parar de forma abruptA”; ele avisará o utilizador sobre o problema.

Por que o Semantic Kernel é o Futuro do Desenvolvimento com IA?

O que vimos hoje não foi apenas uma forma de conectar o C# ao Gemini. O Semantic Kernel (SK) introduz uma camada de abstração que resolve problemas críticos de engenharia:

Agnosticismo de Modelo: O código que escrevemos hoje para o Gemini poderia ser adaptado para o GPT-4 ou um modelo local (Llama 3) com alterações mínimas. Isso protege o seu projeto contra mudanças de mercado ou de preços. 🔄
Segurança e Governança: Ao usar Plugins, você controla exatamente o que a IA pode ou não acessar. O Gemini não “inventa” dados da sua agenda; ele solicita ao seu código C#, que atua como um guardião dos dados. 🛡️
Escalabilidade: Diferente de enviar prompts gigantescos, o SK permite que você organize habilidades em bibliotecas reutilizáveis, facilitando a manutenção de projetos grandes e complexos. 🏗️

Em resumo, o Semantic Kernel transforma a IA generativa em uma ferramenta de software previsível e integrada, permitindo que nós, desenvolvedores, foquemos no que realmente importa: resolver problemas de negócio com inteligência.