Vercel AI Gateway : j'ai arrêté d'appeler les APIs direct

En octobre 2025, j'appelais 4 providers LLM différents depuis mon code : Anthropic (pour les tâches longues), OpenAI (pour les embeddings), Cohere (pour le rerank), Mistral (pour les fallbacks). Chacun avec son SDK, sa gestion d'erreur, sa stratégie de retry. 800 lignes de code de plomberie. En novembre, je suis passé au Vercel AI Gateway. 6 mois plus tard, ces 800 lignes sont devenues 40 lignes, j'ai du routage automatique, des fallbacks gratuits, et ma facture a baissé de 15%. Voici le setup complet et les chiffres.

Ce que le Vercel AI Gateway fait vraiment

Le Vercel AI Gateway est une couche HTTP qui se place entre ton code et les providers LLM. Tu fais un seul type d'appel (compatible OpenAI SDK), le gateway route vers le bon provider, gère les erreurs, applique tes règles de routing.

Features utiles :

• •Routing automatique basé sur des règles (par modèle, par user, par coût)
• •Fallbacks en cascade si un provider plante
• •Cache HTTP sur les prompts identiques (via le prompt caching Anthropic quand possible)
• •Observability : dashboard avec latence, coût, erreurs par provider
• •Zero data retention (par défaut) — important pour la compliance

Le code avant (800 lignes de plomberie)

Mon setup historique :

// lib/llm/anthropic.ts
async function callClaude(prompt: string) {
  const anthropic = new Anthropic();
  for (let i = 0; i < 3; i++) {
    try {
      return await anthropic.messages.create({...});
    } catch (e) {
      if (e.status === 429) await sleep(2 ** i * 1000);
      else throw e;
    }
  }
}

// lib/llm/openai.ts
// 50 lignes similaires
// lib/llm/mistral.ts
// 50 lignes similaires
// lib/llm/router.ts
// 200 lignes pour choisir le bon provider
// lib/llm/fallback.ts
// 150 lignes de logique de cascade

800 lignes en tout, dont la moitié de code de fallback et d'observability à la main.

Le code après (40 lignes)

// lib/llm.ts
import { generateText } from 'ai';
import { createGateway } from '@ai-sdk/gateway';

// Auth OIDC automatique : `vercel env pull` injecte un token court
// qui rotate tout seul. Pas de clé statique à gérer.
export async function callLLM(prompt: string, opts: { taskType: string }) {
  const model = pickModelForTask(opts.taskType);
  const result = await generateText({
    model,  // AI SDK v6 : string direct, gateway utilisé via OIDC
    prompt,
  });
  return result.text;
}

function pickModelForTask(taskType: string): string {
  const routing = {
    code: "anthropic/claude-opus-4.6",
    chat: "openai/gpt-5-mini",
    summary: "google/gemini-3-pro",
    embedding: "openai/text-embedding-3-small",
  };
  return routing[taskType] ?? "openai/gpt-5-mini";
}

C'est tout. Les retries, les fallbacks, le logging : gérés par le gateway côté Vercel. Mon code n'a plus qu'à dire « quelle tâche » et quel modèle par défaut.

Les 3 features qui valent vraiment

1. Fallbacks en cascade déclaratifs

Dans le dashboard Vercel, je définis :

Primary: anthropic/claude-opus-4-6
Fallback 1: openai/gpt-5 (si Anthropic 503 ou timeout > 30s)
Fallback 2: google/gemini-3-pro (si les 2 précédents échouent)

Quand Anthropic a eu une panne de 2h en mars, mon app est restée en ligne parce que le gateway a automatiquement basculé vers OpenAI. Aucun code à changer.

2. Observability native

Le dashboard me montre : latence p50/p95/p99 par modèle, coût cumulé par jour, taux d'erreur, distribution des types de tâches. Tout ce que j'aurais dû construire moi-même avec Datadog.

3. Prompt caching transparent

Quand Anthropic supporte le prompt caching sur une requête, le gateway l'active automatiquement. Pour mes prompts système de 1 500 tokens qui sont identiques à chaque appel, le coût de prompt chute de 90% sur les appels suivants. Sans changer mon code.

Les chiffres en 6 mois

-15% de facture grâce au prompt caching automatique et au routage optimisé. 0 downtime grâce aux fallbacks. -95% de lignes de code.

Les 2 limites à connaître

Limite 1 : overhead de latence

Le gateway ajoute ~50-120 ms à chaque requête (une hop réseau supplémentaire). Pour des workloads sensibles à la latence (genre streaming UI temps réel), ça peut se sentir.

Mitigation : le gateway a des régions dans la même zone que ton déploiement Vercel, donc l'overhead est minime si tu déploies tout chez Vercel.

Limite 2 : vendor lock-in léger

Techniquement, tu peux migrer vers un autre gateway (LangSmith, OpenRouter, Portkey) puisque l'API est standard (OpenAI-compatible). Mais tu perds ta config de routing, tes dashboards, tes historiques d'observability.

Dans mon cas, le lock-in vaut le gain. Je n'ai pas l'intention de migrer.

Ma config actuelle (extrait)

Dans le dashboard Vercel AI Gateway :

Routes:
  - code-tasks:
      primary: anthropic/claude-opus-4-6
      fallback: [openai/gpt-5, google/gemini-3-pro]
      cache: true
      max_retries: 2
  - summary-tasks:
      primary: google/gemini-3-pro
      fallback: [anthropic/claude-sonnet-4-5]
      cache: true
  - embeddings:
      primary: openai/text-embedding-3-small
      fallback: [voyage/voyage-3-lite]
      cache: false

Ce qu'il faut retenir

1. 1.Le Vercel AI Gateway remplace 800 lignes de plomberie par 40.
2. 2.Fallbacks automatiques = zéro downtime pendant la panne Anthropic de mars.
3. 3.-15% de facture grâce au prompt caching automatique.
4. 4.Observability native meilleure que ce que je construisais à la main.
5. 5.Limite : léger overhead de latence (50-120 ms).

Pour le workflow complet de construction d'agents LLM en Python qui exploitent ce type de gateway, j'ai écrit un guide dédié :

Agents LLM en Python

Des agents qui marchent. En Python.

Découvrir →