> ## Documentation Index > Fetch the complete documentation index at: https://docs.one.fim.ai/llms.txt > Use this file to discover all available pages before exploring further. # Modèles recommandés > Choisissez le bon LLM pour votre déploiement FIM One. FIM One est **agnostique du fournisseur** — tout point de terminaison compatible OpenAI fonctionne. Cette page vous aide à choisir la meilleure combinaison de modèles pour votre cas d'usage. Pour les détails de configuration, consultez [Variables d'environnement](/configuration/environment-variables). ## Comment FIM One utilise les modèles FIM One a trois rôles de modèle : | Rôle | Variable d'environnement | Utilisé pour | | ------------- | ------------------------ | -------------------------------------------------------------------------- | | **General** | `LLM_MODEL` | Planification, analyse, agent ReAct, raisonnement complexe | | **Fast** | `FAST_LLM_MODEL` | Exécution des étapes DAG, compaction de contexte (moins cher, plus rapide) | | **Reasoning** | `REASONING_LLM_MODEL` | Analyse approfondie, planification complexe, preuves mathématiques | Fast et Reasoning reviennent à General s'ils ne sont pas configurés. Pour les déploiements en production, la division en au moins deux modèles (General + Fast) offre le meilleur équilibre coût/qualité. Ces rôles peuvent être configurés via des variables d'environnement ou via la fonctionnalité **Model Groups** de l'interface d'administration, qui permet de basculer en un clic entre des ensembles de modèles. Consultez [Gestion des modèles](/configuration/model-management) pour le guide complet de l'interface d'administration. ## Matrice de Sélection Rapide | Fournisseur | LLM Principal | LLM Rapide | Raisonnement | Vision | Notes | | ------------------- | ------------------------------------------- | --------------------------------------------- | ----------------------------------- | --------------------- | ------------------------------------------------------------------------------ | | **OpenAI** | `gpt-5.4` | `gpt-5.4-mini` / `gpt-5.4-nano` | ✅ `reasoning_effort` | ✅ Tous | Meilleur appel d'outils natif ; GPT-5.4 est le dernier modèle phare (mar 2026) | | **Anthropic** | `claude-sonnet-4-6` | `claude-haiku-4-5` | ✅ via LiteLLM | ✅ Tous | Routage API natif ; support complet de `reasoning_content` ; contexte 1M GA | | **Google Gemini** | `gemini-2.5-pro` / `gemini-3.1-pro-preview` | `gemini-2.5-flash` / `gemini-3-flash-preview` | ✅ `reasoning_effort` | ✅ Tous | 2.5 est GA stable ; 3.x est en aperçu ; `gemini-3-pro-preview` arrêté le 9 mar | | **DeepSeek** | `deepseek-chat` (V3.2) | `deepseek-chat` | ✅ `deepseek-reasoner` | ❌ | Texte uniquement ; V4 (avr 2026) ajoutera la vision | | **Qwen (Alibaba)** | `qwen3.5-plus` / `qwen3-max` | `qwen3.5-flash` / `qwen-turbo` | ✅ `enable_thinking` sur `qwen3-max` | ⚠️ qwen3.5 uniquement | Meilleure langue chinoise ; qwq/raisonnement texte uniquement | | **ChatGLM (Zhipu)** | `glm-4.7` | `glm-4.7-flash` | `glm-5` | ⚠️ GLM-4.6V | FC forcé non supporté ; la vision nécessite un modèle VLM séparé | | **MiniMax** | `MiniMax-M2.7` | `MiniMax-M2.5` | ❌ | ❌ | Texte uniquement ; M2.7 dernier (mar 2026) ; 80,2% SWE-Bench | | **Kimi (Moonshot)** | `kimi-k2.5` | `kimi-k2` | ✅ `kimi-k2-thinking` | ⚠️ K2.5 uniquement | K2-thinking texte uniquement ; FC forcé non supporté avec raisonnement | | **Ollama (local)** | `qwen3.5` / `llama4` | `qwen3.5:9b` | ❌ | Varie | Entièrement hors ligne, pas de clé API ; Llama 4 supporte la vision | **Vision** indique si le modèle accepte l'entrée d'image. Ceci est requis pour le [Traitement Intelligent des Documents (IDP)](/features/idp) — si votre modèle ne supporte pas la vision, IDP reviendra à l'extraction texte uniquement. Les fournisseurs marqués ⚠️ ont la vision sur certains modèles mais pas d'autres ; vérifiez le modèle spécifique que vous utilisez. Les pièces jointes de chat suivent le même indicateur : avec un modèle texte uniquement, une image jointe n'est pas envoyée, et le modèle reçoit uniquement son nom de fichier. Le compositeur de chat l'indique avant l'envoi, en fonction du modèle que le tour utiliserait réellement (paramètre d'agent, puis le groupe de modèles actif, puis la valeur par défaut du système). Le texte du document n'est pas affecté — un PDF ou DOCX a toujours son contenu extrait et injecté. Ce tableau énumère les combinaisons que nous recommandons, pas l'ensemble complet des fournisseurs que FIM One supporte. xAI (Grok), ByteDance Doubao, Mistral et tout relais compatible OpenAI fonctionnent ; consultez la [Matrice de Capacités des Fournisseurs](/architecture/llm-provider-guide#provider-capability-matrix) pour la liste complète et la façon dont chacun est routé. ## Compatibilité de la sortie structurée Le planificateur DAG de FIM One nécessite que le modèle retourne du JSON structuré valide. En interne, il essaie trois niveaux d'extraction dans l'ordre : 1. **Appel de fonction natif** — force le modèle à produire du JSON correspondant à un schéma via l'API d'appel d'outil. Le plus fiable. 2. **Mode JSON** — demande `response_format: json_object`. Garantit du JSON valide, mais n'impose pas la conformité au schéma. 3. **Extraction en texte brut** — analyse le JSON à partir de texte libre en dernier recours. Les modèles qui supportent le niveau 1 (appel de fonction natif avec `tool_choice` forcé) offrent la meilleure fiabilité de planification. Si un modèle n'atteint que le niveau 2, la qualité de sa sortie dépend de la façon dont il suit les instructions du prompt — les modèles plus faibles peuvent produire du JSON valide qui ne correspond pas à la structure attendue. | Fournisseur | Appel de fonction forcé | Mode JSON | Fiabilité de planification | | --------------------------- | ----------------------------------------------------------------------------------------------------------------- | --------- | -------------------------------------------------------- | | **OpenAI** (GPT-5.x, o3) | ✅ Support complet | ✅ | ⭐⭐⭐ Excellent | | **Anthropic** (Claude 4.x) | ⚠️ Conflits avec le mode réflexion | ✅ | ⭐⭐⭐ Excellent (le suivi d'instructions robuste compense) | | **Google Gemini** (2.5/3.x) | ✅ Support complet | ✅ | ⭐⭐⭐ Excellent | | **Mistral** | ✅ Support complet | ✅ | ⭐⭐ Bon | | **xAI** (Grok 4.1) | ✅ Support complet | ✅ | ⭐⭐ Bon | | **DeepSeek** (V3.2) | ✅ sur `deepseek-chat` ; ❌ sur `deepseek-reasoner`, dont le mode réflexion le rejette | ✅ | ⭐⭐ Bon | | **Qwen** (3.x) | ✅ Supporté | ✅ | ⭐⭐ Bon | | **ByteDance** (Doubao Seed) | ✅ Support complet | ✅ | ⭐⭐ Bon | | **Kimi** (K2.5) | ⚠️ Avec réflexion, seul `auto` est supporté ; l'appel d'outil forcé nécessite la réflexion désactivée (`kimi-k2`) | ✅ | ⭐ Acceptable — peut produire des plans malformés | | **ChatGLM** (GLM-4.7/5) | ❌ Non supporté (`auto` uniquement) | ✅ | ⭐ Acceptable | | **MiniMax** (M2.5/M2.7) | ✅ Support complet, réflexion comprise | ✅ | ⭐⭐ Bon | | **Local (Ollama)** | Varie selon le modèle | Varie | ⭐ Acceptable — 32B+ recommandé | Ce tableau est une aide à la sélection. La version faisant autorité, ancrée dans le code, incluant les états `tool_choice` que chaque fournisseur accepte et ce que FIM One fait quand l'un d'eux est rejeté, se trouve dans la [Matrice des capacités des fournisseurs](/architecture/llm-provider-guide#provider-capability-matrix). Si vous voyez l'erreur « failed to generate a valid task plan », la capacité de sortie structurée du modèle est insuffisante pour la planification DAG. Changez votre **LLM principal** vers un modèle noté ⭐⭐⭐ ou ⭐⭐ ou plus, ou désactivez le mode DAG et utilisez plutôt l'agent ReAct plus simple. ## Compatibilité de la réflexion / du raisonnement Les différents fournisseurs implémentent la « réflexion » (raisonnement en chaîne de pensée) de manières fondamentalement différentes. Cela importe car le mode de réflexion peut entrer en conflit avec l'appel d'outils, et la sortie apparaît à différents endroits selon le fournisseur. FIM One gère tout cela de manière transparente — ce tableau vous aide à comprendre ce qui se passe sous le capot. ### Concepts clés * **Opt-in** — la réflexion est désactivée par défaut ; vous l'activez via un paramètre API (par exemple, `reasoning_effort`). Peut être désactivée sélectivement par appel. * **Always-on** — le modèle réfléchit toujours ; aucun paramètre API pour le désactiver. Vous devriez basculer vers une variante de modèle sans réflexion pour l'éviter. * **Au niveau du modèle** — la réflexion est déterminée par l'ID de modèle que vous choisissez (par exemple, `deepseek-reasoner` vs `deepseek-chat`), et non par un paramètre. ### Matrice de compatibilité | Fournisseur | Comment activer | Peut désactiver ? | Sortie de réflexion | Conflit FC forcé ? | | --------------------------- | ---------------------------------------------------- | ------------------- | ---------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | | **OpenAI** (GPT-5.x) | Paramètre `reasoning_effort` | ✅ Opt-in | Interne (non visible pour l'utilisateur) | ✅ Les outils + réflexion s'exécutent ensemble via l'API Responses (automatique ; le fallback chat-completions force `reasoning_effort: "none"`) | | **OpenAI** (série o) | Toujours activé | ❌ | Interne (tokens comptabilisés, non retournés) | ✅ Aucun conflit | | **Anthropic** (Claude 4.x) | `reasoning_effort` → `thinking` | ✅ Opt-in | Champ API `reasoning_content` → Panneau de réflexion | ❌ FC forcé + réflexion = **erreur 400** | | **Google Gemini** (2.5/3.x) | Paramètre `reasoning_effort` | ✅ Opt-in | Interne | ✅ Aucun conflit | | **DeepSeek** | Variante de modèle (`deepseek-reasoner`) | Au niveau du modèle | Champ API `reasoning_content` → Panneau de réflexion | ❌ Rejeté sur `deepseek-reasoner`, accepté sur `deepseek-chat` | | **Qwen** (3.x) | Paramètre `enable_thinking`, défini côté fournisseur | ✅ Opt-in | Balises `` dans le contenu | ✅ Aucun conflit | | **MiniMax** (M2.7) | Toujours activé | ❌ | Balises `` dans le contenu | ✅ Aucun conflit | | **ChatGLM** (GLM-5) | Variante de modèle | Au niveau du modèle | Non externalisée | ❌ FC forcé non supporté, avec ou sans réflexion | | **Kimi** (K2-thinking) | Variante de modèle | Au niveau du modèle | Champ API | ❌ Avec réflexion activée, seul `auto` est supporté | Les détails par fournisseur derrière ce tableau, y compris la façon dont chaque niveau d'`effort` est traduit et si la réflexion est rejouée aux tours suivants, se trouvent dans [le tableau C de la matrice de capacités des fournisseurs LLM](/architecture/llm-provider-guide#provider-capability-matrix). ### Comment FIM One gère chaque cas **`reasoning_content` au niveau de l'API** (Claude, DeepSeek) : Le champ reasoning est lu directement de la réponse API et affiché dans le panneau Reasoning de l'interface utilisateur. Aucun post-traitement nécessaire. **Balises `` dans le contenu** (MiniMax, Qwen, QwQ et autres dérivés open-source) : FIM One supprime automatiquement les balises `...` du champ content et réachemine le texte de réflexion vers le panneau Reasoning. Cela fonctionne pour les réponses en streaming et non-streaming. **Les conflits entre FC forcé et thinking** sont spécifiques à chaque fournisseur, et non une propriété des modèles pensants en général. Claude rejette la combinaison mais son thinking est optionnel, donc FIM One désactive le thinking pour cet appel en passant `reasoning_effort=None` et l'appel de fonction natif procède normalement. Kimi le rejette aussi, et son thinking est sélectionné par l'identifiant du modèle plutôt que par un paramètre, donc la solution est de désactiver Native Function Calling pour les modèles pensants. MiniMax pense à chaque appel et accepte quand même l'appel de fonction forcé, c'est pourquoi aucune solution de contournement ne s'applique à lui. **Chaîne de secours** : Si l'appel de fonction forcé échoue pour une raison quelconque, FIM One bascule automatiquement : FC natif → mode JSON → extraction de texte brut. Cette approche à trois niveaux garantit que la planification fonctionne même avec les fournisseurs qui ont un support d'outils partiel. Si vous utilisez un modèle qui pense toujours (MiniMax M2.7, `deepseek-reasoner`) comme votre LLM principal, la sortie de réflexion apparaîtra dans le panneau Reasoning de chaque itération d'agent. C'est normal — cela n'affecte pas la fonctionnalité, et vous pouvez voir le processus de raisonnement du modèle. ## Détails du fournisseur ### OpenAI L'option la plus éprouvée. Les modèles OpenAI offrent le meilleur support natif des appels de fonction (tool-calling), ce qui impacte directement la fiabilité des agents. La famille GPT-5 (août 2025+) représente un saut générationnel majeur par rapport à GPT-4. **Modèles recommandés :** * Principal : `gpt-5.4` (dernier flagship, mars 2026 — contexte 1M+, computer use) ou `o3` (meilleure précision de raisonnement) * Rapide : `gpt-5.4-mini` ($0.75/$4.50 par MTok) ou `gpt-5.4-nano` (le moins cher à $0.20/$1.25 par MTok) * Budget Rapide : `gpt-5-mini` ($0.25/$2.00) et `gpt-5-nano` ($0.05/$0.40) restent disponibles à des prix plus bas * Hérité : `gpt-4.1` (toujours dans l'API, contexte 1M, bon pour le coding) **Raisonnement :** Définissez `LLM_REASONING_EFFORT=medium` — fonctionne nativement avec les modèles o-series et GPT-5.x. GPT-5.4 supporte `reasoning_effort` avec les niveaux `none`, `low`, `medium`, `high`, `xhigh`. La série o-series nécessite `max_completion_tokens` au lieu de `max_tokens`, que LiteLLM gère automatiquement. Remarque : `/v1/chat/completions` rejette les requêtes GPT-5.x qui combinent tools et raisonnement, donc FIM One utilise directement l'API Responses pour GPT-5.x, où les deux fonctionnent ensemble. Ce chemin porte également le raisonnement chiffré de chaque tour au suivant, de sorte qu'un agent construisant une réponse multi-étapes conserve ce qu'il a déjà élaboré au lieu de le redériver à chaque appel d'outil. Les endpoints sans route `/v1/responses` reviennent à chat completions avec un `reasoning_effort: "none"` explicite lors des étapes tool-use de l'agent, et `FIM_GPT5_RESPONSES_MODE` peut forcer l'un ou l'autre fallback manuellement. Les autres familles de modèles sur des endpoints compatibles OpenAI restent sur chat completions : elles ne gagnent rien avec Responses, et les shims proxy pour cela peuvent mal mettre en buffer le streaming. GPT-5.4 nécessite `temperature=1`, que FIM One gère automatiquement via le filtrage de paramètres de LiteLLM (`drop_params`). | Modèle | Input \$/MTok | Output \$/MTok | Contexte | | -------------- | ------------- | -------------- | ------------------------ | | `gpt-5.4` | \$2.50 | \$15.00 | 1,050K (surcharge >272K) | | `gpt-5.4-mini` | \$0.75 | \$4.50 | 400K | | `gpt-5.4-nano` | \$0.20 | \$1.25 | 400K | | `o3` | \$2.00 | \$8.00 | 200K | | `o4-mini` | \$1.10 | \$4.40 | 200K | | `gpt-5-mini` | \$0.25 | \$2.00 | 400K | | `gpt-5-nano` | \$0.05 | \$0.40 | 400K | ```bash theme={null} # .env — OpenAI (production with reasoning) LLM_API_KEY=sk-... LLM_BASE_URL=https://api.openai.com/v1 LLM_MODEL=gpt-5.4 FAST_LLM_MODEL=gpt-5.4-nano LLM_REASONING_EFFORT=medium ``` ```bash theme={null} # .env — OpenAI (budget reasoning) LLM_API_KEY=sk-... LLM_BASE_URL=https://api.openai.com/v1 LLM_MODEL=o3 FAST_LLM_MODEL=gpt-5.4-nano LLM_REASONING_EFFORT=medium ``` ### Anthropic (Claude) Claude excels at nuanced reasoning and complex multi-step tasks. FIM One connects via [LiteLLM](https://github.com/BerriAI/litellm), which routes Anthropic models through their native API automatically. The current generation is Claude 4.6 (February 2026). **Modèles recommandés :** * Main: `claude-sonnet-4-6` (best balance of capability and cost — $3/$15 per MTok) * Fast: `claude-haiku-4-5` (fast and cheap — $1/$5 per MTok) * Premium: `claude-opus-4-6` (most capable, 128K max output — $5/$25 per MTok) **URL de base :** `https://api.anthropic.com/v1/` Opus 4.6 and Sonnet 4.6 have a 1M context window (GA since March 13, 2026 — no beta header needed). Haiku 4.5 has a 200K context window. **Reasoning :** Set `LLM_REASONING_EFFORT=medium`. LiteLLM routes Anthropic models through the native API, so `reasoning_content` (extended thinking) is fully returned and visible in the UI "thinking" step. Claude 4.6 and newer use Adaptive Thinking (`thinking: {type: "adaptive"}` plus `output_config.effort`) in place of a manual `budget_tokens`, which FIM One emits directly rather than relying on LiteLLM's mapping. Anthropic requires `temperature=1` while thinking is active, and the system enforces that for you: the request builder pins the value on Anthropic routes, and on models that reject sampling parameters outright it removes `temperature` altogether. Do not set `LLM_TEMPERATURE=1` by hand. See [Extended Thinking](/configuration/environment-variables#extended-thinking-reasoning) for details. ```bash theme={null} # .env — Anthropic Claude LLM_API_KEY=sk-ant-... LLM_BASE_URL=https://api.anthropic.com/v1/ LLM_MODEL=claude-sonnet-4-6 FAST_LLM_MODEL=claude-haiku-4-5 LLM_REASONING_EFFORT=medium ``` *** ### Google Gemini Les modèles Gemini offrent des performances solides à des prix compétitifs via le point de terminaison compatible OpenAI de Google. La génération 3.x (fin 2025+) est un grand bond en avant — Gemini 3 Flash surpasse 2.5 Pro tout en étant 3 fois plus rapide. Remarque : `gemini-3-pro-preview` a été arrêté le 9 mars 2026 — utilisez `gemini-3.1-pro-preview` à la place. **Modèles recommandés :** * Stable (GA) : `gemini-2.5-pro` (principal) + `gemini-2.5-flash` (rapide) — prêt pour la production * Dernier (Aperçu) : `gemini-3.1-pro-preview` (principal) + `gemini-3-flash-preview` (rapide) + `gemini-3.1-flash-lite-preview` (rapide économique) — meilleures performances, mais en statut d'aperçu **URL de base :** `https://generativelanguage.googleapis.com/v1beta/openai/` **Raisonnement :** `reasoning_effort` est pris en charge sur le point de terminaison de compatibilité — définissez `LLM_REASONING_EFFORT=medium` et cela fonctionne immédiatement. | Modèle | Entrée \$/MTok | Sortie \$/MTok | Statut | | ------------------------------- | -------------- | -------------- | ----------------- | | `gemini-3.1-pro-preview` | \$2.00 | \$12.00 | Aperçu | | `gemini-3-flash-preview` | \$0.50 | \$3.00 | Aperçu | | `gemini-3.1-flash-lite-preview` | \$0.25 | \$1.50 | Aperçu (mar 2026) | | `gemini-2.5-pro` | \$1.25 | \$10.00 | GA Stable | | `gemini-2.5-flash` | \$0.30 | \$2.50 | GA Stable | | `gemini-2.5-flash-lite` | \$0.10 | \$0.40 | GA Stable | ```bash theme={null} # .env — Gemini (stable) LLM_API_KEY=AIza... LLM_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai/ LLM_MODEL=gemini-2.5-pro FAST_LLM_MODEL=gemini-2.5-flash LLM_REASONING_EFFORT=medium ``` ```bash theme={null} # .env — Gemini (latest preview) LLM_API_KEY=AIza... LLM_BASE_URL=https://generativelanguage.googleapis.com/v1beta/openai/ LLM_MODEL=gemini-3.1-pro-preview FAST_LLM_MODEL=gemini-3-flash-preview LLM_REASONING_EFFORT=medium ``` *** ### DeepSeek DeepSeek offre le meilleur rapport coût/performance du marché. V3.2 (décembre 2025) a unifié les lignées de chat et de raisonnement en un seul modèle, avec une tarification incroyablement basse. **ID de modèles** (tous deux soutenus par V3.2) : * `deepseek-chat` — usage général (mode non-thinking) * `deepseek-reasoner` — mode de raisonnement chaîne de pensée, retourne `reasoning_content` **URL de base :** `https://api.deepseek.com` **Tarification :** $0.28/$0.42 par MTok (cache hit : \$0.028) — de loin l'API frontier-class la moins chère. **Limites de sortie :** la sortie maximale de `deepseek-chat` est de 8K tokens (doit être défini explicitement via `max_tokens`). La sortie maximale de `deepseek-reasoner` est de 64K tokens (inclut la chaîne de pensée). > **V4 attendue avril 2026** : modèle multimodal avec paramètres en trillions et fenêtre de contexte de 1M. Attendez-vous à de nouveaux ID de modèles lors de son lancement. ```bash theme={null} # .env — DeepSeek (budget-friendly) LLM_API_KEY=sk-... LLM_BASE_URL=https://api.deepseek.com LLM_MODEL=deepseek-chat FAST_LLM_MODEL=deepseek-chat ``` ```bash theme={null} # .env — DeepSeek (with reasoning) LLM_API_KEY=sk-... LLM_BASE_URL=https://api.deepseek.com LLM_MODEL=deepseek-reasoner FAST_LLM_MODEL=deepseek-chat ``` *** ### Modèles nationaux chinois Tous les principaux fournisseurs de modèles chinois exposent des points de terminaison compatibles avec OpenAI. Ceux-ci sont particulièrement performants pour les tâches en langue chinoise et offrent des tarifs locaux compétitifs. #### Qwen / 通义千问 (Alibaba Cloud) Qwen 3.5 (février 2026) est la dernière génération — le flagship MoE 397B surpasse GPT-5.2 sur MMLU-Pro. Support de la langue chinoise le plus fort et tarification de classe frontière la moins chère (\~\$0.11/MTok en entrée). * **URL de base (Chine) :** `https://dashscope.aliyuncs.com/compatible-mode/v1` * **URL de base (Global) :** `https://dashscope-intl.aliyuncs.com/compatible-mode/v1` * **Principal :** `qwen3.5-plus` (flagship, contexte 1M, $0.11/$0.66 par MTok) ou `qwen3-max` (256K, le plus puissant) * **Rapide :** `qwen3.5-flash` ($0.055/$0.22 par MTok) ou `qwen-turbo` ($0.04/$0.08 par MTok) * **Raisonnement :** `qwen3-max` avec paramètre `enable_thinking: true` (il n'y a pas d'ID de modèle `qwen3-max-thinking` séparé) ```bash theme={null} # .env — Qwen (China) LLM_API_KEY=sk-... LLM_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1 LLM_MODEL=qwen3.5-plus FAST_LLM_MODEL=qwen3.5-flash ``` ```bash theme={null} # .env — Qwen (Global) LLM_API_KEY=sk-... LLM_BASE_URL=https://dashscope-intl.aliyuncs.com/compatible-mode/v1 LLM_MODEL=qwen3.5-plus FAST_LLM_MODEL=qwen3.5-flash ``` #### ChatGLM / 智谱 GLM-4.7 et GLM-5 (2026) sont les derniers modèles. GLM-5 est le flagship MoE 745B approchant le niveau Claude Opus sur les tâches de codage/agent. * **URL de base (Domestique) :** `https://open.bigmodel.cn/api/paas/v4` * **URL de base (Z.AI International) :** `https://api.z.ai/api/paas/v4` * **Principal :** `glm-4.7` (codage puissant, $0.60/$2.20 sur Z.AI) * **Rapide :** `glm-4.7-flash` (niveau gratuit !) ou `glm-4.7-flashx` ($0.07/$0.40, débit plus élevé) * **Raisonnement :** `glm-5` (flagship MoE 745B, $1.00/$3.20) Le `tool_choice` forcé n'est pas supporté — seul `"auto"` fonctionne. Certains clients HTTP ajoutent automatiquement `/v1` aux URL de base. Zhipu utilise `/v4` — assurez-vous que votre client ne force pas un suffixe de chemin de style OpenAI ou vous obtiendrez des erreurs 404. ```bash theme={null} # .env — ChatGLM (domestic) LLM_API_KEY=... LLM_BASE_URL=https://open.bigmodel.cn/api/paas/v4 LLM_MODEL=glm-4.7 FAST_LLM_MODEL=glm-4.7-flash ``` ```bash theme={null} # .env — ChatGLM (Z.AI international) LLM_API_KEY=... LLM_BASE_URL=https://api.z.ai/api/paas/v4 LLM_MODEL=glm-4.7 FAST_LLM_MODEL=glm-4.7-flash ``` #### MiniMax MiniMax M2.7 (18 mars 2026) est le dernier modèle, open-weight et obtient 80,2% sur SWE-Bench. M2.5 reste disponible comme option rapide/économique. MiniMax fournit deux points de terminaison API distincts pour différentes régions : * **URL de base (Global/海外版) :** `https://api.minimax.io/v1` -- pour les utilisateurs en dehors de la Chine continentale * **URL de base (China/国内版) :** `https://api.minimaxi.com/v1` -- pour les utilisateurs en Chine continentale (notez le `i` supplémentaire dans `minimaxi`) * **Principal :** `MiniMax-M2.7` * **Rapide :** `MiniMax-M2.5` * **Vitesse :** `MiniMax-M2.7-highspeed` (coût 2x, latence inférieure) | Modèle | Entrée \$/MTok | Sortie \$/MTok | | ------------------------ | -------------- | -------------- | | `MiniMax-M2.7` | \$0.30 | \$1.20 | | `MiniMax-M2.7-highspeed` | \$0.60 | \$2.40 | | `MiniMax-M2.5` | \$0.30 | \$1.20 | | `MiniMax-M2.5-highspeed` | \$0.60 | \$2.40 | ```bash theme={null} # .env — MiniMax (global endpoint) LLM_API_KEY=... LLM_BASE_URL=https://api.minimax.io/v1 LLM_MODEL=MiniMax-M2.7 FAST_LLM_MODEL=MiniMax-M2.5 ``` ```bash theme={null} # .env — MiniMax (China mainland endpoint) LLM_API_KEY=... LLM_BASE_URL=https://api.minimaxi.com/v1 LLM_MODEL=MiniMax-M2.7 FAST_LLM_MODEL=MiniMax-M2.5 ``` #### Kimi / 月之暗面 (Moonshot) Kimi K2.5 (janvier 2026) dispose d'un contexte de 256K et de performances de codage solides (76,8% SWE-Bench parmi les modèles open-source). * **URL de base (Global) :** `https://api.moonshot.ai/v1` * **URL de base (Chine) :** `https://api.moonshot.cn/v1` * **Principal :** `kimi-k2.5` * **Rapide :** `kimi-k2` (sans réflexion, l'appel de fonction fonctionne) * **Raisonnement :** `kimi-k2-thinking` ($0.47/$2.00 par MTok) Le forçage de `tool_choice` ne fonctionne que lorsque le mode de réflexion est désactivé. Lorsque la réflexion est activée, seul `"auto"` est supporté. ```bash theme={null} # .env — Kimi (Global) LLM_API_KEY=... LLM_BASE_URL=https://api.moonshot.ai/v1 LLM_MODEL=kimi-k2.5 FAST_LLM_MODEL=kimi-k2 ``` ```bash theme={null} # .env — Kimi (China) LLM_API_KEY=... LLM_BASE_URL=https://api.moonshot.cn/v1 LLM_MODEL=kimi-k2.5 FAST_LLM_MODEL=kimi-k2 ``` *** ### Modèles locaux (Ollama) Exécutez des modèles entièrement sur votre propre matériel — aucune clé API nécessaire, entièrement hors ligne. Ollama expose un point de terminaison compatible OpenAI prêt à l'emploi. Le paysage open-source a changé de manière spectaculaire — Qwen 3.5, Llama 4 et GPT-OSS (les premiers modèles à poids ouvert d'OpenAI) sont tous disponibles. **URL de base :** `http://localhost:11434/v1` **Modèles recommandés par VRAM :** | VRAM | LLM principal | LLM rapide | Notes | | ------ | --------------------------------- | ------------- | ------------------------------------------------ | | 8 GB | `qwen3.5:9b` / `gemma3:4b` | `qwen3.5:4b` | Qwen 3.5 9B est le meilleur à ce niveau | | 16 GB | `gpt-oss:20b` / `deepseek-r1:14b` | `qwen3.5:9b` | GPT-OSS 20B est optimisé pour les agents | | 24 GB | `qwen3:32b` / `deepseek-r1:32b` | `qwen3.5:9b` | Qwen 3 32B est le meilleur pour l'appel d'outils | | 48 GB+ | `llama3.3:70b` / `gpt-oss:120b` | `qwen3.5:14b` | Qualité proche de la frontière | **Meilleur pour l'appel d'outils :** Qwen 3/3.5 (32B+), GLM-4.7, GPT-OSS, Mistral — ces modèles ont un entraînement explicite pour l'appel de fonctions. Les modèles avec 14B+ paramètres sont le minimum pour un appel d'outils fiable ; 32B+ est fortement recommandé. **La qualité de l'appel d'outils varie considérablement selon les modèles locaux.** Tous les modèles ne génèrent pas de manière fiable des appels de fonction valides. Testez votre modèle choisi avec des flux de travail d'agents avant d'utiliser en production. La règle générale : 14B minimum, 32B+ recommandé pour les tâches d'agents. ```bash theme={null} # .env — Ollama (balanced, 16GB VRAM) LLM_API_KEY=ollama LLM_BASE_URL=http://localhost:11434/v1 LLM_MODEL=gpt-oss:20b FAST_LLM_MODEL=qwen3.5:9b LLM_CONTEXT_SIZE=32768 LLM_MAX_OUTPUT_TOKENS=8192 ``` ```bash theme={null} # .env — Ollama (agent-optimized, 24GB VRAM) LLM_API_KEY=ollama LLM_BASE_URL=http://localhost:11434/v1 LLM_MODEL=qwen3:32b FAST_LLM_MODEL=qwen3.5:9b LLM_CONTEXT_SIZE=32768 LLM_MAX_OUTPUT_TOKENS=8192 ``` *** ## Plateformes de relais tiers De nombreux utilisateurs accèdent à plusieurs fournisseurs de modèles via un seul service de relais (proxy). FIM One détecte automatiquement le protocole API correct en fonction des modèles de chemin d'URL — il suffit de remplir `LLM_BASE_URL` et cela fonctionne. ### Fonctionnement Lorsque votre URL de base pointe vers un relais tiers, FIM One inspecte le chemin d'accès de l'URL pour déterminer le protocole à utiliser : | Le chemin d'accès URL contient | Protocole détecté | En-tête d'authentification | Avantage clé | | -------------------------------- | ----------------- | -------------------------- | ---------------------------------------------------------- | | `/v1` (ou aucune correspondance) | Compatible OpenAI | `Authorization: Bearer` | Secours universel, fonctionne avec la plupart des relais | | `/claude` ou `/anthropic` | Anthropic natif | `x-api-key` | Support complet de `reasoning_content` (extended thinking) | | `/gemini` | Google natif | `x-goog-api-key` | Traduction native des paramètres Gemini | **Ordre de résolution :** Champ de fournisseur DB explicite > correspondance de domaine (API officielles) > indice de chemin d'accès URL (plateformes de relais) > secours compatible OpenAI. ### Exemple : Un relais, trois protocoles Avec un seul compte relais, vous pouvez accéder à différents fournisseurs en changeant simplement le chemin d'URL de base : ```bash theme={null} # .env — Claude via relay (Anthropic native protocol) LLM_API_KEY=your-relay-key LLM_BASE_URL=https://relay.example.com/anthropic LLM_MODEL=claude-sonnet-4-6 ``` ```bash theme={null} # .env — Gemini via relay (Google native protocol) LLM_API_KEY=your-relay-key LLM_BASE_URL=https://relay.example.com/gemini LLM_MODEL=gemini-2.5-pro ``` ```bash theme={null} # .env — GPT via relay (OpenAI compatible protocol) LLM_API_KEY=your-relay-key LLM_BASE_URL=https://relay.example.com/v1 LLM_MODEL=gpt-5.4 ``` Aucune configuration supplémentaire nécessaire — les en-têtes d'authentification, les formats de paramètres et l'analyse des réponses changent automatiquement. ### Étape par étape : Comment fonctionne la détection de chemin Voici un exemple concret montrant ce qui se passe en interne lorsque vous configurez un relais : ```bash theme={null} # .env — Claude via a relay platform LLM_API_KEY=your-relay-key LLM_BASE_URL=https://my-relay.example.com/claude LLM_MODEL=claude-sonnet-4-6 LLM_REASONING_EFFORT=medium ``` 1. FIM One détecte `/claude` dans le chemin URL → détecte le protocole **natif Anthropic** 2. Le modèle est préfixé comme `anthropic/claude-sonnet-4-6` pour le routage LiteLLM 3. Les requêtes utilisent le format `/v1/messages` d'Anthropic avec l'en-tête d'authentification `x-api-key` 4. `reasoning_effort=medium` est traduit en paramètre natif Anthropic `thinking` (pas le `reasoning_effort` d'OpenAI) Si l'URL du relais était `https://my-relay.example.com/v1` à la place, l'indice `/claude` serait manquant — FIM One reviendrait au protocole compatible OpenAI, envoyant des requêtes `/v1/chat/completions` à un point de terminaison natif Claude, ce qui échouerait. **Le chemin URL est important.** ### Pourquoi cela importe * **Point de terminaison natif Anthropic** vous donne un support approprié de `reasoning_content` (extended thinking visible dans l'interface utilisateur), un format correct d'appel d'outils, et une authentification `x-api-key` — des fonctionnalités perdues lors de l'utilisation de la traduction compatible OpenAI. * **Point de terminaison natif Google** vous donne des paramètres Gemini natifs et une authentification `x-goog-api-key`. * **Compatible OpenAI** est le recours universel et fonctionne avec n'importe quel relais, mais les fonctionnalités spécifiques au fournisseur (comme la sortie extended thinking) peuvent ne pas être disponibles. Si votre plateforme de relais utilise des conventions de chemin non standard (par exemple, pas de `/claude` ou `/anthropic` dans l'URL), FIM One revient au protocole compatible OpenAI — qui fonctionne pour la plupart des cas d'usage. Pour un support complet du protocole natif, vous pouvez définir explicitement le champ `provider` via l'interface utilisateur de configuration du modèle admin. Les relais échouent également de manière qu'un fournisseur direct ne le ferait pas, et la plupart de ces défaillances sont silencieuses : un paramètre supprimé, un point de rupture de cache retiré, un flux mis en mémoire tampon qui ne génère jamais d'erreur. La liste symptôme par symptôme se trouve dans [Relais/proxy gotchas](/architecture/llm-provider-guide#relayproxy-gotchas). **Les relais sont au mieux des efforts.** Le comportement documenté de FIM One est garanti pour les points de terminaison de première partie, c'est-à-dire OpenAI, Anthropic, Google et d'autres fournisseurs servant directement leurs propres modèles. Les relais fonctionnent et sont largement utilisés, y compris pour les modèles qui ne sont accessibles que de cette façon, mais ce qu'un relais fait à une requête échappe à notre contrôle, donc ils ne portent aucune garantie. Rien n'est bloqué par nom d'hôte : la capacité est sondée par point de terminaison, et le comportement non supporté revient de lui-même. Avant de signaler un bug au niveau du modèle, reproduisez-le par rapport au point de terminaison de première partie. ## Stratégie de Configuration ### Principal vs Rapide : Quand diviser * **Diviser** quand votre modèle principal est coûteux ou lent (par exemple, `gpt-5.4` + `gpt-5.4-nano`). Le mode DAG exécute de nombreuses étapes en parallèle — utiliser un modèle rapide moins cher permet d'économiser des coûts significatifs. * **Même modèle** quand votre modèle est déjà bon marché (par exemple, `deepseek-chat` pour les deux). La surcharge de gestion de deux modèles n'en vaut pas la peine. ### Quand activer le raisonnement * **Activer** pour les tâches analytiques complexes, la planification multi-étapes et les tâches nécessitant un jugement prudent * **Désactiver** (par défaut) pour les tâches de routine, les Q\&R simples et les déploiements sensibles aux coûts * Le raisonnement augmente généralement le coût de 2 à 5 fois par requête — l'effort `medium` est un bon point de départ ### Dimensionnement de la fenêtre de contexte Définissez `LLM_CONTEXT_SIZE` pour correspondre à la fenêtre réelle de votre modèle : | Modèle | Fenêtre de contexte | | ----------------- | ------------------------ | | GPT-5.4 | 1,050K (surcharge >272K) | | o3 / o4-mini | 200K | | Claude Opus 4.6 | 1M | | Claude Sonnet 4.6 | 1M | | Claude Haiku 4.5 | 200K | | Gemini 2.5 Pro | 1M | | Gemini 3.1 Pro | 1M | | DeepSeek V3.2 | 128K | | Qwen 3.5 Plus | 1M | | Local (Ollama) | 4K–128K (varie) | Pour les modèles locaux, définissez explicitement `LLM_CONTEXT_SIZE` et `LLM_MAX_OUTPUT_TOKENS` — les valeurs par défaut supposent des fenêtres de contexte à l'échelle du cloud que les modèles locaux ne peuvent pas supporter.