opencode/packages/web/src/content/docs/de/providers.mdx at b7b8b06011ff58f7d52dc0f73df67b459d9f5dce · anomalyco/opencode

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

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

OpenCode verwendet AI SDK und 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:

Fügen Sie die API-Schlüssel für den Anbieter mit dem Befehl /connect hinzu.
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.

{
  "$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.

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

Führen Sie den Befehl /connect in TUI aus, wählen Sie OpenCode aus und gehen Sie zu opencode.ai/auth.
```
/connect
```
Melden Sie sich an, geben Sie Ihre Rechnungsdaten ein und kopieren Sie Ihren API-Schlüssel.
Fügen Sie Ihren API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie /models in TUI aus, um die Liste der von uns empfohlenen Modelle anzuzeigen.
```
/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.

Führen Sie den Befehl /connect in der TUI aus, waehlen Sie OpenCode Go und gehen Sie zu opencode.ai/auth.
```
/connect
```
Melden Sie sich an, geben Sie Ihre Rechnungsdaten ein und kopieren Sie Ihren API-Schlüssel.
Fügen Sie Ihren API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie /models in der TUI aus, um die Liste der empfohlenen Modelle zu sehen.
```
/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

Gehen Sie zu 302.AI console, erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach 302.AI.
```
/connect
```
Geben Sie Ihren 302.AI API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell auszuwählen.
```
/models
```

Amazon Bedrock

So verwenden Sie Amazon Bedrock mit OpenCode:

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. :::
Konfigurieren Sie die Authentifizierung mit einer der folgenden Methoden:

Umgebungsvariablen (Schnellstart)

Legen Sie eine dieser Umgebungsvariablen fest, während Sie OpenCode ausführen:
```
# 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:
```
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:
```
{
  "$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:
```
{
  "$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. :::
Führen Sie den Befehl /models aus, um das gewünschte Modell auszuwählen.
```
/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:

{
  "$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

Sobald Sie sich angemeldet haben, führen Sie den Befehl /connect aus und wählen Sie Anthropic aus.
```
/connect
```
Hier können Sie die Option Claude Pro/Max auswählen und Ihr Browser wird geöffnet und bitten Sie, sich zu authentifizieren.
```
┌ Select auth method
│
│ Claude Pro/Max
│ Create an API Key
│ Manually enter API Key
└
```
Jetzt sollten alle Anthropic-Modelle verfügbar sein, wenn Sie den Befehl /models verwenden.
```
/models
```

:::info Die Verwendung Ihres Claude Pro/Max-Abonnements in OpenCode wird von Anthropic 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 verwendet — eine Desktop-Anwendung, die lokale LLMs hinter einem OpenAI-kompatiblen API-Server bereitstellt (Standard-Endpunkt http://127.0.0.1:1337/v1).

{
  "$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. :::

Gehen Sie zu Azure portal 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
Gehen Sie zu Azure AI Foundry und stellen Sie ein Modell bereit.

:::note Der Bereitstellungsname muss mit dem Modellnamen übereinstimmen, damit OpenCode ordnungsgemäß funktioniert. :::
Führen Sie den Befehl /connect aus und suchen Sie nach Azure.
```
/connect
```
Geben Sie Ihren API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Legen Sie Ihren Ressourcennamen als Umgebungsvariable fest:
```
AZURE_RESOURCE_NAME=XXX opencode
```
Oder fügen Sie es Ihrem Bash-Profil hinzu:
```
export AZURE_RESOURCE_NAME=XXX
```
Führen Sie den Befehl /models aus, um Ihr bereitgestelltes Modell auszuwählen.
```
/models
```

Azure Cognitive Services

Gehen Sie zu Azure portal 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
Gehen Sie zu Azure AI Foundry und stellen Sie ein Modell bereit.

:::note Der Bereitstellungsname muss mit dem Modellnamen übereinstimmen, damit OpenCode ordnungsgemäß funktioniert. :::
Führen Sie den Befehl /connect aus und suchen Sie nach Azure Cognitive Services.
```
/connect
```
Geben Sie Ihren API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Legen Sie Ihren Ressourcennamen als Umgebungsvariable fest:
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
```
Oder fügen Sie es Ihrem Bash-Profil hinzu:
```
export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
```
Führen Sie den Befehl /models aus, um Ihr bereitgestelltes Modell auszuwählen.
```
/models
```

Baseten

Gehen Sie zu Baseten, erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach Baseten.
```
/connect
```
Geben Sie Ihren Baseten API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell auszuwählen.
```
/models
```

Cerebras

Gehen Sie zu Cerebras console, erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach Cerebras.
```
/connect
```
Geben Sie Ihren Cerebras-API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell wie Qwen 3 Coder 480B auszuwählen.
```
/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 benötigen Sie nicht für jeden Anbieter separate API-Schlüssel.

Gehen Sie zu Cloudflare dashboard, navigieren Sie zu AI > AI Gateway und erstellen Sie ein neues Gateway.

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

export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_GATEWAY_ID=your-gateway-id

Führen Sie den Befehl /connect aus und suchen Sie nach Cloudflare AI Gateway.
```
/connect
```
Geben Sie Ihr Cloudflare-API-Token ein.
```
┌ API key
│
│
└ enter
```
Oder legen Sie es als Umgebungsvariable fest.
```
export CLOUDFLARE_API_TOKEN=your-api-token
```

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

/models

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

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

Cortecs

Gehen Sie zu Cortecs console, erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach Cortecs.
```
/connect
```
Geben Sie Ihren Cortecs-API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell wie Kimi K2 Instruct auszuwählen.
```
/models
```

DeepSeek

Gehen Sie zu DeepSeek console, erstellen Sie ein Konto und klicken Sie auf Neuen API-Schlüssel erstellen.
Führen Sie den Befehl /connect aus und suchen Sie nach DeepSeek.
```
/connect
```
Geben Sie Ihren DeepSeek API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein DeepSeek-Modell wie DeepSeek V4 Pro auszuwählen.
```
/models
```

Deep Infra

Gehen Sie zu Deep Infra dashboard, erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach Deep Infra.
```
/connect
```
Geben Sie Ihren Deep Infra API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell auszuwählen.
```
/models
```

FrogBot

Gehen Sie zu FrogBot dashboard, erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach FrogBot.
```
/connect
```
Geben Sie Ihren FrogBot API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell auszuwählen.
```
/models
```

Fireworks AI

Gehen Sie zu Fireworks AI console, erstellen Sie ein Konto und klicken Sie auf API-Schlüssel erstellen.
Führen Sie den Befehl /connect aus und suchen Sie nach Fireworks AI.
```
/connect
```
Geben Sie Ihren Fireworks AI API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell wie Kimi K2 Instruct auszuwählen.
```
/models
```

GitLab Duo

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

Führen Sie den Befehl /connect aus und wählen Sie GitLab aus.
```
/connect
```
Wählen Sie Ihre Authentifizierungsmethode:
```
┌ 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
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
Führen Sie den Befehl /models aus, um verfügbare Modelle anzuzeigen.
```
/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.

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

:::

Für selbstgehostete GitLab-Instanzen:

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

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

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

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

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:

Duo Agent Platform für den Benutzer, die Gruppe oder die Instanz
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:

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

Weitere Dokumentation auf der opencode-gitlab-auth-Homepage.

Konfiguration

Anpassen über 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.):

{
  "$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 zur Verwendung.

Einige Modelle müssen in Ihrem GitHub Copilot settings manuell aktiviert werden. :::

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

Navigieren Sie zu github.com/login/device und geben Sie den Code ein.

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

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

Google Vertex AI

So verwenden Sie Google Vertex AI mit OpenCode:

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. :::
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.
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
```
Oder fügen Sie sie Ihrem Bash-Profil hinzu.
```
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 :::

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

Groq

Gehen Sie zu Groq console, klicken Sie auf Create API Key und kopieren Sie den Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach Groq.
```
/connect
```
Geben Sie den Schlüssel API für den Anbieter ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um das gewünschte auszuwählen.
```
/models
```

Hugging Face

Hugging Face Inference Providers bietet Zugriff auf offene Modelle, die von 17+-Anbietern unterstützt werden.

Gehen Sie zu Hugging Face settings, um ein Token mit der Berechtigung zum Aufrufen von Inferenzanbietern zu erstellen.
Führen Sie den Befehl /connect aus und suchen Sie nach Hugging Face.
```
/connect
```
Geben Sie Ihren Hugging Face-Token ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell wie Kimi-K2-Instruct oder GLM-4.6 auszuwählen.
```
/models
```

Helicone

Helicone 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.

Gehen Sie zu Helicone, erstellen Sie ein Konto und generieren Sie einen API-Schlüssel über Ihr Dashboard.
Führen Sie den Befehl /connect aus und suchen Sie nach Helicone.
```
/connect
```
Geben Sie Ihren Helicone-API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell auszuwählen.
```
/models
```

Weitere Anbieter und erweiterte Funktionen wie Caching und Ratenbegrenzung finden Sie unter Helicone documentation.

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. Sie benötigen dies, um die IDs der Modelle abzurufen, die Sie hinzufügen möchten.

{
  "$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:

{
  "$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-Funktion von Helicone können Sie zusammengehörige LLM-Anfragen gruppieren. Verwenden Sie das opencode-helicone-session-Plugin, um jede OpenCode-Konversation automatisch als Sitzung in Helicone zu protokollieren.

npm install -g opencode-helicone-session

Fügen Sie es Ihrer Konfiguration hinzu.

{
  "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.

llama.cpp

Sie können OpenCode für die Verwendung lokaler Modelle über das Dienstprogramm llama.cpp's llama-server konfigurieren

{
  "$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:

Gehen Sie zu IO.NET console, erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach IO.NET.
```
/connect
```
Geben Sie Ihren IO.NET API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell auszuwählen.
```
/models
```

LM Studio

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

{
  "$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:

Gehen Sie zu Moonshot AI console, erstellen Sie ein Konto und klicken Sie auf Schlüssel API erstellen.
Führen Sie den Befehl /connect aus und suchen Sie nach Moonshot AI.
```
/connect
```
Geben Sie Ihren Moonshot API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um Kimi K2 auszuwählen.
```
/models
```

MiniMax

Gehen Sie zu MiniMax API Console, erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach MiniMax.
```
/connect
```
Geben Sie Ihren MiniMax API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell wie M2.1 auszuwählen.
```
/models
```

Nebius Token Factory

Gehen Sie zu Nebius Token Factory console, erstellen Sie ein Konto und klicken Sie auf Schlüssel hinzufügen.
Führen Sie den Befehl /connect aus und suchen Sie nach Nebius Token Factory.
```
/connect
```
Geben Sie Ihren Nebius Token Factory API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell wie Kimi K2 Instruct auszuwählen.
```
/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. :::

{
  "$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:

Gehen Sie zu https://ollama.com/ und melden Sie sich an oder erstellen Sie ein Konto.
Navigieren Sie zu Einstellungen > Schlüssel und klicken Sie auf Add API Key, um einen neuen API-Schlüssel zu generieren.
Kopieren Sie den API-Schlüssel zur Verwendung in OpenCode.
Führen Sie den Befehl /connect aus und suchen Sie nach Ollama Cloud.
```
/connect
```
Geben Sie Ihren Ollama Cloud API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Wichtig: Bevor Sie Cloud-Modelle in OpenCode verwenden, müssen Sie die Modellinformationen lokal abrufen:
```
ollama pull gpt-oss:20b-cloud
```
Führen Sie den Befehl /models aus, um Ihr Ollama Cloud-Modell auszuwählen.
```
/models
```

OpenAI

Wir empfehlen, sich für ChatGPT Plus or Pro anzumelden.

Führen Sie nach der Anmeldung den Befehl /connect aus und wählen Sie OpenAI aus.
```
/connect
```
Hier können Sie die Option ChatGPT Plus/Pro auswählen und Ihr Browser wird geöffnet und bitten Sie, sich zu authentifizieren.
```
┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└
```
Jetzt sollten alle OpenAI-Modelle verfügbar sein, wenn Sie den Befehl /models verwenden.
```
/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.

Melden Sie sich bei OpenCode Zen an und klicken Sie auf Create API Key.
Führen Sie den Befehl /connect aus und suchen Sie nach OpenCode Zen.
```
/connect
```
Geben Sie Ihren OpenCode API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell wie Qwen 3 Coder 480B auszuwählen.
```
/models
```

OpenRouter

Gehen Sie zu OpenRouter dashboard, klicken Sie auf Create API Key und kopieren Sie den Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach OpenRouter.
```
/connect
```
Geben Sie den Schlüssel API für den Anbieter ein.
```
┌ API key
│
│
└ enter
```
Viele OpenRouter-Modelle sind standardmäßig vorinstalliert. Führen Sie den Befehl /models aus, um das gewünschte Modell auszuwählen.
```
/models
```
Sie können auch zusätzliche Modelle über Ihre OpenCode-Konfiguration hinzufügen.
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

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

{
  "$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.

Gehen Sie zu Ihrem SAP BTP Cockpit, 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. :::
Führen Sie den Befehl /connect aus und suchen Sie nach SAP AI Core.
```
/connect
```

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

┌ Service key
│
│
└ enter

Oder legen Sie die Umgebungsvariable AICORE_SERVICE_KEY fest:

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

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

export AICORE_SERVICE_KEY='{"clientid":"...","clientsecret":"...","url":"...","serviceurls":{"AI_API_URL":"..."}}'

Legen Sie optional die Bereitstellung ID und die Ressourcengruppe fest:
```
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. :::
Führen Sie den Befehl /models aus, um aus 40+ verfügbaren Modellen auszuwählen.
```
/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.

Gehen Sie zum STACKIT Portal, 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. :::
Führen Sie den Befehl /connect aus und suchen Sie nach STACKIT.
```
/connect
```
Geben Sie Ihr STACKIT AI Model Serving Auth-Token ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um aus verfügbaren Modellen wie Qwen3-VL 235B oder Llama 3.3 70B auszuwählen.
```
/models
```

OVHcloud AI Endpoints

Gehen Sie zum OVHcloud panel. 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.
Führen Sie den Befehl /connect aus und suchen Sie nach OVHcloud AI Endpoints.
```
/connect
```
Geben Sie Ihren OVHcloud AI Endpoints API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell wie gpt-oss-120b auszuwählen.
```
/models
```

Scaleway

So verwenden Sie Scaleway Generative APIs mit OpenCode:

Gehen Sie zu Scaleway Console IAM settings, um einen neuen API-Schlüssel zu generieren.
Führen Sie den Befehl /connect aus und suchen Sie nach Scaleway.
```
/connect
```
Geben Sie Ihren Scaleway-API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell wie devstral-2-123b-instruct-2512 oder gpt-oss-120b auszuwählen.
```
/models
```

Together AI

Gehen Sie zu Together AI console, erstellen Sie ein Konto und klicken Sie auf Schlüssel hinzufügen.
Führen Sie den Befehl /connect aus und suchen Sie nach Together AI.
```
/connect
```
Geben Sie Ihren Together AI API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell wie Kimi K2 Instruct auszuwählen.
```
/models
```

Venice AI

Gehen Sie zu Venice AI console, erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach Venice AI.
```
/connect
```
Geben Sie Ihren Venice AI API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell wie Llama 3.3 70B auszuwählen.
```
/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.

Gehen Sie zum Vercel dashboard, navigieren Sie zur Registerkarte AI Gateway und klicken Sie auf API-Schlüssel, um einen neuen API-Schlüssel zu erstellen.
Führen Sie den Befehl /connect aus und suchen Sie nach Vercel AI Gateway.
```
/connect
```
Geben Sie Ihren Vercel AI Gateway API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell auszuwählen.
```
/models
```

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

{
  "$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

Gehen Sie zu xAI console, erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach xAI.
```
/connect
```
Geben Sie Ihren xAI API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell wie Grok Beta auszuwählen.
```
/models
```

Z.AI

Gehen Sie zu Z.AI API console, erstellen Sie ein Konto und klicken Sie auf Neuen API-Schlüssel erstellen.
Führen Sie den Befehl /connect aus und suchen Sie nach Z.AI.
```
/connect
```
Wenn Sie den GLM Coding Plan abonniert haben, wählen Sie Z.AI Coding Plan.
Geben Sie Ihren Z.AI API-Schlüssel ein.
```
┌ API key
│
│
└ enter
```
Führen Sie den Befehl /models aus, um ein Modell wie GLM-4.7 auszuwählen.
```
/models
```

ZenMux

Gehen Sie zu ZenMux dashboard, klicken Sie auf Create API Key und kopieren Sie den Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach ZenMux.
```
/connect
```
Geben Sie den Schlüssel API für den Anbieter ein.
```
┌ API key
│
│
└ enter
```
Viele ZenMux-Modelle sind standardmäßig vorinstalliert. Führen Sie den Befehl /models aus, um das gewünschte Modell auszuwählen.
```
/models
```
Sie können auch zusätzliche Modelle über Ihre OpenCode-Konfiguration hinzufügen.
```
{
  "$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. :::

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

$ /connect

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

Geben Sie einen eindeutigen ID für den Anbieter ein.
```
$ /connect

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
:::note Wählen Sie einen einprägsamen ID, den Sie in Ihrer Konfigurationsdatei verwenden. :::

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

$ /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-...
└

Erstellen oder aktualisieren Sie Ihre opencode.json-Datei in Ihrem Projektverzeichnis:
```
{
  "$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.
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.

{
  "$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, 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:

Ü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.
Ü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.

FilesExpand file tree

providers.mdx

Latest commit

History

providers.mdx

File metadata and controls

Anmeldeinformationen

Konfiguration

Base URL

OpenCode Zen

OpenCode Go

Verzeichnis

302.AI

Amazon Bedrock

Umgebungsvariablen (Schnellstart)

Konfigurationsdatei (empfohlen)

Erweitert: VPC Endpunkte

Authentifizierungsmethoden

Authentifizierungspriorität

Anthropic

Verwendung von API-Keys

Atomic Chat

Azure OpenAI

Azure Cognitive Services

Baseten

Cerebras

Cloudflare AI Gateway

Cortecs

DeepSeek

Deep Infra

FrogBot

Fireworks AI

GitLab Duo

Verwendung von OAuth (empfohlen)

Verwendung eines persönlichen Zugriffstokens

Selbstgehostetes GitLab

OAuth für selbstgehostete Instanzen

Konfiguration

GitLab API Tools (Optional, aber dringend empfohlen)

GitHub Copilot

Google Vertex AI

Groq

Hugging Face

Helicone

Optionale Konfigurationen

Benutzerdefinierte Header

Sitzungsverfolgung

Gängige Helicone-Header

llama.cpp

IO.NET

LM Studio

Moonshot AI

MiniMax

Nebius Token Factory

Ollama

Ollama Cloud

OpenAI

Verwendung von API-Keys

OpenCode Zen

OpenRouter

SAP AI Core

STACKIT

OVHcloud AI Endpoints

Scaleway

Together AI

Venice AI

Vercel AI Gateway

xAI

Z.AI

ZenMux

Benutzerdefinierter Anbieter

Beispiel

Fehlerbehebung