Fournisseurs

Utiliser n'importe quel fournisseur de LLM dans OpenCode.

OpenCode utilise l’AI SDK et Models.dev pour prendre en charge plus de 75 fournisseurs de LLM et il prend en charge l’exécution de modèles locaux.

Pour ajouter un fournisseur, vous devez :

Ajouter les clés API du fournisseur à l’aide de la commande /connect.
Configurer le fournisseur dans votre configuration OpenCode.

Identifiants

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

Configuration

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

URL de base

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

{
  "$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és et vérifiés pour bien fonctionner avec OpenCode. En savoir plus.

Exécutez la commande /connect dans le TUI, sélectionnez opencode et accédez à opencode.ai/auth.
```
/connect
```
Connectez-vous, ajoutez vos informations de facturation et copiez votre clé API.
Collez votre clé API.
```
┌ API key
│
│
└ enter
```
Exécutez /models dans le TUI pour voir la liste des modèles que nous recommandons.
```
/models
```

Cela fonctionne comme n’importe quel autre fournisseur dans OpenCode. Son utilisation est entièrement facultative.

Annuaire

Examinons en détail certains des fournisseurs. Si vous souhaitez ajouter un fournisseur à la liste, n’hésitez pas à ouvrir une PR.

Amazon Bedrock

Pour utiliser Amazon Bedrock avec OpenCode :

Accédez au Catalogue de modèles dans la console Amazon Bedrock et demandez l’accès aux modèles que vous souhaitez.

Vous devez avoir accès au modèle que vous souhaitez dans Amazon Bedrock.
Configurez l’authentification en utilisant 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 d’opencode :
Fenêtre de terminal
```
# Option 1 : Utilisation des clés d'accès AWS
AWS_ACCESS_KEY_ID=XXX AWS_SECRET_ACCESS_KEY=YYY opencode

# Option 2 : Utilisation d'un profil AWS nommé
AWS_PROFILE=my-profile opencode

# Option 3 : Utilisation du jeton bearer Bedrock
AWS_BEARER_TOKEN_BEDROCK=XXX opencode
```
Ou ajoutez-les à votre profil bash :
~/.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 :
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 AWS nommé depuis ~/.aws/credentials
- endpoint - URL de point de terminaison personnalisée pour les points de terminaison VPC (alias pour l’option générique baseURL)
Les options du fichier de configuration prennent le pas sur les variables d’environnement.

Avancé : Points de terminaison VPC

Si vous utilisez des points de terminaison VPC pour Bedrock :
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"
      }
    }
  }
}
```
L’option endpoint est un alias pour l’option générique baseURL, utilisant une terminologie spécifique à AWS. Si endpoint et baseURL sont tous deux spécifiés, endpoint a priorité.

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 des profils nommés depuis ~/.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 depuis la console Amazon Bedrock
Priorité d’authentification

Amazon Bedrock utilise la priorité d’authentification suivante :
1. Jeton Bearer - Variable d’environnement AWS_BEARER_TOKEN_BEDROCK ou jeton de la commande /connect
2. Chaîne d’informations d’identification AWS - Profil, clés d’accès, informations d’identification partagées, rôles IAM, métadonnées d’instance
Lorsqu’un jeton bearer est défini (via /connect ou AWS_BEARER_TOKEN_BEDROCK), il a priorité sur toutes les méthodes d’information d’identification AWS, y compris les profils configurés.
Exécutez la commande /models pour sélectionner le modèle que vous souhaitez.
```
/models
```

Anthropic

Nous recommandons de vous inscrire à Claude Pro ou Max.

Une fois inscrit, exécutez la commande /connect et sélectionnez Anthropic.
```
/connect
```
Ici, vous pouvez sélectionner l’option Claude Pro/Max et cela ouvrira votre navigateur et vous demandera de vous authentifier.
```
┌ Select auth method
│
│ Claude Pro/Max
│ Create an API Key
│ Manually enter API Key
└
```
Maintenant, tous les modèles Anthropic devraient être disponibles lorsque vous utilisez la commande /models.
```
/models
```

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

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

Azure OpenAI

Accédez au portail Azure 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 soit KEY 2 de votre ressource
Accédez à Azure AI Foundry et déployez un modèle.

Le nom du déploiement doit correspondre au nom du modèle pour qu’opencode fonctionne correctement.
Exécutez la commande /connect et recherchez Azure.
```
/connect
```
Entrez votre clé API.
```
┌ API key
│
│
└ enter
```
Définissez votre nom de ressource comme variable d’environnement :
Fenêtre de terminal
```
AZURE_RESOURCE_NAME=XXX opencode
```
Ou ajoutez-le à votre profil bash :
~/.bash_profile
```
export AZURE_RESOURCE_NAME=XXX
```
Exécutez la commande /models pour sélectionner votre modèle déployé.
```
/models
```

Azure Cognitive Services

Accédez au portail Azure 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 soit KEY 2 de votre ressource
Accédez à Azure AI Foundry et déployez un modèle.

Le nom du déploiement doit correspondre au nom du modèle pour qu’opencode fonctionne correctement.
Exécutez la commande /connect et recherchez Azure Cognitive Services.
```
/connect
```
Entrez votre clé API.
```
┌ API key
│
│
└ enter
```
Définissez votre nom de ressource comme variable d’environnement :
Fenêtre de terminal
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
```
Ou ajoutez-le à votre profil bash :
~/.bash_profile
```
export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX
```
Exécutez la commande /models pour sélectionner votre modèle déployé.
```
/models
```

