Deutsch
Dokumentation
Anbieter

Provider

Beliebige LLM-Provider in OpenCode verwenden.

OpenCode nutzt das AI SDK (opens in a new tab) und Models.dev (opens in a new tab), um 75+ LLM-Provider zu unterstützen, und es unterstützt das Ausführen lokaler Modelle.

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

  1. Die API-Schlüssel für den Provider mit dem Befehl /connect hinzufügen.
  2. Den Provider in Ihrer OpenCode-Konfiguration konfigurieren.

Credentials

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

Config

Sie können die Provider über den Abschnitt provider in Ihrer OpenCode-Konfiguration anpassen.

Base URL

Sie können die Base URL für jeden Provider anpassen, indem Sie die Option baseURL setzen. Das ist nützlich, wenn Sie Proxy-Dienste oder benutzerdefinierte Endpunkte verwenden.

opencode.json
{
  "$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 und getestet und verifiziert wurden, dass sie gut mit OpenCode funktionieren. Mehr erfahren.

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

  1. Führen Sie den Befehl /connect in der TUI aus, wählen Sie OpenCode Zen und gehen Sie zu opencode.ai/auth (opens in a new tab).

    /connect

  2. Melden Sie sich an, fügen Sie Ihre Abrechnungsdaten hinzu und kopieren Sie Ihren API-Schlüssel.

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

    ┌ API key
│
│
└ enter

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

    /models

Es funktioniert wie jeder andere Provider in OpenCode und ist vollkommen optional in der Nutzung.

OpenCode Go

OpenCode Go ist ein kostengünstiger Abonnementplan, der zuverlässigen Zugang zu beliebten offenen Coding-Modellen bietet, die vom OpenCode-Team bereitgestellt und getestet und verifiziert wurden, dass sie gut mit OpenCode funktionieren.

  1. Führen Sie den Befehl /connect in der TUI aus, wählen Sie OpenCode Go und gehen Sie zu opencode.ai/auth (opens in a new tab).

    /connect

  2. Melden Sie sich an, fügen Sie Ihre Abrechnungsdaten hinzu und kopieren Sie Ihren API-Schlüssel.

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

    ┌ API key
│
│
└ enter

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

    /models

Es funktioniert wie jeder andere Provider in OpenCode und ist vollkommen optional in der Nutzung.

Directory

Sehen wir uns einige der Provider im Detail an. Wenn Sie einen Provider zur Liste hinzufügen möchten, können Sie gerne einen PR öffnen.

Hinweis: Sie sehen einen Provider hier nicht? Reichen Sie einen PR ein.

302.AI

  1. Gehen Sie zur 302.AI Console (opens in a new tab), 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.

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

Amazon Bedrock

So verwenden Sie Amazon Bedrock mit OpenCode:

  1. Gehen Sie zum Model catalog in der Amazon Bedrock Console und fordern Sie Zugang zu den gewünschten Modellen an.

    Tipp: Sie müssen Zugang zu dem gewünschten Modell in Amazon Bedrock haben.

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

    Umgebungsvariablen (Schnellstart)

    Setzen Sie eine dieser Umgebungsvariablen, 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 zu Ihrem Bash-Profil hinzu:

    ~/.bash_profile
    export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1

    Konfigurationsdatei (Empfohlen)

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

    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 (z. B. us-east-1 , eu-west-1 )

    • profile - Benanntes AWS-Profil aus ~/.aws/credentials

    • endpoint - Benutzerdefinierte Endpunkt-URL für VPC-Endpunkte (Alias für die generische Option baseURL)

    Tipp: Optionen aus der Konfigurationsdatei haben Vorrang vor Umgebungsvariablen.

    Erweitert: VPC-Endpunkte

    Wenn Sie VPC-Endpunkte für Bedrock verwenden:

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

    Hinweis: Die Option endpoint ist ein Alias für die generische Option baseURL, der AWS-spezifische Terminologie verwendet. 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 Console
    • AWS_PROFILE : Verwenden Sie benannte Profile aus ~/.aws/credentials . Konfigurieren Sie zunächst mit aws configure --profile my-profile oder aws sso login
    • AWS_BEARER_TOKEN_BEDROCK : Generieren Sie langfristige API-Schlüssel über die Amazon Bedrock Console
    • AWS_WEB_IDENTITY_TOKEN_FILE / AWS_ROLE_ARN : Für EKS IRSA (IAM Roles for Service Accounts) oder andere Kubernetes-Umgebungen mit OIDC-Föderation. Diese Umgebungsvariablen werden von Kubernetes automatisch injiziert, wenn Service-Account-Annotationen verwendet werden.

    Authentifizierungsreihenfolge

    Amazon Bedrock verwendet die folgende Authentifizierungspriorität:

    1. Bearer Token - Umgebungsvariable AWS_BEARER_TOKEN_BEDROCK oder Token aus dem Befehl /connect

    2. AWS Credential Chain - Profil, Zugriffsschlüssel, gemeinsame Credentials, IAM-Rollen, Web Identity Tokens (EKS IRSA), Instance-Metadaten

    Hinweis: Wenn ein Bearer Token gesetzt ist (über /connect oder AWS_BEARER_TOKEN_BEDROCK), hat es Vorrang vor allen AWS-Credential-Methoden einschließlich konfigurierter Profile.

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

    /models

Hinweis: Verwenden Sie für benutzerdefinierte Inference Profiles den Modell- und Provider-Namen im Schlüssel und setzen Sie die Eigenschaft id auf den ARN. Das stellt korrektes Caching sicher.

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.

    /connect

  2. Hier können Sie die Option Claude Pro/Max auswählen, und sie öffnet Ihren Browser und bittet Sie, sich zu authentifizieren.

    ┌ Select auth method
│
│ Manually enter API Key
└

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

    /models

Es gibt Plugins, mit denen Sie Ihre Claude Pro/Max-Modelle mit OpenCode verwenden können. Anthropic verbietet dies ausdrücklich.

Frühere Versionen von OpenCode wurden mit diesen Plugins ausgeliefert, das ist aber seit 1.3.0 nicht mehr der Fall.

Andere Unternehmen unterstützen die Wahlfreiheit bei Entwickler-Tooling – Sie können die folgenden Abonnements ohne jegliche Einrichtung in OpenCode verwenden:

  • ChatGPT Plus
  • Github Copilot
  • Gitlab Duo

Atomic Chat

Sie können opencode so konfigurieren, dass es lokale Modelle über Atomic Chat (opens in a new tab) verwendet, eine Desktop-Anwendung, die lokale LLMs hinter einem OpenAI-kompatiblen API-Server ausführt (Standard-Endpunkt http://127.0.0.1:1337/v1).

opencode.json
{
  "$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. Das 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 Anzeigename für den Provider in der UI.
  • options.baseURL ist der Endpunkt für den lokalen Server. Ändern Sie Host und Port passend zu Ihrer Atomic Chat-Einrichtung.
  • models ist eine Zuordnung von Modell-IDs zu ihren Anzeigenamen. Jede ID muss mit der id übereinstimmen, die von GET /v1/models zurückgegeben wird — führen Sie curl http://127.0.0.1:1337/v1/models aus, um die aktuell in Atomic Chat geladenen IDs aufzulisten.

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

Azure OpenAI

Hinweis: Wenn Sie auf "I'm sorry, but I cannot assist with that request"-Fehler stoßen, versuchen Sie, den Content-Filter in Ihrer Azure-Ressource von DefaultV2 auf Default zu ändern.

  1. Gehen Sie zum Azure Portal (opens in a new tab) und erstellen Sie eine Azure OpenAI-Ressource. Sie benötigen:

    • Resource name : Dieser wird Teil Ihres API-Endpunkts ( https://RESOURCE_NAME.openai.azure.com/ )
    • API key : Entweder KEY 1 oder KEY 2 aus Ihrer Ressource

  2. Gehen Sie zur Azure AI Foundry (opens in a new tab) und stellen Sie ein Modell bereit.

    Hinweis: Der Bereitstellungsname muss mit dem Modellnamen übereinstimmen, damit opencode korrekt funktioniert.

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

    /connect

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

    ┌ API key
│
│
└ enter

  5. Setzen Sie Ihren Ressourcennamen als Umgebungsvariable:

    AZURE_RESOURCE_NAME=XXX opencode

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

    ~/.bash_profile
    export AZURE_RESOURCE_NAME=XXX

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

    /models

Azure Cognitive Services

  1. Gehen Sie zum Azure Portal (opens in a new tab) und erstellen Sie eine Azure OpenAI-Ressource. Sie benötigen:

    • Resource name : Dieser wird Teil Ihres API-Endpunkts ( https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/ )
    • API key : Entweder KEY 1 oder KEY 2 aus Ihrer Ressource

  2. Gehen Sie zur Azure AI Foundry (opens in a new tab) und stellen Sie ein Modell bereit.

    Hinweis: Der Bereitstellungsname muss mit dem Modellnamen übereinstimmen, damit opencode korrekt funktioniert.

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

    /connect

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

    ┌ API key
│
│
└ enter

  5. Setzen Sie Ihren Ressourcennamen als Umgebungsvariable:

    AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode

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

    ~/.bash_profile
    export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX

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

    /models

Baseten

  1. Gehen Sie zu Baseten (opens in a new tab), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

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

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

Cerebras

  1. Gehen Sie zur Cerebras Console (opens in a new tab), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

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

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

Cloudflare AI Gateway

Cloudflare AI Gateway ermöglicht Ihnen den Zugriff auf Modelle von OpenAI, Anthropic, Workers AI und mehr über einen einheitlichen Endpunkt. Mit Unified Billing (opens in a new tab) benötigen Sie keine separaten API-Schlüssel für jeden Provider.

  1. Gehen Sie zum Cloudflare Dashboard (opens in a new tab), navigieren Sie zu AI > AI Gateway und erstellen Sie ein neues Gateway. Notieren Sie sich Ihre Account ID und Gateway ID.

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

    /connect

  3. Geben Sie Ihre Account ID ein, wenn Sie dazu aufgefordert werden.

    ┌ Enter your Cloudflare Account ID
│
│
└ enter

  4. Geben Sie Ihre Gateway ID ein, wenn Sie dazu aufgefordert werden.

    ┌ Enter your Cloudflare AI Gateway ID
│
│
└ enter

  5. Geben Sie Ihr Cloudflare API token ein.

    ┌ Gateway API token
│
│
└ enter

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

    /models

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

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

    Alternativ können Sie Umgebungsvariablen setzen, anstatt /connect zu verwenden.

    ~/.bash_profile
    export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_GATEWAY_ID=your-gateway-id
export CLOUDFLARE_API_TOKEN=your-api-token

Cloudflare Workers AI

Cloudflare Workers AI ermöglicht Ihnen, KI-Modelle direkt über die REST-API im globalen Netzwerk von Cloudflare auszuführen, ohne separate Provider-Konten für unterstützte Modelle.

  1. Gehen Sie zum Cloudflare Dashboard (opens in a new tab), navigieren Sie zu Workers AI und wählen Sie Use REST API, um Ihre Account ID zu erhalten und ein API-Token zu erstellen.

  2. Führen Sie den Befehl /connect aus und suchen Sie nach Cloudflare Workers AI.

    /connect

  3. Geben Sie Ihre Account ID ein, wenn Sie dazu aufgefordert werden.

    ┌ Enter your Cloudflare Account ID
│
│
└ enter

  4. Geben Sie Ihren Cloudflare API key ein.

    ┌ API key
│
│
└ enter

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

    /models

    Alternativ können Sie Umgebungsvariablen setzen, anstatt /connect zu verwenden.

    ~/.bash_profile
    export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_API_KEY=your-api-token

Cortecs

  1. Gehen Sie zur Cortecs Console (opens in a new tab), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

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

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

DeepSeek

  1. Gehen Sie zur DeepSeek Console (opens in a new tab), erstellen Sie ein Konto und klicken Sie auf Create new API key.

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

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

Deep Infra

  1. Gehen Sie zum Deep Infra Dashboard (opens in a new tab), 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.

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

DigitalOcean

Die Inference Engine (opens in a new tab) von DigitalOcean bietet Zugang zu offenen Modellen wie GPT-OSS, Llama, Qwen und DeepSeek sowie zu benutzerdefinierten Inference Routers (opens in a new tab), die jede Anfrage an das günstigste, schnellste oder am besten geeignete Modell für eine Aufgabe routen.

OpenCode unterstützt zwei Authentifizierungsmethoden:

  • OAuth (Empfohlen) — Melden Sie sich bei Ihrem DigitalOcean-Konto an; OpenCode erstellt automatisch einen Model Access Key und entdeckt Ihre verfügbaren Models & Inference Routers.
  • Model Access Key — Fügen Sie einen vorhandenen Schlüssel aus der DigitalOcean Console ein.

OAuth (Empfohlen)

  1. Führen Sie den Befehl /connect aus und suchen Sie nach DigitalOcean.

    /connect

  2. Wählen Sie Login with DigitalOcean.

    ┌ Select auth method
│
│ Login with DigitalOcean
│ Paste Model Access Key
└

  3. Ihr Browser öffnet sich, um OpenCode zu autorisieren. Melden Sie sich an und bestätigen Sie.

    Hinweis: OpenCode erstellt einen Model Access Key namens opencode-oauth-<timestamp> in Ihrem DigitalOcean-Konto. Sie können ihn auf der Seite Model Access Keys im Abschnitt "Manage" der DigitalOcean Console unter Inference rotieren oder widerrufen.

  4. Führen Sie den Befehl /models aus. Ihre Inference Routers erscheinen im Format router: in der Modellauswahl.

    /models

  5. Um neu erstellte Inference Routers zu übernehmen, führen Sie /connect erneut aus und wählen Sie erneut DigitalOcean.

Einen Model Access Key verwenden

Wenn Sie lieber einen Schlüssel direkt einfügen möchten:

  1. Gehen Sie zur Seite Manage im Inference-Abschnitt der DigitalOcean Console (opens in a new tab) und erstellen Sie einen neuen Schlüssel.

  2. Führen Sie den Befehl /connect aus und wählen Sie DigitalOcean, dann Paste Model Access Key.

    ┌ Enter your DigitalOcean Model Access Key
│
│
└ enter

    Hinweis: Inference Routers werden mit dieser Methode nicht automatisch entdeckt. Um sie in der Modellauswahl anzuzeigen, melden Sie sich stattdessen über OAuth an.

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

    /models

Umgebungsvariable

Alternativ setzen Sie Ihren Model Access Key als Umgebungsvariable.

export DIGITALOCEAN_ACCESS_TOKEN=your-model-access-key

Inference Routers

Mit Inference Routers können Sie eine Routing-Richtlinie über mehrere Modelle hinweg definieren — sie wählen das günstigste, schnellste oder am besten geeignete Modell pro Anfrage basierend auf der Aufgabe. Nach OAuth zeigt OpenCode jeden Router als router:<router-name> in der Modellauswahl an.

Die Auswahl eines Router-Modells ist ein direkter Ersatz für jedes andere Modell — OpenCode leitet Ihre Anfrage weiter und DigitalOcean wählt das zugrunde liegende Modell basierend auf der Richtlinie Ihres Routers aus. Mehr über Inference Routers (opens in a new tab)

FrogBot

  1. Gehen Sie zum FrogBot Dashboard (opens in a new tab), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

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

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

Fireworks AI

  1. Gehen Sie zur Fireworks AI Console (opens in a new tab), erstellen Sie ein Konto und klicken Sie auf Create API Key.

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

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

GitLab Duo

Vorsicht: Die GitLab Duo-Unterstützung in OpenCode ist experimentell. Funktionen, Konfiguration und Verhalten können sich in zukünftigen Releases ändern.

OpenCode integriert sich mit der GitLab Duo Agent Platform (opens in a new tab) und bietet KI-gestützten agentischen Chat mit nativen Tool-Calling-Funktionen.

Hinweis: Die GitLab Duo Agent Platform erfordert ein Premium- oder Ultimate-GitLab- Abonnement. Sie ist auf GitLab.com und GitLab Self-Managed verfügbar. Siehe GitLab Duo Agent Platform prerequisites (opens in a new tab) für die vollständigen Anforderungen.

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

    /connect

  2. Wählen Sie Ihre Authentifizierungsmethode:

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

    OAuth verwenden (Empfohlen)

    Wählen Sie OAuth, und Ihr Browser öffnet sich zur Autorisierung.

    Personal Access Token verwenden

    1. Gehen Sie zu GitLab User Settings > Access Tokens (opens in a new tab)
    2. Klicken Sie auf Add new token
    3. Name: OpenCode , Scopes: 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 die verfügbaren Modelle zu sehen.

    /models

    Drei Claude-basierte Modelle sind verfügbar:

    • duo-chat-haiku-4-5 (Standard) - Schnelle Antworten für schnelle Aufgaben
    • duo-chat-sonnet-4-5 - Ausgewogene Leistung für die meisten Workflows
    • duo-chat-opus-4-5 - Am leistungsfähigsten für komplexe Analysen

Hinweis: Sie können auch die Umgebungsvariable 'GITLAB_TOKEN' angeben, wenn Sie das Token nicht im opencode-Auth-Speicher ablegen möchten.

Self-Hosted GitLab

Hinweis: OpenCode verwendet für einige KI-Aufgaben wie das Generieren des Sitzungstitels ein kleines Modell. Es ist standardmäßig so konfiguriert, dass es gpt-5-nano verwendet, gehostet von Zen. Um OpenCode ausschließlich auf Ihre eigene GitLab-gehostete Instanz zu beschränken, fügen Sie Folgendes zu Ihrer opencode.json-Datei hinzu. Es wird außerdem empfohlen, das Session-Sharing zu deaktivieren.

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

Für selbst gehostete GitLab-Instanzen:

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

Wenn Ihre Instanz ein benutzerdefiniertes AI Gateway betreibt:

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

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

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

Hinweis: Ihr GitLab-Administrator muss:

  1. GitLab Duo aktivieren (opens in a new tab) für den Benutzer, die Gruppe oder die Instanz
  2. Die Agent Platform aktivieren (opens in a new tab) (GitLab 18.8+) oder Beta- und experimentelle Funktionen aktivieren (opens in a new tab) (GitLab 18.7 und früher)
  3. Für Self-Managed Ihre Instanz konfigurieren (opens in a new tab)
OAuth für Self-Hosted-Instanzen

Damit OAuth für Ihre selbst gehostete Instanz funktioniert, müssen Sie eine neue Anwendung erstellen (Settings → Applications) mit der Callback-URL http://127.0.0.1:8080/callback und den folgenden Scopes:

  • api (Access the API on your behalf)
  • read_user (Read your personal information)
  • read_repository (Allows read-only access to the repository)

Stellen Sie dann die Anwendungs-ID als Umgebungsvariable bereit:

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

Weitere Dokumentation auf der opencode-gitlab-auth (opens in a new tab)-Homepage.

Konfiguration

Anpassung über opencode.json:

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "gitlab": {
      "options": {
        "instanceUrl": "https://gitlab.com"
      }
    }
  }
}
GitLab Duo Agent Platform (DAP) Workflow-Modelle

DAP-Workflow-Modelle bieten einen alternativen Ausführungspfad, der Tool-Aufrufe durch den Duo Workflow Service (DWS) von GitLab statt durch den standardmäßigen agentischen Chat routet. Wenn ein duo-workflow-*-Modell ausgewählt wird, führt OpenCode Folgendes aus:

  1. Verfügbare Modelle aus Ihrem GitLab-Namespace entdecken
  2. Eine Auswahlmaske anzeigen, wenn mehrere Modelle verfügbar sind
  3. Das ausgewählte Modell für schnelle nachfolgende Starts auf die Festplatte cachen
  4. Tool-Ausführungsanfragen durch das berechtigungsgesteuerte Tool-System von OpenCode routen

Verfügbare DAP-Workflow-Modelle folgen der Namenskonvention duo-workflow-* und werden dynamisch aus Ihrer GitLab-Instanz entdeckt.

GitLab API Tools (Optional, aber sehr empfohlen)

Um auf GitLab-Tools zuzugreifen (Merge Requests, Issues, Pipelines, CI/CD usw.):

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

Dieses Plugin bietet umfassende GitLab-Repository-Verwaltungsfunktionen, einschließlich MR-Reviews, Issue-Tracking, Pipeline-Überwachung und mehr.

GitHub Copilot

So verwenden Sie Ihr GitHub Copilot-Abonnement mit opencode:

Hinweis: Einige Modelle benötigen möglicherweise ein Pro+- Abonnement (opens in a new tab), um verwendet zu werden.

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

    /connect

  2. Navigieren Sie zu github.com/login/device (opens in a new tab) und geben Sie den Code ein.

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

    /models

Google Vertex AI

So verwenden Sie Google Vertex AI mit OpenCode:

  1. Gehen Sie zum Model Garden in der Google Cloud Console und prüfen Sie die in Ihrer Region verfügbaren Modelle.

    Hinweis: Sie benötigen ein Google Cloud-Projekt mit aktivierter Vertex AI API.

  2. Setzen Sie die erforderlichen Umgebungsvariablen:

    • GOOGLE_CLOUD_PROJECT : Ihre Google Cloud-Projekt-ID

    • VERTEX_LOCATION (optional): Die Region für Vertex AI (Standard global )

    • Authentifizierung (eine wählen):

      • GOOGLE_APPLICATION_CREDENTIALS : Pfad zu Ihrer Service-Account-JSON-Schlüsseldatei
      • Authentifizierung über die gcloud CLI: gcloud auth application-default login

    Setzen Sie sie, 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 zu Ihrem Bash-Profil hinzu.

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

Tipp: Die Region global verbessert die Verfügbarkeit und reduziert Fehler ohne zusätzliche Kosten. Verwenden Sie regionale Endpunkte (z. B. us-central1) für Anforderungen an die Datenresidenz. Mehr erfahren (opens in a new tab)

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

    /models

Groq

  1. Gehen Sie zur Groq Console (opens in a new tab), 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.

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

Hugging Face

Hugging Face Inference Providers (opens in a new tab) bietet Zugang zu offenen Modellen, die von 17+ Providern unterstützt werden.

  1. Gehen Sie zu den Hugging Face Settings (opens in a new tab), um ein Token mit der Berechtigung zu erstellen, Aufrufe an Inference Providers zu tätigen.

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

    /connect

  3. Geben Sie Ihr Hugging Face-Token ein.

    ┌ API key
│
│
└ enter

  4. Führen Sie den Befehl /models aus, um ein Modell wie Kimi-K2-Instruct oder GLM-4.6 auszuwählen.

    /models

Helicone

Helicone (opens in a new tab) ist eine LLM-Observability-Plattform, die Logging, Monitoring und Analysen für Ihre KI-Anwendungen bietet. Das Helicone AI Gateway leitet Ihre Anfragen automatisch basierend auf dem Modell an den passenden Provider weiter.

  1. Gehen Sie zu Helicone (opens in a new tab), 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.

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

Für weitere Provider und erweiterte Funktionen wie Caching und Rate Limiting siehe die Helicone-Dokumentation (opens in a new tab).

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 Helicones Model Directory (opens in a new tab); Sie benötigen es, um die IDs der Modelle zu erhalten, die Sie hinzufügen möchten.

~/.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, User-Tracking und Session-Management. Fügen Sie sie über options.headers zu Ihrer Provider-Konfiguration hinzu:

~/.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",
        },
      },
    },
  },
}
Session-Tracking

