File size: 52,066 Bytes

0dbc9de

---
title: Fournisseurs
description: Utiliser n’importe quel fournisseur LLM en OpenCode.
---

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

OpenCode utilise [AI SDK](https://ai-sdk.dev/) et [Models.dev](https://models.dev) pour prendre en charge **75+ fournisseurs LLM** et prend en charge l'exécution de modèles locaux.

Pour ajouter un fournisseur, vous devez :

1. Ajoutez les clés API pour le fournisseur à l'aide de la commande `/connect`.
2. Configurez le fournisseur dans votre configuration OpenCode.

---

### Informations d'identification

Lorsque vous ajoutez les clés API d'un fournisseur avec la commande `/connect`, elles sont stockées
en `~/.local/share/opencode/auth.json`.

---

### Configuration

Vous pouvez personnaliser les fournisseurs via la section `provider` de votre OpenCode
configuration.

---

#### Socle URL

Vous pouvez personnaliser la base URL pour n'importe quel fournisseur en définissant l'option `baseURL`. Ceci est utile lors de l'utilisation de services proxy ou de points de terminaison personnalisés.

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

---

## OpenCode Zen

OpenCode Zen est une liste de modèles fournis par l'équipe OpenCode qui ont été
testé et vérifié pour fonctionner correctement avec OpenCode. [En savoir plus](/docs/zen).

:::tip
Si vous êtes nouveau, nous vous recommandons de commencer par OpenCode Zen.
:::

1. Exécutez la commande `/connect` dans le TUI, sélectionnez opencode et dirigez-vous vers [opencode.ai/auth](https://opencode.ai/auth).

   ```txt
   /connect
   ```

2. Connectez-vous, ajoutez vos informations de facturation et copiez votre clé API.

3. Collez votre clé API.

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

4. Exécutez `/models` dans le TUI pour voir la liste des modèles que nous recommandons.

   ```txt
   /models
   ```

Il fonctionne comme n’importe quel autre fournisseur dans OpenCode et son utilisation est totalement facultative.

---

## OpenCode Go

OpenCode Go est un plan d'abonnement à faible coût qui offre un accès fiable aux modèles de codage ouverts populaires fournis par l'équipe OpenCode qui ont été
testé et vérifié pour fonctionner correctement avec OpenCode.

1. Exécutez la commande `/connect` dans le TUI, sélectionnez `OpenCode Go` et rendez-vous sur [opencode.ai/auth](https://opencode.ai/zen).

   ```txt
   /connect
   ```

2. Connectez-vous, ajoutez vos informations de facturation et copiez votre clé API.

3. Collez votre clé API.

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

4. Exécutez `/models` dans le TUI pour voir la liste des modèles que nous recommandons.

   ```txt
   /models
   ```

Il fonctionne comme n’importe quel autre fournisseur dans OpenCode et son utilisation est totalement facultative.

---

## Annuaire

Examinons certains fournisseurs en détail. Si vous souhaitez ajouter un fournisseur au
liste, n'hésitez pas à ouvrir un PR.

:::note
Vous ne voyez pas de fournisseur ici ? Soumettez un PR.
:::

---

### 302.AI

1. Rendez-vous sur la [console 302.AI](https://302.ai/), créez un compte et générez une clé API.

2. Exécutez la commande `/connect` et recherchez **302.AI**.

   ```txt
   /connect
   ```

3. Saisissez votre clé 302.AI API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle.

   ```txt
   /models
   ```

---

### Amazon Bedrock

Pour utiliser Amazon Bedrock avec OpenCode :

1. Rendez-vous sur le **Catalogue de modèles** dans la console Amazon Bedrock et demandez
   accédez aux modèles que vous souhaitez.

   :::tip
   Vous devez avoir accès au modèle souhaité dans Amazon Bedrock.
   :::

2. **Configurez l'authentification** à l'aide de l'une des méthodes suivantes :

   #### Variables d'environnement (démarrage rapide)

Définissez l'une de ces variables d'environnement lors de l'exécution de opencode :

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

Ou ajoutez-les à votre profil bash :

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

#### Fichier de configuration (recommandé)

Pour une configuration spécifique au projet ou persistante, utilisez `opencode.json` :

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

**Options disponibles :**

- `region` - Région AWS (par exemple, `us-east-1`, `eu-west-1`)
- `profile` - Profil nommé AWS de `~/.aws/credentials`
- `endpoint` - URL de point de terminaison personnalisée pour les endpoints VPC (alias de l'option générique `baseURL`)

:::tip
Les options du fichier de configuration sont prioritaires sur les variables d'environnement.
:::

#### Avancé : points de terminaison d'un VPC

Si vous utilisez des points de terminaison d'un VPC pour Bedrock :

```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
L'option `endpoint` est un alias pour l'option générique `baseURL`, utilisant la terminologie spécifique à AWS. Si `endpoint` et `baseURL` sont spécifiés, `endpoint` est prioritaire.
:::

#### Méthodes d'authentification

- **`AWS_ACCESS_KEY_ID` / `AWS_SECRET_ACCESS_KEY`** : créez un utilisateur IAM et générez des clés d'accès dans la console AWS
- **`AWS_PROFILE`** : utilisez les profils nommés de `~/.aws/credentials`. Configurez d'abord avec `aws configure --profile my-profile` ou `aws sso login`
- **`AWS_BEARER_TOKEN_BEDROCK`** : Générez des clés API à long terme à partir de la console Amazon Bedrock
- **`AWS_WEB_IDENTITY_TOKEN_FILE` / `AWS_ROLE_ARN`** : pour EKS IRSA (rôles IAM pour les comptes de service) ou d'autres environnements Kubernetes avec fédération OIDC. Ces variables d'environnement sont automatiquement injectées par Kubernetes lors de l'utilisation des annotations de compte de service.

#### Priorité d'authentification

Amazon Bedrock utilise la priorité d'authentification suivante :

1.  **Bearer Token** - Variable d'environnement `AWS_BEARER_TOKEN_BEDROCK` ou jeton de la commande `/connect`
2.  **AWS Credential Chain** - Profil, clés d'accès, informations d'identification partagées, rôles IAM, jetons d'identité Web (EKS IRSA), métadonnées d'instance

:::note
Lorsqu'un jeton de porteur est défini (via `/connect` ou `AWS_BEARER_TOKEN_BEDROCK`), il est prioritaire sur toutes les méthodes d'identification AWS, y compris les profils configurés.
:::

3. Exécutez la commande `/models` pour sélectionner le modèle souhaité.

   ```txt
   /models
   ```

:::note
Pour les profils d'inférence personnalisés, utilisez le nom du modèle et du fournisseur dans la clé et définissez la propriété `id` sur l'arn. Cela garantit une mise en cache correcte :

```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. Une fois inscrit, exécutez la commande `/connect` et sélectionnez Anthropic.

   ```txt
   /connect
   ```

2. Ici, vous pouvez sélectionner l'option **Claude Pro/Max** et cela ouvrira votre navigateur.
   et vous demande de vous authentifier.

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

3. Désormais, tous les modèles Anthropic devraient être disponibles lorsque vous utilisez la commande `/models`.

   ```txt
   /models
   ```

:::info
L'utilisation de votre abonnement Claude Pro/Max dans OpenCode n'est pas officiellement prise en charge par [Anthropic](https://anthropic.com).
:::

##### Utilisation des clés API

Vous pouvez également sélectionner **Créer une clé API** si vous n'avez pas d'abonnement Pro/Max. Il ouvrira également votre navigateur et vous demandera de vous connecter à Anthropic et vous donnera un code que vous pourrez coller dans votre terminal.

Ou si vous disposez déjà d'une clé API, vous pouvez sélectionner **Entrer manuellement la clé API** et la coller dans votre terminal.

---

### Atomic Chat

Vous pouvez configurer opencode pour utiliser des modèles locaux via [Atomic Chat](https://atomic.chat), une application de bureau qui exécute des LLM locaux derrière un serveur API compatible OpenAI (point de terminaison par défaut `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>"
        }
      }
    }
  }
}
```

Dans cet exemple :

- `atomic-chat` est l'identifiant personnalisé du fournisseur. Il peut s'agir de n'importe quelle chaîne.
- `npm` spécifie le paquet à utiliser pour ce fournisseur. Ici, `@ai-sdk/openai-compatible` est utilisé pour toute API compatible OpenAI.
- `name` est le nom du fournisseur affiché dans l'interface.
- `options.baseURL` est le point de terminaison du serveur local. Modifiez l'hôte et le port selon votre configuration Atomic Chat.
- `models` est une carte d'ID de modèles vers leurs noms d'affichage. Chaque ID doit correspondre à l'`id` renvoyé par `GET /v1/models` — exécutez `curl http://127.0.0.1:1337/v1/models` pour lister les ID actuellement chargés dans Atomic Chat.

:::tip
Si les appels d'outils ne fonctionnent pas bien, choisissez un modèle chargé avec un bon support du tool calling (par exemple, une variante Qwen-Coder ou DeepSeek-Coder).
:::

---

### Azure OpenAI

:::note
Si vous rencontrez des erreurs « Je suis désolé, mais je ne peux pas vous aider avec cette demande », essayez de modifier le filtre de contenu de **DefaultV2** à **Default** dans votre ressource Azure.
:::

1. Rendez-vous sur le [portail Azure](https://portal.azure.com/) et créez une ressource **Azure OpenAI**. Vous aurez besoin de :
   - **Nom de la ressource** : cela fait partie de votre point de terminaison API (`https://RESOURCE_NAME.openai.azure.com/`)
   - **Clé API** : soit `KEY 1` ou `KEY 2` de votre ressource

2. Accédez à [Azure AI Foundry](https://ai.azure.com/) et déployez un modèle.

   :::note
   Le nom du déploiement doit correspondre au nom du modèle pour que opencode fonctionne correctement.
   :::

3. Exécutez la commande `/connect` et recherchez **Azure**.

   ```txt
   /connect
   ```

4. Entrez votre clé API.

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

5. Définissez le nom de votre ressource comme variable d'environnement :

   ```bash
   AZURE_RESOURCE_NAME=XXX opencode
   ```

Ou ajoutez-le à votre profil bash :

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

6. Exécutez la commande `/models` pour sélectionner votre modèle déployé.

   ```txt
   /models
   ```

---

### Azure Cognitive Services

1. Rendez-vous sur le [portail Azure](https://portal.azure.com/) et créez une ressource **Azure OpenAI**. Vous aurez besoin de :
   - **Nom de la ressource** : cela fait partie de votre point de terminaison API (`https://AZURE_COGNITIVE_SERVICES_RESOURCE_NAME.cognitiveservices.azure.com/`)
   - **Clé API** : soit `KEY 1` ou `KEY 2` de votre ressource

2. Accédez à [Azure AI Foundry](https://ai.azure.com/) et déployez un modèle.

   :::note
   Le nom du déploiement doit correspondre au nom du modèle pour que opencode fonctionne correctement.
   :::

3. Exécutez la commande `/connect` et recherchez **Azure Cognitive Services**.

   ```txt
   /connect
   ```

4. Entrez votre clé API.

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

5. Définissez le nom de votre ressource comme variable d'environnement :

   ```bash
   AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
   ```

Ou ajoutez-le à votre profil bash :

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

6. Exécutez la commande `/models` pour sélectionner votre modèle déployé.

   ```txt
   /models
   ```

---

### Baseten

1. Rendez-vous sur [Baseten](https://app.baseten.co/), créez un compte et générez une clé API.

2. Exécutez la commande `/connect` et recherchez **Baseten**.

   ```txt
   /connect
   ```

3. Entrez votre clé Baseten API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle.

   ```txt
   /models
   ```

---

### Cerebras

1. Rendez-vous sur la [console Cerebras](https://inference.cerebras.ai/), créez un compte et générez une clé API.

2. Exécutez la commande `/connect` et recherchez **Cerebras**.

   ```txt
   /connect
   ```

3. Entrez votre clé Cerebras API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle tel que _Qwen 3 Coder 480B_.

   ```txt
   /models
   ```

---

### Cloudflare AI Gateway

Cloudflare AI Gateway vous permet d'accéder aux modèles de OpenAI, Anthropic, Workers AI et bien plus encore via un point de terminaison unifié. Avec [Unified Billing](https://developers.cloudflare.com/ai-gateway/features/unified-billing/), vous n'avez pas besoin de clés API distinctes pour chaque fournisseur.

1. Rendez-vous sur le [tableau de bord Cloudflare](https://dash.cloudflare.com/), accédez à **AI** > **AI Gateway** et créez une nouvelle passerelle.

2. Définissez votre ID de compte et votre ID de passerelle comme variables d'environnement.

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

3. Exécutez la commande `/connect` et recherchez **Cloudflare AI Gateway**.

   ```txt
   /connect
   ```

4. Entrez votre jeton Cloudflare API.

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

Ou définissez-le comme variable d'environnement.

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

5. Exécutez la commande `/models` pour sélectionner un modèle.

   ```txt
   /models
   ```

Vous pouvez également ajouter des modèles via votre configuration opencode.

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

---

### Cortecs

1. Rendez-vous sur la [console Cortecs](https://cortecs.ai/), créez un compte et générez une clé API.

2. Exécutez la commande `/connect` et recherchez **Cortecs**.

   ```txt
   /connect
   ```

3. Entrez votre clé Cortecs API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle tel que _Kimi K2 Instruct_.

   ```txt
   /models
   ```

---

### DeepSeek

1. Rendez-vous sur la [console DeepSeek](https://platform.deepseek.com/), créez un compte et cliquez sur **Créer une nouvelle clé API**.

2. Exécutez la commande `/connect` et recherchez **DeepSeek**.

   ```txt
   /connect
   ```

3. Entrez votre clé DeepSeek API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle DeepSeek tel que _DeepSeek V4 Pro_.

   ```txt
   /models
   ```

---

### Deep Infra

1. Rendez-vous sur le [tableau de bord Deep Infra](https://deepinfra.com/dash), créez un compte et générez une clé API.

2. Exécutez la commande `/connect` et recherchez **Deep Infra**.

   ```txt
   /connect
   ```

3. Entrez votre clé Deep Infra API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle.

   ```txt
   /models
   ```

---

### FrogBot

1. Rendez-vous sur le [Tableau de bord du micrologiciel](https://app.frogbot.ai/signup), créez un compte et générez une clé API.

2. Exécutez la commande `/connect` et recherchez **FrogBot**.

   ```txt
   /connect
   ```

3. Entrez la clé API de votre micrologiciel.

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

4. Exécutez la commande `/models` pour sélectionner un modèle.

   ```txt
   /models
   ```

---

### Fireworks AI

1. Rendez-vous sur la [console Fireworks AI](https://app.fireworks.ai/), créez un compte et cliquez sur **Créer une clé API**.

2. Exécutez la commande `/connect` et recherchez **Fireworks AI**.

   ```txt
   /connect
   ```

3. Entrez votre clé Fireworks AI API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle tel que _Kimi K2 Instruct_.

   ```txt
   /models
   ```

---

### GitLab Duo

GitLab Duo fournit un chat agent basé sur l'IA avec des capacités d'appel d'outils natives via le proxy Anthropic de GitLab.

1. Exécutez la commande `/connect` et sélectionnez GitLab.

   ```txt
   /connect
   ```

2. Choisissez votre méthode d'authentification :

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

   #### Utilisation de OAuth (recommandé)

Sélectionnez **OAuth** et votre navigateur s'ouvrira pour autorisation.

#### Utilisation d'un jeton d'accès personnel

1.  Accédez à [GitLab Paramètres utilisateur > Jetons d'accès](https://gitlab.com/-/user_settings/personal_access_tokens)
2.  Cliquez sur **Ajouter un nouveau jeton**
3.  Nom : `OpenCode`, Portées : `api`
4.  Copiez le jeton (commence par `glpat-`)
5.  Entrez-le dans le terminal

6.  Exécutez la commande `/models` pour voir les modèles disponibles.

    ```txt
    /models
    ```

````

Trois modèles basés sur Claude sont disponibles :

- **duo-chat-haiku-4-5** (Par défaut) - Réponses rapides pour des tâches rapides
- **duo-chat-sonnet-4-5** - Performances équilibrées pour la plupart des flux de travail
- **duo-chat-opus-4-5** - Le plus capable pour les analyses complexes

:::note
Vous pouvez également spécifier la variable d'environnement 'GITLAB_TOKEN' si vous ne souhaitez pas
pour stocker le jeton dans le stockage d'authentification opencode.
:::

##### GitLab auto-hébergé

:::note[note de conformité]
OpenCode utilise un petit modèle pour certaines tâches d'IA telles que la génération du titre de la session.
Il est configuré pour utiliser gpt-5-nano par défaut, hébergé par Zen. Pour verrouiller OpenCode
pour utiliser uniquement votre propre instance hébergée par GitLab, ajoutez ce qui suit à votre
Fichier `opencode.json`. Il est également recommandé de désactiver le partage de session.

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

:::

Pour les instances GitLab auto-hébergées :

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

Si votre instance exécute une AI Gateway personnalisée :

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

Ou ajoutez à votre profil bash :

```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
Votre administrateur GitLab doit activer les éléments suivants :

1. [Duo Agent Platform](https://docs.gitlab.com/user/duo_agent_platform/turn_on_off/) pour l'utilisateur, le groupe ou l'instance
2. Indicateurs de fonctionnalités (via la console Rails) :
   - `agent_platform_claude_code`
   - `third_party_agents_enabled`
     :::

##### OAuth pour les instances auto-hébergées

Afin que Oauth fonctionne pour votre instance auto-hébergée, vous devez créer
une nouvelle application (Paramètres → Applications) avec le
rappel URL `http://127.0.0.1:8080/callback` et étendues suivantes :

- api (Accédez au API en votre nom)
- read_user (Lire vos informations personnelles)
- read_repository (Autorise l'accès en lecture seule au référentiel)

Exposez ensuite l'ID de l'application en tant que variable d'environnement :

```bash
export GITLAB_OAUTH_CLIENT_ID=your_application_id_here
```

Plus de documentation sur la page d'accueil [opencode-gitlab-auth](https://www.npmjs.com/package/opencode-gitlab-auth).

##### Configuration

Personnalisez via `opencode.json` :

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

##### Outils GitLab API (facultatif, mais fortement recommandé)

Pour accéder aux outils GitLab (demandes de fusion, tickets, pipelines, CI/CD, etc.) :

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

Ce plugin fournit des fonctionnalités complètes de gestion du référentiel GitLab, notamment les examens MR, le suivi des problèmes, la surveillance du pipeline, etc.

---

### GitHub Copilot

Pour utiliser votre abonnement GitHub Copilot avec opencode :

:::note
Certains modèles peuvent avoir besoin d'un [Pro+
abonnement](https://github.com/features/copilot/plans) à utiliser.

Certains modèles doivent être activés manuellement dans vos [GitHub Copilot paramètres](https://docs.github.com/en/copilot/how-tos/use-ai-models/configure-access-to-ai-models#setup-for-individual-use).
:::

1. Exécutez la commande `/connect` et recherchez GitHub Copilot.

   ```txt
   /connect
   ```

2. Accédez à [github.com/login/device](https://github.com/login/device) et entrez le code.

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

3. Exécutez maintenant la commande `/models` pour sélectionner le modèle souhaité.

   ```txt
   /models
   ```

---

### Google Vertex AI

Pour utiliser Google Vertex AI avec OpenCode :

1. Rendez-vous sur **Model Garden** dans Google Cloud Console et vérifiez les
   modèles disponibles dans votre région.

   :::note
   Vous devez disposer d'un projet Google Cloud avec Vertex AI API activé.
   :::

2. Définissez les variables d'environnement requises :
   - `GOOGLE_CLOUD_PROJECT` : ID de votre projet Google Cloud
   - `VERTEX_LOCATION` (facultatif) : région pour Vertex AI (par défaut : `global`)
   - Authentification (au choix) :
     - `GOOGLE_APPLICATION_CREDENTIALS` : chemin d'accès au fichier de clé JSON de votre compte de service
     - Authentifiez-vous à l'aide de gcloud CLI : `gcloud auth application-default login`

Définissez-les lors de l'exécution de opencode.

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

Ou ajoutez-les à votre profil bash.

```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
La région `global` améliore la disponibilité et réduit les erreurs sans frais supplémentaires. Utilisez des points de terminaison régionaux (par exemple, `us-central1`) pour les exigences de résidence des données. [En savoir plus](https://cloud.google.com/vertex-ai/generative-ai/docs/partner-models/use-partner-models#regional_and_global_endpoints)
:::

3. Exécutez la commande `/models` pour sélectionner le modèle souhaité.

   ```txt
   /models
   ```

---

### Groq

1. Rendez-vous sur la [console Groq](https://console.groq.com/), cliquez sur **Créer une clé API** et copiez la clé.

2. Exécutez la commande `/connect` et recherchez Groq.

   ```txt
   /connect
   ```

3. Saisissez la clé API du fournisseur.

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

4. Exécutez la commande `/models` pour sélectionner celle que vous souhaitez.

   ```txt
   /models
   ```

---

### Hugging Face

[Hugging Face Inference Providers](https://huggingface.co/docs/inference-providers) donne accès à des modèles ouverts pris en charge par plus de 17 fournisseurs.

1. Rendez-vous sur [Hugging Face settings](https://huggingface.co/settings/tokens/new?ownUserPermissions=inference.serverless.write&tokenType=fineGrained) pour créer un jeton avec l'autorisation de passer des appels aux fournisseurs d'inférence.

2. Exécutez la commande `/connect` et recherchez **Hugging Face**.

   ```txt
   /connect
   ```

3. Entrez votre jeton Hugging Face.

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

4. Exécutez la commande `/models` pour sélectionner un modèle comme _Kimi-K2-Instruct_ ou _GLM-4.6_.

   ```txt
   /models
   ```

---

### Helicone

[Helicone](https://helicone.ai) est une plate-forme d'observabilité LLM qui fournit la journalisation, la surveillance et l'analyse de vos applications d'IA. L'Helicone AI Gateway achemine automatiquement vos demandes vers le fournisseur approprié en fonction du modèle.

1. Rendez-vous sur [Helicone](https://helicone.ai), créez un compte et générez une clé API à partir de votre tableau de bord.

2. Exécutez la commande `/connect` et recherchez **Helicone**.

   ```txt
   /connect
   ```

3. Entrez votre clé Helicone API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle.

   ```txt
   /models
   ```

Pour plus de fournisseurs et de fonctionnalités avancées telles que la mise en cache et la limitation de débit, consultez la [documentation Helicone](https://docs.helicone.ai).

#### Configurations facultatives

Si vous voyez une fonctionnalité ou un modèle d'Helicone qui n'est pas configuré automatiquement via opencode, vous pouvez toujours le configurer vous-même.

Voici le [Répertoire des modèles d'Helicone](https://helicone.ai/models), vous en aurez besoin pour récupérer les identifiants des modèles que vous souhaitez ajouter.

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

#### En-têtes personnalisés

Helicone prend en charge les en-têtes personnalisés pour des fonctionnalités telles que la mise en cache, le suivi des utilisateurs et la gestion des sessions. Ajoutez-les à la configuration de votre fournisseur en utilisant `options.headers` :

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

##### Suivi des sessions

La fonctionnalité [Sessions](https://docs.helicone.ai/features/sessions) d'Helicone vous permet de regrouper les requêtes LLM associées. Utilisez le plugin [opencode-helicone-session](https://github.com/H2Shami/opencode-helicone-session) pour enregistrer automatiquement chaque conversation OpenCode en tant que session dans Helicone.

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

Ajoutez-le à votre configuration.

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

Le plugin injecte les en-têtes `Helicone-Session-Id` et `Helicone-Session-Name` dans vos requêtes. Sur la page Sessions d'Helicone, vous verrez chaque conversation OpenCode répertoriée comme une session distincte.

##### En-têtes Helicone communs

| En-tête                    | Descriptif                                                                           |
| -------------------------- | ------------------------------------------------------------------------------------ |
| `Helicone-Cache-Enabled`   | Activer la mise en cache des réponses (`true`/`false`)                               |
| `Helicone-User-Id`         | Suivre les métriques par utilisateur                                                 |
| `Helicone-Property-[Name]` | Ajouter des propriétés personnalisées (par exemple, `Helicone-Property-Environment`) |
| `Helicone-Prompt-Id`       | Associer les requêtes aux versions d'invite                                          |

Consultez le [Helicone Header Directory](https://docs.helicone.ai/helicone-headers/header-directory) pour tous les en-têtes disponibles.

---

### llama.cpp

Vous pouvez configurer opencode pour utiliser des modèles locaux via l'utilitaire llama-server de [llama.cpp's](https://github.com/ggml-org/llama.cpp)

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

Dans cet exemple :

- `llama.cpp` est l'ID du fournisseur personnalisé. Cela peut être n’importe quelle chaîne de votre choix.
- `npm` spécifie le package à utiliser pour ce fournisseur. Ici, `@ai-sdk/openai-compatible` est utilisé pour tout API compatible OpenAI.
- `name` est le nom d'affichage du fournisseur dans l'interface utilisateur.
- `options.baseURL` est le point de terminaison du serveur local.
- `models` est une carte des ID de modèle avec leurs configurations. Le nom du modèle sera affiché dans la liste de sélection du modèle.

---

### IO.NET

IO.NET propose 17 modèles optimisés pour différents cas d'utilisation :

1. Rendez-vous sur la [console IO.NET](https://ai.io.net/), créez un compte et générez une clé API.

2. Exécutez la commande `/connect` et recherchez **IO.NET**.

   ```txt
   /connect
   ```

3. Entrez votre clé IO.NET API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle.

   ```txt
   /models
   ```

---

### LM Studio

Vous pouvez configurer opencode pour utiliser des modèles locaux via LM Studio.

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

Dans cet exemple :

- `lmstudio` est l'ID du fournisseur personnalisé. Cela peut être n’importe quelle chaîne de votre choix.
- `npm` spécifie le package à utiliser pour ce fournisseur. Ici, `@ai-sdk/openai-compatible` est utilisé pour tout API compatible OpenAI.
- `name` est le nom d'affichage du fournisseur dans l'interface utilisateur.
- `options.baseURL` est le point de terminaison du serveur local.
- `models` est une carte des ID de modèle avec leurs configurations. Le nom du modèle sera affiché dans la liste de sélection du modèle.

---

### Moonshot AI

Pour utiliser Kimi K2 de Moonshot AI :

1. Rendez-vous sur la [console Moonshot AI](https://platform.moonshot.ai/console), créez un compte et cliquez sur **Créer une clé API**.

2. Exécutez la commande `/connect` et recherchez **Moonshot AI**.

   ```txt
   /connect
   ```

3. Entrez votre clé Moonshot API.

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

4. Exécutez la commande `/models` pour sélectionner _Kimi K2_.

   ```txt
   /models
   ```

---

### MiniMax

1. Rendez-vous sur la [Console MiniMax API](https://platform.minimax.io/login), créez un compte et générez une clé API.

2. Exécutez la commande `/connect` et recherchez **MiniMax**.

   ```txt
   /connect
   ```

3. Entrez votre clé MiniMax API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle tel que _M2.1_.

   ```txt
   /models
   ```

---

### Nebius Token Factory

1. Rendez-vous sur la [console Nebius Token Factory](https://tokenfactory.nebius.com/), créez un compte et cliquez sur **Ajouter une clé**.

2. Exécutez la commande `/connect` et recherchez **Nebius Token Factory**.

   ```txt
   /connect
   ```

3. Entrez votre clé Nebius Token Factory API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle tel que _Kimi K2 Instruct_.

   ```txt
   /models
   ```

---

### Ollama

Vous pouvez configurer opencode pour utiliser des modèles locaux via Ollama.

:::tip
Ollama peut se configurer automatiquement pour OpenCode. Voir les [documents d'intégration Ollama](https://docs.ollama.com/integrations/opencode) pour plus de détails.
:::

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

Dans cet exemple :

- `ollama` est l'ID du fournisseur personnalisé. Cela peut être n’importe quelle chaîne de votre choix.
- `npm` spécifie le package à utiliser pour ce fournisseur. Ici, `@ai-sdk/openai-compatible` est utilisé pour tout API compatible OpenAI.
- `name` est le nom d'affichage du fournisseur dans l'interface utilisateur.
- `options.baseURL` est le point de terminaison du serveur local.
- `models` est une carte des ID de modèle avec leurs configurations. Le nom du modèle sera affiché dans la liste de sélection du modèle.

:::tip
Si les appels d'outils ne fonctionnent pas, essayez d'augmenter `num_ctx` dans Ollama. Commencez vers 16k - 32k.
:::

---

### Ollama Cloud

Pour utiliser Ollama Cloud avec OpenCode :

1. Rendez-vous sur [https://ollama.com/](https://ollama.com/) et connectez-vous ou créez un compte.

2. Accédez à **Paramètres** > **Clés** et cliquez sur **Ajouter une clé API** pour générer une nouvelle clé API.

3. Copiez la clé API à utiliser dans OpenCode.

4. Exécutez la commande `/connect` et recherchez **Ollama Cloud**.

   ```txt
   /connect
   ```

5. Entrez votre clé Ollama Cloud API.

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

6. **Important** : Avant d'utiliser des modèles cloud dans OpenCode, vous devez extraire les informations du modèle localement :

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

7. Exécutez la commande `/models` pour sélectionner votre modèle Ollama Cloud.

   ```txt
   /models
   ```

---

### OpenAI

Nous vous recommandons de vous inscrire à [ChatGPT Plus ou Pro](https://chatgpt.com/pricing).

1. Une fois inscrit, exécutez la commande `/connect` et sélectionnez OpenAI.

   ```txt
   /connect
   ```

2. Ici, vous pouvez sélectionner l'option **ChatGPT Plus/Pro** et cela ouvrira votre navigateur.
   et vous demande de vous authentifier.

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

3. Désormais, tous les modèles OpenAI devraient être disponibles lorsque vous utilisez la commande `/models`.

   ```txt
   /models
   ```

##### Utilisation des clés API

Si vous disposez déjà d'une clé API, vous pouvez sélectionner **Entrer manuellement la clé API** et la coller dans votre terminal.

---

### OpenCode Zen

OpenCode Zen est une liste de modèles testés et vérifiés fournie par l'équipe OpenCode. [En savoir plus](/docs/zen).

1. Connectez-vous à **<a href={console}>OpenCode Zen</a>** et cliquez sur **Créer une clé API**.

2. Exécutez la commande `/connect` et recherchez **OpenCode Zen**.

   ```txt
   /connect
   ```

3. Entrez votre clé OpenCode API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle tel que _Qwen 3 Coder 480B_.

   ```txt
   /models
   ```

---

### OpenRouter

1. Rendez-vous sur le [tableau de bord OpenRouter](https://openrouter.ai/settings/keys), cliquez sur **Créer une clé API** et copiez la clé.

2. Exécutez la commande `/connect` et recherchez OpenRouter.

   ```txt
   /connect
   ```

3. Saisissez la clé API du fournisseur.

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

4. De nombreux modèles OpenRouter sont préchargés par défaut, exécutez la commande `/models` pour sélectionner celui que vous souhaitez.

   ```txt
   /models
   ```

Vous pouvez également ajouter des modèles supplémentaires via votre configuration opencode.

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

5. Vous pouvez également les personnaliser via votre configuration opencode. Voici un exemple de spécification d'un fournisseur

   ```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 donne accès à plus de 40 modèles de OpenAI, Anthropic, Google, Amazon, Meta, Mistral et AI21 via une plateforme unifiée.

1. Accédez à votre [SAP BTP Cockpit](https://account.hana.ondemand.com/), accédez à votre instance de service SAP AI Core et créez une clé de service.

   :::tip
   La clé de service est un objet JSON contenant `clientid`, `clientsecret`, `url` et `serviceurls.AI_API_URL`. Vous pouvez trouver votre instance AI Core sous **Services** > **Instances et abonnements** dans le cockpit BTP.
   :::

2. Exécutez la commande `/connect` et recherchez **SAP AI Core**.

   ```txt
   /connect
   ```

3. Entrez votre clé de service JSON.

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

Ou définissez la variable d'environnement `AICORE_SERVICE_KEY` :

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

Ou ajoutez-le à votre profil bash :

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

4. Définissez éventuellement l'ID de déploiement et le groupe de ressources :

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

   :::note
   Ces paramètres sont facultatifs et doivent être configurés en fonction de votre configuration SAP AI Core.
   :::

5. Exécutez la commande `/models` pour sélectionner parmi plus de 40 modèles disponibles.

   ```txt
   /models
   ```

---

### STACKIT

STACKIT AI Model Serving fournit un environnement d'hébergement souverain entièrement géré pour les modèles d'IA, se concentrant sur les LLM comme Llama, Mistral et Qwen, avec une souveraineté maximale des données sur l'infrastructure européenne.

1. Rendez-vous sur le [portail STACKIT](https://portal.stackit.cloud), accédez à **AI Model Serving** et créez un jeton d'authentification pour votre projet.

   :::tip
   Vous avez besoin d'un compte client STACKIT, d'un compte utilisateur et d'un projet avant de créer des jetons d'authentification.
   :::

2. Exécutez la commande `/connect` et recherchez **STACKIT**.

   ```txt
   /connect
   ```

3. Entrez votre jeton d'authentification STACKIT AI Model Serving.

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

4. Exécutez la commande `/models` pour sélectionner parmi les modèles disponibles tels que _Qwen3-VL 235B_ ou _Llama 3.3 70B_.

   ```txt
   /models
   ```

---

### OVHcloud AI Endpoints

1. Rendez-vous sur le [Panneau OVHcloud](https://ovh.com/manager). Accédez à la section `Public Cloud`, `AI & Machine Learning` > `AI Endpoints` et dans l'onglet `API Keys`, cliquez sur **Créer une nouvelle clé API**.

2. Exécutez la commande `/connect` et recherchez **OVHcloud AI Endpoints**.

   ```txt
   /connect
   ```

3. Saisissez votre clé OVHcloud AI Endpoints API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle tel que _gpt-oss-120b_.

   ```txt
   /models
   ```

---

### Scaleway

Pour utiliser [Scaleway Generative APIs](https://www.scaleway.com/en/docs/generative-apis/) avec Opencode :

1. Rendez-vous dans les [Paramètres IAM de la console Scaleway](https://console.scaleway.com/iam/api-keys) pour générer une nouvelle clé API.

2. Exécutez la commande `/connect` et recherchez **Scaleway**.

   ```txt
   /connect
   ```

3. Entrez votre clé Scaleway API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle tel que _devstral-2-123b-instruct-2512_ ou _gpt-oss-120b_.

   ```txt
   /models
   ```

---

### Together AI

1. Rendez-vous sur [Together AI console](https://api.together.ai), créez un compte et cliquez sur **Ajouter une clé**.

2. Exécutez la commande `/connect` et recherchez **Together AI**.

   ```txt
   /connect
   ```

3. Entrez votre clé Together AI API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle tel que _Kimi K2 Instruct_.

   ```txt
   /models
   ```

---

### Venice AI

1. Rendez-vous sur la [Venice AI console](https://venice.ai), créez un compte et générez une clé API.

2. Exécutez la commande `/connect` et recherchez **Venice AI**.

   ```txt
   /connect
   ```

3. Entrez votre clé Venise AI API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle tel que _Llama 3.3 70B_.

   ```txt
   /models
   ```

---

### Vercel AI Gateway

Vercel AI Gateway vous permet d'accéder aux modèles de OpenAI, Anthropic, Google, xAI et plus encore via un point de terminaison unifié. Les modèles sont proposés au prix catalogue sans majoration.

1. Rendez-vous sur le [tableau de bord Vercel](https://vercel.com/), accédez à l'onglet **AI Gateway** et cliquez sur **API Keys** pour créer une nouvelle clé API.

2. Exécutez la commande `/connect` et recherchez **Vercel AI Gateway**.

   ```txt
   /connect
   ```

3. Entrez votre clé Vercel AI Gateway API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle.

   ```txt
   /models
   ```

Vous pouvez également personnaliser les modèles via votre configuration opencode. Voici un exemple de spécification de l'ordre de routage du fournisseur.

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

Quelques options de routage utiles :

| Options             | Descriptif                                                                                  |
| ------------------- | ------------------------------------------------------------------------------------------- |
| `order`             | Séquence de fournisseur à essayer                                                           |
| `only`              | Restreindre à des fournisseurs spécifiques                                                  |
| `zeroDataRetention` | Utilisez uniquement des fournisseurs avec des politiques de conservation des données nulles |

---

### xAI

1. Rendez-vous sur la [console xAI](https://console.x.ai/), créez un compte et générez une clé API.

2. Exécutez la commande `/connect` et recherchez **xAI**.

   ```txt
   /connect
   ```

3. Entrez votre clé xAI API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle tel que _Grok Beta_.

   ```txt
   /models
   ```

---

### Z.AI

1. Rendez-vous sur la [console Z.AI API](https://z.ai/manage-apikey/apikey-list), créez un compte et cliquez sur **Créer une nouvelle clé API**.

2. Exécutez la commande `/connect` et recherchez **Z.AI**.

   ```txt
   /connect
   ```

Si vous êtes abonné au **Plan de codage GLM**, sélectionnez **Plan de codage Z.AI**.

3. Entrez votre clé Z.AI API.

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

4. Exécutez la commande `/models` pour sélectionner un modèle tel que _GLM-4.7_.

   ```txt
   /models
   ```

---

### ZenMux

1. Rendez-vous sur le [tableau de bord ZenMux](https://zenmux.ai/settings/keys), cliquez sur **Créer une clé API** et copiez la clé.

2. Exécutez la commande `/connect` et recherchez ZenMux.

   ```txt
   /connect
   ```

3. Saisissez la clé API du fournisseur.

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

4. De nombreux modèles ZenMux sont préchargés par défaut, exécutez la commande `/models` pour sélectionner celui que vous souhaitez.

   ```txt
   /models
   ```

Vous pouvez également ajouter des modèles supplémentaires via votre configuration opencode.

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

---

## Fournisseur personnalisé

Pour ajouter un fournisseur **OpenAI-compatible** qui n'est pas répertorié dans la commande `/connect` :

:::tip
Vous pouvez utiliser n'importe quel fournisseur compatible OpenAI avec opencode. La plupart des fournisseurs d'IA modernes proposent des API compatibles OpenAI.
:::

1. Exécutez la commande `/connect` et faites défiler jusqu'à **Autre**.

   ```bash
   $ /connect

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

2. Saisissez un identifiant unique pour le fournisseur.

   ```bash
   $ /connect

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

   :::note
   Choisissez un identifiant mémorable, vous l'utiliserez dans votre fichier de configuration.
   :::

3. Entrez votre clé API pour le fournisseur.

   ```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. Créez ou mettez à jour votre fichier `opencode.json` dans le répertoire de votre projet :

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

Voici les options de configuration :

- **npm** : package AI SDK à utiliser, `@ai-sdk/openai-compatible` pour les fournisseurs compatibles OpenAI
- **nom** : nom à afficher dans l'interface utilisateur.
- **modèles** : Modèles disponibles.
- **options.baseURL** : URL de l'endpoint API.
- **options.apiKey** : définissez éventuellement la clé API, si vous n'utilisez pas d'authentification.
- **options.headers** : définissez éventuellement des en-têtes personnalisés.

En savoir plus sur les options avancées dans l'exemple ci-dessous.

5. Exécutez la commande `/models` et votre fournisseur et vos modèles personnalisés apparaîtront dans la liste de sélection.

---

##### Exemple

Voici un exemple de définition des options `apiKey`, `headers` et modèle `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
          }
        }
      }
    }
  }
}
```

Détails de configuration :

- **apiKey** : défini à l'aide de la syntaxe de variable `env`, [en savoir plus](/docs/config#env-vars).
- **headers** : en-têtes personnalisés envoyés avec chaque requête.
- **limit.context** : nombre maximal de jetons d'entrée acceptés par le modèle.
- **limit.output** : nombre maximal de jetons que le modèle peut générer.

Les champs `limit` permettent à OpenCode de comprendre la quantité de contexte qu'il vous reste. Les fournisseurs standard les extraient automatiquement de models.dev.

---

## Dépannage

Si vous rencontrez des difficultés lors de la configuration d'un fournisseur, vérifiez les points suivants :

1. **Vérifiez la configuration de l'authentification** : exécutez `opencode auth list` pour voir si les informations d'identification
   pour le fournisseur sont ajoutés à votre configuration.

Cela ne s'applique pas aux fournisseurs comme Amazon Bedrock, qui s'appuient sur des variables d'environnement pour leur authentification.

2. Pour les fournisseurs personnalisés, vérifiez la configuration opencode et :
   - Assurez-vous que l'ID du fournisseur utilisé dans la commande `/connect` correspond à l'ID de votre configuration opencode.
   - Le bon package npm est utilisé pour le fournisseur. Par exemple, utilisez `@ai-sdk/cerebras` pour Cerebras. Et pour tous les autres fournisseurs compatibles OpenAI, utilisez `@ai-sdk/openai-compatible`.
   - Vérifiez que le point de terminaison API correct est utilisé dans le champ `options.baseURL`.