# GateLLM — Passerelle LLM d’entreprise auto-hébergée

> Environ 1/7 du coût, à charge de travail égale. Une passerelle LLM (passerelle IA) fiable, conforme et auto-hébergée qui orchestre les modèles fermés de pointe aux côtés des modèles SOTA ouverts — planification sur les modèles de pointe, exécution sur la SOTA ouverte.

Canonique: https://www.gatellm.io/fr/

## Des modèles de pointe planifient. La SOTA ouverte exécute. Environ 1/7 du coût.
Les modèles les plus performants prennent en charge la planification ; les modèles SOTA ouverts assurent les 90 % des tâches routinières. La composition ramène la facture à ~1/7 — les chiffres sont calculés en direct dans le calculateur, pas affirmés ici.
```
from openai import OpenAI

# One line change: point your SDK at your own gateway
client = OpenAI(
    base_url="https://your-gateway.gatellm.io/v1",
    api_key="your-gateway-api-key",
)

# Existing code unchanged — the gateway routes each request
# to the right model tier (planning vs execution) per your console policy
resp = client.chat.completions.create(
    model="claude-opus-5",  # or claude-sonnet-5, gpt-6-astra, deepseek-flash...
    messages=[{"role": "user", "content": "Plan the architecture"}],
)
```
Mélangez les modèles : Claude Opus planifie, DeepSeek / Qwen exécutent — ~1/7 du coût, jusqu’à 90 % moins cher

La passerelle décide quel modèle s’exécute réellement : quelle que soit la configuration du client, le modèle d’arrivée est celui fixé par les admins — liste d’autorisation en entrée + correspondance générique « * »

Un seul protocole suffit : parlez OpenAI ou Anthropic et atteignez les modèles des quatre familles de protocoles de chat (OpenAI / Anthropic / Gemini / DashScope) — changer de modèle ne touche jamais votre code

Les données restent sur site : entièrement auto-hébergé, les prompts ne nous parviennent jamais ; identifiants et données personnelles détectés sur le chemin de la requête — journaliser / masquer / bloquer selon la portée

## Trois choses que la passerelle fait et qu’un modèle seul ne peut pas faire
Mélangez les modèles pour réduire les coûts, imposez celui qui s’exécute réellement et gardez le code client sur un seul protocole.
### Mélanger les modèles plutôt que d’exécuter le plus cher partout
Les modèles de pointe (Claude Opus) planifient et raisonnent ; les modèles SOTA ouverts (DeepSeek / Qwen / GLM) assurent l’exécution courante. Avec le mélange par défaut, la facture est d’environ 1/7, avec ~97 % des capacités conservées sur les tâches d’exécution courantes — calculé en direct dans le calculateur, non affirmé ici.
- Mode plan détecté par requête — aucun changement côté client
- Paliers attribués par groupe de clés ou identité
- Attribution des coûts et plafonds budgétaires par mode
### La passerelle décide quel modèle s’exécute réellement
Quel que soit le modèle configuré par un développeur, la requête est normalisée à l’arrivée. Les noms hors liste d’autorisation reçoivent un 403 ; une correspondance générique « * » réécrit tout le reste vers le modèle autorisé. Correspondances et règles sont rechargées à chaud — aucun déploiement par développeur.
- La liste d’autorisation du groupe de clés filtre les noms de modèles en entrée
- La correspondance générique fixe le modèle d’arrivée
- Chaque requête journalise le modèle d’arrivée réel (balise SW pour les bascules par script, MM pour les correspondances d’identité)
### Écrivez le client une fois, changez de backend librement
Votre application parle un seul protocole — OpenAI ou Anthropic. La passerelle traduit entre les quatre familles de protocoles de chat (OpenAI / Anthropic / Gemini / DashScope) et normalise le streaming, les appels d’outils et les autres différences de capacités : ajouter un fournisseur ou un modèle ne touche jamais le code métier.
- De tout vers tout entre les quatre familles de protocoles de chat
- Les clients Anthropic uniquement (Claude Code, claude-code-action) peuvent exécuter les modèles d’autres fournisseurs
- 15 formes de protocoles amont au-delà des quatre familles, documentées dans la matrice d’interopérabilité

Intégré à plus de 100 fournisseurs de LLM · plus de 30 SDK et frameworks

## Vérifiez par vous-même
Nous publions les documents au lieu de vous demander de nous croire sur parole. Chaque affirmation de cette page est étayée par des pièces que vous pouvez consulter avant même de nous parler.

### [Sécurité et conformité](https://www.gatellm.io/fr/security.md)
Architecture, gestion des clés et modèle d’isolation.

### [Questionnaire de sécurité](https://www.gatellm.io/trust.md)
Réponses CAIQ / SIG / VSA, dûment remplies.

### [Liste des sous-traitants](https://www.gatellm.io/subprocessors.md)
Chaque tiers susceptible d’accéder à vos données.

### [Réponse aux incidents et support](https://www.gatellm.io/sla.md)
Objectifs de réponse et engagements de support.

