Passer au contenu principal
FIM One est agnostique du fournisseur — n’importe quel endpoint 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.

​
Comment FIM One utilise les modèles

FIM One dispose de deux emplacements de modèles :
EmplacementVariable d’environnementUtilisé pour
LLM principalLLM_MODELPlanification, analyse, agent ReAct, raisonnement complexe
LLM rapideFAST_LLM_MODELExécution des étapes DAG, compaction de contexte (moins cher, plus rapide)
Si FAST_LLM_MODEL n’est pas défini, il revient à LLM_MODEL. Pour les déploiements en production, la division en deux modèles offre le meilleur équilibre coût/qualité.

​
Matrice de sélection rapide

FournisseurLLM principalLLM rapideRaisonnementNotes
OpenAIgpt-5.4 / o3gpt-5-mini / gpt-5-nano✅ reasoning_effortMeilleur appel d’outils natif ; GPT-5.4 est le dernier modèle phare
Anthropicclaude-sonnet-4-6claude-haiku-4-5✅ via LiteLLMRoutage API natif ; support complet de reasoning_content
Google Geminigemini-2.5-pro / gemini-3.1-pro-previewgemini-2.5-flash / gemini-3-flash-preview✅ reasoning_effort2.5 est GA stable ; 3.x est en aperçu
DeepSeekdeepseek-chat (V3.2)deepseek-chat✅ deepseek-reasonerMeilleur rapport coût/performance ; V4 imminent
Qwen (Alibaba)qwen3.5-plus / qwen3-maxqwen-turbo✅ qwen3-max-thinkingSupport de la langue chinoise le plus robuste
ChatGLM (Zhipu)glm-5glm-4-flash❌GLM-5 est MoE 744B ; niveau gratuit sur glm-4-flash
MiniMaxMiniMax-M2.5MiniMax-M2.5-Lightning❌Poids ouvert, codage robuste (80,2% SWE-Bench)
Kimi (Moonshot)kimi-k2.5kimi-k2.5❌Contexte 256K, codage robuste
Ollama (local)qwen3.5 / llama4qwen3.5:9b❌Entièrement hors ligne, pas de clé API

​
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é de l’agent. 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 modèle phare, mars 2026 — utilisation informatique intégrée) ou o3 (meilleure précision de raisonnement)
  • Rapide : gpt-5-mini (0.25/0.25/2.00 par MTok) ou gpt-5-nano (le moins cher à 0.05/0.05/0.40 par MTok)
  • Hérité : gpt-4.1 (toujours dans l’API, contexte 1M, bon pour le codage) — retiré de ChatGPT février 2026
Raisonnement : Définissez LLM_REASONING_EFFORT=medium — fonctionne nativement avec les modèles de la série o et GPT-5.x. La série o nécessite max_completion_tokens au lieu de max_tokens, que LiteLLM gère automatiquement. Remarque : GPT-5.x ne supporte pas reasoning_effort combiné avec tool-calling dans /v1/chat/completions — FIM One le supprime silencieusement lors des étapes d’utilisation d’outils de l’agent pour que les workflows s’exécutent sans interruption. GPT-5.x supporte également uniquement temperature=1 — FIM One gère cela automatiquement via le filtrage des paramètres de LiteLLM (drop_params).
ModèleEntrée $/MTokSortie $/MTokContexte
gpt-5.4$2.50$15.00272K
o3$2.00$8.00200K
o4-mini$1.10$4.40200K
gpt-5-mini$0.25$2.00—
gpt-5-nano$0.05$0.40—
# .env — OpenAI (production avec raisonnement)
LLM_API_KEY=sk-...
LLM_BASE_URL=https://api.openai.com/v1
LLM_MODEL=gpt-5.4
FAST_LLM_MODEL=gpt-5-nano
LLM_REASONING_EFFORT=medium

