GitHub Models: um guia com exemplos práticos

O que são os GitHub Models?

GitHub Models são modelos de IA incorporados diretamente à plataforma do GitHub para ajudar você a trabalhar de forma mais inteligente e rápida com código, repositórios e documentação. Com GitHub Models, você pode:

• Criar prompts em um editor estruturado que oferece instruções de sistema, entradas de teste e configuração de parâmetros.
• Comparar modelos lado a lado, experimentando prompts idênticos em diferentes modelos.
• Avaliar saídas com métricas como similaridade, relevância ou avaliadores personalizados para acompanhar o desempenho.
• Armazenar configurações de prompt como arquivos .prompt.yml para controle de versão e reprodutibilidade.
• Integrar modelos em produção via SDKs ou REST API.

O controle de versão permite colaborar em prompts da mesma forma que em código. Ao fazer commit de um arquivo de prompt, ele segue o mesmo fluxo de pull request, permitindo ao seu time saber quem mudou, o que foi alterado e por quê.

GitHub Models é uma plataforma útil feita para times de software que querem usar IA mantendo-a integrada aos seus fluxos de trabalho.

Recursos principais do GitHub Models

Antes de entrar em como usar o GitHub Models, confira rapidamente os recursos centrais:

1. Hospedado pelo GitHub: você não gerencia servidores ou GPUs. Os modelos rodam na infraestrutura do GitHub, oferecendo segurança e performance em nível corporativo por padrão.
2. Prompts e esquemas estruturados: você define a estrutura exata de entrada e saída via schemas JSON. Isso torna as respostas previsíveis e fáceis de integrar.
3. Comparações entre múltiplos modelos: o Playground permite testar prompts em vários modelos ao mesmo tempo. Assim, você compara custo e desempenho para escolher a melhor opção para sua necessidade.
4. Ferramentas de avaliação: avaliadores integrados fornecem métricas quantitativas, como relevância ou groundedness. Você também pode criar avaliadores personalizados para checagens específicas do seu domínio.
5. Caminhos de integração: use o Playground para experimentos rápidos, a REST API para automação, GitHub Actions para CI/CD e a CLI ou o Copilot Chat para uso conversacional.
6. Presets e editor de prompts: salve um preset do estado do seu playground, incluindo parâmetros, histórico do chat e mais, para compartilhar ou iterar depois. O editor de prompts permite desenhar seus prompts.

Resumindo, o GitHub Models foi pensado para levar sua ideia do conceito à produção. Você começa com experimentos, avalia e depois faz o deploy. Tudo isso em um só lugar. 

Como usar o GitHub Models

Você pode interagir com o GitHub Models de várias maneiras. O caminho certo depende se você está experimentando, automatizando um fluxo ou integrando IA a um aplicativo.

As seções a seguir trazem explicações detalhadas dos métodos, com exemplos relevantes.

Usando o GitHub Models no Playground

O playground é meu ponto de partida favorito. É um sandbox onde você experimenta prompts, ajusta parâmetros e compara modelos lado a lado. 

Você acessa pelo GitHub Marketplace ou diretamente de um repositório.

Vamos começar escolhendo um modelo. Para abrir um modelo no playground, acesse o GitHub Marketplace e selecione um modelo no menu suspenso. Você pode clicar em “View all models” para explorar o catálogo e então escolher “Playground” em qualquer modelo.

No playground, você pode ajustar parâmetros como temperatura, máximo de tokens e penalidades de presença ou frequência. 

Captura de tela de um prompt de sistema e um prompt do usuário com a descrição de um bug.

Ao alternar para a guia “Code”, você vê a chamada de API correspondente usando um SDK na linguagem de sua preferência, o que permite replicá-la nos seus scripts. 

E se você clicar em "Compare" ao lado do seu modelo, pode selecionar um segundo modelo para comparar. O playground espelha seu prompt para ambos e exibe as respostas lado a lado. É ótimo para comparar modelos para tarefas específicas.

Mas o ideal é comparar dois modelos não só por intuição, e sim por métricas objetivas. É aí que entram os avaliadores. Você pode aplicar avaliadores como similaridade ou groundedness a cada saída, ou até criar avaliadores personalizados para métricas do seu domínio. 

E se encontrar uma combinação de prompt e parâmetros que gosta, salve como preset. Presets armazenam seu estado, parâmetros e, opcionalmente, o histórico do chat. Você pode carregar depois ou compartilhar por URL — perfeito para colaborar com o time.