## Une seule interface, tous les modèles combinables
Du simple routage de modèles à l’orchestration multi-modèles, GateLLM offre des capacités complètes de niveau entreprise.
### Routage multi-modèles
Une seule interface pour appeler tous les modèles. Repli intelligent, répartition de charge, nouvelle tentative automatique.
- API unifiée pour plus de 100 fournisseurs de LLM
- Routage de repli intelligent
- Répartition de charge et limitation de débit
- Mutualisation des clés amont : un appelant reste sur une clé et bascule vers la suivante en cas d’échec
- Ollama / vLLM / llama.cpp comme amonts compatibles OpenAI, un seul plan de gouvernance
### Composition
Routage par paliers selon le mode plan, l’identité ou la forme de la requête : planification sur les modèles de pointe, exécution sur la SOTA ouverte. La passerelle réécrit le nom du modèle — le code client ne change jamais.
- Détection du mode plan : planification sur les modèles de pointe, exécution sur la SOTA ouverte — aucun changement côté client
- Mappage de modèles par identité : un même nom de modèle → des amonts différents selon le groupe de clés
- Règles switch-route : rediriger les requêtes avec image ou les requêtes spéciales vers le bon modèle
- Rétrogradation dans l’agent : plan verrouillé / rétrogradation automatique hors plan
### Revue de code multi-modèles
Exécutez 2 à 3 modèles en parallèle sur la même PR. La passerelle fournit l’interopérabilité protocolaire et la mesure à clé unique ; la diffusion, la fusion et le score de confiance résident dans l’action d’orchestration open source.
- Interopérabilité protocolaire de la passerelle : les modèles non Anthropic rejoignent les files de revue réservées à Anthropic
- Une seule clé d’accès mesure et gouverne toute la diffusion
- Diffusion, score [Consensus N/M] et fusion dans gatellm-io/gatellm-code-review (côté orchestration)
### Gouvernance des outils MCP
Regroupez les serveurs d’outils MCP externes derrière un point de terminaison /mcp unique : ACL au niveau des outils, budgets de contexte et audit des appels. Les outils qu’un agent peut utiliser relèvent du même plan de permissions que les modèles qu’il peut appeler.
- Plusieurs serveurs MCP derrière un point de terminaison /mcp unique
- Autorisation/refus d’outils par groupe de clés + filtres d’étiquettes
- Récupération BM25 intégrée lorsque la liste d’outils s’allonge
- Pont REST : encapsulez n’importe quelle API REST en outil MCP depuis une spécification simplifiée, sans code
- Appels MCP / violations / sessions entièrement audités
### Injection de recherche web
Donnez la recherche web à chaque modèle, uniformément : la passerelle récupère et injecte les résultats, en synthétisant des blocs de recherche natifs selon le protocole du client — les modèles ouverts bénéficient aussi de l’ancrage par recherche.
- Blocs de recherche natifs par protocole (Anthropic / OpenAI / Responses)
- Bascule à trois positions par modèle, dégradation gracieuse en cas d’échec
- La recherche injectée est exclue de la facturation à l’usage
### Maîtrise des coûts
Gestion des budgets, limitation de débit, imputation des coûts par équipe, politique de modèles selon le mode. Jamais de marge sur les tokens, BYOK avec vos propres clés.
- Imputation des coûts par projet/fonctionnalité
- Alertes de budget progressives
- BYOK : payez les fournisseurs aux tarifs standard
- Politique de modèles selon le mode (plan/exécution, opposable)
### Gouvernance et intégrations
Du contrôle d’accès client à l’intégration CI/CD — étendez les capacités de la passerelle à vos workflows de développement et de collaboration.
- Contrôle d’accès client (politique User-Agent)
- Revue de code GitHub Actions via votre propre passerelle
- Configuration par lots : préparer → prévisualiser l’ensemble des conflits → validation atomique en une transaction
### Complément Office / M365
Utilisez votre propre passerelle de modèles directement dans Excel, Word, PowerPoint et Outlook — complément auto-hébergé, les données ne quittent jamais le réseau, aucune dépendance à un pivot.
- Modélisation financière Excel / revue de contrats Word / boîte de réception Outlook
- SSO Entra + blocage par étiquette Purview
- 33 compétences métier intégrées, extension payante
### Scripts de transformation
Un moteur JavaScript isolé (QuickJS) réécrit le JSON des requêtes et des réponses au niveau de la passerelle. Modifiez dans la console, appliqué en direct — sans redéploiement, sans code de liaison.
- Emplacements avant / après requête + un emplacement réponse : voyez le format client avant traduction ou le format amont après traduction
- context.useModel() bascule toute la route — base_url, protocole et identifiants ensemble
- Bibliothèque intégrée : json_path / str_* / regex_* / array_* / encoding + hash / UUID + time
- Isolé (sans réseau, sans système de fichiers) avec modes fail-open/fail-closed et un testeur de scripts dans la console

## Combinaison de modèles : une qualité qu’aucun modèle seul ne peut offrir
La composition est un modèle natif de la passerelle ; la revue de code multi-modèles est un modèle côté orchestration que la passerelle rend possible — les deux reposent sur la couche de normalisation des capacités.
### Composition : routage par paliers entre modèles
Routez selon le mode plan, l’identité ou la forme de la requête : la planification reste sur les modèles de pointe, l’exécution descend vers la SOTA ouverte. La passerelle réécrit le nom du modèle et traduit les protocoles — le code client ne change jamais.
- Détection du mode plan : planification sur les modèles de pointe, exécution sur la SOTA ouverte — aucun changement côté client
- Mappage de modèles par identité : un même nom de modèle → des amonts différents selon le groupe de clés / l’en-tête
- Règles switch-route : rediriger les requêtes avec image ou les requêtes spéciales vers le bon modèle
- Aucun code de liaison — la traduction des protocoles est assurée par la passerelle
- Politique opposable : les administrateurs verrouillent les paliers de modèles par mode plan/exécution, empêchant tout usage sur les modèles les plus chers
```
// before-slot transform script (JavaScript) — switch execution model by plan mode.
// Mounted on the entry model in the console; runs before routing.
function transform(body, context) {
    if (context.sourceProtocol !== "Anthropic") {
        return body;
    }
    const EXEC_MODEL = "qwen3.8-max"; // a model name configured in the gateway
    const PLAN = /plan mode is active/i;
    const EXIT = /exited plan mode/i;
    // take the last marker-bearing message: later marker wins
    const messages = body.messages || [];
    for (let i = messages.length - 1; i >= 0; i--) {
        const s = JSON.stringify(messages[i].content || "");
        const inPlan = PLAN.test(s);
        const exited = EXIT.test(s);
        if (inPlan || exited) {
            // not in plan mode → switch execution to the cost-efficient model
            if (exited || !inPlan) context.useModel(EXEC_MODEL);
            return body;
        }
    }
    context.useModel(EXEC_MODEL);
    return body;
}
```
### Revue de code multi-modèles (côté orchestration)
La passerelle rend le modèle possible, la couche d’orchestration l’exécute : claude-code-action ne parle que le protocole Anthropic, et l’interopérabilité protocolaire de la passerelle permet à des modèles non Anthropic comme qwen3.8-max et kimi-k3 de rejoindre la file de revue. Une seule clé d’accès à la passerelle mesure uniformément chaque modèle de revue.
- Les annotations de confiance [Consensus N/M], la fusion et la déduplication sont produites par l’action
- Chaque modèle de revue est facturé séparément et agrégé uniformément par la passerelle
- Le seuil sur le nombre de lignes de la PR et la reprise des commentaires historiques sont intégrés à l’action

## Trois étapes vers votre premier token.
Passez d’un modèle unique à l’orchestration multi-modèles en trois étapes, sans réécrire le code métier. N’importe quel SDK (OpenAI / Anthropic / Gemini / DashScope) fonctionne.
### Déployer la passerelle
Lancement Docker en un clic, ou déploiement Kubernetes Helm dans votre environnement privé.
### Configurer les clés
Mode BYOK : saisissez vos clés API de fournisseurs existantes, les données restent sur site et ne sont jamais persistées.
### Remplacer le point de terminaison
Faites pointer le base_url du SDK OpenAI vers GateLLM, appelez tous les modèles avec une interface unifiée.
```
# Just one line change: point base_url to GateLLM
from openai import OpenAI

client = OpenAI(
    base_url="https://your-gateway.gatellm.io/v1",
    api_key="your-gatellm-api-key"
)

# Existing code unchanged, call any model
response = client.chat.completions.create(
    model="claude-opus-5",  # or claude-sonnet-5, gpt-6-astra, deepseek-flash...
    messages=[{"role": "user", "content": "Hello"}]
)
```
## Ou confiez-le à votre agent

Installez et configurez la passerelle GateLLM. Commencez par récupérer en curl le Markdown brut de ce guide d’installation, lisez-le intégralement, puis suivez chaque étape dans l’ordre (les étapes ont des dépendances — par exemple, un groupe de clés doit exister avant une clé d’accès ; ne sautez pas d’étape) :

curl -fsSL https://docs.gatellm.io/en/quickstart/docker-single-node.md

L’agent n’a besoin que d’une chose de votre part : la clé API du fournisseur amont. Il génère le reste, configure tout via l’API Console — sans navigateur — et a terminé dès que la première requête renvoie une complétion.

## Ou exécutez-le vous-même

