GitHub Models: Integración Sencilla de IA para Flujos DevOps

7 minute read

GitHub Models Simple AI Workflows

Me topé con GitHub Models mientras navegaba las últimas funcionalidades de GitHub y decidí probarlo. Lo que me llamó la atención no fue solo otra API de IA—sino la integración fluida con GitHub Actions y el hecho de que es completamente gratuito para la mayoría de flujos de desarrollo.

Después de experimentar con él durante un tiempo, me di cuenta de que GitHub Models llena un nicho específico: integración de IA directa y simple sin la complejidad de configurar servicios externos o manejar claves API. Esto es lo que aprendí y cómo se compara con soluciones más sofisticadas.

🚀 ¿Qué es GitHub Models?

GitHub Models es el servicio nativo de inferencia de IA de GitHub que proporciona acceso gratuito a modelos de nivel empresarial directamente dentro de tus repositorios. Piénsalo como IA-como-Servicio, pero integrado en la plataforma donde ya vive tu código.

Modelos Clave Disponibles

OpenAI GPT-4o: Ideal para análisis complejos y razonamiento
GPT-4o mini: Más rápido y económico para tareas simples
Meta Llama 3.1 (8B, 70B, 405B): Alternativas de código abierto
Microsoft Phi 3: Eficiente para respuestas rápidas
Mistral Large: Razonamiento multilingüe y especializado

Lo Que Lo Hace Diferente

Sin configuración externa: Usa tus credenciales de GitHub
Nivel gratuito: 50,000 tokens/mes en todos los modelos
Integración nativa con Actions: Sin claves API en secretos
Privacidad primero: Tus prompts no entrenan los modelos

🔧 Primeros Pasos: El Enfoque Oficial de GitHub

La forma más simple de usar GitHub Models es a través de llamadas directas a la API en GitHub Actions. Aquí está la configuración básica:

Configuración de Autenticación

GitHub Models usa el GITHUB_TOKEN integrado de tu repositorio con el permiso models: read:

name: Flujo de Análisis con IA

on: [push, pull_request]

permissions:
  contents: read
  models: read  # Requerido para GitHub Models

jobs:
  ai-analysis:
    runs-on: ubuntu-latest
    steps:
      - name: Analizar con IA
        env:
          GITHUB_TOKEN: $
        run: |
          curl -X POST "https://models.github.ai/inference/chat/completions" \
            -H "Content-Type: application/json" \
            -H "Authorization: Bearer $GITHUB_TOKEN" \
            -d '{
              "model": "openai/gpt-4o",
              "messages": [
                {"role": "user", "content": "Analiza esto en busca de problemas potenciales"}
              ]
            }'

Usando la Action actions/ai-inference

GitHub proporciona una action oficial que simplifica las llamadas a la API:

- name: Ejecutar Análisis con IA
  id: ai-analysis
  uses: actions/ai-inference@v1
  with:
    model: 'gpt-4o'
    system-prompt: 'Eres un ingeniero DevOps revisando infraestructura'
    prompt: |
      Analiza los siguientes resultados de validación de Terraform:
      $

      Proporciona:
      1. Evaluación general
      2. Hallazgos clave
      3. Recomendaciones
      4. Consideraciones de seguridad

🎯 Ejemplos del Mundo Real

1. Análisis Inteligente de Reportes de Bugs

Este flujo analiza reportes de bugs para determinar si contienen suficiente información para reproducirlos:

name: Análisis de Reporte de Bug

on:
  issues:
    types: [opened, edited]

permissions:
  issues: write
  models: read

jobs:
  analyze-bug-report:
    if: contains(github.event.issue.labels.*.name, 'bug')
    runs-on: ubuntu-latest

    steps:
    - name: Analizar Reporte de Bug
      env:
        GITHUB_TOKEN: $
      run: |
        ISSUE_CONTENT="$ - $"

        ANALYSIS=$(curl -s -X POST "https://models.github.ai/inference/chat/completions" \
          -H "Content-Type: application/json" \
          -H "Authorization: Bearer $GITHUB_TOKEN" \
          -d "{
            \"model\": \"openai/gpt-4o\",
            \"messages\": [
              {
                \"role\": \"system\",
                \"content\": \"Analiza reportes de bugs para viabilidad de reproducción. Devuelve JSON con reproducible (boolean), missing_info (array), y confidence (0-1).\"
              },
              {
                \"role\": \"user\",
                \"content\": \"$ISSUE_CONTENT\"
              }
            ],
            \"max_tokens\": 500
          }")

        REPRODUCIBLE=$(echo "$ANALYSIS" | jq -r '.choices[0].message.content' | jq -r '.reproducible')

        if [ "$REPRODUCIBLE" = "true" ]; then
          gh issue edit $ --add-label "ready-for-reproduction"
        else
          gh issue edit $ --add-label "needs-more-info"
        fi