Mit der Sessions (opens in a new tab)-Funktion von Helicone können Sie zusammengehörige LLM-Anfragen gruppieren. Verwenden Sie das opencode-helicone-session (opens in a new tab)-Plugin, um jede OpenCode-Konversation automatisch als Session in Helicone zu protokollieren.

npm install -g opencode-helicone-session

Fügen Sie es zu Ihrer Konfiguration hinzu.

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

Das Plugin injiziert die Header Helicone-Session-Id und Helicone-Session-Name in Ihre Anfragen. Auf der Sessions-Seite von Helicone sehen Sie jede OpenCode-Konversation als separate Session aufgelistet.

Häufige Helicone-Header
HeaderBeschreibung
Helicone-Cache-EnabledAntwort-Caching aktivieren (true/false)
Helicone-User-IdMetriken nach Benutzer verfolgen
Helicone-Property-[Name]Benutzerdefinierte Eigenschaften hinzufügen (z. B. Helicone-Property-Environment)
Helicone-Prompt-IdAnfragen mit Prompt-Versionen verknüpfen

Siehe das Helicone Header Directory (opens in a new tab) für alle verfügbaren Header.

llama.cpp

Sie können opencode so konfigurieren, dass es lokale Modelle über das llama-server-Dienstprogramm von llama.cpp (opens in a new tab) verwendet.