```bash
docker run -d \
  --name gatellm \
  -p 7890:7890 \
  -e CONSOLE_PASSWORD=change-me-on-first-login \
  -e ENCRYPTION_KEY=REPLACE_WITH_YOUR_ENCRYPTION_KEY \
  -e CONSOLE_SECRET_KEY=REPLACE_WITH_YOUR_CONSOLE_SECRET_KEY \
  -e STORAGE_MODE=sqlite \
  -v gatellm-data:/var/lib/protoflux \
  ghcr.io/gatellm-io/gatellm:latest
```

Remplacez les trois valeurs d’exemple avant l’exécution — le guide explique ce que chacune représente et pourquoi la laisser telle quelle est risqué.

## Gardez le SDK que vous avez déjà. Changez une ligne.
Les mêmes quatre protocoles des deux côtés. Convertissez de n’importe quel format vers n’importe quel autre sans code de liaison, pour le chat, l’image, la parole, la vidéo, la voix en temps réel, l’embedding et le rerank.
### Toutes les modalités
- chat
- image
- parole
- vidéo
- voix en temps réel
- embedding
- rerank

- Entrée native : les SDK OpenAI / Anthropic / Gemini / DashScope se connectent directement, sans autre changement que le base_url
- Sortie native : routage vers n’importe quel fournisseur dans son protocole natif, et non vers une enveloppe OpenAI unifiée retraduite
- Conversion de tout vers tout : entrée A → sortie B de façon transparente (par exemple, un appel via le SDK Anthropic → routé vers un modèle natif DashScope, converti au protocole DashScope)
- Toutes les modalités + embedding/rerank : chat / image / parole / vidéo / voix en temps réel, plus les protocoles embedding et rerank unifiés
- Plus fort que « compatible OpenAI » : synthorai et d’autres proposent trois protocoles d’entrée unifiés vers une seule surface OpenAI ; GateLLM propose quatre entrées + quatre sorties, de tout vers tout
- Surface de protocoles de sortie plus large : au-delà des quatre grandes familles de protocoles, 15 formes de protocoles amont au total (dont AWS Bedrock Converse / Invoke, Realtime, passthrough) — les modèles d’entreprise sur Bedrock et les modèles auto-hébergés se branchent tous sur une seule passerelle
- Sessions de voix en temps réel (/v1/realtime, openai_realtime + dashscope_realtime) mesurées par tour dans le même pipeline de statistiques / facturation / journaux que le HTTP

## Fonctionne avec le SDK que vous avez déjà
Pointez n’importe quel SDK ou framework vers la passerelle en une ligne. OpenAI, Anthropic, Gemini et DashScope se connectent nativement ; LangChain, LlamaIndex, CrewAI, Vercel AI SDK et plus de 30 autres via le même remplacement de base_url.
### Pointer base_url vers la passerelle
Par défaut https://your-gateway.gatellm.io — la présence de /v1 dépend du SDK (chaque exemple donne la valeur exacte).
### Remplacer par une clé d’accès à la passerelle
Ce n’est pas une clé amont sk-… — la même clé d’accès s’insère dans l’en-tête attendu par votre SDK.
### Utiliser le nom de modèle de la passerelle
Celui que vous avez configuré dans la console — pas le nom officiel du fournisseur.
```
# base_url convention differs by SDK — match the one you're using
from openai import OpenAI
OpenAI(base_url="https://your-gateway.gatellm.io/v1")        # OpenAI SDK: /v1

import anthropic
anthropic.Anthropic(base_url="https://your-gateway.gatellm.io")  # Anthropic SDK: root (appends /v1/messages)

# Vercel AI SDK createAnthropic: baseURL ".../v1" (appends /messages) — the reverse
# LangChain ChatOpenAI: base_url="https://your-gateway.gatellm.io/v1"
```
### `Authorization: Bearer <key>`
- SDK / framework: OpenAI · DashScope · générique
- Le préfixe Bearer est insensible à la casse

### `x-api-key: <key>`
- SDK / framework: SDK Anthropic
- Authorization est également accepté

### `x-goog-api-key: <key>`
- SDK / framework: SDK Gemini
- Authorization est également accepté

### SDK officiels des fournisseurs
Les SDK OpenAI / Anthropic / Google se connectent nativement — seul le base_url change

### Natif DashScope
Texte, image, vidéo asynchrone, embedding et rerank via un seul point de terminaison

### SDK et passerelles unifiés
Vercel AI SDK, LiteLLM, Portkey, Semantic Kernel, Spring AI

### Frameworks d’orchestration
LangChain, LlamaIndex, CrewAI, AutoGen, DSPy, Haystack

### SDK d’agents
OpenAI Agents, Claude Agent, Pydantic AI, ADK, Mastra

### Temps réel et audio
Voix WebSocket en temps réel + ASR / TTS openai_audio

### Local / auto-hébergé
Ollama, vLLM, llama.cpp comme amonts — conservez n’importe quel SDK client

### Le nom du modèle doit correspondre à la configuration de la passerelle
Ni le nom officiel du fournisseur, ni l’ID du modèle amont — celui que vous lui avez donné dans la console. Un nom erroné → 404 model_not_found.

### La présence de /v1 dans base_url varie selon le SDK
Le SDK OpenAI prend /v1 ; le SDK Anthropic prend la racine (il ajoute /v1/messages) ; createAnthropic du Vercel AI SDK prend /v1 (il ajoute /messages). Se tromper ajoute ou supprime un segment de chemin.

### Les champs sont traduits et contraints d’un protocole à l’autre
Un max_tokens peut devenir max_output_tokens avec une borne inférieure (par exemple ≥16) lorsque l’amont est un modèle au protocole Responses — une valeur trop petite → 400.

### Les blocs de réflexion sont encapsulés par la passerelle
Le contenu et les signatures de réflexion de Claude / Gemini sont transmis ou supprimés — prenez l’élément type == "text" du tableau content, ne supposez pas que content[0] est du texte.

### Le SDK OpenAI Agents utilise /v1/responses par défaut
Il appelle l’API Responses, pas Chat Completions. Si l’amont est openai (Chat), basculez explicitement avec OpenAIChatCompletionsModel ; si c’est openai_response, un nom de modèle sous forme de chaîne fonctionne tel quel.

### LlamaIndex valide le nom du modèle par rapport à une liste d’autorisation
La classe OpenAI n’accepte que les familles qu’elle reconnaît et rejette les noms personnalisés de passerelle — utilisez OpenAILike (Python) ou déclarez explicitement les informations du modèle.

### CrewAI est piloté par LiteLLM en interne
base_url n’est pas un paramètre du framework — c’est la variable d’environnement OPENAI_API_BASE, et le modèle a besoin du préfixe openai/.

### AutoGen exige un model_info explicite
Les noms de modèles inconnus produisent une erreur sur la liste par défaut — déclarez model_info explicitement pour contourner la vérification.

### Le SDK Google GenAI pointe vers la racine
base_url passe par http_options.base_url (sans /v1) et la clé s’insère dans l’en-tête x-goog-api-key.