2. Validación de Infraestructura con IA

Basado en tu ejemplo de flujo, aquí está cómo analizar resultados de validación de Terraform:

name: Revisión de Infraestructura

on:
  pull_request:
    paths: ['**.tf', '**.tfvars']

permissions:
  contents: read
  models: read
  pull-requests: write

jobs:
  terraform-ai-review:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4

    - name: Validar Terraform
      id: validate
      run: |
        terraform init
        terraform validate -json > validation.json

    - name: Análisis de Infraestructura con IA
      uses: actions/ai-inference@v1
      id: ai-analysis
      with:
        model: 'gpt-4o'
        system-prompt: 'Eres un ingeniero DevOps senior revisando configuraciones de Terraform'
        prompt: |
          Analiza este resultado de validación de Terraform:

          $

          Proporciona:
          1. **Evaluación General**: Resumen del estado de validación
          2. **Hallazgos Clave**: Problemas importantes o éxitos identificados
          3. **Recomendaciones**: Acciones específicas para mejorar la infraestructura
          4. **Consideraciones de Seguridad**: Cualquier implicación de seguridad
          5. **Mejores Prácticas**: Sugerencias para seguir las mejores prácticas de AWS/Terraform

          Formatear como secciones markdown claras.

    - name: Publicar Análisis en PR
      if: github.event_name == 'pull_request'
      env:
        GITHUB_TOKEN: $
      run: |
        gh pr comment $ --body "
        ## 🤖 Análisis de Infraestructura con IA

        **Analizado por**: $

        $

        ---
        *Este análisis fue generado por IA usando GitHub Models. Por favor revisa las recomendaciones cuidadosamente antes de implementar.*
        "

3. Generación Automatizada de Changelog

Simplifica la gestión de releases con changelogs generados por IA:

name: Generar Changelog

on:
  push:
    tags: ['v*']

permissions:
  contents: write
  models: read

jobs:
  generate-changelog:
    runs-on: ubuntu-latest

    steps:
    - uses: actions/checkout@v4
      with:
        fetch-depth: 0

    - name: Obtener Commits Desde Último Tag
      id: commits
      run: |
        LAST_TAG=$(git describe --tags --abbrev=0 HEAD^)
        COMMITS=$(git log --pretty=format:"%h %s" $LAST_TAG..HEAD)
        echo "commits<<EOF" >> $GITHUB_OUTPUT
        echo "$COMMITS" >> $GITHUB_OUTPUT
        echo "EOF" >> $GITHUB_OUTPUT

    - name: Generar Changelog con IA
      env:
        GITHUB_TOKEN: $
      run: |
        CHANGELOG=$(curl -s -X POST "https://models.github.ai/inference/chat/completions" \
          -H "Content-Type: application/json" \
          -H "Authorization: Bearer $GITHUB_TOKEN" \
          -d "{
            \"model\": \"openai/gpt-4o\",
            \"messages\": [
              {
                \"role\": \"system\",
                \"content\": \"Genera changelogs concisos a partir de commits de git. Agrupa en Funcionalidades, Correcciones de Bugs y Mejoras. Usa viñetas.\"
              },
              {
                \"role\": \"user\",
                \"content\": \"Genera changelog para estos commits:\n$\"
              }
            ]
          }")

        CONTENT=$(echo "$CHANGELOG" | jq -r '.choices[0].message.content')

        gh release create $ \
          --title "Release $" \
          --notes "$CONTENT"

⚖️ GitHub Models vs Claude Code: Cuándo Elegir Qué

Después de usar tanto GitHub Models como Claude Code Action, aquí está cómo se comparan:

GitHub Models: El Enfoque de Llamada de Función

Ideal para:

✅ Tareas simples de análisis y clasificación
✅ Generación y resumen de texto
✅ Flujos de toma de decisiones rápidas
✅ Equipos que quieren cero dependencias externas
✅ Proyectos sensibles al costo (nivel gratuito)

Características:

Menos agéntico: Patrón directo prompt → respuesta
Integración simple: Solo llamadas API en flujos
Contexto limitado: Interacciones de prompt único
Configuración rápida: No se necesitan cuentas externas