opencode.json
{
  "$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 die benutzerdefinierte Provider-ID. Das 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 Anzeigename für den Provider in der 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 zur IO.NET Console (opens in a new tab), 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.

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

LM Studio

Sie können opencode so konfigurieren, dass es lokale Modelle über LM Studio verwendet.

opencode.json
{
  "$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 die benutzerdefinierte Provider-ID. Das 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 Anzeigename für den Provider in der 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 zur Moonshot AI Console (opens in a new tab), erstellen Sie ein Konto und klicken Sie auf Create API key.

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

    /connect

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

    ┌ API key
│
│
└ enter

  4. Führen Sie den Befehl /models aus, um Kimi K2 auszuwählen.

    /models

MiniMax

  1. Gehen Sie zur MiniMax API Console (opens in a new tab), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

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

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

NVIDIA

NVIDIA bietet kostenlosen Zugang zu Nemotron-Modellen und vielen anderen offenen Modellen über build.nvidia.com (opens in a new tab).

  1. Gehen Sie zu build.nvidia.com (opens in a new tab), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

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

    /connect

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

    ┌ API key
│
│
└ enter

  4. Führen Sie den Befehl /models aus, um ein Modell wie nemotron-3-super-120b-a12b auszuwählen.

    /models

On-Prem / NIM

Sie können NVIDIA-Modelle auch lokal über NVIDIA NIM (opens in a new tab) verwenden, indem Sie eine benutzerdefinierte Base URL setzen.

opencode.json
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "nvidia": {
      "options": {
        "baseURL": "http://localhost:8000/v1"
      }
    }
  }
}