## Pointez n’importe quel agent de codage IA vers la passerelle
```
# Every agent is one base_url + one access key away
export ANTHROPIC_BASE_URL="https://your-gateway.gatellm.io"   # Anthropic agents: root (no /v1)
export ANTHROPIC_API_KEY="<gateway access key>"

export OPENAI_API_BASE="https://your-gateway.gatellm.io/v1"   # OpenAI-compatible agents: /v1
export OPENAI_API_KEY="<gateway access key>"

# Codex CLI (~/.codex/config.toml) speaks the Responses protocol
# [model_providers.gatellm]
# base_url = "https://your-gateway.gatellm.io/v1"
# wire_api = "responses"
```
### Agents en terminal
Claude Code, Codex CLI, Gemini CLI, OpenClaw, opencode, Crush, Droid, Goose, Aider, Qwen Code, OpenHands, Kimi Code, Plandex, SWE-agent, Grok Build, Mistral Vibe, MiMo Code, ForgeCode, Codebuff

### IDE et extensions
Cline, Roo Code, Kilo Code, Continue, Zed, Cursor, Windsurf, GitHub Copilot (BYOK)

### Plateformes managées
Warp (clés BYOK uniquement), Amazon Q Developer CLI, Devin — point de terminaison fixe ou non modifiable

### L’outil impose son propre ID de modèle
Claude Code envoie sa valeur par défaut configurée (par exemple claude-opus-5 ou claude-sonnet-5) — pas le nom de votre passerelle. Soit nommez le modèle de la passerelle exactement comme l’outil le demande, soit définissez sa variable d’environnement de modèle (par exemple ANTHROPIC_MODEL) sur votre nom de passerelle. En cas d’incohérence → 404 model_not_found dès le premier message.

### Les outils au protocole Anthropic prennent la racine, pas /v1
L’URL de base des clients de style Anthropic pointe vers la racine de la passerelle (sans /v1) — le client ajoute lui-même /v1/messages. Ajouter /v1 ici double le segment de chemin.

### Les fournisseurs personnalisés Codex exigent wire_api="responses"
Codex CLI impose wire_api = "responses" pour un bloc [model_providers.*] personnalisé. La passerelle implémente /v1/responses nativement — pointez base_url vers elle et définissez env_key sur une clé d’accès à la passerelle.

### Les outils reposant sur LiteLLM veulent un préfixe de modèle openai/
Aider, OpenHands et SWE-agent reposent sur LiteLLM : définissez OPENAI_API_BASE sur la passerelle et donnez au modèle un préfixe openai/ (par exemple openai/gateway-model-name) pour que LiteLLM le route comme un point de terminaison compatible OpenAI.

### Par défaut, c’est l’OAuth d’abonnement, pas votre clé
Codex, Gemini CLI et Qwen Code utilisent par défaut la connexion OAuth / abonnement du fournisseur. Pour router via la passerelle, vous devez passer à l’authentification par clé API (définir explicitement la clé + l’URL de base) — sinon l’agent contourne entièrement la passerelle.

### Les IDE déduisent la prise en charge des outils/vision depuis l’ID de modèle
Cline / Roo / Kilo et d’autres décident de la capacité d’appel d’outils et de vision à partir du nom du modèle. Un nom de passerelle personnalisé peut désactiver l’appel de fonctions — si les appels d’outils échouent, vérifiez les règles de détection de capacités du client ou nommez le modèle comme une famille connue.

### Une inférence longue ajoute :keep-alive et _gateway_warning
Pendant une longue inférence amont, la passerelle émet des lignes de commentaire SSE :keep-alive (inoffensives — ignorez les lignes commençant par :), et en cas de rupture en cours de flux elle insère un champ _gateway_warning au lieu de renvoyer une erreur, afin que des outils comme Claude Code n’interrompent pas toute la conversation.

### Mode auto de Claude Code : décidez qui répond au verdict de sécurité
En mode auto, Claude Code attend un verdict côté serveur (un champ safeguards dans la requête) avant une action potentiellement dangereuse. Lorsque l’amont est Anthropic officiel, le verdict est produit dans la même requête et la passerelle le transmet tel quel. Lorsque l’amont est un tiers qui ignore ce champ, c’est la passerelle qui répond — et la valeur par défaut livrée (allow_all) libère toutes les actions, ce qui est plus permissif que de laisser l’appel intact. Rendez une route à son amont en écrivant "anthropic_server_safeguards": "upstream" dans l’extra_config de cet amont ; le réglage dans la console est réservé aux administrateurs.

## Normalisation des capacités : rendre possible le mélange entre fournisseurs
Le mélange de modèles entre fournisseurs repose sur la couche de normalisation des capacités, qui unifie sept points de couplage afin que changer de modèle n’implique jamais de réécrire du code de liaison.
### Normalisation de l’appel d’outils
OpenAI / Anthropic / Gemini / les modèles chinois ont tous des schémas d’appel d’outils différents. Nous les unifions à la base : écrivez le code une fois, appelez tous les modèles.
### Compatibilité des sorties structurées
Chaque fournisseur utilise des protocoles différents (schéma JSON strict, json_mode, tool_use). Nous unifions vers une interface cohérente.
### Unification de la mise en cache des prompts
cache_control d’Anthropic, mise en cache automatique d’OpenAI, contexte de Gemini — les mécanismes diffèrent. Nous fournissons une stratégie de cache unifiée.
### Adaptation des tokens de raisonnement
Les formats de sortie d’o1 / Claude thinking / DeepSeek R1 diffèrent. Nous nous adaptons au protocole de tokens de raisonnement de chaque fournisseur.
### Prise en charge des formats multimodaux
Les protocoles vision / audio / téléversement de fichiers diffèrent selon les fournisseurs. Nous unifions les formats d’entrée multimodaux.
### Abstraction du modèle de facturation
La structure tarifaire de chaque fournisseur diffère. Nous l’abstrayons derrière une interface unifiée de suivi des coûts.
### Normalisation de la sémantique des erreurs
Les codes et corps d’erreur de chaque fournisseur diffèrent. Nous les normalisons vers un corps d’erreur uniforme, avec z-request-id pour corréler chaque requête de bout en bout.
### Flux de données : reste sur site, jamais persisté
En mode BYOK, les clés API sont stockées uniquement en mémoire de la passerelle, jamais persistées ni transmises. Les requêtes passent par la passerelle directement vers les API officielles des fournisseurs ; les données ne quittent jamais votre réseau privé.
Contrôles SOC 2 alignés

Contrôles ISO 27001 alignés

RGPD

## Pourquoi ~1/7 du coût ?
Prenons une entreprise qui traite 1 milliard de tokens par jour : même charge de travail — comparez la facture « modèles de pointe de bout en bout » et « modèles de pointe pour planifier, modèles ouverts pour exécuter ».
## Trois sources d’économies :
- BYOK sans marge sur les tokens — vous payez les fournisseurs aux tarifs standard, GateLLM ne prend aucune commission (les agrégateurs ajoutent généralement des frais de plateforme et de paiement au prix catalogue) ;
- Composition — les modèles SOTA ouverts (GLM / Qwen / DeepSeek) assurent l’essentiel de l’exécution (classification, extraction, traduction), les modèles fermés de pointe (comme Claude Opus) servent uniquement à la planification et au raisonnement difficile ;
- Mise en cache des prompts — les appels à haute fréquence touchent le cache, le prix unitaire baisse de 50 % à 90 %.
Les chiffres sont des modèles illustratifs fondés sur les tarifs publics ; les économies réelles dépendent des scénarios métier et des ratios de mix. Le tarif de la licence Pro de 400 $/mois (instance unique 2 Go) est inclus dans l’offre GateLLM.

