GitHub Models: Ein Leitfaden mit praxisnahen Beispielen

Was sind GitHub Models?

GitHub Models sind KI-Modelle, die direkt in GitHubs Plattform integriert sind, um dich beim Arbeiten mit Code, Repositories und Dokumentation schneller und smarter zu machen. Mit GitHub Models kannst du:

• Prompts entwickeln in einem strukturierten Editor, der Systemanweisungen, Testeingaben und Parameterkonfiguration unterstützt.
• Modelle direkt vergleichen, indem du identische Prompts mit verschiedenen Modellen testest.
• Ausgaben evaluieren mit Kennzahlen wie Ähnlichkeit, Relevanz oder eigenen Evaluatoren, um die Leistung zu verfolgen.
• Prompt-Konfigurationen speichern als .prompt.yml-Dateien für Versionierung und Reproduzierbarkeit.
• Modelle integrieren bis in die Produktion über SDKs oder die REST-API.

Mit Versionskontrolle kannst du an Prompts zusammenarbeiten wie an Code. Wenn du eine Prompt-Datei committest, durchläuft sie denselben Pull-Request-Prozess. So weiß dein Team, wer was und warum geändert hat.

GitHub Models ist eine praktische Plattform für Softwareteams, die KI nutzen wollen und sie eng in ihre bestehenden Workflows einbinden möchten.

Kernfunktionen von GitHub Models

Bevor wir tiefer einsteigen, hier kurz die wichtigsten Funktionen:

1. Von GitHub gehostet: Du musst keine Server oder GPUs verwalten. Die Modelle laufen auf GitHubs Infrastruktur – standardmäßig mit Enterprise-Security und -Performance.
2. Strukturierte Prompts und Schemas: Du definierst die genaue Ein- und Ausgabestruktur per JSON-Schema. Das macht Antworten vorhersagbar und leicht integrierbar.
3. Vergleich mehrerer Modelle: Im Playground testest du Prompts parallel gegen mehrere Modelle. So vergleichst du Kosten und Performance und wählst die beste Option für deinen Bedarf.
4. Evaluations-Tools: Integrierte Evaluatoren liefern quantitative Metriken wie Relevanz oder Groundedness. Du kannst auch eigene Evaluatoren für domänenspezifische Checks schreiben.
5. Integrationspfade: Nutze den Playground für schnelle Experimente, die REST-API für Automatisierung, GitHub Actions für CI/CD sowie CLI oder Copilot Chat für dialogische Nutzung.
6. Presets und Prompt-Editor: Speichere einen Preset deines Playground-Status – inklusive Parametern, Chatverlauf u. v. m. – um ihn später zu teilen oder zu iterieren. Der Prompt-Editor hilft dir beim Design deiner Prompts.

Kurz gesagt: GitHub Models hilft dir, Ideen vom Konzept bis zur Produktion zu bringen. Du startest mit Experimenten, evaluierst und stellst dann bereit – alles an einem Ort. 

So nutzt du GitHub Models

Du kannst auf mehrere Arten mit GitHub Models arbeiten. Der richtige Weg hängt davon ab, ob du experimentierst, einen Workflow automatisierst oder KI in eine Anwendung integrierst.

Die folgenden Abschnitte erklären die Methoden im Detail – inklusive passender Beispiele.

GitHub Models im Playground nutzen

Der Playground ist mein Lieblingsstartpunkt. Eine Sandbox, in der du mit Prompts experimentierst, Parameter anpasst und Modelle direkt nebeneinander vergleichst. 

Du erreichst ihn über den GitHub Marketplace oder direkt aus einem Repository.

Beginnen wir mit der Modellauswahl. Um ein Modell im Playground zu öffnen, gehe zum GitHub Marketplace und wähle ein Modell im Dropdown. Klicke auf „View all models“, um den Katalog zu durchsuchen, und anschließend auf „Playground“ beim gewünschten Modell.

Im Playground kannst du Parameter wie Temperature, maximale Tokens sowie Presence- oder Frequency-Penalties anpassen. 

Screenshot eines System-Prompts und eines User-Prompts mit einer Bug-Beschreibung.

Im Tab „Code“ siehst du den passenden API-Call mit einem SDK in der Programmiersprache deiner Wahl, um ihn in deinen Skripten zu reproduzieren. 

Und mit einem Klick auf "Compare" neben deinem Modell wählst du ein zweites Modell zum Vergleich. Der Playground spiegelt deinen Prompt an beide Modelle und zeigt die Antworten nebeneinander. Ideal, um Modelle für bestimmte Aufgaben gegenüberzustellen.

Du willst zwei Modelle aber nicht nur nach Bauchgefühl vergleichen, sondern mit objektiven Metriken. Hier kommen die Evaluatoren ins Spiel. Du kannst Evaluatoren wie Ähnlichkeit oder Groundedness auf jede Ausgabe anwenden oder eigene, domänenspezifische Metriken implementieren. 

