Fournisseurs

Utiliser n’importe quel fournisseur LLM en OpenCode.

OpenCode utilise AI SDK et 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 :

Ajoutez les clés API pour le fournisseur à l’aide de la commande /connect.
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.

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.

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

Exécutez la commande /connect dans le TUI, sélectionnez opencode et dirigez-vous vers 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
```

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.

302.AI

Rendez-vous sur la console 302.AI, créez un compte et générez une clé API.
Exécutez la commande /connect et recherchez 302.AI.
```
/connect
```
Saisissez votre clé 302.AI API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle.
```
/models
```

Amazon Bedrock

Pour utiliser Amazon Bedrock avec OpenCode :

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

Vous devez avoir accès au modèle souhaité dans Amazon Bedrock.
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 :

   # 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 :

   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 :

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

Avancé : points de terminaison d’un VPC

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

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

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 :

Bearer Token - Variable d’environnement AWS_BEARER_TOKEN_BEDROCK ou jeton de la commande /connect
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

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

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 :

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

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 demande de vous authentifier.
```
┌ Select auth method
│
│ Claude Pro/Max
│ Create an API Key
│ Manually enter API Key
└
```
Désormais, tous les modèles Anthropic devraient être disponibles lorsque vous utilisez la commande /models.
```
/models
```

L’utilisation de votre abonnement Claude Pro/Max dans OpenCode n’est pas officiellement prise en charge par Anthropic.

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.

Azure OpenAI

Rendez-vous sur le 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 ou 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 que opencode fonctionne correctement.
Exécutez la commande /connect et recherchez Azure.
```
/connect
```
Entrez votre clé API.
```
┌ API key
│
│
└ enter
```
Définissez le nom de votre ressource comme variable d’environnement :
Fenêtre de terminal
```
AZURE_RESOURCE_NAME=XXX opencode
```

Ou ajoutez-le à votre profil bash :

   export AZURE_RESOURCE_NAME=XXX

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

Azure Cognitive Services

Rendez-vous sur le 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 ou 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 que opencode fonctionne correctement.
Exécutez la commande /connect et recherchez Azure Cognitive Services.
```
/connect
```
Entrez votre clé API.
```
┌ API key
│
│
└ enter
```
Définissez le nom de votre ressource comme variable d’environnement :
Fenêtre de terminal
```
AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX opencode
```

Ou ajoutez-le à votre profil bash :

   export AZURE_COGNITIVE_SERVICES_RESOURCE_NAME=XXX

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

Baseten

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

Cerebras

Rendez-vous sur 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é Cerebras API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle tel que Qwen 3 Coder 480B.
```
/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, vous n’avez pas besoin de clés API distinctes pour chaque fournisseur.

Rendez-vous sur le tableau de bord Cloudflare, accédez à 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 Cloudflare API.
```
┌ API key
│
│
└ enter
```

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

   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

Rendez-vous sur 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é Cortecs API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle tel que Kimi K2 Instruct.
```
/models
```

DeepSeek

Rendez-vous sur 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é DeepSeek API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle DeepSeek tel que DeepSeek Reasoner.
```
/models
```

Deep Infra

Rendez-vous sur le 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é Deep Infra API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle.
```
/models
```

Firmware

Rendez-vous sur le Tableau de bord du micrologiciel, créez un compte et générez une clé API.
Exécutez la commande /connect et recherchez Firmware.
```
/connect
```
Entrez la clé API de votre micrologiciel.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle.
```
/models
```

Fireworks AI

Rendez-vous sur 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é Fireworks AI API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle tel que Kimi K2 Instruct.
```
/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.

Exécutez la commande /connect et sélectionnez GitLab.
```
/connect
```
Choisissez votre méthode d’authentification :
```
┌ 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

Accédez à GitLab Paramètres utilisateur > Jetons d’accès
Cliquez sur Ajouter un nouveau jeton
Nom : OpenCode, Portées : api
Copiez le jeton (commence par glpat-)
Entrez-le dans le terminal
Exécutez la commande /models pour voir les modèles disponibles.
```
/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 :

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

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

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

Ou ajoutez à votre profil bash :

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

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 :

export GITLAB_OAUTH_CLIENT_ID=your_application_id_here

Plus de documentation sur la page d’accueil opencode-gitlab-auth.

Configuration

Personnalisez via opencode.json :

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

Outils GitLab API (facultatif, mais fortement recommandé)

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

{
  "$schema": "https://opencode.ai/config.json",
  "plugin": ["@gitlab/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 :

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

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

Google Vertex AI

Pour utiliser Google Vertex AI avec OpenCode :

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

Vous devez disposer d’un projet Google Cloud avec Vertex AI API activé.
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.

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

Ou ajoutez-les à votre profil bash.

   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 souhaité.
```
/models
```

Groq

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

Hugging Face

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

Rendez-vous sur Hugging Face settings pour créer un jeton avec l’autorisation de passer 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 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.

Rendez-vous sur Helicone, créez un compte et générez une clé API à partir de votre tableau de bord.
Exécutez la commande /connect et recherchez Helicone.
```
/connect
```
Entrez votre clé Helicone API.
```
┌ 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 telles que la mise en cache et la limitation de débit, consultez la documentation Helicone.

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, vous en aurez besoin pour récupérer les identifiants 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": {
          // 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 :