Baseten

Accédez à Baseten, créez un compte et générez une clé API.
Exécutez la commande /connect et recherchez Baseten.
```
/connect
```
Entrez votre clé API Baseten.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle.
```
/models
```

Cerebras

Accédez à la console Cerebras, créez un compte et générez une clé API.
Exécutez la commande /connect et recherchez Cerebras.
```
/connect
```
Entrez votre clé API Cerebras.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle comme Qwen 3 Coder 480B.
```
/models
```

Cloudflare AI Gateway

Cloudflare AI Gateway vous permet d’accéder aux modèles d’OpenAI, Anthropic, Workers AI, etc. via un point de terminaison unifié. Avec la Facturation unifiée, vous n’avez pas besoin de clés API distinctes pour chaque fournisseur.

Accédez au tableau de bord Cloudflare, naviguez vers AI > AI Gateway et créez une nouvelle passerelle.
Définissez votre ID de compte et votre ID de passerelle comme variables d’environnement.
~/.bash_profile
```
export CLOUDFLARE_ACCOUNT_ID=your-32-character-account-id
export CLOUDFLARE_GATEWAY_ID=your-gateway-id
```
Exécutez la commande /connect et recherchez Cloudflare AI Gateway.
```
/connect
```
Entrez votre jeton API Cloudflare.
```
┌ API key
│
│
└ enter
```
Ou définissez-le comme variable d’environnement.
~/.bash_profile
```
export CLOUDFLARE_API_TOKEN=your-api-token
```

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

/models

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

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

Cortecs

Accédez à la console Cortecs, créez un compte et générez une clé API.
Exécutez la commande /connect et recherchez Cortecs.
```
/connect
```
Entrez votre clé API Cortecs.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle comme Kimi K2 Instruct.
```
/models
```

DeepSeek

Accédez à la console DeepSeek, créez un compte et cliquez sur Créer une nouvelle clé API.
Exécutez la commande /connect et recherchez DeepSeek.
```
/connect
```
Entrez votre clé API DeepSeek.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle DeepSeek comme DeepSeek Reasoner.
```
/models
```

Deep Infra

Accédez au tableau de bord Deep Infra, créez un compte et générez une clé API.
Exécutez la commande /connect et recherchez Deep Infra.
```
/connect
```
Entrez votre clé API Deep Infra.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle.
```
/models
```