Wenn du eine gelungene Kombination aus Prompt und Parametern gefunden hast, speichere sie als Preset. Presets halten deinen Status, Parameter und optional den Chatverlauf fest. Du kannst sie später laden oder per URL teilen – perfekt für die Zusammenarbeit im Team.

Erstellen eines neuen Presets, das versioniert und mit deinem Team geteilt werden kann.

In meinen privaten Projekten habe ich den Playground genutzt, um Unit-Tests zu generieren, Commit-Zusammenfassungen zu erstellen und sogar Fehlermeldungen zu brainstormen. Es ist der schnellste Weg zu sehen, was ein Modell mit dem Kontext deines Repos leisten kann.

GitHub Models über die API nutzen

Der Playground ist super, um die Modelle kennenzulernen, Features auszuprobieren und ein Gefühl dafür zu bekommen.

Ich empfehle dir aber, einen Schritt weiterzugehen: Nutze GitHub Models, um Workflows zu automatisieren oder in deine Anwendungen zu integrieren. Dafür brauchst du die GitHub-Models-API.

Hier ein Überblick, wie du die rohe API verwendest:

• Endpoint: POST /inference/chat/completions oder /orgs/{org}/inference/chat/completions für organisationsweite Requests.
• Authentifizierung: Das Token benötigt die Berechtigung models: read (feingranulares PAT oder GitHub-App-Token). Der Header Authorization: Bearer <TOKEN> ist erforderlich.
• Request-Body: Gib die model ID an (z. B. openai/gpt‑4.1) und ein Array von Messages, jeweils mit role (system, user, assistant oder developer) und Content. Du kannst zudem Parameter wie max_tokens, temperature, frequency_penalty, presence_penalty und response_format setzen.
• Response: Die API liefert ein JSON-Objekt mit einem choices-Array, das die Antwort des Modells enthält.

Unten ein einfaches Python-Beispiel mit requests (vorausgesetzt, du hast ein Personal Access Token mit dem Scope models: read).

Du kannst das Token in deinen GitHub-Einstellungen erstellen.

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())

Dieses Skript sendet einen Chat-Prompt an das GPT‑4.1‑Modell und gibt die Antwort des Assistenten aus. In der Praxis bindest du diesen Call in einen Bot, einen CI‑Workflow oder ein eigenes Tool ein.

Du kannst dir auch den Tab „Code“ in der GitHub-Models-Playground-UI ansehen, wenn du lieber eine High-Level-Python-Bibliothek zur Kommunikation mit deinem GitHub-Modell nutzen willst – oder sogar eine andere Programmiersprache. Im Code-Tab kannst du für Python zwischen Azure AI Inference SDK und OpenAI SDK wählen.

Code-Bereich zur Kommunikation mit einem GitHub-Modell über das Azure AI Inference SDK oder das OpenAI SDK

Diese Variante empfehle ich gegenüber rohen Requests, da sie Komplexität abstrahiert. Der Code ist jedoch nicht für alle Modelle verfügbar.

KI-Modelle in Workflows integrieren

Wenn du mit Playground und API vertraut bist, entsteht die eigentliche Power durch die Integration in deine täglichen Entwicklungsprozesse. GitHub bietet Erweiterungen für Copilot Chat, GitHub Actions und die GitHub CLI.

Copilot-Chat-Erweiterung

Wenn du ein Copilot-Abo hast, installiere die GitHub Models Copilot Extension. Damit chattest du direkt mit spezifischen Modellen im Copilot Chat und kannst dir sogar anhand von Kriterien ein Modell empfehlen lassen (z. B. „Welches günstige Modell unterstützt Function Calling?“). Tippe @models DEIN‑PROMPT in den Chat und wähle dein Modell.

GitHub Actions

Du kannst die Inference-API in einem Workflow-File aufrufen, indem du die Berechtigung models: read setzt und eine HTTP-Anfrage stellst. Die GitHub-Dokumentation zeigt ein Beispiel mit curl, das die API aufruft und die Antwort in die Workflow-Ausgabe schreibt. 

Hier der Snippet:

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"            }'

GitHub-CLI-Erweiterung

Ich nutze gern die Kommandozeile, um schnell Anfragen an ein Modell zu schicken – ja, echter Entwickler-Nerd.

Wenn du die CLI ebenfalls bevorzugst, installiere das CLI-Tool und die GitHub-Models-CLI-Erweiterung. 

Die Installationsanleitung für das CLI-Tool findest du in den offiziellen CLI-Dokumenten.

Führe zuerst gh auth login aus, um dich bei GitHub anzumelden.

