GitHub Models Integration Guide¶

x-ratelimit-limit-requests: 50
x-ratelimit-remaining-requests: 45
x-ratelimit-limit-tokens: 16000
x-ratelimit-remaining-tokens: 14500

import time

def call_with_retry(prompt, max_retries=3):
    """Call GitHub Models with exponential backoff."""
    for attempt in range(max_retries):
        response = call_github_models(prompt)
        if response.status_code == 429:
            wait_time = 2 ** attempt * 10  # 10s, 20s, 40s
            print(f"Rate limited. Waiting {wait_time}s...")
            time.sleep(wait_time)
            continue
        return response
    raise Exception("Max retries exceeded")

permissions:
  contents: read
  models: read

steps:
  - name: Call Model
    env:
      GH_TOKEN: ${{ github.token }}
    run: |
      gh models run openai/gpt-4o "Hello, world!"

# Set environment variable
export GH_TOKEN="ghp_xxxxxxxxxxxxxxxxxxxx"

# Or use gh auth
gh auth login

# Install gh-models extension
gh extension install github/gh-models

# Verify installation
gh models --help

# Simple prompt
gh models run openai/gpt-4o "Explain async/await in Python"

# Interactive mode
gh models run openai/gpt-4o

# Pipe input
echo "What is this code doing?" | gh models run openai/gpt-4o

# With file context
cat script.py | gh models run openai/gpt-4o "Review this code"

# List available models
gh models list

# Use specific model
gh models run meta/llama-3.3-70b-instruct "Prompt here"
gh models run openai/gpt-4o-mini "Prompt here"
gh models run mistral/codestral-2501 "Prompt here"

# Set temperature (0.0-2.0, default 1.0)
gh models run openai/gpt-4o --temperature 0.7 "Be creative"

# Set max tokens
gh models run openai/gpt-4o --max-tokens 500 "Short answer"

# System prompt
gh models run openai/gpt-4o \
  --system "You are a security expert" \
  "Review this code for vulnerabilities"

POST https://models.github.ai/inference/chat/completions

#!/usr/bin/env python3
"""GitHub Models API client example."""

import os
import requests

def call_github_models(
    prompt: str,
    model: str = "openai/gpt-4o",
    temperature: float = 0.7,
    max_tokens: int = 1000,
    system_prompt: str | None = None,
) -> str:
    """
    Call GitHub Models API.

    Args:
        prompt: User prompt
        model: Model identifier (e.g., "openai/gpt-4o")
        temperature: Sampling temperature (0.0-2.0)
        max_tokens: Maximum response tokens
        system_prompt: Optional system prompt

    Returns:
        Model response text
    """
    token = os.environ.get("GH_TOKEN") or os.environ.get("GITHUB_TOKEN")
    if not token:
        raise ValueError("GH_TOKEN or GITHUB_TOKEN environment variable required")

    messages = []
    if system_prompt:
        messages.append({"role": "system", "content": system_prompt})
    messages.append({"role": "user", "content": prompt})

    response = requests.post(
        "https://models.github.ai/inference/chat/completions",
        headers={
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json",
        },
        json={
            "model": model,
            "messages": messages,
            "temperature": temperature,
            "max_tokens": max_tokens,
        },
        timeout=60,
    )
    response.raise_for_status()

    return response.json()["choices"][0]["message"]["content"]


if __name__ == "__main__":
    result = call_github_models("What is 2 + 2?")
    print(result)

from openai import OpenAI

client = OpenAI(
    base_url="https://models.github.ai/inference",
    api_key=os.environ["GH_TOKEN"],
)

response = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello!"},
    ],
)
print(response.choices[0].message.content)

name: AI Code Review

on:
  pull_request:
    types: [opened, synchronize]
    branches: [main]

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

jobs:
  ai-review:
    name: GPT-5 Code Review
    runs-on: ubuntu-latest
    if: github.event.pull_request.draft == false

    steps:
      - name: Install gh-models extension
        run: gh extension install github/gh-models || true

      - name: Run AI Code Review
        env:
          GH_TOKEN: ${{ github.token }}
        run: |
          # Review prompt with tech stack context
          cat << 'PROMPT_END' > review_prompt.txt
          You are an expert code reviewer for a home security application.
          Tech stack: Python FastAPI, React TypeScript, YOLO26, Nemotron.

          Review for:
          1. Security Issues
          2. Performance
          3. Best Practices
          4. Bugs
          PROMPT_END

          cat pr_diff.txt >> review_prompt.txt

          # Call GPT-4o with fallback to mini
          REVIEW=$(cat review_prompt.txt | gh models run openai/gpt-4o 2>&1) || \
          REVIEW=$(cat review_prompt.txt | gh models run openai/gpt-4o-mini 2>&1)

          echo "$REVIEW" > review_output.md