Umgebungsvariable

Alternativ setzen Sie Ihren API-Schlüssel als Umgebungsvariable.

export NVIDIA_API_KEY=nvapi-your-key-here

Nebius Token Factory

  1. Gehen Sie zur Nebius Token Factory Console (opens in a new tab), erstellen Sie ein Konto und klicken Sie auf Add Key.

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

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

Ollama

Sie können opencode so konfigurieren, dass es lokale Modelle über Ollama verwendet.

Tipp: Ollama kann sich automatisch für OpenCode konfigurieren. Siehe die Ollama integration docs (opens in a new tab) für Details.

opencode.json
{
  "$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 die benutzerdefinierte Provider-ID. Das 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 Anzeigename für den Provider in der 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.

Tipp: Wenn Tool-Aufrufe nicht funktionieren, versuchen Sie, num_ctx in Ollama zu erhöhen. Beginnen Sie bei etwa 16k - 32k.

Ollama Cloud

So verwenden Sie Ollama Cloud mit OpenCode:

  1. Gehen Sie zu https://ollama.com/ (opens in a new tab) und melden Sie sich an oder erstellen Sie ein Konto.

  2. Navigieren Sie zu Settings > Keys 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.

    /connect

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

    ┌ API key
│
│
└ enter

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

    ollama pull gpt-oss:20b-cloud

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

    /models

OpenAI

Wir empfehlen, sich für ChatGPT Plus oder Pro (opens in a new tab) anzumelden.

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

    /connect

  2. Hier können Sie die Option ChatGPT Plus/Pro auswählen, und sie öffnet Ihren Browser und bittet Sie, sich zu authentifizieren.

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

    /models
API-Schlüssel verwenden

Wenn Sie bereits einen API-Schlüssel haben, können Sie Manually enter API Key auswählen und ihn in Ihrem Terminal einfügen.

OpenCode Zen

OpenCode Zen ist eine Liste getesteter und verifizierter Modelle, die vom OpenCode-Team bereitgestellt werden. Mehr erfahren.

  1. Melden Sie sich bei OpenCode Zen (opens in a new tab) an und klicken Sie auf Create API Key.

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

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

OpenRouter

  1. Gehen Sie zum OpenRouter Dashboard (opens in a new tab), 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.

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

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

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

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

LLM Gateway

  1. Gehen Sie zum LLM Gateway Dashboard (opens in a new tab), klicken Sie auf Create API Key und kopieren Sie den Schlüssel.

  2. Führen Sie den Befehl /connect aus und suchen Sie nach LLM Gateway.

    /connect

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

    ┌ API key
│
│
└ enter

  4. Viele LLM Gateway-Modelle sind standardmäßig vorgeladen, führen Sie den Befehl /models aus, um das gewünschte auszuwählen.

    /models

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

    opencode.json
    {
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llmgateway": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}

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

    opencode.json
    {
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llmgateway": {
      "models": {
        "glm-4.7": {
          "name": "GLM 4.7"
        },
        "gpt-5.2": {
          "name": "GPT-5.2"
        },
        "gemini-2.5-pro": {
          "name": "Gemini 2.5 Pro"
        },
        "claude-3-5-sonnet-20241022": {
          "name": "Claude 3.5 Sonnet"
        }
      }
    }
  }
}