## Un usage visible, un coût imputable, des budgets maîtrisés
Token Ops suit qui utilise quoi ; Token FinOps transforme les tokens en argent facturable et plafonné. Un seul plan de contrôle rend les dépenses IA aussi pilotables que les dépenses cloud.
### Observabilité de l’usage et des coûts
Décomposez chaque appel par modèle, clé d’accès et groupe de clés, avec les tokens d’entrée / de sortie / de cache mesurés séparément à une granularité d’une minute.
- Regroupement par modèle / clé / groupe de clés
- Entrée, sortie et cache mesurés séparément
- Séries temporelles 24 h / 7 j / 30 j / personnalisées
### Admission des clients et piste d’audit
Seuls les clients que vous avez approuvés atteignent la passerelle — autorisez, limitez ou refusez selon le User-Agent. Chaque appel laisse une trace auditable pour la gouvernance des points de terminaison et les preuves de conformité.
- Contrôle d’accès client (politique User-Agent)
- Enregistrements d’appels avec rétention des journaux (Pro et supérieur)
- Intégration audit / DLP (Enterprise)
### API de gestion (contrôle programmatique)
Gérez la passerelle par API : créez / révoquez des clés API, définissez des quotas et des budgets, interrogez l’usage et les coûts, exportez les journaux d’audit — branchez-la sur vos systèmes internes d’exploitation et de facturation.
- Création / révocation programmatique de clés API
- Quotas et budgets via API
- API d’interrogation de l’usage et des coûts
- Export des journaux d’audit
### Votre propre grille tarifaire et des instantanés de prix
Saisissez à la main le prix privé que vous avez négocié : il fait autorité, les actualisations du système ne l’écrasent jamais. Chaque prix couvre une fenêtre de validité : planifiez des baisses à l’avance, et les modifications ne réécrivent jamais le coût historique.
- Le prix privé épinglé prime sur l’automatique et n’est jamais écrasé
- Les instantanés prennent effet par fenêtre temporelle
- Remplir l’historique / planifier des baisses de prix
- Modes de facturation au token · par appel · par seconde
### Allocation par étiquettes et refacturation
Étiquetez les clés et les groupes de clés, puis agrègez l’usage et les coûts par étiquette pour imputer les dépenses de tokens au bon centre de coûts. L’export Excel découpe le grand livre par modèle × clé pour le showback ou la refacturation interne.
- Étiquettes libres sur les clés / groupes de clés
- Agrégation de l’usage et des coûts par étiquette
- Export Excel à 6 feuilles (dont clé × modèle)
- Prêt pour le showback / la refacturation interne
### Quotas et plafonds de coût
Définissez des plafonds de dépense quotidiens et mensuels par clé — évalués indépendamment sur le jour et le mois calendaires UTC, bloqués dès que l’un ou l’autre est atteint. Les quotas héritent de clé → groupe → global, en retenant le plus large entre les groupes.
- Plafonds quotidiens / mensuels, évalués indépendamment
- Héritage clé → groupe → global
- 429 quota_exceeded, Retry-After sur le quota quotidien

## GateLLM vs LiteLLM
Une comparaison vérifiée à la source. GateLLM est seul à proposer plusieurs mécanismes que LiteLLM n’a pas ; les deux partagent une base établie ; quelques points diffèrent par nature. Décidez sur les deux premières couches, pas sur le bruit marketing.
### Seul GateLLM le propose
Mécanismes que LiteLLM n’a pas — la ligne « comment ça marche » figure sous chaque fonctionnalité.
| Fonctionnalité | GateLLM | LiteLLM |
| --- | --- | --- |
| Bascule conditionnelle de modèle | ✓ | ✗ |
| Mélange de modèles / SDK entre protocoles | ✓ | ✗ |
| Validation de configuration en une transaction | ✓ | ✗ |
| Verrou dur des quotas de coût | ✓ | ✗ |
| Facturation résistante aux plantages | ✓ | ✗ |
| Mutualisation de clés amont et liaison persistante | ✓ | ✗ |
| Trois modes de facturation + multidevise | ✓ | ✗ |
| Connexion aux identifiants amont via SSO | ✓ | ✗ |
| Registre de métadonnées de capacités | ✓ | ✗ |
| Branche de version LTS | ✓ | ✗ |

- **Bascule conditionnelle de modèle**: Règles déclaratives switch-route + détection intégrée du mode plan + scripts context.useModel() — aucun changement client. LiteLLM exige des callbacks Python personnalisés.
- **Mélange de modèles / SDK entre protocoles**: Points d’entrée natifs de tout vers tout — appelez GPT depuis le SDK Anthropic, DeepSeek depuis le SDK Gemini. LiteLLM est centré OpenAI ; les chemins inverses passent par des cales (shims).
- **Validation de configuration en une transaction**: Préparer → prévisualiser l’ensemble des conflits → validation atomique ; tout le lot est annulé au moindre conflit.
- **Verrou dur des quotas de coût**: Les cycles quotidien / mensuel renvoient 429 quota_exceeded dès que la dépense est atteinte. LiteLLM envoie uniquement des alertes de budget.
- **Facturation résistante aux plantages**: Pré-débit → règlement → remboursement avec un grand livre en cours — correct même en cas de plantage du processus.
- **Mutualisation de clés amont et liaison persistante**: Un hachage pondéré FNV-1a fixe chaque appelant sur une clé et bascule vers la clé suivante non essayée ; les clés de poids 0 restent en veille.
- **Trois modes de facturation + multidevise**: Au token / par appel / par durée, USD/CNY/EUR/JPY/GBP, dimensions personnalisées. LiteLLM ne fait que du suivi fondé sur les tokens.
- **Connexion aux identifiants amont via SSO**: Intègre des fournisseurs sans clé statique (par exemple Kiro). LiteLLM n’accepte que des clés API statiques.
- **Registre de métadonnées de capacités**: Pilote l’injection et la dégradation automatiques ; l’évolution des capacités d’un nouveau modèle ne nécessite aucune modification de code.
- **Branche de version LTS**: N-1 + branche LTS (voir /lifecycle). LiteLLM ne maintient que les 4 dernières lignes mineures.

### Les deux le font bien
Une base établie — l’une ou l’autre passerelle couvre cette couche. La décision se joue dans les couches au-dessus et en dessous.
| Fonctionnalité | GateLLM | LiteLLM |
| --- | --- | --- |
| Routage API · repli · répartition de charge | ✓ | ✓ |
| BYOK, sans marge sur les tokens | ✓ | ✓ |
| Entièrement auto-hébergé, données sur site | ✓ | ✓ |
| Normalisation de l’appel d’outils entre fournisseurs | ✓ | ✓ |
| Normalisation des sorties structurées (JSON Schema) | ✓ | ✓ |
| Adaptation des tokens de raisonnement / réflexion | ✓ | ✓ |
| Mise en cache des prompts entre modèles | ✓ | ✓ |
| Injection de recherche web | ✓ | ✓ |
| Passerelle MCP (agrégation d’outils) | ✓ | ✓ |
| Console visuelle de configuration | ✓ | ✓ |
| Journaux d’audit et mesure de l’usage / des coûts | ✓ | ✓ |