{
  "$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 d’Helicone vous permet de regrouper les requêtes LLM associées. Utilisez le plugin opencode-helicone-session pour enregistrer automatiquement chaque conversation OpenCode en tant que 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 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 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

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

Rendez-vous sur 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é IO.NET API.
```
┌ 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 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 :

Rendez-vous sur 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é Moonshot API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner Kimi K2.
```
/models
```

MiniMax

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

Nebius Token Factory

Rendez-vous sur 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é Nebius Token Factory API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle tel que 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 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.

Ollama Cloud

Pour utiliser Ollama Cloud avec OpenCode :

Rendez-vous sur https://ollama.com/ et connectez-vous ou créez un compte.
Accédez à Paramètres > Clés et cliquez sur Ajouter une clé API pour générer une nouvelle clé API.
Copiez la clé API à utiliser dans OpenCode.
Exécutez la commande /connect et recherchez Ollama Cloud.
```
/connect
```
Entrez votre clé Ollama Cloud API.
```
┌ API key
│
│
└ enter
```
Important : Avant d’utiliser des modèles cloud dans OpenCode, vous devez extraire 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 vous 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 demande de vous authentifier.
```
┌ Select auth method
│
│ ChatGPT Plus/Pro
│ Manually enter API Key
└
```
Désormais, tous les modèles OpenAI devraient être disponibles lorsque vous utilisez la commande /models.
```
/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.

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é OpenCode API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle tel que Qwen 3 Coder 480B.
```
/models
```

OpenRouter

Rendez-vous sur le tableau de bord OpenRouter, cliquez sur Créer une clé API et copiez la clé.
Exécutez la commande /connect et recherchez OpenRouter.
```
/connect
```
Saisissez 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.

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

Accédez à votre SAP BTP Cockpit, accédez à 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-le à votre profil bash :

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

Définissez éventuellement 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

Rendez-vous sur le Panneau OVHcloud. 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.
Exécutez la commande /connect et recherchez OVHcloud AI Endpoints.
```
/connect
```
Saisissez votre clé OVHcloud AI Endpoints API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle tel que gpt-oss-120b.
```
/models
```

Scaleway

Pour utiliser Scaleway Generative APIs avec Opencode :

Rendez-vous dans les 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é Scaleway API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle tel que devstral-2-123b-instruct-2512 ou gpt-oss-120b.
```
/models
```

Together AI

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

Venice AI

Rendez-vous sur la Venice AI console, créez un compte et générez une clé API.
Exécutez la commande /connect et recherchez Venice AI.
```
/connect
```
Entrez votre clé Venise AI API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle tel que Llama 3.3 70B.
```
/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.

Rendez-vous sur le tableau de bord Vercel, accédez à l’onglet AI Gateway et cliquez sur API Keys pour créer une nouvelle clé API.
Exécutez la commande /connect et recherchez Vercel AI Gateway.
```
/connect
```
Entrez votre clé Vercel AI Gateway API.
```
┌ 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 :

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

Rendez-vous sur 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é xAI API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle tel que Grok Beta.
```
/models
```

Z.AI

Rendez-vous sur la console Z.AI API, 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é Z.AI API.
```
┌ API key
│
│
└ enter
```
Exécutez la commande /models pour sélectionner un modèle tel que GLM-4.7.
```
/models
```

ZenMux

Rendez-vous sur le tableau de bord ZenMux, cliquez sur Créer une clé API et copiez la clé.
Exécutez la commande /connect et recherchez ZenMux.
```
/connect
```
Saisissez 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.

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

Exécutez la commande /connect et faites défiler jusqu’à Autre.

$ /connect

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

Saisissez un identifiant unique pour le fournisseur.
Fenêtre de terminal
```
$ /connect

┌  Add credential
│
◇  Enter provider id
│  myprovider
└
```
Choisissez un identifiant mémorable, 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 le répertoire de votre projet :

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

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.

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

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.

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.