SAP AI Core

SAP AI Core bietet Zugang zu 40+ Modellen von OpenAI, Anthropic, Google, Amazon, Meta, Mistral und AI21 über eine einheitliche Plattform.

  1. Gehen Sie zu Ihrem SAP BTP Cockpit (opens in a new tab), navigieren Sie zu Ihrer SAP AI Core-Service-Instanz und erstellen Sie einen Service-Key.

    Tipp: Der Service-Key ist ein JSON-Objekt, das clientid, clientsecret, url und serviceurls.AI_API_URL enthält. Sie finden Ihre AI Core-Instanz unter Services > Instances and Subscriptions im BTP Cockpit.

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

    /connect

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

    ┌ Service key
│
│
└ enter

    Oder setzen Sie die Umgebungsvariable AICORE_SERVICE_KEY:

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

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

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

  4. Optional setzen Sie Deployment-ID und Resource Group:

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

    Hinweis: Diese Einstellungen sind optional und sollten entsprechend Ihrer SAP AI Core-Einrichtung konfiguriert werden.

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

    /models

STACKIT

STACKIT AI Model Serving bietet eine vollständig verwaltete, souveräne Hosting-Umgebung für KI-Modelle, mit Fokus auf LLMs wie Llama, Mistral und Qwen, mit maximaler Datensouveränität auf europäischer Infrastruktur.

  1. Gehen Sie zum STACKIT Portal (opens in a new tab), navigieren Sie zu AI Model Serving und erstellen Sie einen Auth-Token für Ihr Projekt.

    Tipp: Sie benötigen ein STACKIT-Kundenkonto, ein Benutzerkonto und ein Projekt, bevor Sie Auth-Tokens erstellen.

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

    /connect

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

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

    /models