Ausgabe der Authentifizierung mit der GitHub CLI (Bild: Autor).

Nach der Anmeldung installierst du die Erweiterung mit gh extension install https://github.com/github/gh-models. 

Danach kannst du mit einem einzigen Befehl ein Modell ansprechen: 

# 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

Perfekt für Skripting oder wenn du schnelle Antworten brauchst, ohne das Terminal zu verlassen.

GitHub Models im Enterprise-Einsatz

Wenn du in einer größeren Organisation arbeitest, bietet GitHub Models Funktionen auf Enterprise-Niveau und umfangreiche Anpassungen.

Laut GitHubs Dokumentation gehören dazu:

• Zentrales Modellmanagement: Admins steuern, welche KI-Modelle und -Provider für Entwickler in der gesamten Organisation verfügbar sind.
• Eigene Modelle: Bringe eigene LLM-API-Keys mit, um externe oder kundenspezifische Modelle zu verbinden – die Abrechnung läuft über bestehende Abos.
• Governance und Compliance: Setze Standards durch und überwache die Nutzung, um z. B. GDPR, SOC 2 oder ISO 27001 einzuhalten.
• Kostenoptimierung: Vergleiche Kosten und Performance verschiedener Modelle und wähle für weniger kritische Aufgaben die wirtschaftlichsten Varianten.
• Zusammenarbeit und Versionierung: Prompts und Ergebnisse liegen im Repository und laufen über Pull Requests – Teams iterieren mit voller Transparenz.
• API mit hoher Durchsatzrate: Nutze die Models-REST-API, um Prompts zu verwalten, Inference-Requests programmatisch auszuführen und GitHub Actions oder externe Systeme anzubinden.

In großen Projekten, an denen ich mitgewirkt habe, sind diese Steuerungsmöglichkeiten entscheidend. Wenn mehrere Teams mit KI experimentieren, willst du nicht 50 Prompts für dieselbe Aufgabe oder ausufernde API-Rechnungen. GitHub Models hilft, einheitliche Prompts durchzusetzen und Modelle teamübergreifend zu evaluieren – so profitiert die gesamte Organisation vom geteilten Lernen.

Wann solltest du GitHub Models nutzen?

Bei so vielen KI-Tools stellt sich die Frage: Wann lohnt sich GitHub Models gegenüber Alternativen wie der direkten OpenAI‑API oder nur Copilot? 

Hier ein paar Leitlinien aus meiner Erfahrung:

• Wenn du ohnehin auf GitHub arbeitest und möglichst wenig Setup willst, sind Models-Tab und Playground ideal. Alles ist gehostet – du fokussierst dich auf Prompts und Evaluation statt auf Infrastruktur.
• Wenn du strukturierte Prompts und Antworten brauchst (z. B. JSON-Output für eine automatisierte Labeling-Pipeline), helfen dir die Schema-Funktionen von GitHub Models, konsistente Ergebnisse zu erzielen.
• Wenn du Modelle vergleichen oder als Team an Prompts iterieren willst, machen die integrierten Vergleichs- und Evaluations-Tools das Experimentieren deutlich einfacher als manuelle OpenAI-API-Calls.
• Wenn du internes Tooling baust (Bots, Actions, Skripte) und alles im GitHub-Ökosystem halten willst, integriert sich die Models-API sauber mit GitHub Actions, CLI und Copilot.
• Wenn du experimentierst oder Prompt Engineering lernst, starte im Playground. Wenn du dich sicher fühlst, wechsle zur API-Integration.

Wenn du dagegen bereits eine stabile Pipeline mit einem anderen KI-Provider hast oder ein Modell brauchst, das GitHub nicht hostet, bleib bei deinem Setup. GitHub Models ist ein zusätzliches Werkzeug – kein Ersatz für alles rund um KI.

Fazit

Mit GitHub Models gehen Entwicklerinnen und Entwickler jetzt vom Prompt-Konzept bis zur Produktionsintegration, ohne das Repository zu verlassen. 

Du kannst im Playground experimentieren, mit integrierten Metriken evaluieren, Prompts für versionierte Zusammenarbeit speichern und die Modelle per API, GitHub Actions oder CLI aufrufen. Für Enterprise-Teams kommen Governance, Kostenkontrolle und die Möglichkeit hinzu, eigene Modelle anzubinden – und damit Lösungen für viele Bedenken bei der KI-Einführung.

Meine Empfehlung? Starte klein. Teste Prompts im Playground, fasse Issues zusammen oder generiere Dokus.  Integriere dann deinen besten Prompt als GitHub Action für eine wiederkehrende Aufgabe. Mit der Zeit siehst du, wo dir KI am meisten Zeit spart. Und weil alles versioniert und transparent ist, wächst das Vertrauen – und du verbesserst deinen Workflow Schritt für Schritt.