Buckets:

GHHG10
/

CodeServer

Files

xet

GHHG10/CodeServer / opencode /packages /web /src /content /docs /de /providers.mdx

GHHG10

about 2 months ago

download

raw

52.5 kB

	---
	title: Anbieter
	description: Verwendung eines beliebigen LLM-Anbieters in OpenCode.
	---

	import config from "../../../../config.mjs"
	export const console = config.console

	OpenCode verwendet [AI SDK](https://ai-sdk.dev/) und [Models.dev](https://models.dev) zur Unterstützung von 75+ LLM-Anbietern und unterstützt die Ausführung lokaler Modelle.

	Um einen Anbieter hinzuzufügen, müssen Sie:

	1. Fügen Sie die API-Schlüssel für den Anbieter mit dem Befehl `/connect` hinzu.
	2. Konfigurieren Sie den Anbieter in Ihrer OpenCode-Konfiguration.

	---

	### Anmeldeinformationen

	Wenn Sie die API-Schlüssel eines Anbieters mit dem Befehl `/connect` hinzufügen, werden diese gespeichert
	in `~/.local/share/opencode/auth.json`.

	---

	### Konfiguration

	Sie können die Anbieter über den Abschnitt `provider` in Ihrem OpenCode anpassen
	config.

	---

	#### Base URL

	Sie können die Base URL für jeden Anbieter anpassen, indem Sie die Option `baseURL` festlegen. Das ist nuetzlich, wenn Sie Proxy-Dienste oder benutzerdefinierte Endpunkte verwenden.

	```json title="opencode.json" {6}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"anthropic": {
	"options": {
	"baseURL": "https://api.anthropic.com/v1"
	}
	}
	}
	}
	```

	---

	## OpenCode Zen

	OpenCode Zen ist eine Liste von Modellen, die vom OpenCode-Team bereitgestellt wurden
	Getestet und verifiziert, dass es gut mit OpenCode funktioniert. [Learn more](/docs/zen).

	:::tip
	Wenn Sie neu sind, empfehlen wir Ihnen, mit OpenCode Zen zu beginnen.
	:::

	1. Führen Sie den Befehl `/connect` in TUI aus, wählen Sie OpenCode aus und gehen Sie zu [opencode.ai/auth](https://opencode.ai/auth).

	```txt
	/connect
	```

	2. Melden Sie sich an, geben Sie Ihre Rechnungsdaten ein und kopieren Sie Ihren API-Schlüssel.

	3. Fügen Sie Ihren API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie `/models` in TUI aus, um die Liste der von uns empfohlenen Modelle anzuzeigen.

	```txt
	/models
	```

	Es funktioniert wie jeder andere Anbieter in OpenCode und ist völlig optional.

	---

	## OpenCode Go

	OpenCode Go ist ein kostenguenstiges Abonnement, das zuverlaessigen Zugriff auf beliebte Open-Coding-Modelle bietet, die vom OpenCode-Team getestet und verifiziert wurden, dass sie gut mit OpenCode funktionieren.

	1. Führen Sie den Befehl `/connect` in der TUI aus, waehlen Sie `OpenCode Go` und gehen Sie zu [opencode.ai/auth](https://opencode.ai/zen).

	```txt
	/connect
	```

	2. Melden Sie sich an, geben Sie Ihre Rechnungsdaten ein und kopieren Sie Ihren API-Schlüssel.

	3. Fügen Sie Ihren API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie `/models` in der TUI aus, um die Liste der empfohlenen Modelle zu sehen.

	```txt
	/models
	```

	Es funktioniert wie jeder andere Anbieter in OpenCode und ist völlig optional.

	---

	## Verzeichnis

	Schauen wir uns einige der Anbieter im Detail an. Wenn Sie einen Anbieter hinzufügen möchten
	Liste, zögern Sie nicht, ein PR zu öffnen.

	:::note
	Sehen Sie hier keinen Anbieter? Senden Sie einen PR.
	:::

	---

	### 302.AI

	1. Gehen Sie zu [302.AI console](https://302.ai/), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach 302.AI.

	```txt
	/connect
	```

	3. Geben Sie Ihren 302.AI API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell auszuwählen.

	```txt
	/models
	```

	---

	### Amazon Bedrock

	So verwenden Sie Amazon Bedrock mit OpenCode:

	1. Gehen Sie zum Modellkatalog in der Amazon Bedrock-Konsole und fordern Sie an
	Zugriff auf die gewünschten Modelle.

	:::tip
	Sie müssen Zugriff auf das gewünschte Modell in Amazon Bedrock haben.
	:::

	2. Konfigurieren Sie die Authentifizierung mit einer der folgenden Methoden:

	#### Umgebungsvariablen (Schnellstart)

	Legen Sie eine dieser Umgebungsvariablen fest, während Sie OpenCode ausführen:

	```bash
	# Option 1: Using AWS access keys
	AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY opencode

	# Option 2: Using named AWS profile
	AWS_PROFILE=my-profile opencode

	# Option 3: Using Bedrock bearer token
	AWS_BEARER_TOKEN_BEDROCK=XXX opencode
	```

	Oder fügen Sie sie Ihrem Bash-Profil hinzu:

	```bash title="~/.bash_profile"
	export AWS_PROFILE=my-dev-profile
	export AWS_REGION=us-east-1
	```

	#### Konfigurationsdatei (empfohlen)

	Für eine projektspezifische oder dauerhafte Konfiguration verwenden Sie `opencode.json`:

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"amazon-bedrock": {
	"options": {
	"region": "us-east-1",
	"profile": "my-aws-profile"
	}
	}
	}
	}
	```

	Verfügbare Optionen:
	- `region` - AWS region (e.g., `us-east-1`, `eu-west-1`)
	- `profile` - AWS named profile from `~/.aws/credentials`
	- `endpoint` – Benutzerdefinierter Endpunkt URL für VPC-Endpunkte (Alias für generische `baseURL`-Option)

	:::tip
	Konfigurationsdateioptionen haben Vorrang vor Umgebungsvariablen.
	:::

	#### Erweitert: VPC Endpunkte

	Wenn Sie VPC-Endpunkte für Bedrock verwenden:

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"amazon-bedrock": {
	"options": {
	"region": "us-east-1",
	"profile": "production",
	"endpoint": "https://bedrock-runtime.us-east-1.vpce-xxxxx.amazonaws.com"
	}
	}
	}
	}
	```

	:::note
	Die Option `endpoint` ist ein Alias für die generische Option `baseURL` und verwendet AWS-spezifische Terminologie. Wenn sowohl `endpoint` als auch `baseURL` angegeben sind, hat `endpoint` Vorrang.
	:::

	#### Authentifizierungsmethoden
	- `AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY`: Erstellen Sie einen IAM-Benutzer und generieren Sie Zugriffsschlüssel in der AWS-Konsole
	- `AWS_PROFILE`: Benannte Profile von `~/.aws/credentials` verwenden. Zuerst mit `aws configure --profile my-profile` oder `aws sso login` konfigurieren
	- `AWS_BEARER_TOKEN_BEDROCK`: Generieren Sie langfristige API-Schlüssel aus der Amazon Bedrock-Konsole
	- `AWS_WEB_IDENTITY_TOKEN_FILE` / `AWS_ROLE_ARN`: Für EKS IRSA (IAM Rollen für Dienstkonten) oder andere Kubernetes-Umgebungen mit OIDC-Verbund. Diese Umgebungsvariablen werden von Kubernetes automatisch eingefügt, wenn Dienstkontoanmerkungen verwendet werden.

	#### Authentifizierungspriorität

	Amazon Bedrock verwendet die folgende Authentifizierungspriorität:
	1. Bearer-Token – `AWS_BEARER_TOKEN_BEDROCK`-Umgebungsvariable oder Token aus dem `/connect`-Befehl
	2. AWS Anmeldeinformationskette – Profil, Zugriffsschlüssel, gemeinsame Anmeldeinformationen, IAM Rollen, Web-Identitätstoken (EKS IRSA), Instanzmetadaten

	:::note
	Wenn ein Inhabertoken festgelegt ist (über `/connect` oder `AWS_BEARER_TOKEN_BEDROCK`), hat es Vorrang vor allen AWS-Anmeldeinformationsmethoden, einschließlich konfigurierter Profile.
	:::

	3. Führen Sie den Befehl `/models` aus, um das gewünschte Modell auszuwählen.

	```txt
	/models
	```

	:::note
	Verwenden Sie für benutzerdefinierte Inferenzprofile den Modell- und Anbieternamen im Schlüssel und legen Sie die Eigenschaft `id` auf den Arn fest. Dadurch wird ein korrektes Caching sichergestellt:

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"amazon-bedrock": {
	// ...
	"models": {
	"anthropic-claude-sonnet-4.5": {
	"id": "arn:aws:bedrock:us-east-1:xxx:application-inference-profile/yyy"
	}
	}
	}
	}
	}
	```

	:::

	---

	### Anthropic

	1. Sobald Sie sich angemeldet haben, führen Sie den Befehl `/connect` aus und wählen Sie Anthropic aus.

	```txt
	/connect
	```

	2. Hier können Sie die Option Claude Pro/Max auswählen und Ihr Browser wird geöffnet
	und bitten Sie, sich zu authentifizieren.

	```txt
	┌ Select auth method
	│
	│ Claude Pro/Max
	│ Create an API Key
	│ Manually enter API Key
	└
	```

	3. Jetzt sollten alle Anthropic-Modelle verfügbar sein, wenn Sie den Befehl `/models` verwenden.

	```txt
	/models
	```

	:::info
	Die Verwendung Ihres Claude Pro/Max-Abonnements in OpenCode wird von [Anthropic](https://anthropic.com) nicht offiziell unterstützt.
	:::

	##### Verwendung von API-Keys

	Sie können auch Erstellen eines API-Schlüssels auswählen, wenn Sie kein Pro/Max-Abonnement haben. Außerdem wird Ihr Browser geöffnet, Sie werden aufgefordert, sich bei Anthropic anzumelden, und Sie erhalten einen Code, den Sie in Ihr Terminal einfügen können.

	Wenn Sie bereits über einen API-Schlüssel verfügen, können Sie API-Schlüssel manuell eingeben auswählen und ihn in Ihr Terminal einfügen.

	---

	### Atomic Chat

	Sie können opencode so konfigurieren, dass es lokale Modelle über [Atomic Chat](https://atomic.chat) verwendet — eine Desktop-Anwendung, die lokale LLMs hinter einem OpenAI-kompatiblen API-Server bereitstellt (Standard-Endpunkt `http://127.0.0.1:1337/v1`).

	```json title="opencode.json" "atomic-chat" {5, 6, 8, 10-14}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"atomic-chat": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "Atomic Chat (local)",
	"options": {
	"baseURL": "http://127.0.0.1:1337/v1"
	},
	"models": {
	"<your-model-id>": {
	"name": "<your-model-name>"
	}
	}
	}
	}
	}
	```

	In diesem Beispiel:

	- `atomic-chat` ist die benutzerdefinierte Provider-ID. Dies kann eine beliebige Zeichenkette sein.
	- `npm` gibt das für diesen Provider zu verwendende Paket an. Hier wird `@ai-sdk/openai-compatible` für jede OpenAI-kompatible API verwendet.
	- `name` ist der in der UI angezeigte Name des Providers.
	- `options.baseURL` ist der Endpunkt des lokalen Servers. Passen Sie Host und Port an Ihre Atomic-Chat-Konfiguration an.
	- `models` ist eine Zuordnung von Modell-IDs zu ihren Anzeigenamen. Jede ID muss dem `id`-Wert entsprechen, den `GET /v1/models` zurückgibt — führen Sie `curl http://127.0.0.1:1337/v1/models` aus, um die aktuell in Atomic Chat geladenen IDs aufzulisten.

	:::tip
	Wenn Tool-Aufrufe nicht zuverlässig funktionieren, wählen Sie ein geladenes Modell mit starker Tool-Calling-Unterstützung (zum Beispiel eine Qwen-Coder- oder DeepSeek-Coder-Variante).
	:::

	---

	### Azure OpenAI

	:::note
	Wenn Sie auf die Fehlermeldung „Es tut mir leid, aber ich kann Ihnen bei dieser Anfrage nicht weiterhelfen“ stoßen, versuchen Sie, den Inhaltsfilter in Ihrer Azure-Ressource von DefaultV2 in Default zu ändern.
	:::

	1. Gehen Sie zu [Azure portal](https://portal.azure.com/) und erstellen Sie eine Azure OpenAI-Ressource. Sie benötigen:
	- Ressourcenname: Dies wird Teil Ihres API-Endpunkts (`https://RESOURCE_NAME.openai.azure.com/`)
	- API-Schlüssel: Entweder `KEY 1` oder `KEY 2` aus Ihrer Ressource

	2. Gehen Sie zu [Azure AI Foundry](https://ai.azure.com/) und stellen Sie ein Modell bereit.

	:::note
	Der Bereitstellungsname muss mit dem Modellnamen übereinstimmen, damit OpenCode ordnungsgemäß funktioniert.
	:::

	3. Führen Sie den Befehl `/connect` aus und suchen Sie nach Azure.

	```txt
	/connect
	```

	4. Geben Sie Ihren API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	5. Legen Sie Ihren Ressourcennamen als Umgebungsvariable fest:

	```bash
	AZURE_RESOURCE_NAME=XXX opencode
	```

	Oder fügen Sie es Ihrem Bash-Profil hinzu:

	```bash title="~/.bash_profile"
	export AZURE_RESOURCE_NAME=XXX
	```

	6. Führen Sie den Befehl `/models` aus, um Ihr bereitgestelltes Modell auszuwählen.

	```txt
	/models
	```

	---

	### Azure Cognitive Services

	1. Gehen Sie zu [Azure portal](https://portal.azure.com/) und erstellen Sie eine Azure OpenAI-Ressource. Sie benötigen:
	- Ressourcenname: Dies wird Teil Ihres API-Endpunkts (`https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/`)
	- API-Schlüssel: Entweder `KEY 1` oder `KEY 2` aus Ihrer Ressource

	2. Gehen Sie zu [Azure AI Foundry](https://ai.azure.com/) und stellen Sie ein Modell bereit.

	:::note
	Der Bereitstellungsname muss mit dem Modellnamen übereinstimmen, damit OpenCode ordnungsgemäß funktioniert.
	:::

	3. Führen Sie den Befehl `/connect` aus und suchen Sie nach Azure Cognitive Services.

	```txt
	/connect
	```

	4. Geben Sie Ihren API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	5. Legen Sie Ihren Ressourcennamen als Umgebungsvariable fest:

	```bash
	AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
	```

	Oder fügen Sie es Ihrem Bash-Profil hinzu:

	```bash title="~/.bash_profile"
	export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
	```

	6. Führen Sie den Befehl `/models` aus, um Ihr bereitgestelltes Modell auszuwählen.

	```txt
	/models
	```

	---

	### Baseten

	1. Gehen Sie zu [Baseten](https://app.baseten.co/), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Baseten.

	```txt
	/connect
	```

	3. Geben Sie Ihren Baseten API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell auszuwählen.

	```txt
	/models
	```

	---

	### Cerebras

	1. Gehen Sie zu [Cerebras console](https://inference.cerebras.ai/), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Cerebras.

	```txt
	/connect
	```

	3. Geben Sie Ihren Cerebras-API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell wie _Qwen 3 Coder 480B_ auszuwählen.

	```txt
	/models
	```

	---

	### Cloudflare AI Gateway

	Mit dem Cloudflare AI Gateway können Sie über einen einheitlichen Endpunkt auf Modelle von OpenAI, Anthropic, Workers AI und mehr zugreifen. Mit [Unified Billing](https://developers.cloudflare.com/ai-gateway/features/unified-billing/) benötigen Sie nicht für jeden Anbieter separate API-Schlüssel.

	1. Gehen Sie zu [Cloudflare dashboard](https://dash.cloudflare.com/), navigieren Sie zu AI > AI Gateway und erstellen Sie ein neues Gateway.

	2. Legen Sie Ihr Konto ID und Ihr Gateway ID als Umgebungsvariablen fest.

	```bash title="~/.bash_profile"
	export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
	export CLOUDFLARE_GATEWAY_ID=your-gateway-id
	```

	3. Führen Sie den Befehl `/connect` aus und suchen Sie nach Cloudflare AI Gateway.

	```txt
	/connect
	```

	4. Geben Sie Ihr Cloudflare-API-Token ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	Oder legen Sie es als Umgebungsvariable fest.

	```bash title="~/.bash_profile"
	export CLOUDFLARE_API_TOKEN=your-api-token
	```

	5. Führen Sie den Befehl `/models` aus, um ein Modell auszuwählen.

	```txt
	/models
	```

	Sie können Modelle auch über Ihre OpenCode-Konfiguration hinzufügen.

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"cloudflare-ai-gateway": {
	"models": {
	"openai/gpt-4o": {},
	"anthropic/claude-sonnet-4": {}
	}
	}
	}
	}
	```

	---

	### Cortecs

	1. Gehen Sie zu [Cortecs console](https://cortecs.ai/), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Cortecs.

	```txt
	/connect
	```

	3. Geben Sie Ihren Cortecs-API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell wie _Kimi K2 Instruct_ auszuwählen.

	```txt
	/models
	```

	---

	### DeepSeek

	1. Gehen Sie zu [DeepSeek console](https://platform.deepseek.com/), erstellen Sie ein Konto und klicken Sie auf Neuen API-Schlüssel erstellen.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach DeepSeek.

	```txt
	/connect
	```

	3. Geben Sie Ihren DeepSeek API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein DeepSeek-Modell wie _DeepSeek V4 Pro_ auszuwählen.

	```txt
	/models
	```

	---

	### Deep Infra

	1. Gehen Sie zu [Deep Infra dashboard](https://deepinfra.com/dash), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Deep Infra.

	```txt
	/connect
	```

	3. Geben Sie Ihren Deep Infra API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell auszuwählen.

	```txt
	/models
	```

	---

	### FrogBot

	1. Gehen Sie zu [FrogBot dashboard](https://app.frogbot.ai/signup), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach FrogBot.

	```txt
	/connect
	```

	3. Geben Sie Ihren FrogBot API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell auszuwählen.

	```txt
	/models
	```

	---

	### Fireworks AI

	1. Gehen Sie zu [Fireworks AI console](https://app.fireworks.ai/), erstellen Sie ein Konto und klicken Sie auf API-Schlüssel erstellen.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Fireworks AI.

	```txt
	/connect
	```

	3. Geben Sie Ihren Fireworks AI API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell wie _Kimi K2 Instruct_ auszuwählen.

	```txt
	/models
	```

	---

	### GitLab Duo

	GitLab Duo bietet AI-gestützten Agenten-Chat mit nativen Tool-Aufruffunktionen über den Anthropic-Proxy von GitLab.

	1. Führen Sie den Befehl `/connect` aus und wählen Sie GitLab aus.

	```txt
	/connect
	```

	2. Wählen Sie Ihre Authentifizierungsmethode:

	```txt
	┌ Select auth method
	│
	│ OAuth (Recommended)
	│ Personal Access Token
	└
	```

	#### Verwendung von OAuth (empfohlen)

	Wählen Sie OAuth und Ihr Browser wird zur Autorisierung geöffnet.

	#### Verwendung eines persönlichen Zugriffstokens
	1. Gehe zu [GitLab User Settings > Access Tokens](https://gitlab.com/-/user_settings/personal_access_tokens)
	2. Klicken Sie auf Neues Token hinzufügen
	3. Name: `OpenCode`, Bereiche: `api`
	4. Kopieren Sie das Token (beginnt mit `glpat-`)
	5. Geben Sie es im Terminal ein

	3. Führen Sie den Befehl `/models` aus, um verfügbare Modelle anzuzeigen.

	```txt
	/models
	```

	Es stehen drei Claude-basierte Modelle zur Verfügung:
	- duo-chat-haiku-4-5 (Standard) – Schnelle Antworten für schnelle Aufgaben
	- duo-chat-sonnet-4-5 – Ausgewogene Leistung für die meisten Arbeitsabläufe
	- duo-chat-opus-4-5 – Am besten geeignet für komplexe Analysen

	:::note
	Sie können auch die Umgebungsvariable „GITLAB_TOKEN“ angeben, wenn Sie dies nicht möchten
	um das Token im OpenCode-Authentifizierungsspeicher zu speichern.
	:::

	##### Selbstgehostetes GitLab

	:::note[Compliance-Hinweis]
	OpenCode verwendet ein kleines Modell für einige AI-Aufgaben wie das Generieren des Sitzungstitels.
	Es ist standardmäßig für die Verwendung von gpt-5-nano konfiguriert und wird von Zen gehostet. Zum Sperren von OpenCode
	Um nur Ihre eigene von GitLab gehostete Instanz zu verwenden, fügen Sie Folgendes zu Ihrer hinzu
	`opencode.json`-Datei. Es wird außerdem empfohlen, die Sitzungsfreigabe zu deaktivieren.

	```json
	{
	"$schema": "https://opencode.ai/config.json",
	"small_model": "gitlab/duo-chat-haiku-4-5",
	"share": "disabled"
	}
	```

	:::

	Für selbstgehostete GitLab-Instanzen:

	```bash
	export GITLAB_INSTANCE_URL=https://gitlab.company.com
	export GITLAB_TOKEN=glpat-...
	```

	Wenn Ihre Instanz ein benutzerdefiniertes AI-Gateway ausführt:

	```bash
	GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com
	```

	Oder fügen Sie zu Ihrem Bash-Profil hinzu:

	```bash title="~/.bash_profile"
	export GITLAB_INSTANCE_URL=https://gitlab.company.com
	export GITLAB_AI_GATEWAY_URL=https://ai-gateway.company.com
	export GITLAB_TOKEN=glpat-...
	```

	:::note
	Ihr GitLab-Administrator muss Folgendes aktivieren:

	1. [Duo Agent Platform](https://docs.gitlab.com/user/duo_agent_platform/turn_on_off/) für den Benutzer, die Gruppe oder die Instanz
	2. Feature-Flags (über die Rails-Konsole):
	- `agent_platform_claude_code`
	- `third_party_agents_enabled`
	:::

	##### OAuth für selbstgehostete Instanzen

	Damit OAuth für Ihre selbst gehostete Instanz funktioniert, müssen Sie eine erstellen
	eine neue Anwendung (Einstellungen → Anwendungen) mit dem
	Rückruf URL `http://127.0.0.1:8080/callback` und folgende Bereiche:

	- API (Greifen Sie in Ihrem Namen auf API zu)
	- read_user (Lesen Sie Ihre persönlichen Daten)
	- read_repository (Ermöglicht schreibgeschützten Zugriff auf das Repository)

	Stellen Sie dann die Anwendung ID als Umgebungsvariable bereit:

	```bash
	export GITLAB_OAUTH_CLIENT_ID=your_application_id_here
	```

	Weitere Dokumentation auf der [opencode-gitlab-auth](https://www.npmjs.com/package/opencode-gitlab-auth)-Homepage.

	##### Konfiguration

	Anpassen über `opencode.json`:

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"gitlab": {
	"options": {
	"instanceUrl": "https://gitlab.com"
	}
	}
	}
	}
	```

	##### GitLab API Tools (Optional, aber dringend empfohlen)

	So greifen Sie auf GitLab-Tools zu (Zusammenführungsanfragen, Probleme, Pipelines, CI/CD usw.):

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"plugin": ["opencode-gitlab-plugin"]
	}
	```

	Dieses Plugin bietet umfassende GitLab-Repository-Verwaltungsfunktionen, einschließlich MR-Überprüfungen, Problemverfolgung, Pipeline-Überwachung und mehr.

	---

	### GitHub Copilot

	So verwenden Sie Ihr GitHub Copilot-Abonnement mit OpenCode:

	:::note
	Einige Modelle benötigen möglicherweise ein [Pro+
	Abonnement](https://github.com/features/copilot/plans) zur Verwendung.

	Einige Modelle müssen in Ihrem [GitHub Copilot settings](https://docs.github.com/en/copilot/how-tos/use-ai-models/configure-access-to-ai-models#setup-for-individual-use) manuell aktiviert werden.
	:::

	1. Führen Sie den Befehl `/connect` aus und suchen Sie nach GitHub Copilot.

	```txt
	/connect
	```

	2. Navigieren Sie zu [github.com/login/device](https://github.com/login/device) und geben Sie den Code ein.

	```txt
	┌ Login with GitHub Copilot
	│
	│ https://github.com/login/device
	│
	│ Enter code: 8F43-6FCF
	│
	└ Waiting for authorization...
	```

	3. Führen Sie nun den Befehl `/models` aus, um das gewünschte Modell auszuwählen.

	```txt
	/models
	```

	---

	### Google Vertex AI

	So verwenden Sie Google Vertex AI mit OpenCode:

	1. Gehen Sie zum Model Garden in der Google Cloud Console und überprüfen Sie die
	Modelle, die in Ihrer Region verfügbar sind.

	:::note
	Sie benötigen ein Google Cloud-Projekt mit aktiviertem Vertex AI API.
	:::

	2. Legen Sie die erforderlichen Umgebungsvariablen fest:
	- `GOOGLE_CLOUD_PROJECT`: Ihr Google Cloud-Projekt ID
	- `VERTEX_LOCATION` (optional): Die Region für Vertex AI (standardmäßig `global`)
	- Authentifizierung (wählen Sie eine aus):
	- `GOOGLE_APPLICATION_CREDENTIALS`: Pfad zur Schlüsseldatei Ihres Dienstkontos JSON
	- Authentifizieren Sie sich mit gcloud CLI: `gcloud auth application-default login`

	Legen Sie sie fest, während Sie OpenCode ausführen.

	```bash
	GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
	```

	Oder fügen Sie sie Ihrem Bash-Profil hinzu.

	```bash title="~/.bash_profile"
	export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
	export GOOGLE_CLOUD_PROJECT=your-project-id
	export VERTEX_LOCATION=global
	```

	:::tip
	Die Region `global` verbessert die Verfügbarkeit und reduziert Fehler ohne zusätzliche Kosten. Verwenden Sie regionale Endpunkte (e.g., `us-central1`) für Datenresidenzanforderungen. [Learn more](https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-partner-models#regional_and_global_endpoints)
	:::

	3. Führen Sie den Befehl `/models` aus, um das gewünschte Modell auszuwählen.

	```txt
	/models
	```

	---

	### Groq

	1. Gehen Sie zu [Groq console](https://console.groq.com/), klicken Sie auf Create API Key und kopieren Sie den Schlüssel.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Groq.

	```txt
	/connect
	```

	3. Geben Sie den Schlüssel API für den Anbieter ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um das gewünschte auszuwählen.

	```txt
	/models
	```

	---

	### Hugging Face

	[Hugging Face Inference Providers](https://huggingface.co/docs/inference-providers) bietet Zugriff auf offene Modelle, die von 17+-Anbietern unterstützt werden.

	1. Gehen Sie zu [Hugging Face settings](https://huggingface.co/settings/tokens/new?ownUserPermissions=inference.serverless.write&tokenType=fineGrained), um ein Token mit der Berechtigung zum Aufrufen von Inferenzanbietern zu erstellen.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Hugging Face.

	```txt
	/connect
	```

	3. Geben Sie Ihren Hugging Face-Token ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell wie _Kimi-K2-Instruct_ oder _GLM-4.6_ auszuwählen.

	```txt
	/models
	```

	---

	### Helicone

	[Helicone](https://helicone.ai) ist eine LLM-Beobachtbarkeitsplattform, die Protokollierung, Überwachung und Analyse für Ihre AI-Anwendungen bietet. Das Helicone AI Gateway leitet Ihre Anfragen basierend auf dem Modell automatisch an den entsprechenden Anbieter weiter.

	1. Gehen Sie zu [Helicone](https://helicone.ai), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel über Ihr Dashboard.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Helicone.

	```txt
	/connect
	```

	3. Geben Sie Ihren Helicone-API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell auszuwählen.

	```txt
	/models
	```

	Weitere Anbieter und erweiterte Funktionen wie Caching und Ratenbegrenzung finden Sie unter [Helicone documentation](https://docs.helicone.ai).

	#### Optionale Konfigurationen

	Falls Sie eine Funktion oder ein Modell von Helicone sehen, das nicht automatisch über OpenCode konfiguriert wird, können Sie es jederzeit selbst konfigurieren.

	Hier ist [Helicone's Model Directory](https://helicone.ai/models). Sie benötigen dies, um die IDs der Modelle abzurufen, die Sie hinzufügen möchten.

	```jsonc title="~/.config/opencode/opencode.jsonc"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"helicone": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "Helicone",
	"options": {
	"baseURL": "https://ai-gateway.helicone.ai",
	},
	"models": {
	"gpt-4o": {
	// Model ID (from Helicone's model directory page)
	"name": "GPT-4o", // Your own custom name for the model
	},
	"claude-sonnet-4-20250514": {
	"name": "Claude Sonnet 4",
	},
	},
	},
	},
	}
	```

	#### Benutzerdefinierte Header

	Helicone unterstützt benutzerdefinierte Header für Funktionen wie Caching, Benutzerverfolgung und Sitzungsverwaltung. Fügen Sie sie mit `options.headers` zu Ihrer Anbieterkonfiguration hinzu:

	```jsonc title="~/.config/opencode/opencode.jsonc"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"helicone": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "Helicone",
	"options": {
	"baseURL": "https://ai-gateway.helicone.ai",
	"headers": {
	"Helicone-Cache-Enabled": "true",
	"Helicone-User-Id": "opencode",
	},
	},
	},
	},
	}
	```

	##### Sitzungsverfolgung

	Mit der [Sessions](https://docs.helicone.ai/features/sessions)-Funktion von Helicone können Sie zusammengehörige LLM-Anfragen gruppieren. Verwenden Sie das [opencode-helicone-session](https://github.com/H2Shami/opencode-helicone-session)-Plugin, um jede OpenCode-Konversation automatisch als Sitzung in Helicone zu protokollieren.

	```bash
	npm install -g opencode-helicone-session
	```

	Fügen Sie es Ihrer Konfiguration hinzu.

	```json title="opencode.json"
	{
	"plugin": ["opencode-helicone-session"]
	}
	```

	Das Plugin fügt `Helicone-Session-Id`- und `Helicone-Session-Name`-Header in Ihre Anfragen ein. Auf der Seite „Sitzungen“ von Helicone wird jede OpenCode-Konversation als separate Sitzung aufgeführt.

	##### Gängige Helicone-Header

	\| Kopfzeile \| Beschreibung \|
	\| -------------------------- \| ----------------------------------------------------------------------------------- \|
	\| `Helicone-Cache-Enabled` \| Antwort-Caching aktivieren (`true`/`false`) \|
	\| `Helicone-User-Id` \| Verfolgen Sie Metriken nach Benutzer \|
	\| `Helicone-Property-[Name]` \| Benutzerdefinierte Eigenschaften hinzufügen (e.g., `Helicone-Property-Environment`) \|
	\| `Helicone-Prompt-Id` \| Anfragen mit Eingabeaufforderungsversionen verknüpfen \|

	Alle verfügbaren Header finden Sie unter [Helicone Header Directory](https://docs.helicone.ai/helicone-headers/header-directory).

	---

	### llama.cpp

	Sie können OpenCode für die Verwendung lokaler Modelle über das Dienstprogramm [llama.cpp's](https://github.com/ggml-org/llama.cpp) llama-server konfigurieren

	```json title="opencode.json" "llama.cpp" {5, 6, 8, 10-15}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"llama.cpp": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "llama-server (local)",
	"options": {
	"baseURL": "http://127.0.0.1:8080/v1"
	},
	"models": {
	"qwen3-coder:a3b": {
	"name": "Qwen3-Coder: a3b-30b (local)",
	"limit": {
	"context": 128000,
	"output": 65536
	}
	}
	}
	}
	}
	}
	```

	In diesem Beispiel:

	- `llama.cpp` ist der benutzerdefinierte Anbieter ID. Dies kann eine beliebige Zeichenfolge sein.
	- `npm` gibt das Paket an, das für diesen Anbieter verwendet werden soll. Hier wird `@ai-sdk/openai-compatible` für jeden OpenAI-kompatiblen API verwendet.
	- `name` ist der Anzeigename für den Anbieter im UI.
	- `options.baseURL` ist der Endpunkt für den lokalen Server.
	- `models` ist eine Zuordnung von Modell-IDs zu ihren Konfigurationen. Der Modellname wird in der Modellauswahlliste angezeigt.

	---

	### IO.NET

	IO.NET bietet 17-Modelle, die für verschiedene Anwendungsfälle optimiert sind:

	1. Gehen Sie zu [IO.NET console](https://ai.io.net/), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach IO.NET.

	```txt
	/connect
	```

	3. Geben Sie Ihren IO.NET API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell auszuwählen.

	```txt
	/models
	```

	---

	### LM Studio

	Sie können OpenCode über LM Studio für die Verwendung lokaler Modelle konfigurieren.

	```json title="opencode.json" "lmstudio" {5, 6, 8, 10-14}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"lmstudio": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "LM Studio (local)",
	"options": {
	"baseURL": "http://127.0.0.1:1234/v1"
	},
	"models": {
	"google/gemma-3n-e4b": {
	"name": "Gemma 3n-e4b (local)"
	}
	}
	}
	}
	}
	```

	In diesem Beispiel:

	- `lmstudio` ist der benutzerdefinierte Anbieter ID. Dies kann eine beliebige Zeichenfolge sein.
	- `npm` gibt das Paket an, das für diesen Anbieter verwendet werden soll. Hier wird `@ai-sdk/openai-compatible` für jeden OpenAI-kompatiblen API verwendet.
	- `name` ist der Anzeigename für den Anbieter im UI.
	- `options.baseURL` ist der Endpunkt für den lokalen Server.
	- `models` ist eine Zuordnung von Modell-IDs zu ihren Konfigurationen. Der Modellname wird in der Modellauswahlliste angezeigt.

	---

	### Moonshot AI

	So verwenden Sie Kimi K2 von Moonshot AI:

	1. Gehen Sie zu [Moonshot AI console](https://platform.moonshot.ai/console), erstellen Sie ein Konto und klicken Sie auf Schlüssel API erstellen.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Moonshot AI.

	```txt
	/connect
	```

	3. Geben Sie Ihren Moonshot API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um _Kimi K2_ auszuwählen.

	```txt
	/models
	```

	---

	### MiniMax

	1. Gehen Sie zu [MiniMax API Console](https://platform.minimax.io/login), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach MiniMax.

	```txt
	/connect
	```

	3. Geben Sie Ihren MiniMax API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell wie _M2.1_ auszuwählen.

	```txt
	/models
	```

	---

	### Nebius Token Factory

	1. Gehen Sie zu [Nebius Token Factory console](https://tokenfactory.nebius.com/), erstellen Sie ein Konto und klicken Sie auf Schlüssel hinzufügen.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Nebius Token Factory.

	```txt
	/connect
	```

	3. Geben Sie Ihren Nebius Token Factory API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell wie _Kimi K2 Instruct_ auszuwählen.

	```txt
	/models
	```

	---

	### Ollama

	Sie können OpenCode über Ollama für die Verwendung lokaler Modelle konfigurieren.

	:::tip
	Ollama kann sich automatisch für OpenCode konfigurieren. Weitere Informationen finden Sie unter [Ollama integration docs](https://docs.ollama.com/integrations/opencode).
	:::

	```json title="opencode.json" "ollama" {5, 6, 8, 10-14}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"ollama": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "Ollama (local)",
	"options": {
	"baseURL": "http://localhost:11434/v1"
	},
	"models": {
	"llama2": {
	"name": "Llama 2"
	}
	}
	}
	}
	}
	```

	In diesem Beispiel:

	- `ollama` ist der benutzerdefinierte Anbieter ID. Dies kann eine beliebige Zeichenfolge sein.
	- `npm` gibt das Paket an, das für diesen Anbieter verwendet werden soll. Hier wird `@ai-sdk/openai-compatible` für jeden OpenAI-kompatiblen API verwendet.
	- `name` ist der Anzeigename für den Anbieter im UI.
	- `options.baseURL` ist der Endpunkt für den lokalen Server.
	- `models` ist eine Zuordnung von Modell-IDs zu ihren Konfigurationen. Der Modellname wird in der Modellauswahlliste angezeigt.

	:::tip
	Wenn Toolaufrufe nicht funktionieren, versuchen Sie, `num_ctx` in Ollama zu erhöhen. Beginnen Sie bei ca. 16.000 – 32.000 km.
	:::

	---

	### Ollama Cloud

	So verwenden Sie Ollama Cloud mit OpenCode:

	1. Gehen Sie zu [https://ollama.com/](https://ollama.com/) und melden Sie sich an oder erstellen Sie ein Konto.

	2. Navigieren Sie zu Einstellungen > Schlüssel und klicken Sie auf Add API Key, um einen neuen API-Schlüssel zu generieren.

	3. Kopieren Sie den API-Schlüssel zur Verwendung in OpenCode.

	4. Führen Sie den Befehl `/connect` aus und suchen Sie nach Ollama Cloud.

	```txt
	/connect
	```

	5. Geben Sie Ihren Ollama Cloud API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	6. Wichtig: Bevor Sie Cloud-Modelle in OpenCode verwenden, müssen Sie die Modellinformationen lokal abrufen:

	```bash
	ollama pull gpt-oss:20b-cloud
	```

	7. Führen Sie den Befehl `/models` aus, um Ihr Ollama Cloud-Modell auszuwählen.

	```txt
	/models
	```

	---

	### OpenAI

	Wir empfehlen, sich für [ChatGPT Plus or Pro](https://chatgpt.com/pricing) anzumelden.

	1. Führen Sie nach der Anmeldung den Befehl `/connect` aus und wählen Sie OpenAI aus.

	```txt
	/connect
	```

	2. Hier können Sie die Option ChatGPT Plus/Pro auswählen und Ihr Browser wird geöffnet
	und bitten Sie, sich zu authentifizieren.

	```txt
	┌ Select auth method
	│
	│ ChatGPT Plus/Pro
	│ Manually enter API Key
	└
	```

	3. Jetzt sollten alle OpenAI-Modelle verfügbar sein, wenn Sie den Befehl `/models` verwenden.

	```txt
	/models
	```

	##### Verwendung von API-Keys

	Wenn Sie bereits über einen API-Schlüssel verfügen, können Sie API-Schlüssel manuell eingeben auswählen und ihn in Ihr Terminal einfügen.

	---

	### OpenCode Zen

	OpenCode Zen ist eine Liste getesteter und verifizierter Modelle, die vom OpenCode-Team bereitgestellt werden. [Learn more](/docs/zen).

	1. Melden Sie sich bei <a href={console}>OpenCode Zen</a> an und klicken Sie auf Create API Key.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach OpenCode Zen.

	```txt
	/connect
	```

	3. Geben Sie Ihren OpenCode API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell wie _Qwen 3 Coder 480B_ auszuwählen.

	```txt
	/models
	```

	---

	### OpenRouter

	1. Gehen Sie zu [OpenRouter dashboard](https://openrouter.ai/settings/keys), klicken Sie auf Create API Key und kopieren Sie den Schlüssel.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach OpenRouter.

	```txt
	/connect
	```

	3. Geben Sie den Schlüssel API für den Anbieter ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Viele OpenRouter-Modelle sind standardmäßig vorinstalliert. Führen Sie den Befehl `/models` aus, um das gewünschte Modell auszuwählen.

	```txt
	/models
	```

	Sie können auch zusätzliche Modelle über Ihre OpenCode-Konfiguration hinzufügen.

	```json title="opencode.json" {6}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"openrouter": {
	"models": {
	"somecoolnewmodel": {}
	}
	}
	}
	}
	```

	5. Sie können sie auch über Ihre OpenCode-Konfiguration anpassen. Hier ist ein Beispiel für die Angabe eines Anbieters

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"openrouter": {
	"models": {
	"moonshotai/kimi-k2": {
	"options": {
	"provider": {
	"order": ["baseten"],
	"allow_fallbacks": false
	}
	}
	}
	}
	}
	}
	}
	```

	---

	### SAP AI Core

	SAP AI Core bietet Zugriff auf 40+ Modelle von OpenAI, Anthropic, Google, Amazon, Meta, Mistral und AI21 über eine einheitliche Plattform.

	1. Gehen Sie zu Ihrem [SAP BTP Cockpit](https://account.hana.ondemand.com/), navigieren Sie zu Ihrer SAP AI Core-Dienstinstanz und erstellen Sie einen Dienstschlüssel.

	:::tip
	Der Dienstschlüssel ist ein JSON-Objekt, das `clientid`, `clientsecret`, `url` und `serviceurls.AI_API_URL` enthält. Sie finden Ihre AI Core-Instanz unter Dienste > Instanzen und Abonnements im BTP Cockpit.
	:::

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach SAP AI Core.

	```txt
	/connect
	```

	3. Geben Sie Ihren JSON-Service-Account-Key ein.

	```txt
	┌ Service key
	│
	│
	└ enter
	```

	Oder legen Sie die Umgebungsvariable `AICORE_SERVICE_KEY` fest:

	```bash
	AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}' opencode
	```

	Oder fügen Sie es Ihrem Bash-Profil hinzu:

	```bash title="~/.bash_profile"
	export AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}'
	```

	4. Legen Sie optional die Bereitstellung ID und die Ressourcengruppe fest:

	```bash
	AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
	```

	:::note
	Diese Einstellungen sind optional und sollten entsprechend Ihrem SAP AI Core-Setup konfiguriert werden.
	:::

	5. Führen Sie den Befehl `/models` aus, um aus 40+ verfügbaren Modellen auszuwählen.

	```txt
	/models
	```

	---

	### STACKIT

	STACKIT AI Model Serving bietet eine voll verwaltete, souveraene Hosting-Umgebung fuer AI-Modelle, mit Fokus auf LLMs wie Llama, Mistral und Qwen, mit maximaler Datensouveraenitaet auf europaeischer Infrastruktur.

	1. Gehen Sie zum [STACKIT Portal](https://portal.stackit.cloud), navigieren Sie zu AI Model Serving und erstellen Sie ein Auth-Token fuer Ihr Projekt.

	:::tip
	Sie benoetigen ein STACKIT-Kundenkonto, Benutzerkonto und Projekt, bevor Sie Auth-Tokens erstellen koennen.
	:::

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach STACKIT.

	```txt
	/connect
	```

	3. Geben Sie Ihr STACKIT AI Model Serving Auth-Token ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um aus verfügbaren Modellen wie _Qwen3-VL 235B_ oder _Llama 3.3 70B_ auszuwählen.

	```txt
	/models
	```

	---

	### OVHcloud AI Endpoints

	1. Gehen Sie zum [OVHcloud panel](https://ovh.com/manager). Navigieren Sie zum Abschnitt `Public Cloud`, `AI & Machine Learning` > `AI Endpoints` und klicken Sie auf der Registerkarte `API Keys` auf Neuen API-Schlüssel erstellen.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach OVHcloud AI Endpoints.

	```txt
	/connect
	```

	3. Geben Sie Ihren OVHcloud AI Endpoints API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell wie _gpt-oss-120b_ auszuwählen.

	```txt
	/models
	```

	---

	### Scaleway

	So verwenden Sie [Scaleway Generative APIs](https://www.scaleway.com/en/docs/generative-apis/) mit OpenCode:

	1. Gehen Sie zu [Scaleway Console IAM settings](https://console.scaleway.com/iam/api-keys), um einen neuen API-Schlüssel zu generieren.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Scaleway.

	```txt
	/connect
	```

	3. Geben Sie Ihren Scaleway-API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell wie _devstral-2-123b-instruct-2512_ oder _gpt-oss-120b_ auszuwählen.

	```txt
	/models
	```

	---

	### Together AI

	1. Gehen Sie zu [Together AI console](https://api.together.ai), erstellen Sie ein Konto und klicken Sie auf Schlüssel hinzufügen.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Together AI.

	```txt
	/connect
	```

	3. Geben Sie Ihren Together AI API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell wie _Kimi K2 Instruct_ auszuwählen.

	```txt
	/models
	```

	---

	### Venice AI

	1. Gehen Sie zu [Venice AI console](https://venice.ai), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Venice AI.

	```txt
	/connect
	```

	3. Geben Sie Ihren Venice AI API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell wie _Llama 3.3 70B_ auszuwählen.

	```txt
	/models
	```

	---

	### Vercel AI Gateway

	Mit dem Vercel AI Gateway können Sie über einen einheitlichen Endpunkt auf Modelle von OpenAI, Anthropic, Google, xAI und mehr zugreifen. Die Modelle werden zum Listenpreis ohne Aufschlag angeboten.

	1. Gehen Sie zum [Vercel dashboard](https://vercel.com/), navigieren Sie zur Registerkarte AI Gateway und klicken Sie auf API-Schlüssel, um einen neuen API-Schlüssel zu erstellen.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Vercel AI Gateway.

	```txt
	/connect
	```

	3. Geben Sie Ihren Vercel AI Gateway API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell auszuwählen.

	```txt
	/models
	```

	Sie können Modelle auch über Ihre OpenCode-Konfiguration anpassen. Hier ist ein Beispiel für die Angabe der Provider-Routing-Reihenfolge.

	```json title="opencode.json"
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"vercel": {
	"models": {
	"anthropic/claude-sonnet-4": {
	"options": {
	"order": ["anthropic", "vertex"]
	}
	}
	}
	}
	}
	}
	```

	Einige nützliche Routing-Optionen:

	\| Option \| Beschreibung \|
	\| ------------------- \| ----------------------------------------------------------------- \|
	\| `order` \| Anbietersequenz zum Ausprobieren \|
	\| `only` \| Auf bestimmte Anbieter beschränken \|
	\| `zeroDataRetention` \| Verwenden Sie nur Anbieter mit Null-Datenaufbewahrungsrichtlinien \|

	---

	### xAI

	1. Gehen Sie zu [xAI console](https://console.x.ai/), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach xAI.

	```txt
	/connect
	```

	3. Geben Sie Ihren xAI API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell wie _Grok Beta_ auszuwählen.

	```txt
	/models
	```

	---

	### Z.AI

	1. Gehen Sie zu [Z.AI API console](https://z.ai/manage-apikey/apikey-list), erstellen Sie ein Konto und klicken Sie auf Neuen API-Schlüssel erstellen.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach Z.AI.

	```txt
	/connect
	```

	Wenn Sie den GLM Coding Plan abonniert haben, wählen Sie Z.AI Coding Plan.

	3. Geben Sie Ihren Z.AI API-Schlüssel ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Führen Sie den Befehl `/models` aus, um ein Modell wie _GLM-4.7_ auszuwählen.

	```txt
	/models
	```

	---

	### ZenMux

	1. Gehen Sie zu [ZenMux dashboard](https://zenmux.ai/settings/keys), klicken Sie auf Create API Key und kopieren Sie den Schlüssel.

	2. Führen Sie den Befehl `/connect` aus und suchen Sie nach ZenMux.

	```txt
	/connect
	```

	3. Geben Sie den Schlüssel API für den Anbieter ein.

	```txt
	┌ API key
	│
	│
	└ enter
	```

	4. Viele ZenMux-Modelle sind standardmäßig vorinstalliert. Führen Sie den Befehl `/models` aus, um das gewünschte Modell auszuwählen.

	```txt
	/models
	```

	Sie können auch zusätzliche Modelle über Ihre OpenCode-Konfiguration hinzufügen.

	```json title="opencode.json" {6}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"zenmux": {
	"models": {
	"somecoolnewmodel": {}
	}
	}
	}
	}
	```

	---

	## Benutzerdefinierter Anbieter

	So fügen Sie einen OpenAI-kompatiblen Anbieter hinzu, der nicht im Befehl `/connect` aufgeführt ist:

	:::tip
	Sie können jeden OpenAI-kompatiblen Anbieter mit OpenCode verwenden. Die meisten modernen AI-Anbieter bieten OpenAI-kompatible APIs an.
	:::

	1. Führen Sie den Befehl `/connect` aus und scrollen Sie nach unten zu Andere.

	```bash
	$ /connect

	┌ Add credential
	│
	◆ Select provider
	│ ...
	│ ● Other
	└
	```

	2. Geben Sie einen eindeutigen ID für den Anbieter ein.

	```bash
	$ /connect

	┌ Add credential
	│
	◇ Enter provider id
	│ myprovider
	└
	```

	:::note
	Wählen Sie einen einprägsamen ID, den Sie in Ihrer Konfigurationsdatei verwenden.
	:::

	3. Geben Sie Ihren API-Schlüssel für den Anbieter ein.

	```bash
	$ /connect

	┌ Add credential
	│
	▲ This only stores a credential for myprovider - you will need to configure it in opencode.json, check the docs for examples.
	│
	◇ Enter your API key
	│ sk-...
	└
	```

	4. Erstellen oder aktualisieren Sie Ihre `opencode.json`-Datei in Ihrem Projektverzeichnis:

	```json title="opencode.json" ""myprovider"" {5-15}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"myprovider": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "My AI ProviderDisplay Name",
	"options": {
	"baseURL": "https://api.myprovider.com/v1"
	},
	"models": {
	"my-model-name": {
	"name": "My Model Display Name"
	}
	}
	}
	}
	}
	```

	Hier sind die Konfigurationsmöglichkeiten:
	- npm: AI SDK zu verwendendes Paket, `@ai-sdk/openai-compatible` für OpenAI-kompatible Anbieter
	- Name: Anzeigename in UI.
	- Modelle: Verfügbare Modelle.
	- options.baseURL: API endpoint URL.
	- Optionen.apiKey: Legen Sie optional den Schlüssel API fest, wenn Sie keine Authentifizierung verwenden.
	- options.headers: Optional benutzerdefinierte Header festlegen.

	Mehr zu den erweiterten Optionen im Beispiel unten.

	5. Führen Sie den Befehl `/models` aus und Ihr benutzerdefinierter Anbieter und Ihre Modelle werden in der Auswahlliste angezeigt.

	---

	##### Beispiel

	Hier ist ein Beispiel für die Einstellung der Optionen `apiKey`, `headers` und Modell `limit`.

	```json title="opencode.json" {9,11,17-20}
	{
	"$schema": "https://opencode.ai/config.json",
	"provider": {
	"myprovider": {
	"npm": "@ai-sdk/openai-compatible",
	"name": "My AI ProviderDisplay Name",
	"options": {
	"baseURL": "https://api.myprovider.com/v1",
	"apiKey": "{env:ANTHROPIC_API_KEY}",
	"headers": {
	"Authorization": "Bearer custom-token"
	}
	},
	"models": {
	"my-model-name": {
	"name": "My Model Display Name",
	"limit": {
	"context": 200000,
	"output": 65536
	}
	}
	}
	}
	}
	}
	```

	Konfigurationsdetails:

	- apiKey: Wird mit der Variablensyntax `env`, [learn more](/docs/config#env-vars), festgelegt.
	- Header: Benutzerdefinierte Header, die mit jeder Anfrage gesendet werden.
	- limit.context: Maximale Eingabetokens, die das Modell akzeptiert.
	- limit.output: Maximale Token, die das Modell generieren kann.

	Mithilfe der `limit`-Felder kann OpenCode erkennen, wie viel Kontext Sie noch haben. Standardanbieter beziehen diese automatisch von models.dev.

	---

	## Fehlerbehebung

	Wenn Sie Probleme beim Konfigurieren eines Anbieters haben, überprüfen Sie Folgendes:

	1. Überprüfen Sie die Authentifizierungseinrichtung: Führen Sie `opencode auth list` aus, um zu sehen, ob die Anmeldeinformationen vorhanden sind
	für den Anbieter werden Ihrer Konfiguration hinzugefügt.

	Dies gilt nicht für Anbieter wie Amazon Bedrock, die für ihre Authentifizierung auf Umgebungsvariablen angewiesen sind.

	2. Überprüfen Sie bei benutzerdefinierten Anbietern die OpenCode-Konfiguration und:
	- Stellen Sie sicher, dass der im Befehl `/connect` verwendete Anbieter ID mit dem ID in Ihrer OpenCode-Konfiguration übereinstimmt.
	- Für den Anbieter wird das richtige npm-Paket verwendet. Verwenden Sie beispielsweise `@ai-sdk/cerebras` für Cerebras. Und für alle anderen OpenAI-kompatiblen Anbieter verwenden Sie `@ai-sdk/openai-compatible`.
	- Überprüfen Sie, ob im Feld `options.baseURL` der richtige Endpunkt API verwendet wird.

Xet Storage Details

Size:: 52.5 kB
Xet hash:: 3682e4f30261ab6f979d7d8ff7fb29e6b958be28e4b9012d4b7afe872c32c985

Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.