.NET - Usando Github Models com Semantic Kernel

Hoje vou apresentar o GitHub Models e mostrar como usá-lo na plataforma .NET usando o Semantic Kernel.

O Github Models é uma plataforma unificada dentro do GitHub que serve como um catálogo e ambiente de trabalho para modelos de IA. Ele permite que os desenvolvedores:

Encontrem Modelos: Tenham acesso a uma vasta seleção de modelos populares (como GPT-4.1, Llama, Mistral, etc.), sejam eles proprietários ou open-source, tudo em um só lugar.

Experimentem Rapidamente: Facilita a prototipagem e o ajuste fino de prompts e parâmetros, usando apenas as credenciais do GitHub.

Incorporem Facilmente: Fornece APIs e SDKs simples para integrar o modelo escolhido em aplicações e fluxos de trabalho (como você está fazendo com o .NET).

O objetivo principal do GitHub Models é democratizar e profissionalizar o desenvolvimento de aplicações baseadas em IA para equipes de software. Ele permite:

Integrar a IA ao Dev Workflow - Mover o desenvolvimento de IA de um processo isolado de data science para um fluxo de trabalho de engenharia de software que utiliza o Git e o GitHub (PRs, versionamento, colaboração).

Prototipagem de Baixo Atrito - Permitir que desenvolvedores de software (que não são especialistas em IA) experimentem e testem LLMs gratuitamente e rapidamente, sem precisar configurar infraestrutura complexa (servidores, GPUs) ou gerenciar várias chaves de API de fornecedores diferentes.

Gerenciamento de Prompts como Código - ratar prompts (as instruções que você deu ao seu chatbot) como ativos de primeira classe, permitindo que sejam versionados, revisados e compartilhados em repositórios, garantindo reprodutibilidade.

Segurança e Conformidade - Fornecer uma camada de segurança e gerenciamento (especialmente para clientes Enterprise) sobre quais modelos podem ser usados, mantendo a autenticação e o tráfego dentro do ecossistema Microsoft/Azure.

Para isso ele oferece um conjunto de ferramentas poderosas para ajudar o desenvolvedor:

Playground (Área de Teste) - Uma interface de chat gratuita para experimentar modelos lado a lado, comparar respostas de diferentes LLMs (ex: GPT vs. Llama) e ajustar parâmetros (temperature, max tokens).

Catálogo de Modelos - Uma lista centralizada e curada de modelos de IA de fornecedores como OpenAI, Meta e outros, prontos para uso.

API e SDK (Como no seu Projeto .NET) - Oferece um endpoint unificado (como o que você viu no Azure AI Inference) e um SDK para acessar qualquer modelo do catálogo usando um único PAT (Personal Access Token) do GitHub.

Configurações de Prompt - Permite salvar a instrução de sistema e os parâmetros do modelo (o seu prompt de chatbot de academia) como um arquivo versionável no seu repositório. Isso garante que o prompt usado no desenvolvimento seja o mesmo usado na produção e que ele passe por revisões de código.

Ferramentas de Avaliação - Recursos para medir o desempenho e a qualidade das respostas do modelo (ex: similaridade, relevância), permitindo que você escolha objetivamente o melhor modelo para sua tarefa.

BYOK (Bring Your Own Key) - Permite que organizações usem suas próprias chaves de API do Azure ou OpenAI para acessar modelos personalizados, mas ainda gerenciem o acesso e a segurança através da plataforma GitHub Models.

Github Models e Semantic Kernel

Desta forma , o GitHub Models fornece vários modelos de IA que você pode usar para construir aplicações de IA Generativa (GenAI), particularmente dentro do Semantic Kernel.

O Semantic Kernel oferece uma estrutura leve para construirmos aplicações e agentes de IA que utilizam LLMs e outros serviços em nuvem. Usando o Semantic Kernel, podemos definir fluxos de trabalho, aplicar raciocínio sobre as saídas do LLM e criar fluxos de trabalho de IA complexos.

Para ver isso em ação, vamos construir uma aplicação básica em C# usando um projeto Console que usa Semantic Kernel e GitHub Models.

Vamos iniciar gerando um token PAT - Personal Access Token - para poder acessar o Github Models

Acesse o Github MarketPlace e dentro do marketplace acesse o menu Models para poder escolher o modelo que você quer usar e para o qual vai gerar o token de acesso:

Para este exemplo vou usar o modelo GPT-4.1 da OpenAI . Localize o modelo e clique sobre ele e depois clique em Use this model (Usar este modelo).

A seguir clique em Create a personal access token (Criar um token de acesso pessoal) e a seguir você deverá definir :

- O nome do Token e sua descrição
- A data de expiração e o acesso aos repositórios
- Definir as permissões (Defina o acesso a Models (Modelos) como Read-only (Somente leitura). Isso permitirá o acesso ao GitHub Models)

Após isso clique no botão - Generate token, e,  copie o token que foi gerado para ser usado no projeto.(  pois não poderá vê-lo novamente depois de sair do GitHub)