### Différent par nature
Ni meilleur ni moins bon — des mécanismes et des conditionnements différents que vous devez peser directement.
| Fonctionnalité | GateLLM | LiteLLM |
| --- | --- | --- |
| Runtime | Binaire Rust unique · aucune pause GC | Processus Python + pile de dépendances |
| Surface de traduction de protocoles | 15 formes de protocoles ; les quatre familles de protocoles de chat (OpenAI / Anthropic / Gemini / DashScope) se traduisent de tout vers tout, le reste selon la matrice d’interopérabilité | Enveloppe centrée OpenAI + points de terminaison compatibles |
| Points d’entrée natifs par protocole | /v1/messages + count_tokens, generateContent Gemini, CRUD /v1beta/cachedContents, /v1/realtime, /mcp — une seule passerelle sert chaque SDK nativement | Point de terminaison compatible OpenAI (plus des variantes compatibles) |
| Profondeur de la mise en cache des prompts | Injection automatique des points de rupture de cache sur les appels au protocole OpenAI + mappage inter-protocoles + déduplication cachedContent de Google | Transmet cache_control, normalise l’usage |
| Valeurs par défaut de confidentialité des journaux | Journaux de requêtes désactivés par défaut · corps de journaux stockés masqués à chaque surface de sortie, révélation brute réservée aux administrateurs et auditée · rétention par défaut de 7 jours | Journalisation des requêtes/réponses activée ; masquage via guardrails |
| Mode de configuration | Entièrement dans la console — pas de YAML, les changements s’appliquent en direct | Centré sur config.yaml |
| Conditionnement SSO et SCIM entreprise | OIDC + SAML 2.0 + SCIM inclus dans la licence forfaitaire par instance, sans frais par siège | L’OSS plafonne le SSO à 5 utilisateurs ; SCIM exige l’offre Enterprise facturée à l’usage |
| Licence | Forfait par instance / mémoire, sans sièges, sans marge sur les tokens | OSS gratuit ; Enterprise facturé à l’usage |
| SLA de support | Support prioritaire inclus dans la licence forfaitaire | L’offre standard n’a aucun engagement de délai de réponse ; le SLA 24/7 est une extension payante (Sev0 1 h / Sev1 6 h) |
| Surface de points de terminaison | Points de terminaison cœur chat / temps réel / MCP | Ajoute /batches, /files, /fine_tuning, /vector_stores, /videos, /containers |
| Écosystème tiers | Journaux / Prometheus / OTel intégrés — sortie en protocoles standard, sans verrouillage sur un fournisseur ; détection des secrets et des données personnelles intégrée à la passerelle, sans moteur tiers | Gestionnaires de secrets AWS KMS / Vault / CyberArk ; guardrails PII Presidio ; observabilité Langfuse / Langsmith / Arize |

Vérifié par rapport à la documentation officielle de chaque produit au 2026-09-04 (docs.litellm.ai / docs.gatellm.io). Certaines capacités de LiteLLM nécessitent une licence Enterprise ; les détails peuvent évoluer — consultez les sources avant tout achat.

## Les secrets et les données personnelles sont détectés à l’entrée — vous décidez de la suite.
Un moteur de règles déterministe inspecte chaque requête de modèle à la recherche de formats d’identifiants et de données personnelles, et consigne ce qu’il a trouvé sans enregistrer le secret lui-même. Les règles intégrées sont livrées désactivées et en mode observation ; vous les activez et choisissez journaliser, masquer ou bloquer selon la portée. Aucun modèle n’intervient dans le chemin de détection.
### Détection déterministe, aucun modèle dans le chemin
Déterministe par construction : d’abord des sondes littérales, puis des règles regex exigeant des mots de contexte, puis des validateurs de somme de contrôle — Luhn pour les numéros de carte, mod-97 pour l’IBAN, la somme de contrôle des pièces d’identité nationales, les blocs de clés privées PEM et OpenSSH, l’IPv4.
- Formats d’identifiants : clés API de fournisseurs de modèles, clés d’accès cloud, jetons GitHub et GitLab, JWT, clés privées PEM et OpenSSH, jetons Slack
- Classes de données personnelles : numéros de mobile de Chine continentale, pièces d’identité nationales, numéros de carte bancaire, IBAN, adresses e-mail, adresses IPv4
- Les conversations multi-tours ne scannent que le nouveau contenu — une chaîne de hachage de curseur évite à une longue session de réanalyser un texte déjà validé
### Un masquage que votre client peut traverser ; un blocage qui ne fuit rien
En mode masquage, le modèle amont reçoit des espaces réservés numérotés et votre client récupère les valeurs réelles — y compris la restauration image SSE par image pendant la diffusion. En mode blocage, le refus porte la catégorie de règle et un identifiant de requête, jamais le texte correspondant.
- L’amont voit des espaces réservés ; la partie qui possède les données voit revenir ses propres valeurs
- Les longs collages ne sont pas exemptés — les chaînes surdimensionnées sont débordées sur disque et scannées par fenêtres de taille fixe, pour que la mémoire reste stable quelle que soit la taille de la charge utile
- La liste d’autorisation correspond par valeur, jamais par chemin : approuver une clé de test n’exempte pas silencieusement tout un champ
### Corps de journaux : stockés tels que reçus, masqués à chaque sortie
La persistance des journaux de requêtes est désactivée dans l’image livrée. Activez-la et les corps sont stockés tels que reçus, puis masqués à chaque surface de sortie — l’API Console masque par défaut, les sorties SSE et terminal sont toujours masquées, et un échec de masquage ferme la réponse au lieu de la laisser fuir.
- Révéler le contenu brut est un acte explicite : un rôle administrateur plus un indicateur de révélation explicite, audités et comptabilisés
- Le masquage couvre les clés sensibles du corps, les paramètres sensibles de requête et d’URL, les en-têtes de schéma d’authentification statiques et personnalisés, et les valeurs de jetons bearer avec révélation partielle
- Une détection conserve un extrait masqué avec un contexte environnant borné, jamais le texte correspondant ; les détections partagent la fenêtre de rétention des journaux, 7 jours par défaut
Désactivé par défaut, à dessein
Le pack de règles intégré est livré désactivé et l’action de chaque règle intégrée est « journaliser ». C’est un déploiement sûr plutôt qu’une lacune : voyez ce qui se serait passé sur votre trafic réel, ajustez la liste d’autorisation contre vos propres faux positifs, puis activez le masquage ou le blocage là où c’est important. La politique s’applique globalement, par groupe de clés d’accès ou par clé d’accès, et les règles se rechargent à chaud.
#### log
Observer. Les détections apparaissent dans la console avec des extraits masqués ; la requête elle-même n’est pas modifiée.
#### mask
Appliquer, de façon réversible. L’amont voit des espaces réservés ; votre client reçoit toujours la valeur réelle.
#### block
Refuser. La requête est rejetée avec la catégorie de règle et un identifiant de requête — jamais le texte correspondant.
### Ce que c’est, et ce que ce n’est pas
#### Ce que c’est
- S’exécute dans votre propre processus de passerelle, sur le chemin des requêtes de modèle, avec une portée globale / par groupe de clés d’accès / par clé d’accès
- Une page dédiée dans la console : une vue des détections pour les rôles administrateur et superviseur, une vue des règles pour les administrateurs, un interrupteur marche/arrêt avec pré-vérification du budget mémoire, rechargement à chaud et entrées d’audit
- Un point de terminaison d’aperçu à blanc, pour tester une règle sur un échantillon avant de l’activer
- Chaque détection est traçable jusqu’au nom de règle, à la catégorie, à la gravité, à l’action appliquée, au nombre de correspondances, au modèle et au nom de la clé d’accès