OVHcloud AI Endpoints

  1. Gehen Sie zum OVHcloud Panel (opens in a new tab). Navigieren Sie zum Abschnitt Public Cloud, AI & Machine Learning > AI Endpoints und klicken Sie im Tab API Keys auf Create a new API key.

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

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

Scaleway

So verwenden Sie Scaleway Generative APIs (opens in a new tab) mit Opencode:

  1. Gehen Sie zu den Scaleway Console IAM settings (opens in a new tab), um einen neuen API-Schlüssel zu generieren.

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

    /connect

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

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

    /models

Together AI

  1. Gehen Sie zur Together AI Console (opens in a new tab), erstellen Sie ein Konto und klicken Sie auf Add Key.

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

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

Venice AI

  1. Gehen Sie zur Venice AI Console (opens in a new tab), 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.

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

Vercel AI Gateway

Vercel AI Gateway ermöglicht Ihnen den Zugriff auf Modelle von OpenAI, Anthropic, Google, xAI und mehr über einen einheitlichen Endpunkt. Die Modelle werden zum Listenpreis ohne Aufschlag angeboten.

  1. Gehen Sie zum Vercel Dashboard (opens in a new tab), navigieren Sie zum Tab AI Gateway und klicken Sie auf API keys, um einen neuen API-Schlüssel zu erstellen.

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

    /connect

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

    ┌ API key