Fireworks AI

Accédez à la console Fireworks AI, créez un compte et cliquez sur Créer une clé API.
Exécutez la commande /connect et recherchez Fireworks AI.
```
/connect
```
Entrez votre clé API Fireworks AI.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle comme Kimi K2 Instruct.
```
/models
```

GitHub Copilot

Pour utiliser votre abonnement GitHub Copilot avec opencode :

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

Accédez à github.com/login/device et entrez le code.

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

Maintenant, exécutez la commande /models pour sélectionner le modèle que vous souhaitez.
```
/models
```

Google Vertex AI

Pour utiliser Google Vertex AI avec OpenCode :

Accédez au Modèle Garden dans la Google Cloud Console et vérifiez les modèles disponibles dans votre région.

Vous devez avoir un projet Google Cloud avec l’API Vertex AI activée.
Définissez les variables d’environnement requises :
- GOOGLE_CLOUD_PROJECT : Votre ID de projet Google Cloud
- VERTEX_LOCATION (facultatif) : La région pour Vertex AI (par défaut global)
- Authentification (choisissez-en une) :
  - GOOGLE_APPLICATION_CREDENTIALS : Chemin vers votre fichier de clé de compte de service JSON
  - Authentifiez-vous via gcloud CLI : gcloud auth application-default login
Définissez-les lors de l’exécution d’opencode.
Fenêtre de terminal
```
GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json GOOGLE_CLOUD_PROJECT=your-project-id opencode
```
Ou ajoutez-les à votre profil bash.
~/.bash_profile
```
export GOOGLE_APPLICATION_CREDENTIALS=/path/to/service-account.json
export GOOGLE_CLOUD_PROJECT=your-project-id
export VERTEX_LOCATION=global
```

Exécutez la commande /models pour sélectionner le modèle que vous souhaitez.
```
/models
```

Groq

Accédez à la console Groq, cliquez sur Créer une clé API et copiez la clé.
Exécutez la commande /connect et recherchez Groq.
```
/connect
```
Entrez la clé API du fournisseur.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner celui que vous souhaitez.
```
/models
```

Hugging Face

Hugging Face Inference Providers donne accès à des modèles open source pris en charge par plus de 17 fournisseurs.

Accédez aux paramètres Hugging Face pour créer un jeton avec l’autorisation de faire des appels aux fournisseurs d’inférence.
Exécutez la commande /connect et recherchez Hugging Face.
```
/connect
```
Entrez votre jeton Hugging Face.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle comme Kimi-K2-Instruct ou GLM-4.6.
```
/models
```

Helicone

Helicone est une plateforme d’observabilité LLM qui fournit des journaux, une surveillance et des analyses pour vos applications IA. La passerelle Helicone AI achemine vos demandes vers le fournisseur approprié automatiquement en fonction du modèle.

Accédez à Helicone, créez un compte et générez une clé API depuis votre tableau de bord.
Exécutez la commande /connect et recherchez Helicone.
```
/connect
```
Entrez votre clé API Helicone.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle.
```
/models
```

Pour plus de fournisseurs et de fonctionnalités avancées comme la mise en cache et la limitation de débit, consultez la documentation Helicone.

Configurations facultatives

Dans le cas où 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 l’Annuaire des modèles Helicone, vous en aurez besoin pour récupérer les ID des modèles que vous souhaitez ajouter.

