path: root/packages/web/src/content/docs/de/providers.mdx

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

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

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

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

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

---

### Anmeldeinformationen

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

---

### Konfiguration

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

---

#### Base URL

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

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

---

## OpenCode Zen

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

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

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

   ```txt
   /connect
   ```

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

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

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

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

   ```txt
   /models
   ```

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

---

## OpenCode Go

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

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

   ```txt
   /connect
   ```

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

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

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

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

   ```txt
   /models
   ```

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

---

## Verzeichnis

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

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

---

### 302.AI

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Amazon Bedrock

So verwenden Sie Amazon Bedrock mit OpenCode:

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

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

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

   #### Umgebungsvariablen (Schnellstart)

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

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

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

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

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

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

   #### Konfigurationsdatei (empfohlen)

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

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

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

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

   #### Erweitert: VPC Endpunkte

   Wenn Sie VPC-Endpunkte für Bedrock verwenden:

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

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

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

   #### Authentifizierungspriorität

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

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

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

   ```txt
   /models
   ```

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

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

:::

---

### Anthropic

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

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

##### Verwendung von API-Keys

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

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

---

### Atomic Chat

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

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

In diesem Beispiel:

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

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

---

### Azure OpenAI

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

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

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

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

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

   ```txt
   /connect
   ```

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

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

5. Legen Sie Ihren Ressourcennamen als Umgebungsvariable fest:

   ```bash
   AZURE_RESOURCE_NAME=XXX opencode
   ```

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

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

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

   ```txt
   /models
   ```

---

### Azure Cognitive Services

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

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

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

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

   ```txt
   /connect
   ```

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

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

5. Legen Sie Ihren Ressourcennamen als Umgebungsvariable fest:

   ```bash
   AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
   ```

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

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

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

   ```txt
   /models
   ```

---

### Baseten

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Cerebras

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Cloudflare AI Gateway

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

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

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

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

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

   ```txt
   /connect
   ```

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

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

   Oder legen Sie es als Umgebungsvariable fest.

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

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

   ```txt
   /models
   ```

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

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

---

### Cortecs

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### DeepSeek

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Deep Infra

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Firmware

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Fireworks AI

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### GitLab Duo

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

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

   ```txt
   /connect
   ```

2. Wählen Sie Ihre Authentifizierungsmethode:

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

   #### Verwendung von OAuth (empfohlen)

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

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

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

   ```txt
   /models
   ```

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

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

##### Selbstgehostetes GitLab

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

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

:::

Für selbstgehostete GitLab-Instanzen:

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

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

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

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

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

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

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

##### OAuth für selbstgehostete Instanzen

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

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

Stellen Sie dann die Anwendung ID als Umgebungsvariable bereit:

```bash
export GITLAB_OAUTH_CLIENT_ID=your_application_id_here
```

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

##### Konfiguration

Anpassen über `opencode.json`:

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

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

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

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

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

---

### GitHub Copilot

So verwenden Sie Ihr GitHub Copilot-Abonnement mit OpenCode:

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

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Google Vertex AI

So verwenden Sie Google Vertex AI mit OpenCode:

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

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

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

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

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

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

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

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

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

   ```txt
   /models
   ```

---

### Groq

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Hugging Face

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

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

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

   ```txt
   /connect
   ```

3. Geben Sie Ihren Hugging Face-Token ein.

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

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

   ```txt
   /models
   ```

---

### Helicone

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

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

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

#### Optionale Konfigurationen

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

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

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

#### Benutzerdefinierte Header

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

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

##### Sitzungsverfolgung

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

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

Fügen Sie es Ihrer Konfiguration hinzu.

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

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

##### Gängige Helicone-Header

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

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

---

### llama.cpp

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

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

In diesem Beispiel:

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

---

### IO.NET

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

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### LM Studio

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

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

In diesem Beispiel:

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

---

### Moonshot AI

So verwenden Sie Kimi K2 von Moonshot AI:

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### MiniMax

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Nebius Token Factory

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Ollama

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

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

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

In diesem Beispiel:

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

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

---

### Ollama Cloud

So verwenden Sie Ollama Cloud mit OpenCode:

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

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

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

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

   ```txt
   /connect
   ```

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

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

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

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

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

   ```txt
   /models
   ```

---

### OpenAI

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

##### Verwendung von API-Keys

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

---

### OpenCode Zen

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

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### OpenRouter

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

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

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

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

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

---

### SAP AI Core

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

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

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

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

   ```txt
   /connect
   ```

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

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

   Oder legen Sie die Umgebungsvariable `AICORE_SERVICE_KEY` fest:

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

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

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

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

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

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

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

   ```txt
   /models
   ```

---

### STACKIT

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

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

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### OVHcloud AI Endpoints

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Scaleway

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

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Together AI

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Venice AI

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Vercel AI Gateway

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

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

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

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

Einige nützliche Routing-Optionen:

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

---

### xAI

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

---

### Z.AI

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

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

   ```txt
   /connect
   ```

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

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

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

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

   ```txt
   /models
   ```

---

### ZenMux

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

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

   ```txt
   /connect
   ```

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

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

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

   ```txt
   /models
   ```

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

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

---

## Benutzerdefinierter Anbieter

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

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

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

   ```bash
   $ /connect

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

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

   ```bash
   $ /connect

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

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

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

   ```bash
   $ /connect

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

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

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

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

   Mehr zu den erweiterten Optionen im Beispiel unten.

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

---

##### Beispiel

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

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

Konfigurationsdetails:

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

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

---

## Fehlerbehebung

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

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

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

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