# .env — OpenAI (raisonnement budgétaire)
LLM_API_KEY=sk-...
LLM_BASE_URL=https://api.openai.com/v1
LLM_MODEL=o3
FAST_LLM_MODEL=gpt-5-nano
LLM_REASONING_EFFORT=medium

​
Anthropic (Claude)

Claude excelle dans le raisonnement nuancé et les tâches complexes multi-étapes. FIM One se connecte via LiteLLM, qui achemine les modèles Anthropic via leur API native automatiquement. La génération actuelle est Claude 4.6 (février 2026). Modèles recommandés :
  • Principal : claude-sonnet-4-6 (meilleur équilibre entre capacité et coût — 3/3/15 par MTok)
  • Rapide : claude-haiku-4-5 (rapide et bon marché — 1/1/5 par MTok)
  • Premium : claude-opus-4-6 (le plus capable, sortie max 128K — 5/5/25 par MTok)
URL de base : https://api.anthropic.com/v1/ Tous les modèles Claude actuels supportent la réflexion étendue et ont une fenêtre de contexte de 200K (1M en bêta). Raisonnement : Définissez LLM_REASONING_EFFORT=medium — LiteLLM achemine les modèles Anthropic via l’API native, donc reasoning_content (réflexion étendue) est entièrement retourné et visible dans l’étape « thinking » de l’interface utilisateur. Lorsque la réflexion étendue est activée, Anthropic nécessite temperature=1 — définissez LLM_TEMPERATURE=1 dans votre .env ou configuration de modèle. Voir Extended Thinking pour plus de détails. 
# .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 saut — Gemini 3 Flash surpasse 2.5 Pro tout en étant 3 fois plus rapide. 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) — meilleures performances, mais statut 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 directement.
ModèleEntrée $/MTokSortie $/MTokStatut
gemini-3.1-pro-preview$2.00$12.00Aperçu
gemini-3-flash-preview$0.50$3.00Aperçu
gemini-2.5-pro$1.25$10.00Stable GA
gemini-2.5-flash$0.30$2.50Stable GA
gemini-2.5-flash-lite$0.10$0.40Stable GA
# .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

# .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èle (tous deux soutenus par V3.2) :
  • deepseek-chat — usage général (mode sans réflexion)
  • 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/0,42 par MTok (cache hit : 0,028 $) — de loin l’API de classe frontière la moins chère.
V4 est imminent (mars 2026) : modèle multimodal de trillion de paramètres avec fenêtre de contexte de 1M. Attendez-vous à de nouveaux ID de modèle lors de son lancement. 
# .env — DeepSeek (économique)
LLM_API_KEY=sk-...
LLM_BASE_URL=https://api.deepseek.com
LLM_MODEL=deepseek-chat
FAST_LLM_MODEL=deepseek-chat

# .env — DeepSeek (avec raisonnement)
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.
  • URL de base : https://dashscope.aliyuncs.com/compatible-mode/v1
  • International : https://dashscope-intl.aliyuncs.com/compatible-mode/v1
  • Principal : qwen3.5-plus (flagship, contexte 1M) ou qwen3-max (trillion-param)
  • Rapide : qwen-turbo (rapide et bon marché)
  • Raisonnement : qwen3-max-thinking (comparable à GPT-5.2-Thinking)
# .env — Qwen
LLM_API_KEY=sk-...
LLM_BASE_URL=https://dashscope.aliyuncs.com/compatible-mode/v1
LLM_MODEL=qwen3.5-plus
FAST_LLM_MODEL=qwen-turbo

​
ChatGLM / 智谱

GLM-5 (2026) est le dernier modèle phare — 744B paramètres totaux (40B actifs), approchant le niveau de Claude Opus sur les tâches de codage et d’agent.
  • URL de base : https://open.bigmodel.cn/api/paas/v4
  • Principal : glm-5 (modèle phare)
  • Rapide : glm-4-flash (niveau gratuit disponible !)
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.
# .env — ChatGLM
LLM_API_KEY=...
LLM_BASE_URL=https://open.bigmodel.cn/api/paas/v4
LLM_MODEL=glm-5
FAST_LLM_MODEL=glm-4-flash