{
  "$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": {
          // ID de modèle (de la page de l'annuaire des modèles Helicone)
          "name": "GPT-4o", // Votre propre nom personnalisé pour le modèle
        },
        "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 comme la mise en cache, le suivi des utilisateurs et la gestion des sessions. Ajoutez-les à votre configuration de fournisseur en utilisant options.headers :

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

La fonctionnalité Sessions d’Helicone vous permet de regrouper des demandes LLM connexes. Utilisez le plugin opencode-helicone-session pour connecter automatiquement chaque conversation OpenCode comme une session dans Helicone.

npm install -g opencode-helicone-session

Ajoutez-le à votre configuration.

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

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

En-têtes Helicone courants

En-tête	Description
`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 demandes aux versions de prompt

Consultez l’Annuaire des en-têtes Helicone 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

{
  "$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 de fournisseur personnalisé. Cela peut être n’importe quelle chaîne que vous souhaitez.
npm spécifie le package à utiliser pour ce fournisseur. Ici, @ai-sdk/openai-compatible est utilisé pour toute 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 vers leurs configurations. Le nom du modèle sera affiché dans la liste de sélection des modèles.

IO.NET

IO.NET propose 17 modèles optimisés pour divers cas d’utilisation :

Accédez à la console IO.NET, créez un compte et générez une clé API.
Exécutez la commande /connect et recherchez IO.NET.
```
/connect
```
Entrez votre clé API IO.NET.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle.
```
/models
```

LM Studio

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

{
  "$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 de fournisseur personnalisé. Cela peut être n’importe quelle chaîne que vous souhaitez.
npm spécifie le package à utiliser pour ce fournisseur. Ici, @ai-sdk/openai-compatible est utilisé pour toute 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 vers leurs configurations. Le nom du modèle sera affiché dans la liste de sélection des modèles.

Moonshot AI

Pour utiliser Kimi K2 de Moonshot AI :

Accédez à la console Moonshot AI, créez un compte et cliquez sur Créer une clé API.
Exécutez la commande /connect et recherchez Moonshot AI.
```
/connect
```
Entrez votre clé API Moonshot.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner Kimi K2.
```
/models
```

MiniMax

Accédez à la Console API MiniMax, créez un compte et générez une clé API.
Exécutez la commande /connect et recherchez MiniMax.
```
/connect
```
Entrez votre clé API MiniMax.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle comme M2.1.
```
/models
```

Nebius Token Factory

Accédez à la console Nebius Token Factory, créez un compte et cliquez sur Ajouter une clé.
Exécutez la commande /connect et recherchez Nebius Token Factory.
```
/connect
```
Entrez votre clé API Nebius Token Factory.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle comme Kimi K2 Instruct.
```
/models
```

Ollama

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

{
  "$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 de fournisseur personnalisé. Cela peut être n’importe quelle chaîne que vous souhaitez.
npm spécifie le package à utiliser pour ce fournisseur. Ici, @ai-sdk/openai-compatible est utilisé pour toute 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 vers leurs configurations. Le nom du modèle sera affiché dans la liste de sélection des modèles.

Ollama Cloud

Pour utiliser Ollama Cloud avec OpenCode :

Accédez à https://ollama.com/ et connectez-vous ou créez un compte.
Naviguez vers Paramètres > Clés et cliquez sur Ajouter une clé API pour générer une nouvelle clé API.
Copiez la clé API pour une utilisation dans OpenCode.
Exécutez la commande /connect et recherchez Ollama Cloud.
```
/connect
```
Entrez votre clé API Ollama Cloud.
```
┌ API key
│
│
└ enter
```
Important : Avant d’utiliser les modèles cloud dans OpenCode, vous devez récupérer les informations du modèle localement :
Fenêtre de terminal
```
ollama pull gpt-oss:20b-cloud
```
Exécutez la commande /models pour sélectionner votre modèle Ollama Cloud.
```
/models
```

OpenAI

Nous recommandons de vous inscrire à ChatGPT Plus ou Pro.

Une fois inscrit, exécutez la commande /connect et sélectionnez OpenAI.
```
/connect
```
Ici, vous pouvez sélectionner l’option ChatGPT Plus/Pro et cela ouvrira votre navigateur et vous demandera de vous authentifier.
```
┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└
```
Maintenant, tous les modèles OpenAI devraient être disponibles lorsque vous utilisez la commande /models.
```
/models
```

Utilisation des clés API

Si vous avez déjà 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 fournis par l’équipe OpenCode. En savoir plus.

Connectez-vous à OpenCode Zen et cliquez sur Créer une clé API.
Exécutez la commande /connect et recherchez OpenCode Zen.
```
/connect
```
Entrez votre clé API OpenCode.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle comme Qwen 3 Coder 480B.
```
/models
```

OpenRouter

Accédez au tableau de bord OpenRouter, cliquez sur Créer une clé API et copiez la clé.
Exécutez la commande /connect et recherchez OpenRouter.
```
/connect
```
Entrez la clé API du fournisseur.
```
┌ API key
│
│
└ enter
```
De nombreux modèles OpenRouter sont préchargés par défaut, exécutez la commande /models pour sélectionner celui que vous souhaitez.
```
/models
```
Vous pouvez également ajouter des modèles supplémentaires via votre configuration opencode.
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openrouter": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

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

{
  "$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 d’OpenAI, Anthropic, Google, Amazon, Meta, Mistral et AI21 via une plateforme unifiée.

Accédez à votre Cockpit SAP BTP, naviguez vers votre instance de service SAP AI Core et créez une clé de service.

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.
Exécutez la commande /connect et recherchez SAP AI Core.
```
/connect
```

Entrez votre clé de service JSON.

┌ Service key
│
│
└ enter

Ou définissez la variable d’environnement AICORE_SERVICE_KEY :

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

Ou ajoutez-la à votre profil bash :

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

Facultativement, définissez l’ID de déploiement et le groupe de ressources :
Fenêtre de terminal
```
AICORE_DEPLOYMENT_ID=your-deployment-id AICORE_RESOURCE_GROUP=your-resource-group opencode
```
Ces paramètres sont facultatifs et doivent être configurés en fonction de votre configuration SAP AI Core.
Exécutez la commande /models pour sélectionner parmi plus de 40 modèles disponibles.
```
/models
```

OVHcloud AI Endpoints

Accédez au panneau OVHcloud. Naviguez vers la section Public Cloud, AI & Machine Learning > AI Endpoints et dans l’onglet API Keys, cliquez sur Créer une nouvelle clé API.
Exécutez la commande /connect et recherchez OVHcloud AI Endpoints.
```
/connect
```
Entrez votre clé API OVHcloud AI Endpoints.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle comme gpt-oss-120b.
```
/models
```

Scaleway

Pour utiliser les API Génératives Scaleway avec Opencode :

Accédez aux paramètres IAM de la console Scaleway pour générer une nouvelle clé API.
Exécutez la commande /connect et recherchez Scaleway.
```
/connect
```
Entrez votre clé API Scaleway.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle comme devstral-2-123b-instruct-2512 ou gpt-oss-120b.
```
/models
```

Together AI

Accédez à la console Together AI, créez un compte et cliquez sur Ajouter une clé.
Exécutez la commande /connect et recherchez Together AI.
```
/connect
```
Entrez votre clé API Together AI.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle comme Kimi K2 Instruct.
```
/models
```

Venice AI

Accédez à la console Venice AI, créez un compte et générez une clé API.
Exécutez la commande /connect et recherchez Venice AI.
```
/connect
```
Entrez votre clé API Venice AI.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle comme Llama 3.3 70B.
```
/models
```

Vercel AI Gateway

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

Accédez au tableau de bord Vercel, naviguez vers l’onglet AI Gateway et cliquez sur Clés API pour créer une nouvelle clé API.
Exécutez la commande /connect et recherchez Vercel AI Gateway.
```
/connect
```
Entrez votre clé API Vercel AI Gateway.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle.
```
/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.

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

Quelques options de routage utiles :

Option	Description
`order`	Séquence de fournisseurs à essayer
`only`	Restreindre à des fournisseurs spécifiques
`zeroDataRetention`	Utiliser uniquement les fournisseurs avec des politiques de zéro rétention de données

xAI

Accédez à la console xAI, créez un compte et générez une clé API.
Exécutez la commande /connect et recherchez xAI.
```
/connect
```
Entrez votre clé API xAI.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle comme Grok Beta.
```
/models
```

Z.AI

Accédez à la console API Z.AI, créez un compte et cliquez sur Créer une nouvelle clé API.
Exécutez la commande /connect et recherchez Z.AI.
```
/connect
```
Si vous êtes abonné au Plan de codage GLM, sélectionnez Plan de codage Z.AI.
Entrez votre clé API Z.AI.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle comme GLM-4.7.
```
/models
```

ZenMux

Accédez au tableau de bord ZenMux, cliquez sur Créer une clé API et copiez la clé.
Exécutez la commande /connect et recherchez ZenMux.
```
/connect
```
Entrez la clé API du fournisseur.
```
┌ API key
│
│
└ enter
```
De nombreux modèles ZenMux sont préchargés par défaut, exécutez la commande /models pour sélectionner celui que vous souhaitez.
```
/models
```
Vous pouvez également ajouter des modèles supplémentaires via votre configuration opencode.
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "zenmux": {
      "models": {
        "somecoolnewmodel": {}
      }
    }
  }
}
```

Fournisseur personnalisé

Pour ajouter n’importe quel fournisseur compatible OpenAI qui n’est pas répertorié dans la commande /connect :

Exécutez la commande /connect et faites défiler vers Autre.

$ /connect

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

Entrez un ID unique pour le fournisseur.
Fenêtre de terminal
```
$ /connect

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
Choisissez un ID mémorisable, vous l’utiliserez dans votre fichier de configuration.