# Patrón GitHub Models
- name: Análisis Simple
  run: |
    curl -X POST "https://models.github.ai/inference/chat/completions" \
      -H "Authorization: Bearer $GITHUB_TOKEN" \
      -d '{"model": "gpt-4o", "messages": [...]}'

Claude Code Action: El Asistente Agéntico

Ideal para:

✅ Revisiones e implementaciones de código complejas
✅ Razonamiento y planificación de múltiples pasos
✅ Resolución interactiva de problemas
✅ Refactorización y mejoras de código
✅ Discusiones conscientes del contexto

Características:

Más agéntico: Puede usar herramientas, implementar cambios, razonar a través de problemas
Interactivo: Responde a menciones @claude en PRs/issues
Consciente del contexto: Entiende la estructura del repositorio
Requiere configuración: Clave API de Anthropic o suscripción Claude Pro / Max

# Patrón Claude Code
- name: Revisión de Código Claude
  uses: anthropics/claude-code-action@v1
  with:
    anthropic_api_key: $
    mode: 'review'

Matriz de Decisión

Caso de Uso	GitHub Models	Claude Code
Clasificación de reportes de bug	✅ Perfecto	❌ Exagerado
Análisis simple de código	✅ Ideal	❌ Muy complejo
Generación de changelog	✅ Excelente	❌ Innecesario
Validación de infraestructura	✅ Bueno	✅ Mejor para casos complejos
Implementación de código	❌ Limitado	✅ Excelente
Refactorización compleja	❌ No puede implementar	✅ Ideal
Planificación de múltiples pasos	❌ Solo disparo único	✅ Sobresale aquí
Debugging interactivo	❌ Sin conversación	✅ Excelentes conversaciones

Comparación de Costos

Solución	Nivel Gratuito	Precios de Pago	Complejidad de Configuración
GitHub Models	50K tokens/mes	Parte del plan GitHub (futuro)	⭐⭐⭐⭐⭐ Sin configuración
Claude Code	Ninguno	$20/mes (Claude Pro)	⭐⭐⭐ Clave API o suscripción

🔧 Comandos CLI Esenciales

Si quieres experimentar localmente, aquí están los comandos CLI que funcionan:

# Instalar GitHub CLI (si no está instalado)
brew install gh  # macOS
sudo apt install gh  # Ubuntu

# Instalar extensión GitHub Models
gh extension install github/gh-models

# Listar modelos disponibles
gh models list

# Probar un prompt simple
gh models run openai/gpt-5 "Hola desde CLI"

🚀 Primeros Pasos: Tu Primer Flujo con IA

Semana 1: Elige Un Caso de Uso

Selecciona la oportunidad de automatización más simple:

Análisis de reportes de bug
Generación de resúmenes de PR
Comentarios simples de revisión de código

Pasos de Implementación

Agrega permisos a tu flujo:
```
permissions:
  models: read
```
Copia un ejemplo básico y modifícalo para tus necesidades
Prueba con prompts pequeños para entender el uso de tokens
Itera y expande basado en resultados

Consejos Pro

Empieza pequeño: Comienza con prompts de 1-2 oraciones
Monitorea uso: Revisa tu consumo de tokens en configuraciones de GitHub
Agrega respaldos: Maneja fallos de API con gracia
Valida salidas: Las respuestas de IA no siempre son correctas

🎯 En Resumen

GitHub Models sobresale en integración de IA simple y directa donde necesitas análisis rápido o generación de texto dentro de tus flujos existentes. Es perfecto para equipos que quieren capacidades de IA sin dependencias externas o configuración compleja.

Elige GitHub Models cuando necesites:

Análisis y clasificación simples
Integración de IA sin configuración
Automatización económica
Control directo de API

Elige Claude Code cuando necesites:

Razonamiento y planificación complejos
Capacidades de implementación de código
Resolución interactiva de problemas
Comportamiento agéntico de múltiples pasos

La belleza de GitHub Models radica en su simplicidad y accesibilidad. Puedes agregar capacidades de IA a tus flujos en minutos, no horas, y empezar a ver valor inmediatamente.

Empieza con GitHub Models para tareas simples, luego gradúa a Claude Code cuando necesites asistencia de IA más sofisticada. Ambos tienen su lugar en el kit de herramientas DevOps moderno.

¿Has probado GitHub Models en tus flujos? ¿Qué casos de uso te emocionan más? Comparte tus experimentos y resultados en los comentarios abajo.

Share on

Twitter Facebook Google+ LinkedIn

Luis M. Gallardo D.