│
│
└ enter

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

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

Einige nützliche Routing-Optionen:

OptionBeschreibung
orderProvider-Reihenfolge, die versucht wird
onlyAuf bestimmte Provider beschränken
zeroDataRetentionNur Provider mit Zero-Data-Retention-Richtlinien verwenden

xAI

Drei Möglichkeiten zur Authentifizierung: ein SuperGrok-Abonnement über Browser-OAuth, dasselbe SuperGrok-Abonnement über einen Headless-Device-Code-Flow (für VPS / SSH / Docker) oder ein Pay-as-you-go-API-Schlüssel aus der xAI Console.

Option A — SuperGrok OAuth (Browser-Login)

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

    /connect

  2. Wählen Sie xAI Grok OAuth (SuperGrok Subscription). OpenCode öffnet den Zustimmungsbildschirm von xAI in Ihrem Browser und wartet auf den Callback unter http://127.0.0.1:56121/callback.

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

    /models

OpenCode aktualisiert das OAuth-Access-Token automatisch. Jeder Grok- oder X Premium-Plan, der Grok-API-Zugang enthält, funktioniert; Sie benötigen keinen separaten XAI_API_KEY.

Option B — SuperGrok Device-Code (Headless / Remote-Server / VPS)

Verwenden Sie dies, wenn OpenCode an einem Ort läuft, an dem ein Browser den Loopback-Redirect nicht erreichen kann: ein VPS, eine Remote-Dev-Box über SSH, innerhalb von Docker, in CI usw. Auf dem Host, der OpenCode ausführt, wird kein Callback-Port geöffnet — stattdessen übergibt xAI der CLI einen kurzen Code, den Sie in einen Browser auf einem beliebigen anderen Gerät (Laptop, Telefon, ...) eingeben.

  1. Führen Sie den Befehl /connect auf dem Remote-Host aus und suchen Sie nach xAI.

    /connect

  2. Wählen Sie xAI Grok OAuth (Headless / Remote / VPS). OpenCode gibt eine Verifizierungs-URL und einen kurzen Benutzercode aus.

    Open https://x.ai/device on any device and enter code: ABCD-1234

  3. Öffnen Sie die URL auf einem Gerät mit Browser (Ihrem Laptop oder Telefon), geben Sie den Code ein und bestätigen Sie den Zustimmungsbildschirm. OpenCode fragt den Token-Endpunkt von xAI ab und speichert die resultierenden OAuth-Tokens, sobald Sie bestätigen. Die Token-Aktualisierung funktioniert genauso wie bei Option A.