​
MiniMax

MiniMax M2.5 (février 2026) est open-weight et obtient 80,2% sur SWE-Bench.
  • URL de base (Chine) : https://api.minimaxi.com/v1
  • URL de base (Global) : https://api.minimax.io
  • Principal : MiniMax-M2.5
  • Rapide : MiniMax-M2.5-Lightning
# .env — MiniMax
LLM_API_KEY=...
LLM_BASE_URL=https://api.minimaxi.com/v1
LLM_MODEL=MiniMax-M2.5
FAST_LLM_MODEL=MiniMax-M2.5-Lightning

​
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 : https://api.moonshot.ai/v1
  • Modèle : kimi-k2.5
# .env — Kimi
LLM_API_KEY=...
LLM_BASE_URL=https://api.moonshot.ai/v1
LLM_MODEL=kimi-k2.5
FAST_LLM_MODEL=kimi-k2.5

​
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 :
VRAMLLM principalLLM rapideNotes
8 GBqwen3.5:9b / gemma3:4bqwen3.5:4bQwen 3.5 9B est le meilleur choix à ce niveau
16 GBgpt-oss:20b / deepseek-r1:14bqwen3.5:9bGPT-OSS 20B est optimisé pour les agents
24 GBqwen3:32b / deepseek-r1:32bqwen3.5:9bQwen 3 32B est le meilleur pour l’appel d’outils
48 GB+llama3.3:70b / gpt-oss:120bqwen3.5:14bQualité 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.
# .env — Ollama (équilibré, 16 Go de 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

# .env — Ollama (agent-optimisé, 24 Go de 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 contientProtocole détectéEn-tête d’authentificationAvantage clé
/v1 (ou aucune correspondance)Compatible OpenAIAuthorization: BearerSecours universel, fonctionne avec la plupart des relais
/claude ou /anthropicNatif Anthropicx-api-keySupport complet de reasoning_content (réflexion étendue)
/geminiNatif Googlex-goog-api-keyTraduction 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 de l’URL de base :

​
.env — Claude via relay (protocole natif Anthropic)

LLM_API_KEY=your-relay-key LLM_BASE_URL=https://relay.example.com/anthropic LLM_MODEL=claude-sonnet-4-6 

```bash
# .env — Gemini via relay (protocole natif Google)
LLM_API_KEY=your-relay-key
LLM_BASE_URL=https://relay.example.com/gemini
LLM_MODEL=gemini-2.5-pro

# .env — GPT via relay (protocole compatible OpenAI)
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 basculent 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 :

​
.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 voit `/claude` dans le chemin URL → détecte le protocole **Anthropic natif**
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'authentification par en-tête `x-api-key`
4. `reasoning_effort=medium` est traduit en paramètre natif `thinking` d'Anthropic (et non en `reasoning_effort` d'OpenAI)

<Warning>
Si la même URL de relais était `https://my-relay.example.com/v1` à la place, l'indice `/claude` serait absent — 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.**
</Warning>

### Pourquoi c'est important

- **Point de terminaison natif Anthropic** vous donne un support approprié de `reasoning_content` (la réflexion étendue visible dans l'interface utilisateur), le format correct d'appel d'outils, et l'authentification `x-api-key` — des fonctionnalités perdues lors de l'utilisation de la traduction compatible OpenAI.
- **Point de terminaison natif Google** vous donne les paramètres natifs de Gemini et l'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 de réflexion étendue) peuvent ne pas être disponibles.

<Note>
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 le champ `provider` explicitement via l'interface utilisateur de configuration du modèle administrateur.
</Note>

## 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-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 importants.
- **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&A 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 | 272K |
| o3 / o4-mini | 200K |
| Claude Sonnet 4.6 | 200K (1M bêta) |
| 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 à la fois `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.