Entrez votre clé API pour le fournisseur.

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

Créez ou mettez à jour votre fichier opencode.json dans votre répertoire de projet :
opencode.json
```
{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "myprovider": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "My AI ProviderDisplay Name",
      "options": {
        "baseURL": "https://api.myprovider.com/v1"
      },
      "models": {
        "my-model-name": {
          "name": "My Model Display Name"
        }
      }
    }
  }
}
```
Voici les options de configuration :
- npm : Package AI SDK à utiliser, @ai-sdk/openai-compatible pour les fournisseurs compatibles OpenAI
- name : Nom d’affichage dans l’interface utilisateur.
- models : Modèles disponibles.
- options.baseURL : URL du point de terminaison API.
- options.apiKey : Définissez facultativement la clé API, si vous n’utilisez pas l’authentification.
- options.headers : Définissez facultativement des en-têtes personnalisés.
Pour plus d’informations sur les options avancées, consultez l’exemple ci-dessous.
Exécutez la commande /models et votre fournisseur personnalisé et vos modèles apparaîtront dans la liste de sélection.

Exemple

Voici un exemple définissant les options apiKey, headers et limit du modèle.

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

apiKey : Défini en utilisant la syntaxe de variable env, en savoir plus.
headers : En-têtes personnalisés envoyés avec chaque demande.
limit.context : Nombre maximal de jetons d’entrée que le modèle accepte.
limit.output : Nombre maximal de jetons que le modèle peut générer.

Les champs limit permettent à OpenCode de comprendre combien de contexte il vous reste. Les fournisseurs standard les récupèrent automatiquement depuis models.dev.

Dépannage

Si vous avez des problèmes pour configurer un fournisseur, vérifiez ce qui suit :

Vérifiez la configuration de l’authentification : Exécutez opencode auth list pour voir si les informations d’identification du fournisseur sont ajoutées à votre configuration.

Cela ne s’applique pas aux fournisseurs comme Amazon Bedrock, qui s’appuient sur des variables d’environnement pour leur authentification.
Pour les fournisseurs personnalisés, vérifiez la configuration opencode et :
- Assurez-vous que l’ID de fournisseur utilisé dans la commande /connect correspond à l’ID dans 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 bon point de terminaison API est utilisé dans le champ options.baseURL.