#### Ce que ce n’est pas
- Aucune détection du contenu des réponses — le volet réponse ne fait que restaurer les espaces réservés
- Aucun ML, aucune détection de jailbreak ou d’injection de prompt, aucune API de modération : les règles sont déterministes
- Aucun ré-audit hors ligne — un contenu non scanné au moment de la requête ne l’est pas plus tard
- Ce n’est pas une suite DLP : aucune couverture des points de terminaison, des e-mails ou d’autres canaux de sortie
- Aucun détecteur de passeport, de numéro de sécurité sociale, de nom ou d’adresse, et les lacunes résiduelles connues sont documentées — les médias encodés en base64 sont ignorés, et un espace réservé coupé entre deux images de flux passe sans modification

## Ce que vous obtenez réellement.
Les trois points qui intéressent les services achats, réglés avant le prix : un DPA que le juridique peut signer, une facture qui ne peut pas s’emballer, et des prompts qui ne nous parviennent jamais.
### Un DPA que votre service juridique peut signer
Prêt pour le RGPD et le CCPA, avec un DPA que votre service juridique peut réellement signer. Auto-hébergé — les données ne quittent jamais votre périmètre — avec SSO entreprise (OIDC / SAML 2.0) et provisionnement SCIM 2.0 inclus.
- RGPD
- CCPA
- DPA
- SSO
- SCIM
- Piste d’audit
### Une facture qui ne peut pas s’emballer
BYOK : payez les fournisseurs aux tarifs standard — sans marge sur les tokens, sans frais par siège. Des plafonds de quota durs par clé et par projet empêchent un script qui s’emballe de dépasser votre budget.
- Sans marge sur les tokens
- 0 frais par siège
- Cache de prompts
- Plafonds de quota durs
- Remboursement 30 jours
### Vos prompts ne nous parviennent jamais
Entièrement auto-hébergé — vos prompts et complétions n’entrent jamais dans nos systèmes. Les clés BYOK résident uniquement en mémoire de la passerelle ; les requêtes vont directement aux API des fournisseurs, sans jamais quitter votre réseau.
- Données sur site
- Clés jamais persistées
- TLS 1.3
- Admission des clients
- Modèles choisis par vous

## Entièrement auto-hébergé · Instance unique 2 Go · Jamais de marge sur les tokens
BYOK (apportez vos propres clés) — vous payez les fournisseurs aux tarifs standard. Nous licencions une instance unique de 2 Go, jamais par siège ni avec une marge sur les tokens. Une mémoire supérieure ou plusieurs instances passent par Enterprise.
Le cœur est construit en Rust. Au niveau du transfert par la passerelle, chaque Go de mémoire soutient environ 100 M de tokens par minute (TPM) et ~500 requêtes par minute (RPM), ce qui sert confortablement ~100 utilisateurs typiques. Ce sont des chiffres de référence : le débit réel est borné par les limites de débit de vos propres fournisseurs et par la complexité des requêtes, et ne constitue pas un engagement SLA.
Inclus dans toutes les offres : BYOK sans marge sur les tokens · routage vers plus de 100 fournisseurs · contrôle d’accès client · cache de prompts · quotas de coût
### Gratuit
0 $
Entièrement auto-hébergé · Licence unique
Instance unique de 512 Mo, aucune rétention de journaux — adapté à l’évaluation et aux POC, pas au trafic de production.
- Routage vers plus de 100 LLM · Repli · Répartition de charge
- Mélange de modèles entre fournisseurs · rétrogradation dans l’agent (plan verrouillé / rétrogradation automatique hors plan)
- Contrôle d’accès client (politique User-Agent)
- Cache de prompts
- BYOK (apportez vos propres clés, sans marge)
- Plafond mémoire de 512 Mo · SQLite · instance unique
- Revue de code GitHub Actions via votre propre passerelle
- Aucune rétention de journaux
### Pro
400 $
Plafond fixe de 2 Go, sans extension. Pour plusieurs nœuds, la conformité (Audit/DLP) ou l’API de gestion, passez à Enterprise.
- Toutes les fonctionnalités de l’offre Gratuit
- Mémoire de 2 Go · instance unique (plafond fixe, sans extension)
- Rétention des journaux
- SSO entreprise (OIDC : Azure AD / Okta / générique, plus SAML 2.0 + SCIM)
- PostgreSQL · mémoire de 2 Go
- Support par e-mail / ticket
Remboursement à 100 % sous 30 jours en cas d’insatisfaction
### Enterprise
à partir de 400 $/Go
Selon la capacité mémoire · Facturé annuellement · Remboursement 30 jours
- Toutes les fonctionnalités de Pro
- Facturation à la capacité (nœuds × mémoire, forfait 400 $/Go/mois)
- Déploiement multi-nœuds / en cluster
- Revue de code GitHub Actions via votre propre passerelle
- Complément Microsoft 365 (Excel/Word/PPT/Outlook, extension payante)
- Rétention des journaux étendue
- Délai de réponse du support prioritaire
- Conformité (Audit / DLP)
- API de gestion (clé API · quota · interrogation de l’usage · export d’audit)
Besoin de plus de capacité ou d’une configuration sur mesure ?
## Comparaison des fonctionnalités

| Fonctionnalité | Gratuit | Pro | Enterprise |
| --- | --- | --- | --- |
| Routage multi-modèles · Repli · Répartition de charge | ✓ | ✓ | ✓ |
| Mélange de modèles entre fournisseurs (planification/exécution par fournisseur) | ✓ | ✓ | ✓ |
| Rétrogradation de modèle dans l’agent (plan verrouillé / rétrogradation automatique hors plan) | ✓ | ✓ | ✓ |
| Cache de prompts | ✓ | ✓ | ✓ |
| BYOK (apportez vos propres clés, sans marge) | ✓ | ✓ | ✓ |
| Palier de mémoire | 512 Mo | 2 Go (fixe) | Sur mesure |
| Stockage / base de données | SQLite (instance unique) | PostgreSQL · 2 Go | PostgreSQL + cluster Redis |
| Échelle de déploiement | 1 instance | 1 instance · 2 Go | Multi-nœuds / cluster |
| Débit par Go (référence) | — | 2 Go ≈ 200 M TPM / 1 000 RPM | ≈ 100 M TPM / 500 RPM par Go |
| Rétention des journaux | Aucune | Conservés | Rétention étendue |
| SSO (OIDC / SAML 2.0) | — | ✓ | ✓ |
| Provisionnement automatique SCIM 2.0 | — | ✓ | ✓ |
| Conformité (Audit / DLP) | — | — | ✓ |
| API de gestion (clé · quota · usage · audit programmatiques) | — | — | ✓ |
| Grille tarifaire propre / instantanés de prix (dont tarification privée) | ✓ | ✓ | ✓ |
| Quotas de coût (quotidiens / mensuels, héritage à trois niveaux) | ✓ | ✓ | ✓ |
| Délai de réponse du support | Communauté | E-mail / ticket | Réponse prioritaire |
| Politique de modèles selon le mode (plan/exécution, opposable) | ✓ | ✓ | ✓ |
| Contrôle d’accès client (politique User-Agent) | ✓ | ✓ | ✓ |
| Revue de code GitHub Actions (via votre passerelle) | ✓ | ✓ | ✓ |
| Complément Microsoft 365 (Excel/Word/PPT/Outlook, auto-hébergé) | — | Extension | Extension |
| Blocage par étiquette de confidentialité Purview (addin.access / file.upload) | — | — | ✓ |

