Anbieter

Verwendung eines beliebigen LLM-Anbieters in OpenCode.

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.

Credentials

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

Config

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.

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.

Directory

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.

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.

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:
Terminal-Fenster
```
# Option 1: Using AWS access keys
AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY opencode

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

# Option 3: Using Bedrock bearer token
AWS_BEARER_TOKEN_BEDROCK=XXX opencode
```
Oder fügen Sie sie Ihrem Bash-Profil hinzu:
~/.bash_profile
```
export AWS_PROFILE=my-dev-profile
export AWS_REGION=us-east-1
```
Konfigurationsdatei (empfohlen)

Für eine projektspezifische oder dauerhafte Konfiguration verwenden Sie opencode.json:
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)
Konfigurationsdateioptionen 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"
      }
    }
  }
}
```
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
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
```

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
```

Die Verwendung Ihres Claude Pro/Max-Abonnements in OpenCode wird von Anthropic nicht offiziell unterstützt.

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.

Azure OpenAI

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.

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:
Terminal-Fenster
```
AZURE_RESOURCE_NAME=XXX opencode
```
Oder fügen Sie es Ihrem Bash-Profil hinzu:
~/.bash_profile
```
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.

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:
Terminal-Fenster
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
```
Oder fügen Sie es Ihrem Bash-Profil hinzu:
~/.bash_profile
```
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.
~/.bash_profile
```
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 Reasoner 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
```

Firmware

Gehen Sie zu Firmware dashboard, erstellen Sie ein Konto und generieren Sie einen API-Schlüssel.
Führen Sie den Befehl /connect aus und suchen Sie nach Firmware.
```
/connect
```
Geben Sie Ihren Firmware 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

Selbstgehostetes GitLab

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

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.

Configuration

Anpassen über opencode.json:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "gitlab": {
      "options": {
        "instanceUrl": "https://gitlab.com",
        "featureFlags": {
          "duo_agent_platform_agentic_chat": true,
          "duo_agent_platform": true
        }
      }
    }
  }
}

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": ["@gitlab/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:

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.

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

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.

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

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:
Terminal-Fenster
```
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.
opencode.json
```
{
  "$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.

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:
Terminal-Fenster
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
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
```

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

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.
Terminal-Fenster
```
$ /connect

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
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:
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 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.

Example

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.

Troubleshooting

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.