Criando um novo preset que pode ser versionado e compartilhado com seu time.

Em projetos pessoais, já usei o playground para gerar testes de unidade, criar resumos de commits e até pensar em mensagens de erro. É a forma mais rápida de ver o que um modelo faz com o contexto do seu repositório.

Usando o GitHub Models via API

O playground é ótimo para conhecer os modelos, explorar recursos e fazer testes.

Mas vale dar um passo além e usar o GitHub Models para automatizar fluxos ou integrar em seus aplicativos. Nesse caso, você vai precisar da API do GitHub Models.

Aqui vai um panorama de como usar a API bruta:

• Endpoint: POST /inference/chat/completions ou /orgs/{org}/inference/chat/completions para requisições no escopo da organização.
• Autenticação: o token deve ter a permissão models: read (um PAT granular ou token de GitHub App). O header Authorization: Bearer <TOKEN> é obrigatório.
• Corpo da requisição: informe o ID do modelo (por exemplo, openai/gpt‑4.1) e um array de mensagens, cada uma com um role (system, user, assistant ou developer) e conteúdo. Você também pode definir parâmetros como max_tokens, temperature, frequency_penalty, presence_penalty e response_format.
• Resposta: a API retorna um objeto JSON com um array choices contendo a resposta do modelo.

Abaixo, um exemplo simples em Python usando requests (assumindo que você tenha um personal access token com escopo models: read).

Você pode criar o token nas suas configurações do GitHub.

import osimport requests# Replace with your fine-grained PATtoken = os.getenv('GITHUB_PAT')url = "https://models.github.ai/inference/chat/completions"payload = {    "model": "openai/gpt-4.1",    "messages": [        {"role": "system", "content": "You are a helpful coding assistant."},        {"role": "user", "content": "Explain the concept of recursion."}    ],    "max_tokens": 150,    "temperature": 0.3}headers = {    "Content-Type": "application/json",    "Accept": "application/vnd.github+json",    "Authorization": f"Bearer {token}"}response = requests.post(url, json=payload, headers=headers)print(response.json())

Esse script envia um prompt de chat para o modelo GPT‑4.1 e imprime a resposta do assistente. Na prática, você incorporaria essa chamada em um bot, um workflow de CI ou uma ferramenta personalizada.

Você também pode conferir a guia “Code” na interface do playground do GitHub Models, caso queira usar uma biblioteca Python de nível mais alto para se comunicar com seu modelo do GitHub, ou até outra linguagem. Na guia de código, no caso do Python, dá para escolher entre usar o Azure AI Inference SDK ou o OpenAI SDK.

Seção de código para se comunicar com um GitHub Model usando Azure AI Inference SDK ou OpenAI SDK

Eu recomendo essa abordagem em vez de usar o pacote requests puro, pois ela abstrai parte da complexidade. Mas o código não está disponível para todos os modelos.

Integrando modelos de IA aos fluxos de trabalho

Quando você estiver confortável com o playground e a API, o verdadeiro poder vem ao integrar modelos aos seus processos diários de desenvolvimento. O GitHub oferece extensões para o Copilot Chat, GitHub Actions e a GitHub CLI.

Extensão do Copilot Chat

Se você tem uma assinatura do Copilot, instale a GitHub Models Copilot Extension. Ela permite conversar diretamente com modelos específicos dentro do Copilot Chat e até pedir recomendações com base em critérios (por exemplo, “Qual é um modelo de baixo custo que suporta function calling?”). Você pode digitar @models SEU‑PROMPT no chat e escolher o modelo.

GitHub Actions

Você pode chamar a inference API dentro de um arquivo de workflow definindo a permissão models: read e fazendo uma requisição HTTP. A documentação do GitHub traz um exemplo usando curl para chamar a API e postar a resposta na saída do workflow. 

Segue o trecho:

name: Use GitHub Modelson: [push]permissions:  models: readjobs:  call-model:    runs-on: ubuntu-latest    steps:      - name: Call AI model        env:          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}        run: |          curl "https://models.github.ai/inference/chat/completions" \             -H "Content-Type: application/json" \             -H "Authorization: Bearer $GITHUB_TOKEN" \             -d '{              "messages": [                  {                     "role": "user",                     "content": "Explain the concept of recursion."                  }               ],               "model": "openai/gpt-4o"            }'

Extensão da GitHub CLI