## FAQ
### Quelle latence ajoute une passerelle IA ?

Une passerelle SaaS ajoute un saut supplémentaire hors de votre réseau. GateLLM est auto-hébergé dans votre VPC ; le saut supplémentaire vers l’API du fournisseur est une communication inter-processus locale — une surcharge inférieure à la milliseconde, avec un impact négligeable sur le délai du premier token en diffusion.
### Que se passe-t-il si un fournisseur tombe en panne ou atteint sa limite de débit ?

L’appel direct à un seul fournisseur est un point de défaillance unique. GateLLM prend en charge le repli entre fournisseurs — lorsque le principal renvoie une 5xx ou expire, le trafic bascule vers un fournisseur de secours sans modification de code. Il mutualise aussi plusieurs clés par amont : un hachage déterministe lie chaque appelant à une clé, et lorsqu’une clé échoue la passerelle réessaie avec la clé suivante non essayée.
### Ai-je vraiment besoin d’une passerelle ?

Critère honnête : un seul fournisseur, une seule équipe, aucune contrainte de conformité, une dépense mensuelle maîtrisée — appelez les API directement ; vous n’avez pas besoin de passerelle. Une passerelle commence à être rentable lorsque vous avez besoin de bascule multi-fournisseurs, d’imputation des coûts par équipe, de conformité / résidence des données, ou de visibilité en temps réel sur les dépenses incontrôlées.
### Comment GateLLM gagne-t-il de l’argent en mode BYOK ?

Nous licencions une instance unique de 2 Go de mémoire (Pro 400 $/mois, 20 % de réduction en annuel à 3 840 $/an), sans marge sur les tokens, sans frais par siège. Vous payez les fournisseurs aux tarifs standard, GateLLM ne prend aucune commission.
### Mes clés API et mes données quittent-elles mon réseau ?

Non. En mode BYOK, les clés API sont stockées uniquement en mémoire de la passerelle, jamais persistées ni transmises. Les requêtes passent par la passerelle directement vers les API officielles des fournisseurs — les données ne quittent jamais votre réseau privé.
### Comment savoir que la passerelle sert le vrai modèle, pas un substitut moins cher ?

Avec un agrégateur SaaS, vous ne pouvez que lui faire confiance. GateLLM est BYOK et auto-hébergé : vous utilisez vos propres clés et les requêtes vont de votre passerelle directement au point de terminaison de l’API du fournisseur — l’identité du modèle est garantie par l’API du fournisseur elle-même, sans saut remplaçable entre les deux.

## Commencez à construire vos applications IA multi-modèles
Entièrement auto-hébergé · Instance unique 2 Go · Jamais de marge sur les tokens.

## Voir aussi
- [Tarifs](https://www.gatellm.io/fr/pricing.md)
- [Calculateur de coûts](https://www.gatellm.io/fr/calculator.md)
- [À propos](https://www.gatellm.io/fr/about.md)
- [Réserver une démo](https://www.gatellm.io/fr/demo.md)
- [FAQ](https://www.gatellm.io/fr/faq.md)
- [Comparer les passerelles IA](https://www.gatellm.io/fr/compare.md)
- [Comparer LiteLLM](https://www.gatellm.io/fr/compare/litellm.md)
- [Comparer OpenRouter](https://www.gatellm.io/fr/compare/openrouter.md)
- [Comparer Alibaba Cloud AI Gateway](https://www.gatellm.io/fr/compare/alibaba-cloud.md)
- [Comparer Azure API Management](https://www.gatellm.io/fr/compare/azure-apim.md)
- [Comparer Apigee](https://www.gatellm.io/fr/compare/apigee.md)
- [Comparer Cloudflare AI Gateway](https://www.gatellm.io/fr/compare/cloudflare.md)
- [Comparer Kong AI Gateway](https://www.gatellm.io/fr/compare/kong.md)
- [Comparer Portkey](https://www.gatellm.io/fr/compare/portkey.md)
- [LiteLLM vs Kong AI Gateway](https://www.gatellm.io/fr/compare/litellm-vs-kong.md)
- [LiteLLM vs OpenRouter](https://www.gatellm.io/fr/compare/litellm-vs-openrouter.md)
- [LiteLLM vs Portkey](https://www.gatellm.io/fr/compare/litellm-vs-portkey.md)
- [Cas d’usage](https://www.gatellm.io/fr/use-cases.md)
- [Réduire le coût des LLM](https://www.gatellm.io/fr/use-cases/reduce-cost.md)
- [Haute disponibilité](https://www.gatellm.io/fr/use-cases/high-availability.md)
- [Isolation multi-tenant](https://www.gatellm.io/fr/use-cases/multi-tenant.md)
- [Conformité et audit](https://www.gatellm.io/fr/use-cases/compliance-audit.md)
- [Dépannage par symptôme](https://www.gatellm.io/fr/use-cases/troubleshooting.md)
- [Pile de modèles multi-fournisseurs](https://www.gatellm.io/fr/use-cases/mixed-model-stack.md)
- [Héberger l’IA en interne dans Office](https://www.gatellm.io/fr/use-cases/self-hosted-office-ai.md)
- [Visibilité et attribution des tokens](https://www.gatellm.io/fr/use-cases/token-ops.md)
- [Token FinOps : allocation et contrôle des coûts IA](https://www.gatellm.io/fr/use-cases/token-finops.md)
- [Gouvernance des outils MCP](https://www.gatellm.io/fr/use-cases/mcp-tool-governance.md)
- [Recherche web pour chaque modèle](https://www.gatellm.io/fr/use-cases/web-search-grounding.md)
- [Rotation et secours multi-clés](https://www.gatellm.io/fr/use-cases/multi-key-pooling.md)
- [Contrôle des clients connectés](https://www.gatellm.io/fr/use-cases/client-admission-control.md)
- [Imposer la politique d’usage des modèles](https://www.gatellm.io/fr/use-cases/enforce-model-policy.md)
- [Aucun choix de modèle côté client](https://www.gatellm.io/fr/use-cases/automatic-model-tiering.md)
- [Un protocole, n’importe quel modèle](https://www.gatellm.io/fr/use-cases/one-protocol-any-model.md)
- [Complément Office / Microsoft 365](https://www.gatellm.io/fr/office-addin.md)
- [Glossaire](https://www.gatellm.io/fr/glossary.md)
- [Catalogue de modèles](https://www.gatellm.io/fr/models.md)
- [Intégrations SDK et frameworks](https://www.gatellm.io/fr/integrations.md)
- [Agents de codage IA et harnais](https://www.gatellm.io/fr/coding-agents.md)
- [Sécurité et conformité](https://www.gatellm.io/fr/security.md)