> ## Documentation Index
> Fetch the complete documentation index at: https://docs.flexinference.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Modèles pris en charge
> Les modèles que FlexInference achemine et les entrées qu'ils acceptent.
FlexInference achemine les alias de modèles **OpenAI**, **Google Gemini** et **Anthropic**. Passez le modèle par son **alias** (par exemple `gpt-5.5` ou `gemini-3.5-flash`), et non par un instantané daté.
Définissez `start_within` sur la durée maximale pendant laquelle vous êtes prêt à attendre le démarrage de la requête. Le planificateur de surface n'exécute la flex race que sur les modèles OpenAI et Gemini compatibles flex listés ci-dessous : il essaie le niveau flex du fournisseur le moins cher par rapport à ce budget, puis passe au niveau standard si le flex ne démarre pas à temps. Consultez [le fonctionnement de la flex race](/fr/deadline-routing) pour tous les détails.
Pour les requêtes sans durée, FlexInference proxyfie tout modèle sur les niveaux de fournisseur qu'il prend en charge. Gemini n'a pas de niveau `auto`, donc `auto` sur un modèle Gemini renvoie `400 auto_unsupported_for_gemini`.
## Modèles compatibles flex
### OpenAI
`gpt-5.6`, `gpt-5.6-sol`, `gpt-5.6-terra`, `gpt-5.6-luna`
`gpt-5.5`, `gpt-5.5-pro`
`gpt-5.4`, `gpt-5.4-mini`, `gpt-5.4-nano`, `gpt-5.4-pro`
`gpt-5.2`
`gpt-5`, `gpt-5-mini`, `gpt-5-nano`, `gpt-5.1`
`o3`, `o4-mini`
### Gemini
`gemini-3.5-flash`, `gemini-3.1-pro-preview`, `gemini-3.1-flash-lite`
`gemini-3-flash-preview`
`gemini-2.5-pro`, `gemini-2.5-flash`, `gemini-2.5-flash-lite`
Une durée `start_within` sur un modèle OpenAI ou Gemini en dehors de cette liste autorisée n'exécute pas la flex race. FlexInference renvoie `400 flex_model_not_capable`. Choisissez un modèle listé pour utiliser le flex. Pour ignorer la flex race, envoyez une valeur de niveau au lieu d'une durée : `default`, `priority`, ou, si pris en charge, `auto`. FlexInference proxyfie les requêtes de niveau prises en charge au fournisseur. Pour Gemini, `default` correspond au niveau **standard** de Gemini, et `auto` renvoie `400 auto_unsupported_for_gemini`.
## Anthropic (Claude)
Les modèles Claude sont acheminés vers Anthropic et sont **uniquement en mode proxy**. Ils prennent en charge `default`, `priority` et `auto`, mais pas la flex race. Une durée `start_within` sur un modèle `claude-*` renvoie `400 flex_unsupported_for_anthropic`, car Anthropic n'a pas de niveau flex.
`default` correspond au niveau de service **standard\_only** d'Anthropic. `auto` laisse Anthropic choisir. `priority` est un effort au mieux et correspond à `auto`, car Anthropic rejette un niveau de priorité littéral.
Anthropic exige `max_tokens` en amont. FlexInference transmet votre champ de jetons de sortie lorsque vous en définissez un et ne synthétise pas de valeur par défaut si vous l'omettez, de sorte qu'Anthropic renvoie sa propre erreur de requête pour les limites manquantes.
`claude-opus-4-8`, `claude-opus-4-7`, `claude-opus-4-6`, `claude-opus-4-5`,
`claude-opus-4-1`
`claude-sonnet-5`, `claude-sonnet-4-6`, `claude-sonnet-4-5`
`claude-haiku-4-5`
`claude-fable-5`
Claude fonctionne avec tous les formats d'appel pris en charge : `/v1/responses`, `/v1/chat/completions`, `/v1/interactions`, et l'API native d'Anthropic [`/v1/messages`](/fr/sdks). FlexInference traduit chacun d'eux vers l'API Messages d'Anthropic. Anthropic décide du niveau de service. Une requête `standard_only` est renvoyée avec `"service_tier": "standard"` dans la réponse.
## Routage des fournisseurs
Un tableau `provider` ordonné et facultatif fixe l'itinéraire que prend votre requête. L'élément 0 est l'itinéraire principal et la seule porte flex ; les éléments 1 à n constituent la chaîne de secours du même modèle, essayée dans l'ordre lorsqu'un itinéraire échoue de manière transitoire. Omettez `provider` et FlexInference utilisera l'itinéraire direct natif du modèle, exactement comme auparavant. Définir le tableau sur l'itinéraire natif de votre modèle est une opération de routage sans effet qui fixe explicitement le même comportement.
`google`, `openai` et `anthropic` sont des **itinéraires directs**. `vertex` (Gemini) et `bedrock` (Claude) sont des **itinéraires cloud** qui servent le même modèle sur un fournisseur différent : `bedrock` sert `claude-*` via Amazon Bedrock (Bedrock Converse), et `vertex` sert `gemini-*` via Google Vertex AI (Vertex generateContent). Un fallback de fournisseur ne change que l'itinéraire : il ne change jamais le modèle ou le niveau, et une entrée de fallback est toujours un appel standard simple, jamais une flex race.
### Chaque itinéraire que vous nommez nécessite sa clé
Une chaîne est une déclaration que vous avez configuré chaque itinéraire qu'elle contient. Chaque itinéraire utilise sa propre clé BYOK : `openai` utilise votre clé OpenAI, `google` votre clé Gemini, `anthropic` votre clé Anthropic, `vertex` votre clé Vertex express, et `bedrock` votre clé et région Bedrock. Ajoutez-les dans le tableau de bord sous Paramètres -> Clés API avant de nommer l'itinéraire.
Une clé manquante est une erreur de configuration, pas une défaillance transitoire, elle ne passe donc pas à l'itinéraire suivant. FlexInference rejette la requête avec le code `400 no_..._key` pour l'itinéraire dont la clé est manquante, avant tout appel en amont et avant tout travail facturable. `["bedrock","anthropic"]` sans clé Bedrock renvoie [`400 no_bedrock_key`](/fr/errors#no_bedrock_key) même si votre clé Anthropic est présente et aurait pu servir le modèle. Un fallback ici masquerait l'itinéraire non configuré et vous servirait silencieusement sur un fournisseur que vous n'aviez pas l'intention d'utiliser, c'est pourquoi FlexInference vous en informe. Ajoutez la clé manquante, ou supprimez cet itinéraire de la chaîne.
Le fallback couvre les défaillances transitoires en amont et rien d'autre : un `429`, un `5xx`, une erreur de connexion ou un timeout, chacun étant intercepté avant que la réponse ne soit validée. Tout ce pour quoi un itinéraire peut être rejeté d'emblée, y compris une clé manquante, un modèle que l'itinéraire ne peut pas servir et une chaîne mal formée, est une requête que vous devez corriger et renvoie un `400`.
Chaque itinéraire sert une famille de modèles, donc une chaîne qui fixe un itinéraire qui ne peut pas servir votre modèle renvoie [`400 provider_model_mismatch`](/fr/errors#provider_model_mismatch). `openai` sert les modèles GPT et de la série o, `google` et `vertex` servent Gemini, et `anthropic` et `bedrock` servent Claude.
| Modèle | Itinéraire direct natif | Itinéraire cloud | Exemples de tableaux valides | Flex race ? |
| :---------------------- | :---------------------- | :--------------- | :----------------------------------------------------------------------------------- | :------------------------------------------------------------------------------ |
| `claude-*` | `anthropic` | `bedrock` | `["anthropic"]`, `["bedrock"]`, `["anthropic","bedrock"]`, `["bedrock","anthropic"]` | Non, Claude n'a pas de niveau flex |
| Flex-capable `gemini-*` | `google` | `vertex` | `["google"]`, `["vertex"]`, `["google","vertex"]`, `["vertex","google"]` | Uniquement lorsque l'élément 0 est `google` et que `start_within` est une durée |
| Non-flex `gemini-*` | `google` | `vertex` | idem | Non, pas sur la liste autorisée flex |
| Flex-capable `gpt-*` | `openai` | aucun | `["openai"]` | Uniquement lorsque l'élément 0 est `openai` et que `start_within` est une durée |
| Non-flex `gpt-*` | `openai` | aucun | `["openai"]` | Non, pas sur la liste autorisée flex |
Une chaîne cloud-first à un seul élément, telle que `["vertex"]` ou `["bedrock"]`, est un itinéraire direct valide sans flex vers ce fournisseur cloud. Une durée `start_within` avec un itinéraire cloud comme élément 0 renvoie [`400 flex_unsupported_on_cloud`](/fr/errors#flex_unsupported_on_cloud), car les itinéraires cloud n'ont pas de niveau flex à concurrencer ; envoyez plutôt une valeur de niveau (`default`, `priority` ou `auto`). Un tableau mal formé (un nom inconnu, un doublon, un tableau vide ou plus de trois entrées) renvoie [`400 invalid_provider_chain`](/fr/errors#invalid_provider_chain).
### Claude sur Bedrock : routage global, opus-4-1 et octrois d'accès
L'itinéraire `bedrock` sert Claude via les profils d'inférence inter-régions d'Amazon. FlexInference l'achemine en **priorité globale** : chaque modèle `claude-*` qu'il sert sur Bedrock est adressé via un profil d'inférence global, de sorte qu'il est servi depuis n'importe quelle région AWS, quel que soit l'endroit où la clé Bedrock de votre organisation est configurée. Une conséquence est un compromis en matière de résidence des données qu'il est bon de connaître : un profil global achemine chaque requête à travers toutes les régions AWS prises en charge, de sorte qu'une requête n'est pas garantie de s'exécuter dans votre propre région. En mode priorité globale, aucun itinéraire ne garantit le traitement dans une région AWS spécifique, et l'itinéraire direct `anthropic` n'est pas une alternative intra-région : il atteint l'infrastructure propre d'Anthropic, pas votre compte AWS. Si le traitement intra-région est une exigence, un profil Bedrock épinglé à une région (`us.` ou `eu.`, correspondant à la région de votre clé Bedrock) est disponible sur demande via une politique de résidence des données par organisation.
`claude-opus-4-1` est la seule exception qui n'est **pas du tout sur l'itinéraire `bedrock`**. Amazon le publie uniquement aux États-Unis, et même pas dans toutes les régions américaines, donc plutôt que de gérer une exception régionale partielle, FlexInference le sert uniquement sur l'itinéraire direct `anthropic` ; une chaîne `["bedrock"]` pour celui-ci renvoie [`400 bedrock_model_unavailable`](/fr/errors#bedrock_model_unavailable) dans toutes les régions. Il est toujours disponible sur l'itinéraire direct `anthropic`, donc omettez `provider` ou envoyez `["anthropic"]` pour l'atteindre depuis n'importe quelle région.
Séparément, un modèle peut être servi globalement et rester inaccessible à votre compte AWS tant que vous n'avez pas demandé l'accès à celui-ci dans la console Amazon Bedrock. Lorsque Bedrock dispose du modèle mais que votre compte AWS n'y a pas eu accès, vous obtenez [`403 bedrock_model_access_denied`](/fr/errors#bedrock_model_access_denied), qui nomme le modèle et cite ce que Bedrock a dit. (L'autre cas, [`400 bedrock_model_unavailable`](/fr/errors#bedrock_model_unavailable) pour un modèle pour lequel Bedrock ne publie aucun profil, ne s'applique désormais effectivement qu'à `claude-opus-4-1`, puisque tous les autres modèles servis ont un profil global.)
Aucun des deux n'est un problème avec votre clé Bedrock, et une clé fonctionnelle reste fonctionnelle : les deux erreurs concernent le modèle, pas les identifiants. Aucun des deux ne passe non plus à l'itinéraire suivant dans la chaîne, car un itinéraire que vous avez nommé est un itinéraire que vous êtes censé avoir configuré. Envoyez plutôt le modèle à l'itinéraire `anthropic`, ou accordez-lui l'accès au compte AWS.
### Les modèles Claude les plus récents sur Bedrock nécessitent une configuration de compte unique
Cinq modèles Claude sont servis sur l'itinéraire `bedrock` une fois que le compte AWS dispose de l'autorisation **Model access** ordinaire : `claude-haiku-4-5`, `claude-sonnet-4-6`, `claude-sonnet-4-5`, `claude-opus-4-6` et `claude-opus-4-5`.
Les quatre modèles les plus récents - `claude-sonnet-5`, `claude-fable-5`, `claude-opus-4-8` et `claude-opus-4-7` - nécessitent deux étapes supplémentaires uniques sur le compte AWS avant que Bedrock ne les serve. L'autorisation **Model access** de la console Amazon Bedrock seule ne les active pas. Exécutez les deux une fois par compte AWS, en utilisant les identifiants AWS d'un administrateur (pas votre clé d'inférence Bedrock).
**Étape 1 - activer le partage de données du fournisseur pour le compte.** Cette étape n'a pas d'interface utilisateur de console, elle doit donc être exécutée depuis l'AWS CLI :
```bash theme={null}
aws bedrock put-account-data-retention --mode provider_data_share
```
**Étape 2 - accepter l'accord du modèle** pour chacun de ces modèles que vous prévoyez d'appeler (exécutez-le une fois par modèle) :
```bash theme={null}
aws bedrock create-foundation-model-agreement
```
Tant que les deux étapes ne sont pas terminées, une requête `bedrock` pour l'un de ces quatre modèles renvoie [`403 bedrock_model_access_denied`](/fr/errors#bedrock_model_access_denied). Il s'agit d'une exigence du compte Amazon Bedrock, et non de FlexInference, c'est donc la même chose que vous atteigniez Bedrock via FlexInference ou directement. `claude-opus-4-1` n'est pas affecté car il n'est pas du tout servi sur l'itinéraire `bedrock` ; atteignez-le sur l'itinéraire `anthropic`.
Les itinéraires cloud `vertex` et `bedrock` sont disponibles aujourd'hui.
`bedrock` sert `claude-*` via Amazon Bedrock et `vertex` sert `gemini-*` via
Google Vertex AI, toujours le même modèle que vous avez demandé. Chaque
itinéraire cloud nécessite l'ajout de la propre clé de ce cloud dans le
tableau de bord : une clé Vertex express (préfixe `AQ.`) pour `vertex`, une
clé Bedrock bearer (préfixe `ABSK`) et une région pour `bedrock`. Les
itinéraires cloud fonctionnent uniquement au niveau standard, sans flex race.
Les deux itinéraires cloud prennent en charge le texte, les images et les
fichiers : une URL d'image ou de fichier `https` distante est récupérée côté
serveur et intégrée pour eux (voir [Entrées](#inputs) ci-dessous).
## Capacités par itinéraire
Le tableau présente un aperçu rapide des capacités par itinéraire. Chaque itinéraire prend en charge le texte, le streaming, l'appel de fonctions, les images, les fichiers (y compris les PDF) et la réflexion/raisonnement ; les lignes en dessous de la ligne de base indiquent les différences entre les itinéraires. `openai`, `anthropic` et `google` sont les itinéraires directs ; `vertex` et `bedrock` sont les itinéraires cloud.
| Capacité | OpenAI (`openai`) | Anthropic (`anthropic`) | Gemini (`google`) | Vertex (`vertex`) | Bedrock (`bedrock`) |
| :---------------------------------------- | :---------------- | :---------------------- | :---------------- | :---------------- | :------------------ |
| Texte, streaming, appel de fonctions | Oui | Oui | Oui | Oui | Oui |
| Images et fichiers (y compris PDF) | Oui | Oui | Oui | Oui | Oui |
| Réflexion / raisonnement | Oui | Oui | Oui | Oui | Oui\* |
| Recherche web | Oui | Oui | Oui | Oui | Non |
| Citations (`url_citation`) | Oui | Oui | Oui | Oui | Non |
| Sorties structurées (`json_schema`) | Oui | Oui | Oui | Oui | Non |
| Format de sortie `json_object` | Oui | Non | Oui | Oui | Non |
| Schéma strict (`text.format.strict`) | Oui | Non | Non | Non | Non |
| `code_execution` / `url_context` (Gemini) | Non | Non | Oui | Oui | Non |
\*Bedrock exécute la réflexion, mais intègre les jetons de raisonnement dans le nombre de jetons de sortie et ne signale pas de total distinct de jetons de raisonnement ; Vertex signale les jetons de raisonnement.
Un `No` est un `400 unsupported_parameter` explicite, et non une suppression silencieuse. Envoyez `web_search`, une sortie structurée `json_schema`, ou `text.format.strict: true` à un itinéraire qui ne le prend pas en charge et FlexInference rejettera la requête en nommant le champ. Acheminez la recherche web ou les sorties structurées vers n'importe quel itinéraire direct ou `vertex`, et acheminez la conformité stricte au schéma vers `openai`.
## Résultats et erreurs Flex
Les en-têtes `x-flexinference-flex-*` signalent les résultats flex sur les réponses réussies. Les erreurs de validation utilisent toujours le corps d'erreur normal. Consultez la [page des erreurs](/fr/errors) pour la structure complète des erreurs et les en-têtes de résultat Flex.
* `flex_model_not_capable` signifie que vous avez envoyé une durée `start_within` à un modèle OpenAI ou Gemini en dehors de la liste autorisée flex. Utilisez une valeur de niveau ou choisissez un modèle compatible flex.
* `auto_unsupported_for_gemini` signifie que vous avez demandé `auto` sur un modèle Gemini, qui n'a pas de niveau `auto`. Utilisez `default` pour le niveau standard de Gemini.
* `flex_unsupported_for_anthropic` signifie que vous avez envoyé une durée `start_within` à un modèle `claude-*`. Utilisez `default`, `priority` ou `auto` pour Claude.
## Entrées
Ces itinéraires acceptent les entrées compatibles OpenAI :
* **Texte** : messages système, développeur, utilisateur et assistant.
* **Images** : passez des URL d'image ou des URL de données base64. Les URL de données base64 sont les plus fiables. Pour les itinéraires Bedrock et Vertex, qui nécessitent des octets intégrés, une URL d'image `https` distante est téléchargée côté serveur et intégrée pour vous, derrière des contrôles de sécurité SSRF (https uniquement, pas d'hôtes privés ou de métadonnées, une limite de taille et une vérification de type par octet magique pour png/jpeg/gif/webp) ; une URL qui échoue à un contrôle renvoie `400 unsupported_parameter` plutôt que d'être silencieusement ignorée.
* **Fichiers** : PDF et autres entrées de fichiers acceptées par l'API Responses. Les URL PDF `https` distantes sont téléchargées et intégrées pour Bedrock et Vertex sous les mêmes contrôles.
Les sorties sont du texte, y compris les appels d'outils, les sorties structurées et le raisonnement. Le streaming fonctionne sur tous les modèles. Sur Gemini, `reasoning.effort` correspond à un `thinking_level` par modèle et peut être limité à la plage prise en charge par ce modèle.
Les paramètres natifs du fournisseur ne sont transmis que lorsque le modèle appartient à ce fournisseur. Consultez les [SDK](/fr/sdks) pour les règles de passthrough spécifiques aux points de terminaison.
La [matrice des capacités](#capabilities-by-route) ci-dessus indique le oui/non
par itinéraire ; cette note explique comment les capacités partagées sont
mappées sur chaque fournisseur. Pour la recherche web, envoyez un outil
`web_search` de Responses ; Gemini le mappe à `google_search` et Anthropic à
son outil `web_search_20250305`. Quel que soit le fournisseur qui traite la
requête, `web_search` (et `url_context` de Gemini) renvoie ses sources sous
forme d'annotations `url_citation` canoniques sur la sortie du message, de
sorte que vous lisez les citations de la même manière quel que soit
l'itinéraire. Les sorties structurées (`text.format` avec un `json_schema`)
sont mappées au `response_format` de Gemini et à l'`output_config`
d'Anthropic ; `json_object` est mappé sur Gemini mais pas sur Anthropic. Le
drapeau `strict` n'est respecté que sur OpenAI. Gemini, Vertex et Anthropic
respectent la forme du schéma de réponse mais ne peuvent garantir une
conformité stricte, donc `text.format.strict: true` renvoie
`400 unsupported_parameter` plutôt que d'être silencieusement ignoré ;
supprimez `strict` ou acheminez vers OpenAI pour l'appliquer. Gemini accepte
en outre les outils `code_execution` et `url_context` ainsi que `top_k`.
Passez les fichiers sous forme d'URL de données base64 ; les PDF sont les plus
fiables sur Gemini.
FlexInference ajoute de nouveaux modèles compatibles flex d'OpenAI et Gemini à
mesure que les fournisseurs les mettent à disposition. Si un modèle que vous
attendez est manquant, vérifiez que vous utilisez son alias et que le
fournisseur propose un niveau flex pour celui-ci.