Às vezes eu prefiro usar a linha de comando para enviar consultas a um modelo — sou dev raiz.

Se você também prefere o terminal, instale a CLI e a extensão GitHub Models. 

Você encontra as instruções de instalação da CLI na documentação oficial da CLI.

Primeiro, rode gh auth login para entrar na sua conta do GitHub.

Saída da autenticação com a GitHub CLI (Imagem do autor).

Depois de autenticar, rode gh extension install https://github.com/github/gh-models. 

Então você pode enviar um prompt com um único comando: 

# ask GPT-4 why the sky is bluegh models run openai/gpt-4.1 "why is the sky blue?"# or start a chat sessiongh models run

Perfeito para scripts ou quando você precisa de respostas rápidas sem sair do terminal.

GitHub Models em nível corporativo

Se você faz parte de uma organização maior, o GitHub Models oferece controles e personalização em nível enterprise.

Segundo a documentação do GitHub, os benefícios incluem:

• Gestão centralizada de modelos: administradores controlam quais modelos e provedores de IA ficam disponíveis para os desenvolvedores da organização.
• Modelos personalizados: você pode usar suas próprias chaves de API de LLM para conectar modelos externos ou customizados, permitindo que a organização pague diretamente via assinaturas existentes.
• Governança e conformidade: imponha padrões e monitore o uso dos modelos para garantir conformidade com exigências como GDPR, SOC 2 ou ISO 27001.
• Otimização de custos: avalie custo e desempenho de diferentes modelos e selecione os mais econômicos para tarefas menos críticas.
• Colaboração e controle de versão: prompts e resultados ficam no repositório e passam por pull requests, permitindo que os times iterem com total visibilidade.
• API de alta vazão: use a Models REST API para gerenciar prompts, executar inferência programaticamente e integrar com GitHub Actions ou sistemas externos.

Em projetos grandes nos quais trabalhei, esses controles fazem diferença. Quando vários times estão experimentando IA, você não quer 50 prompts para a mesma tarefa nem contas de API sem controle. O GitHub Models permite impor prompts consistentes e avaliar modelos entre times, garantindo que toda a organização aproveite o aprendizado coletivo.

Quando usar o GitHub Models?

Com tantas ferramentas de IA disponíveis, quando faz sentido usar GitHub Models em vez de alternativas como a API da OpenAI diretamente ou só o Copilot? 

Aqui vão algumas diretrizes baseadas na minha experiência:

• Se você já usa o GitHub e quer configuração mínima, a aba Models e o playground são perfeitos. Tudo é hospedado, e você foca nos prompts e na avaliação, não na infraestrutura.
• Se você precisa de prompts e respostas estruturados (ex.: saída JSON para um pipeline automático de rotulagem), o suporte a schemas do GitHub Models ajuda a garantir consistência.
• Se você precisa comparar modelos ou iterar em prompts em equipe, as ferramentas de comparação e avaliação integradas tornam a experimentação muito mais fácil do que chamar a API da OpenAI manualmente.
• Se você está criando ferramentas internas (bots, actions, scripts) e quer manter tudo no ecossistema GitHub, a Models API integra bem com GitHub Actions, CLI e Copilot.
• Se você está experimentando ou aprendendo prompt engineering, comece pelo Playground. Depois, avance para a integração via API.

Por outro lado, se você já tem um pipeline robusto com outro provedor de IA ou precisa de um modelo que o GitHub não hospeda, talvez valha manter seu setup atual. GitHub Models é mais uma ferramenta na sua caixa, não um substituto para tudo relacionado a IA.

Conclusão

Com o GitHub Models, desenvolvedores conseguem ir da concepção do prompt à integração em produção sem sair do repositório. 

Você pode experimentar modelos no Playground, avaliá-los com métricas integradas, salvar prompts para colaboração versionada e chamar os modelos via API, GitHub Actions ou CLI. Para times corporativos, o GitHub adiciona governança, controle de custos e a possibilidade de trazer seus próprios modelos, resolvendo várias preocupações sobre adoção de IA em larga escala.

Minha recomendação? Comece pequeno. Use o playground para testar prompts, resumir issues ou gerar documentação.  Depois, integre seu melhor prompt em um GitHub Action para uma tarefa repetitiva. Com o tempo, você vai descobrir onde a IA mais economiza seu tempo. E, como tudo é versionado e transparente, dá para construir confiança e aprimorar seu fluxo conforme avança.