# Hinzufügen von LLM-Modellen zu GitHub Copilot CLI
Verwenden Sie Ihre bevorzugten Remote- oder lokalen Modelle in Copilot CLI.
Es gibt verschiedene Möglichkeiten, Modelle zu Copilot CLIhinzuzufügen.
* **Ollama**: Copilot CLI entdeckt automatisch Modelle, die von Ollama auf Ihrer Maschine bedient werden, und Sie können diese Modelle aus der Modellauswahl hinzufügen.
* **Manuell konfigurierter Modellanbieter**: Fügen Sie einen externen Modellanbieter hinzu, indem Sie Ihre eigenen Anmeldeinformationen in einer Konfigurationsdatei angeben. Diese Methode wird häufig als „Bring Your Own Key“ (BYOK) bezeichnet.
* **MAI Code 1.1 Flash Lokal installieren**: Windows Benutzer mit den erforderlichen Systemspezifikationen können dieses Modell direkt aus der Modellauswahl installieren und auf ihrem lokalen Computer ausführen.
> [!NOTE]
> In diesem Artikel erfahren Sie, wie Sie benutzerdefinierte Modelle für Ihre eigene Verwendung konfigurieren. Informationen zum Einrichten von benutzerdefinierten Modellen für Benutzer in einer Organisation oder einem Unternehmen finden Sie unter [Aktivieren von benutzerdefinierten Modellen für GitHub Copilot in Ihrer Organisation](/de/copilot/how-tos/administer-copilot/manage-for-organization/enable-custom-models) und [Aktivieren von benutzerdefinierten Modellen für GitHub Copilot in Ihrem Unternehmen](/de/copilot/how-tos/administer-copilot/manage-for-enterprise/enable-custom-models).
## Modellanforderungen
Wählen Sie ein Modell und einen Endpunkt aus, die **Toolaufrufe (auch als Funktionsaufrufe bezeichnet)** und **Streaming** unterstützen. Diese Funktionen ermöglichen Copilot CLI, Tools zu verwenden und Antworten während ihres Eintreffens anzuzeigen.
Konfigurieren Sie Tokengrenzwerte für Ihr Modell, insbesondere für kleinere lokale Modelle. Bei einem unbekannten Modell Copilot CLI kann standardmäßig ein Grenzwert von 128.000 Prompt-Token festgelegt werden, der die tatsächliche Kapazität des Modells überschreiten kann. Das Festlegen eines höheren Limits erhöht nicht das Context Window des Modells.
## Hinzufügen von Modellen von Ollama
Wenn Ollama auf Ihrem lokalen Computer ausgeführt wird und Sie bereits ein Modell heruntergeladen haben, kann Copilot CLI das Modell erkennen und Ihnen erlauben, es aus der Modellauswahl hinzuzufügen.
### Voraussetzung
Sie müssen Ollama auf Ihrem lokalen Computer installiert und mindestens ein Modell heruntergeladen haben. Weitere Informationen finden Sie unter [Download Ollama](https://ollama.com/download) auf der Website von Ollama.
### Modell hinzufügen
1. Geben Sie in einer interaktiven Sitzung `/model` ein.
2. Suchen Sie unter "Lokal und selbst gehostet" nach Ollama bereitgestellten Modellen.
Alle Modelle, die Sie von Ollama heruntergeladen, aber noch nicht hinzugefügt haben, werden mit dem Status "Entdeckt" angezeigt.
3. Wählen Sie ein gefundenes Modell aus, und drücken Sie Eingabetaste.
4. Wählen Sie **Hinzufügen und für diese Sitzung verwenden**, um zum Modell zu wechseln, oder **Hinzufügen, ohne zu wechseln**, um Ihr aktuelles Modell weiter zu verwenden.
5. Drücken Sie ESC , um die Auswahl zu beenden.
Die CLI speichert die Modelldetails in der `providers.json` Datei, sodass sie in späteren Sitzungen verfügbar ist.
> [!NOTE]
> Copilot sucht standardmäßig unter `http://127.0.0.1:11434` nach Ollama. Wenn Ollama eine andere lokale Adresse oder einen anderen Port verwendet, setzen Sie `OLLAMA_HOST` vor dem Starten der CLI. Automatische Ermittlung überprüft nur Adressen auf Ihrem eigenen Computer. Verwenden Sie für einen Ollama-Server auf einem anderen Computer stattdessen eine Anbieterkonfigurationsdatei.
## Manuelles Hinzufügen einer Modellanbieterkonfiguration
Um einen anderen Modellanbieter als Ollama zu verwenden, müssen Sie die Anbieterdetails manuell zur `providers.json` Datei hinzufügen.
### Voraussetzung
Sie müssen über einen API-Schlüssel verfügen, um einen Modellanbieter hinzuzufügen, der eine Authentifizierung erfordert.
### Unterstützte Anbieter
Für Verbindungen mit der API eines Modellanbieters stehen die folgenden Anbietertypen zur Verfügung:
| Anbietertyp | Kompatible Dienste |
| ----------- | ---------------------------------------------------------------------------------------------------------------------------- |
| `openai` | OpenAI und Dienste mit einer openAI-kompatiblen API, z. B. Ollama, vLLM und Foundry Local. Dies ist der Standardanbietertyp. |
| `azure` | Azure OpenAI Service. |
| `anthropic` | Anthropic (Claude Modelle). |
### Hinzufügen eines Anbieters und eines Modells
In der `providers.json` Datei werden Details zu konfigurierten Anbietern und Modellen gespeichert. Sie befindet sich normalerweise `~/.copilot`in Ihrem CLI-Konfigurationsverzeichnis. Sie können eine andere Datei verwenden, indem Sie `COPILOT_PROVIDERS_CONFIG` vor dem Starten der CLI auf ihren Pfad setzen.
Modelle, die Sie in der `providers.json` Datei konfigurieren, stehen in der Modellauswahl der CLI zusammen mit den GitHubfür Ihr Konto verfügbaren Modellen zur Verfügung.
> [!IMPORTANT]
> In diese Datei eingegebene Anmeldeinformationen werden als Klartext gespeichert. Behalten Sie die Datei privat, und checken Sie sie nicht in ein Repository ein oder teilen Sie sie nicht. Werte wie `$MY_API_KEY` in JSON werden als Literaltext behandelt, nicht aus Ihrer Umgebung gelesen.
1. Öffnen `providers.json` Oder erstellen Sie es, wenn es nicht vorhanden ist. Fügen Sie Ihren Anbieter und Ihr Modell hinzu. Diese Konfiguration fügt beispielsweise den OpenAI-Modellanbieter und ein Modell hinzu:
```json
{
"providers": [
{
"name": "my-provider",
"type": "openai",
"baseUrl": "https://api.openai.com/v1",
"apiKey": "YOUR-API-KEY"
}
],
"models": [
{
"id": "YOUR-MODEL-NAME",
"provider": "my-provider"
}
]
}
```
Ersetzen Sie `YOUR-API-KEY` durch den API-Schlüssel Ihres Anbieters und `YOUR-MODEL-NAME` durch einen Modellnamen, der für Ihr Konto verfügbar ist. Ändern Sie `baseUrl` für einen anderen OpenAI-kompatiblen Anbieter in dessen API-URL. Lassen Sie `apiKey` aus, wenn der Anbieter keine Authentifizierung erfordert.
Wenn die Datei bereits Anbieter und Modelle enthält, fügen Sie die neuen Daten den vorhandenen Daten hinzu, anstatt sie zu ersetzen.
Für Anbieter oder Modelle, die zusätzliche Einstellungen benötigen:
* Legen Sie das `type` des Anbieters auf `azure` für Azure OpenAI oder auf `anthropic` für Anthropic fest, und verwenden Sie die API-URL und Anmeldeinformationen dieses Anbieters.
* Fügen Sie für OpenAI- oder Azure-Modelle, die die Responses API verwenden, `"wireApi": "responses"` dem Anbieter hinzu. Der Standardwert lautet `completions`.
* Legen Sie für eine Azure-Bereitstellung `wireModel` des Modells auf den Bereitstellungsnamen und `modelId` auf den Namen des bereitgestellten Modells fest. Wenn Sie eine bestimmte API-Version benötigen, fügen Sie `"azure": { "apiVersion": "YOUR-API-VERSION" }` dem Provider hinzu. Ersetzen Sie `YOUR-API-VERSION` durch die von Ihrem Endpunkt erforderliche Version.
* Wenn `id` beim Modell ein Name ist, den Sie anstelle des vom Anbieter akzeptierten Namens gewählt haben, legen Sie `wireModel` auf den Modellnamen des Anbieters fest. Legen Sie für `modelId` einen Modellnamen fest, den die CLI erkennt, damit sie die Funktionen und Grenzwerte dieses Modells verwenden kann.
* Legen Sie `maxPromptTokens` und `maxOutputTokens` an einem Modell so fest, dass sie den unterstützten Grenzwerten entsprechen. Verwenden Sie ganze Zahlen größer als Null.
* Um sich mit einem Bearertoken anstelle eines API-Schlüssels zu authentifizieren, legen Sie `bearerToken` für den Anbieter fest.
Viele andere Parameter können in dieser Datei konfiguriert werden. Weitere Informationen findest du unter [GitHub Copilot CLI-Konfigurationsverzeichnis](/de/copilot/reference/copilot-cli-reference/cli-config-dir-reference#providersjson).
2. Um ein weiteres Modell vom selben Anbieter hinzuzufügen, fügen Sie einen weiteren Eintrag zu `id` mit einem anderen `provider` und demselben `models` hinzu.
> [!NOTE]
> Der Wert jedes Modells `provider` muss mit dem `name` eines Anbieters übereinstimmen.
3. Wenn Sie einen anderen Anbieter hinzufügen möchten, fügen Sie zu `providers` einen Eintrag mit einem eindeutigen `name` hinzu und fügen Sie dann dessen Modelle hinzu.
4. Speichern Sie die Datei, und starten Sie die CLI neu.
5. Um das Beispielmodell beim Starten einer Sitzung auszuwählen, führen Sie Folgendes aus:
```shell
copilot --model PROVIDER-NAME/MODEL-NAME
```
6. Verwenden Sie zum Wechseln von Modellen während einer Sitzung den `/model` Schrägstrichbefehl. Weitere Informationen findest du unter [Auswählen eines Modells in GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/use-copilot-cli/choose-a-model).
7. Um das Laden eines Anbieters aus Ihrer gespeicherten Konfiguration zu beenden, entfernen Sie dessen Eintrag aus `providers` und die Modelleinträge aus `models`, und starten Sie dann die CLI neu. Wählen Sie vor dem Entfernen des aktuellen Standardmodells ein anderes Standardmodell `/model --global` aus.
## Installieren eines lokalen Modells aus der Modellauswahl
> [!NOTE]
> Dieses Feature befindet sich in Öffentliche Vorschau und kann sich ändern. Um dieses Feature zu verwenden, starten Sie die CLI mit der `--experimental` Option, oder verwenden Sie `/experimental on` in einer interaktiven Sitzung, um diese und andere experimentelle Features für die aktuellen und zukünftigen Sitzungen zu aktivieren.
Wenn Sie Windows verwenden und Ihr Computer die folgenden Voraussetzungen erfüllt, können Sie die Modellauswahl der CLI verwenden, um die folgenden Modelle lokal auf Ihrem Gerät zu installieren und auszuführen:
* MAI Code 1.1 Flash
* Flint NVFP4
### Prerequisites
Sie benötigen Folgendes:
* Ein Windows PC
* Eine NVIDIA-GPU (AMD wird nicht unterstützt)
* Minimal verfügbarer kombinierter RAM pro Modell:
* **MAI Code 1.1 Flash:** 96 GB
* **Flint NVFP4:** 48 GB
* Mindestens verfügbarer Speicher pro Modell:
* **MAI Code 1.1 Flash:** 60 GB
* **Flint NVFP4:** 23 GB
* llama.cpp v0.7.0 oder höher muss installiert sein und `LLAMACPP_SERVER_PATH` muss auf seinen Pfad gesetzt sein. Erforderliche Buildversion:
* **MAI Code 1.1 Flash:** [b11669](https://github.com/ggml-org/llama.cpp/releases/tag/b11669?utm_source=local-model-prereq-mai-code\&utm_medium=docs\&utm_campaign=universe-2026) oder höher
* **Flint NVFP4:** [b11803](https://github.com/ggml-org/llama.cpp/releases?q=flint\&expanded=true\&utm_source=local-model-prerequisite-flint\&utm_medium=docs\&utm_campaign=universe-2026#release-b11803) oder neuer
Siehe [llama.cpp unter Windows installieren](#installing-llamacpp-for-windows).
### Vorteile der lokalen Verwendung von MAI Code 1.1 Flash
MAI Code 1.1 Flashist ein codierungsoptimiertes Modell, das Sie lokal auf Ihrem Windows PC ausführen können. Mithilfe eines modells, das lokal ausgeführt wird, können Sie Copilot offline verwenden und den Verbrauch von GitHub AI Credits vermeiden.
Nach der MAI Code 1.1 FlashInstallation können Sie es wie jedes andere Modell aus der Modellauswahl auswählen. Das Modell ist auch für die Leistungsstufe von Copilot FusionFusion Standard verfügbar. Wenn Sie die Modellauswahl mit Fusion Standard auf **Copilot Fusion** festlegen, wird MAI Code 1.1 Flash automatisch für die Arbeit an geeigneten Vorgängen ausgewählt, sodass cloudbasierte Modelle für Vorgänge, die mehr Ressourcen oder eine höhere Leistung erfordern, verbleiben.
### Installieren von llama.cpp für Windows
So installieren Sie llama.cpp auf Windows mit dem CUDA-Build:
1. Wechseln Sie in Ihrem Browser zur Seite "Versionen" des llama.cpp Repositorys: [https://github.com/ggml-org/llama.cpp/releases](https://github.com/ggml-org/llama.cpp/releases?utm_source=llama-windows-install-cta\&utm_medium=docs\&utm_campaign=universe-2026).
2. Wählen Sie die Version aus, die Sie installieren möchten, z. B [. b11803](https://github.com/ggml-org/llama.cpp/releases?q=flint\&expanded=true\&utm_source=local-model-prerequisite-flint\&utm_medium=docs\&utm_campaign=universe-2026#release-b11803).
3. Klicken Sie auf die Links, um beide Dateien für den Windows CUDA 13.4 ARM64-Build herunterzuladen:
* Windows arm64 (CUDA 13)
* CUDA 13.4 DLLs
4. Öffnen Sie die Eingabeaufforderung, und erstellen Sie den Installationsordner:
```shell copy
mkdir "%LOCALAPPDATA%\Programs\llama.cpp\BUILD-cuda-13.4-arm64"
```
`BUILD` Ersetzen Sie die die Buildnummer – z. B. `b11803`.
1. Extrahieren Sie alle Dateien aus beiden ZIP-Dateien direkt in diesen Ordner. Wenn Sie **"Alle extrahieren"** im Datei-Explorer verwenden, ändern Sie das Ziel in diesen Ordner, da standardmäßig im Datei-Explorer für jede ZIP-Datei ein separater Unterordner erstellt wird. Wenn Sie fertig sind, sollte der Ordner eine große Anzahl von Dateien enthalten, einschließlich `llama-server.exe`, `cublas64_13.dll`, `cublasLt64_13.dll` und `cudart64_13.dll`, ohne Unterordner.
2. Festlegen der `LLAMACPP_SERVER_PATH` Umgebungsvariable:
```shell copy
setx LLAMACPP_SERVER_PATH "%LOCALAPPDATA%\Programs\llama.cpp\BUILD-cuda-13.4-arm64\llama-server.exe"
```
`BUILD` Ersetzen Sie die Buildnummer.
1. Schließen Sie die Eingabeaufforderung, und öffnen Sie ein neues Eingabeaufforderungsfenster. Wenn das Copilot app Oder VS Code bereits geöffnet ist, starten Sie es neu. Wenn Copilot CLI ausgeführt wird, beenden Sie es und starten Sie es erneut aus einem neuen Terminalfenster.
2. Um die Installation zu überprüfen, führen Sie aus:
```shell copy
"%LLAMACPP_SERVER_PATH%" --list-devices
```
### Verwenden der Modellauswahl zum Installieren eines lokalen Modells
1. Geben Sie in einer lokalen interaktiven Sitzung `/model` ein.
2. Suchen Sie unter "Lokal und selbst gehostet" nach den unterstützten lokalen Modellen.
Der Status wird als "Download erforderlich" angezeigt.
> [!NOTE]
> Die lokalen Modelle stehen nur zum Download zur Verfügung, wenn ihr lokaler Computer ein Windows PC ist, der die GPU- und Speicheranforderungen erfüllt.
3. Verwenden Sie die NACH-UNTEN-TASTE, um ein lokales Modell auszuwählen, und drücken Sie dann die EINGABETASTE.
Die CLI überprüft, ob Ihr Computer die Installationsanforderungen erfüllt. Lesen Sie die weiter oben in diesem Artikel [aufgeführten Voraussetzungen](#prerequisites) .
4. Wählen Sie **Herunterladen und einrichten** aus, um mit dem Herunterladen des Modells zu beginnen.
Sie können weiterhin andere Modelle verwenden, während der Download ausgeführt wird. Die CLI benachrichtigt Sie in der Unterhaltungsausgabe, wenn der Download abgeschlossen ist.
### Ein lokales Modell verwenden
Nach Abschluss des Downloads steht das lokale Modell für die Verwendung in Ihren Sitzungen zur Verfügung.
Sie können:
* Wählen Sie es aus der Modellauswahl aus und wählen Sie dann **Dieses Modell aus**. Siehe [Auswählen eines Modells in GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/use-copilot-cli/choose-a-model#choosing-a-model).
* **MAI Code 1.1 Flash nur:** Wählen Sie **Copilot Fusion** und dann **Fusion Standard** in der Modellauswahl aus, und Copilot verwendet automatisch das lokale Modell, wenn dies angemessen ist.
* Weisen Sie sie einem custom agent für fokussierte Aufgaben zu. Sie können dann Copilot anweisen, diesen benutzerdefinierten Agenten für einen Teil einer Aufgabe zu verwenden, während Sie Ihre Hauptsitzung auf einem anderen Modell in der Cloud beibehalten. Siehe [Erstellen und Verwenden von benutzerdefinierten Agenten für GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/customize-copilot/create-custom-agents-for-cli#delegating-focused-tasks-to-a-specific-model).
> [!IMPORTANT]
> Nachdem Sie ein lokales Modell aus der Modellauswahl heruntergeladen haben, verwenden Sie es nicht gleichzeitig in Sitzungen innerhalb verschiedener Copilot Oberflächen (Copilot CLI, der Copilot app, VS Code), entweder durch direkte Auswahl oder über Copilot Fusion. Jede Oberfläche lädt eine eigene Instanz des Modells in den Arbeitsspeicher, was wahrscheinlich dazu führt, dass der lokale Computer nicht mehr über genügend RAM verfügt.
## Ausführung im Offlinemodus
Um zu verhindern, dass Copilot CLI die Server von GitHub kontaktiert – z. B. um Telemetriedaten zu senden –, setzen Sie die Umgebungsvariable `COPILOT_OFFLINE` vor dem Starten der CLI auf `true`. Für die vollständige Netzwerkisolation muss Ihr Modellanbieter auch lokal oder innerhalb derselben isolierten Umgebung sein. Siehe [Authentifizierung von GitHub Copilot CLI](/de/copilot/how-tos/copilot-cli/set-up-copilot-cli/authenticate-copilot-cli#offline-mode).
## Troubleshooting
* **Ein Ollama-Modell fehlt:** Überprüfen Sie, ob Ollama ausgeführt wird und das Modell heruntergeladen wurde. Öffnen Sie `/model` und drücken Sie STRG+R, um erneut zu scannen. Konfigurieren Sie für einen Server auf einem anderen Computer die openAI-kompatible API-URL manuell, einschließlich `/v1`.
* **Ein gespeichertes Modell fehlt:** Überprüfen Sie, ob sein `provider` mit dem `name` eines Anbieters übereinstimmt, und starten Sie dann die CLI neu. Wenn beim Hinzufügen eines ermittelten Modells eine Warnung zum Speichern ausgelöst wurde, folgen Sie der Warnung, um die Datei zu korrigieren oder ihre Berechtigungen anzupassen.
* **Umgebungseinstellungen haben keine Auswirkungen:** Überprüfen Sie, ob `providers.json` oder die von `COPILOT_PROVIDERS_CONFIG` ausgewählte Datei bereits Anbieter oder Modelle enthält. Diese Datei hat Vorrang.
* **Anfragen schlagen fehl:** Überprüfen Sie die API-URL, Die Anmeldeinformationen, den Modellnamen und die API-Auswahl. Überprüfen Sie für Azure OpenAI den Bereitstellungsnamen. Legen Sie für Fehler bei der Anforderungsgröße Tokengrenzwerte fest, die ihrem Modell entsprechen.