# Generate docstrings
cat backend/services/detector_client.py | \
  gh models run openai/gpt-4o "Add comprehensive docstrings to this Python code"

# Generate README section
cat backend/api/routes/*.py | \
  gh models run openai/gpt-4o "Create API documentation in markdown format"

# Suggest unit tests
cat backend/services/batch_aggregator.py | \
  gh models run openai/gpt-4o \
  --system "You are a Python testing expert using pytest" \
  "Suggest comprehensive test cases for this service"

# Generate test file skeleton
cat backend/services/nemotron_analyzer.py | \
  gh models run mistral/codestral-2501 \
  "Generate pytest test file with fixtures and edge cases"

# Security review
cat backend/api/routes/events.py | \
  gh models run openai/gpt-4o \
  --system "You are a security expert. Focus on OWASP Top 10" \
  "Analyze this code for security vulnerabilities"

# SQL injection check
grep -r "execute\|raw_sql" backend/ | \
  gh models run openai/gpt-4o "Check for SQL injection risks"

# Generate PR description
gh pr diff 123 | \
  gh models run openai/gpt-4o \
  --system "Generate a clear PR description with summary and test plan" \
  "Describe these changes"

# Generate commit message
git diff --cached | \
  gh models run openai/gpt-4o-mini \
  "Generate a conventional commit message (feat/fix/docs/refactor)"

# Refine risk analysis prompt
cat docs/plans/2024-12-21-dashboard-mvp-design.md | \
  grep -A 50 "Nemotron Prompt" | \
  gh models run openai/gpt-4o \
  "Suggest improvements for this security risk analysis prompt"

# Fallback chain
RESPONSE=$(gh models run openai/gpt-4o "$PROMPT" 2>&1) || \
RESPONSE=$(gh models run openai/gpt-4o-mini "$PROMPT" 2>&1) || \
RESPONSE="Model unavailable"

# Limit to ~20KB (leaves room for prompt overhead)
head -c 20000 large_file.txt > truncated.txt
cat truncated.txt | gh models run openai/gpt-4o "..."

gh models run openai/gpt-4o \
  --system "You are reviewing code for a home security system. \
            The stack is Python FastAPI, React TypeScript, PostgreSQL, Redis. \
            AI models are YOLO26 (detection) and Nemotron (reasoning)." \
  "Review this code"

import hashlib
import json
from pathlib import Path

CACHE_DIR = Path(".github-models-cache")

def cached_query(prompt: str, model: str = "openai/gpt-4o") -> str:
    """Query with file-based caching."""
    cache_key = hashlib.sha256(f"{model}:{prompt}".encode()).hexdigest()[:16]
    cache_file = CACHE_DIR / f"{cache_key}.json"

    if cache_file.exists():
        return json.loads(cache_file.read_text())["response"]

    response = call_github_models(prompt, model=model)

    CACHE_DIR.mkdir(exist_ok=True)
    cache_file.write_text(json.dumps({"prompt": prompt, "response": response}))

    return response

import requests

try:
    response = call_github_models(prompt)
except requests.exceptions.HTTPError as e:
    if e.response.status_code == 429:
        print("Rate limited - try again later")
    elif e.response.status_code == 401:
        print("Authentication failed - check GH_TOKEN")
    elif e.response.status_code == 400:
        print(f"Bad request: {e.response.text}")
    else:
        raise

# macOS
brew install gh

# Ubuntu/Debian
curl -fsSL https://cli.github.com/packages/githubcli-archive-keyring.gpg | \
  sudo dd of=/usr/share/keyrings/githubcli-archive-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/githubcli-archive-keyring.gpg] \
  https://cli.github.com/packages stable main" | \
  sudo tee /etc/apt/sources.list.d/github-cli.list
sudo apt update && sudo apt install gh

# Fedora
sudo dnf install gh

gh extension install github/gh-models

# Verify token is set
echo $GH_TOKEN

# Test authentication
gh auth status

# Re-authenticate if needed
gh auth login

# Check current limits (in workflow)
echo "Remaining: ${{ github.event.rate_limit.remaining }}"

# Wait and retry
sleep 60

# List available models
gh models list

# Use exact name from list
gh models run openai/gpt-4o "test"

gh models run openai/gpt-4o --max-tokens 4000 "Generate detailed output"

response = requests.post(url, json=data, timeout=120)  # 2 minutes