Agora vamos criar um novo projeto Console usando o VS 2022 com o nome DemoGithubModels

Vamos incluir dois pacotes no projeto :

dotnet add package Microsoft.SemanticKernel
dotnet add package Microsoft.Extensions.Configuration.UserSecrets

Feito isso podemos usar User Secrets (Segredos do Usuário) para armazenar nosso Token PAT do GitHub. Para fazer isso, execute o seguinte no diretório do seu projeto:

dotnet user-secrets init
dotnet user-secrets set "GH_PAT" "<seu-token-PAT>"

O comando dotnet user-secrets init é o ponto de partida para habilitar o mecanismo de User Secrets em um projeto .NET. Ele adicona o identificador de segresod ao arquivo de projeto .csrpoj.

O User Secrets armazena essas informações confidenciais em um arquivo JSON separado e local, fora da estrutura do projeto (geralmente na pasta de perfil de usuário da sua máquina), vinculando-o ao seu projeto através de um ID único.

Isso permite que os desenvolvedores definam e acessem segredos de forma programática (como visto no código var githubPAT = config["GH_PAT"];) sem que o valor real do segredo seja visível para quem não tem acesso à sua máquina de desenvolvimento.

Criando um Chat Bot

Podemos agora criar o código no projeto Console usando a classe Program:

using Microsoft.Extensions.Configuration;
using Microsoft.SemanticKernel;
using Microsoft.SemanticKernel.ChatCompletion;
using OpenAI;
using System.ClientModel;
using System.Text;

// Use User Secrets para nossa configuração
var config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .Build();

// Defina o modelo a ser usado como gpt-4.1
var modelId = "gpt-4.1";

// Define o endpoint do modelo
var uri = "https://models.inference.ai.azure.com";
//var uri = "https://models.github.ai";

// Define nosso Token PAT para a variável `githubPAT`
var githubPAT = config["GH_PAT"];

// Cria um cliente para o nosso GitHub Model
var client = new OpenAIClient(new ApiKeyCredential(githubPAT!), new OpenAIClientOptions
{
    Endpoint = new Uri(uri)
});

// Cria um serviço de conclusão de chat
var builder = Kernel.CreateBuilder();
builder.AddOpenAIChatCompletion(modelId, client);

// Obtém o serviço de conclusão de chat
Kernel kernel = builder.Build();
var chat = kernel.GetRequiredService<IChatCompletionService>();

// cria uma nova instância de ChatHistory
// para manter o contexto da conversa 
var history = new ChatHistory();

//Adiciona uma mensagem de sistema ao ChatHistory para
//instruir o chatbot a atuar como um assistente de academia
history.AddSystemMessage("Você é um chatbot útil de academia chamado GPT-4.1. " +
    "Quando perguntado 'quem é você?', responda com a sua descrição e propósito. " +
    "Em todas as outras interações, você limitará suas respostas a tópicos puramente" +
    " relacionados à academia. Para quaisquer outros tópicos," +
    " ou se não souber uma resposta, diga: 'Sinto muito, não posso ajudar com isso!'");

while (true)
{
    Console.Write("Você: ");    

    var userQ = Console.ReadLine();

    if (string.IsNullOrEmpty(userQ))
    {
        break;
    }    

     history.AddUserMessage(userQ);

    var sb = new StringBuilder();
    var result = chat.GetStreamingChatMessageContentsAsync(history);
    Console.Write("GPT4.1>: ");    

    await foreach (var item in result)
    {
        sb.Append(item);
        Console.Write(item.Content);
    }
    Console.WriteLine();
    history.AddAssistantMessage(sb.ToString());
}

Vamos entender o código:

var config = new ConfigurationBuilder()
    .AddUserSecrets<Program>()
    .Build();

- Cria um objeto de configuração usando ConfigurationBuilder.
- Adiciona segredos do usuário (uma maneira segura de armazenar dados confidenciais como chaves de API) com escopo para a classe Program.
- Constrói o objeto de configuração para acessar os segredos armazenados.

var modelId = "gpt-4.1";
var uri = "https://models.inference.ai.azure.com";
var githubPAT = config["GH_PAT"];

var builder = Kernel.CreateBuilder();
builder.AddOpenAIChatCompletion(modelId, client);

Kernel kernel = builder.Build();
var chat = kernel.GetRequiredService<IChatCompletionService>();

while (true)
{
    Console.Write("Você: ");

     var userQ = Console.ReadLine();

    if (string.IsNullOrEmpty(userQ))
    {
        break;
    }    

     history.AddUserMessage(userQ);

    var sb = new StringBuilder();
    var result = chat.GetStreamingChatMessageContentsAsync(history);
    Console.Write("GPT4.1>: ");    

    await foreach (var item in result)
    {
        sb.Append(item);
        Console.Write(item.Content);
    }
    Console.WriteLine();
    history.AddAssistantMessage(sb.ToString());
}