Option C — API-Schlüssel

  1. Gehen Sie zur xAI Console (opens in a new tab), erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.

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

    /connect

  3. Wählen Sie Manually enter API Key und fügen Sie Ihren xAI API-Schlüssel ein.

    ┌ API key
│
│
└ enter

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

    /models

Z.AI

  1. Gehen Sie zur Z.AI API Console (opens in a new tab), erstellen Sie ein Konto und klicken Sie auf Create a new API key.

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

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

    ┌ API key
│
│
└ enter

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

    /models

ZenMux

  1. Gehen Sie zum ZenMux Dashboard (opens in a new tab), 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.

    /connect

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

    ┌ API key
│
│
└ enter

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

    /models

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

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

Custom provider

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

Tipp: Sie können jeden OpenAI-kompatiblen Provider mit opencode verwenden. Die meisten modernen KI-Provider bieten OpenAI-kompatible APIs.

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

    $ /connect
 
┌  Add credential
│
◆  Select provider
│  ...
│  ● Other
└

  2. Geben Sie eine eindeutige ID für den Provider ein.

    $ /connect
 
┌  Add credential
│
◇  Enter provider id
│  myprovider
└

    Hinweis: Wählen Sie eine einprägsame ID, Sie verwenden sie in Ihrer Konfigurationsdatei.

  3. Geben Sie Ihren API-Schlüssel für den Provider 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-...
└

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

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

    • npm : Zu verwendendes AI-SDK-Paket, @ai-sdk/openai-compatible für OpenAI-kompatible Provider (für /v1/chat/completions ). Wenn Ihr Provider/Modell /v1/responses verwendet, verwenden Sie @ai-sdk/openai .
    • name : Anzeigename in der UI.
    • models : Verfügbare Modelle.
    • options.baseURL : API-Endpunkt-URL.
    • options.apiKey : Setzen Sie optional den API-Schlüssel, falls keine Auth verwendet wird.
    • options.headers : Setzen Sie optional benutzerdefinierte Header.

    Mehr zu den erweiterten Optionen im Beispiel unten.

  5. Führen Sie den Befehl /models aus, und Ihr benutzerdefinierter Provider und seine Modelle erscheinen in der Auswahlliste.

Beispiel

Hier ist ein Beispiel, das die Optionen apiKey, headers und das Modell-limit setzt.

opencode.json
{
  "$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 : Mit der env-Variablensyntax gesetzt, mehr erfahren .
  • headers : Benutzerdefinierte Header, die mit jeder Anfrage gesendet werden.
  • limit.context : Maximale Anzahl an Eingabe-Tokens, die das Modell akzeptiert.
  • limit.output : Maximale Anzahl an Tokens, die das Modell generieren kann.

Die limit-Felder ermöglichen es OpenCode zu verstehen, wie viel Kontext Ihnen noch bleibt. Standard-Provider rufen diese automatisch von models.dev ab.

Troubleshooting

Wenn Sie Probleme bei der Konfiguration eines Providers haben, prüfen Sie Folgendes:

  1. Auth-Einrichtung prüfen: Führen Sie opencode auth list aus, um zu sehen, ob die Credentials für den Provider zu Ihrer Konfiguration hinzugefügt wurden. Das gilt nicht für Provider wie Amazon Bedrock, die für ihre Auth auf Umgebungsvariablen angewiesen sind.

  2. Für benutzerdefinierte Provider prüfen Sie die opencode-Konfiguration und:

    • Stellen Sie sicher, dass die im Befehl /connect verwendete Provider-ID mit der ID in Ihrer opencode-Konfiguration übereinstimmt.
    • Das richtige npm-Paket für den Provider verwendet wird. Verwenden Sie zum Beispiel @ai-sdk/cerebras für Cerebras. Und für alle anderen OpenAI-kompatiblen Provider verwenden Sie @ai-sdk/openai-compatible (für /v1/chat/completions ); wenn ein Modell /v1/responses verwendet, verwenden Sie @ai-sdk/openai . Für gemischte Setups unter einem Provider können Sie dies pro Modell über provider.npm überschreiben.
    • Prüfen Sie, dass der richtige API-Endpunkt im Feld options.baseURL verwendet wird.
KonfigurationNetzwerk