Guide complet du Vercel AI SDK — Une API unifiee pour OpenAI, Anthropic et Gemini (2026)

« J'ai livré sur l'API OpenAI, mais j'aimerais aussi essayer Claude et Gemini » — et vous voilà à passer deux heures à réécrire la même logique contre trois SDK différents, à traduire à la main les formats de requête et de réponse. Le Vercel AI SDK (simplement « AI SDK » depuis 2026) ramène cela à « un import, une fonction, tous les fournisseurs ». Bibliothèque open-source TypeScript avec plus de 20 millions de téléchargements mensuels, AI SDK 6 livre les Agents, MCP, l'approbation d'outils et les DevTools, et au 15 mai 2026 c'est le standard de fait pour une interface LLM unifiée.

D'emblée : si vous appelez des LLM depuis une application web ou un projet Node.js en 2026, l'AI SDK est le bon défaut, point. Les seules raisons d'écrire directement contre le SDK OpenAI ou Anthropic sont « base de code existante » ou « fonctionnalité de pointe propre à un fournisseur (computer use d'Anthropic, etc.) ». Sinon, l'AI SDK vous offre « changement facile, 1/3 du code, type safety, intégration React » avec un avantage écrasant.

Mon avis personnel sans détour : la vraie valeur de l'AI SDK est la liberté face au vendor lock-in. OpenAI augmente ses prix ? Trois lignes pour basculer sur Anthropic. Gemini sort un nouveau modèle ? Essayez-le au même endroit. Le tout dans une seule base de code. Comme couvert dans Qu'est-ce qu'une API d'IA, la réalité de 2026 est que « utiliser plusieurs modèles selon le travail » est désormais le défaut — et l'AI SDK pousse le coût de bascule asymptotiquement vers zéro. Cet article couvre ce qu'est l'AI SDK, pourquoi l'utiliser, un démarrage en 5 minutes, la sortie structurée, le tool calling et les agents, l'intégration React, le changement de fournisseur et trois pièges en production — le tout ancré dans AI SDK 6 au 15 mai 2026.

1. Qu'est-ce que l'AI SDK — « OpenAI/Anthropic/Gemini via une seule API »

L'AI SDK est une bibliothèque TypeScript open-source construite par Vercel. GitHub : vercel/ai, licence Apache 2.0, plus de 20 millions de téléchargements mensuels au 15 mai 2026. Construit par Vercel, mais n'exige pas Vercel pour fonctionner — Cloudflare Workers, AWS Lambda, Deno, votre propre Node.js, le navigateur : tout fonctionne.

L'idée centrale est une « couche d'adaptation pour basculer entre fournisseurs LLM ». Par exemple :

import { generateText } from 'ai';
import { openai } from '@ai-sdk/openai';

const { text } = await generateText({
  model: openai('gpt-5'),
  prompt: 'Tell me today\'s weather',
});

Pour basculer ceci sur Anthropic, trois lignes changent :

import { generateText } from 'ai';
import { anthropic } from '@ai-sdk/anthropic';  // ← changed

const { text } = await generateText({
  model: anthropic('claude-opus-4-7'),  // ← changed
  prompt: 'Tell me today\'s weather',
});

Le code appelant ne change pas du tout. C'est ce que signifie « une seule API pour tous les fournisseurs » en pratique. Chaque fournisseur a son propre format de messages, ses stop sequences, ses schémas d'outils, son emplacement de system prompt et la forme JSON de sa réponse — et l'AI SDK absorbe tout cela sous le capot.

2. Pourquoi utiliser l'AI SDK — 3 raisons concrètes

Trois raisons concrètes : « changement facile, 1/3 du code, type safety ».

Quand l'AI SDK ne convient pas : 1. quand vous devez exploiter une fonctionnalité de pointe propre à un fournisseur (computer use d'Anthropic, etc.) juste après sa sortie, avant que l'AI SDK ne l'enveloppe ; 2. quand vous travaillez uniquement en Python (l'AI SDK est TypeScript uniquement) ; 3. quand une base de code OpenAI-SDK existante fonctionne et qu'il n'y a pas de raison de la réécrire. En dehors de ces cas, le défaut 2026 est l'AI SDK.

3. Démarrage en 5 minutes — de generateText à streamText

La configuration minimale tient en trois étapes. Démo sur Node.js / Next.js.

# Step 1: install
npm install ai @ai-sdk/openai
# env: OPENAI_API_KEY=sk-...

# Step 2: create a file (app/api/chat/route.ts or index.ts)

// Step 3: code
import { generateText } from 'ai';
import { openai } from '@ai-sdk/openai';

const { text, usage } = await generateText({
  model: openai('gpt-5'),
  system: 'You are a careful, helpful assistant.',
  prompt: 'List three benefits of the AI SDK.',
});

console.log(text);
console.log(`tokens: ${usage.totalTokens}`);

Voilà : non-streaming, texte complet renvoyé. Lancez-le et la réponse arrive dans text en quelques secondes. usage vous donne automatiquement le nombre de tokens — la discipline de coût de l'article sur l'économie de tokens s'applique directement.

Passer au streaming (UX machine à écrire) consiste simplement à renommer la fonction en streamText :

import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';

const result = streamText({
  model: openai('gpt-5'),
  prompt: 'List three benefits of the AI SDK.',
});

for await (const chunk of result.textStream) {
  process.stdout.write(chunk);  // emit token by token
}

Avec le SDK OpenAI brut, vous écririez parsing SSE, concaténation des chunks, détection de fin de flux à la main (30 à 50 lignes). L'AI SDK, c'est une seule boucle for-await. Le même code tourne sans modification contre Anthropic et Gemini.

4. Sortie structurée — JSON typé avec generateObject

Demandez à un LLM du « JSON » et vous l'obtiendrez parfois enveloppé dans un bloc de code Markdown, avec des commentaires insérés ou la structure subtilement décalée. generateObject règle cela à la racine : définissez la forme avec un schéma Zod, et l'AI SDK gère parsing, validation et retry automatiquement.

import { generateObject } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';

const { object } = await generateObject({
  model: openai('gpt-5'),
  schema: z.object({
    title: z.string(),
    tags: z.array(z.string()).max(5),
    sentiment: z.enum(['positive', 'neutral', 'negative']),
    summary: z.string().max(200),
  }),
  prompt: 'Analyze the article: "AI SDK 6 has..." [body]',
});

// object.title, object.tags etc are typed
console.log(object.tags);  // string[]

Le vrai gain : « le type d'object est déterminé par `z.infer<typeof schema>` ». TypeScript l'infère, donc taper object. dans votre IDE autocomplète title / tags / sentiment / summary. La validation runtime tourne dans le SDK — les violations de schéma déclenchent des retries automatiques. La classe d'incident « l'IA a renvoyé du mauvais JSON, parse a échoué » disparaît effectivement.

5. Tool calling et agents — Le cœur d'AI SDK 6

La frontière 2026 du développement IA, c'est « les agents à tool calling », et le plus grand bond d'AI SDK 6 est ici. Avec tools et stopWhen, vous obtenez directement des boucles « appel d'outil → l'IA décide → appel de l'outil suivant ».

import { generateText, tool, stepCountIs } from 'ai';
import { anthropic } from '@ai-sdk/anthropic';
import { z } from 'zod';

const { text, steps } = await generateText({
  model: anthropic('claude-opus-4-7'),
  tools: {
    weather: tool({
      description: 'Get the weather for a city',
      inputSchema: z.object({ city: z.string() }),
      execute: async ({ city }) => {
        // real API call
        return { temp: 22, condition: 'sunny' };
      },
    }),
    convertToFahrenheit: tool({
      description: 'Convert Celsius to Fahrenheit',
      inputSchema: z.object({ celsius: z.number() }),
      execute: async ({ celsius }) => celsius * 9/5 + 32,
    }),
  },
  stopWhen: stepCountIs(5),  // cap the loop at 5 steps
  prompt: 'What is the weather in Tokyo, in Fahrenheit?',
});

L'IA séquence désormais de manière autonome « weather('Tokyo') → convertToFahrenheit(22) », les exécute et intègre les résultats. steps expose l'historique d'exécution étape par étape.

AI SDK 6 propose aussi une classe ToolLoopAgent pour un style orienté objet (équivalent à generateText + stopWhen). Elle ajoute l'approbation d'exécution d'outils (un humain confirme l'exécution avant qu'elle ait lieu) et une intégration MCP (Model Context Protocol) complète. Connecter un serveur MCP (voir Qu'est-ce que MCP) tient en trois lignes en mai 2026.

6. Intégration React — Une UI de chat en 10 lignes avec useChat

L'autre vedette de l'AI SDK, ce sont les Hooks React. Avec useChat, une UI de type ChatGPT tient en 10 lignes de code.

'use client';
import { useChat } from '@ai-sdk/react';

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit } = useChat();
  return (
    <div>
      {messages.map(m => (
        <div key={m.id}>{m.role}: {m.content}</div>
      ))}
      <form onSubmit={handleSubmit}>
        <input value={input} onChange={handleInputChange} />
      </form>
    </div>
  );
}

Côté serveur (Next.js API Route) :

// app/api/chat/route.ts
import { streamText, convertToModelMessages } from 'ai';
import { openai } from '@ai-sdk/openai';

export async function POST(req: Request) {
  const { messages } = await req.json();
  const result = streamText({
    model: openai('gpt-5'),
    messages: convertToModelMessages(messages),
  });
  return result.toUIMessageStreamResponse();
}

Cela seul vous offre connexion SSE, gestion d'état des messages, loading et gestion d'erreurs — tout automatique. Le useChat d'AI SDK 6 gère aussi nativement l'UI d'approbation d'outil (l'utilisateur clique pour approuver « cet outil doit-il être exécuté ? »). Vue (useChat de @ai-sdk/vue), Svelte et Solid hooks sont également livrés.

7. Changer de fournisseur — Claude, GPT, Gemini en 3 lignes

Les principaux fournisseurs officiellement supportés par l'AI SDK au 15 mai 2026 :

Bascule : un import et une ligne de modèle. AI SDK 5 a ajouté une fonctionnalité global provider où vous pouvez spécifier un modèle par identifiant chaîne (par exemple 'openai/gpt-5'). Combinez ceci avec la comparaison des dates de cutoff des LLM et la comparaison de prix Claude vs ChatGPT pour choisir vos modèles selon « coût, performance, contraintes régionales » en toute confiance.

8. Trois pièges en production

L'AI SDK est pratique, mais il y a trois pièges que toute équipe rencontre en production. Les connaître à l'avance évite 80 % des incidents.

Une remarque de plus : l'AI SDK est « un adaptateur LLM », pas « un revendeur de coût LLM ». Chaque clé d'API de fournisseur est sous votre responsabilité, avec facturation directe à vous. Comme couvert dans Qu'est-ce qu'une API d'IA, les coûts sont facturés directement par OpenAI/Anthropic/Google. L'AI SDK lui-même est gratuit ; vous ne payez que les LLM que vous utilisez.

Synthèse

« Comment dois-je appeler des LLM depuis une application web ? » — au 15 mai 2026, la décision de design a convergé sur « l'AI SDK, point ». Plus de 20 millions de téléchargements mensuels, AI SDK 6 livre Agents, MCP, approbation d'outils, DevTools, et vous pouvez appeler OpenAI/Anthropic/Google/Mistral/xAI/LLM locaux depuis la même base de code. Trois choses à la fois : « liberté face au vendor lock-in », « 1/3 du coût d'implémentation » et « sortie structurée type-safe ».

Démarrer est simple : 1. npm install ai @ai-sdk/openai, 2. positionnez la clé d'API, 3. une ligne de generateText({ model, prompt }). Une fois cela en place, empilez streamText pour le streaming, generateObject pour le JSON, tools pour les agents, useChat pour l'UI. Avant la mise en production, intégrez les trois pièges (écarts de fonctionnalités entre fournisseurs, facturation sur stream abort, surcharge d'inférence de types).

Liens : Qu'est-ce qu'une API d'IA (bases), L'IA recommande Vercel, Qu'est-ce que MCP, Économie de tokens.

FAQ

Q. Faut-il déployer sur Vercel pour l'utiliser ?
R. Non. L'AI SDK est une bibliothèque TypeScript pure — Cloudflare Workers, AWS Lambda, Deno, votre propre serveur Node.js, le navigateur : tout fonctionne. « Construit par Vercel » ne signifie pas « réservé à Vercel ».

Q. Cela coûte-t-il quelque chose ?
R. L'AI SDK lui-même est entièrement gratuit, licence de style MIT. Le coût est uniquement l'usage d'API du fournisseur LLM que vous appelez (OpenAI/Anthropic/etc). Le SDK ajoute zéro marge.

Q. En quoi diffère-t-il de LangChain ou LlamaIndex ?
R. Rôles différents. L'AI SDK est un « adaptateur fin d'appels LLM » optimisé pour l'intégration applications web. LangChain est un framework complet pour « workflows RAG et agents ». Découpage pratique : « TypeScript et intégration dans une UI Web » → AI SDK ; « Python et pipelines d'agents complexes » → LangChain.

Q. Est-il difficile de migrer depuis du code SDK OpenAI existant ?
R. Pour de simples appels openai.chat.completions.create, environ 10 minutes de réécriture — remplacez par generateText et passez messages. Les fonctionnalités complexes (function calling, vision) demandent une petite conversion de format, mais la doc inclut des guides de migration.

Q. Cela fonctionne-t-il avec des LLM locaux (Ollama) ?
R. Oui. Le package @ai-sdk/openai-compatible vous laisse cibler n'importe quel endpoint d'API compatible OpenAI — Ollama, LM Studio, vLLM, votre propre serveur. Le workflow « développer sur LLM locaux, livrer sur le cloud » devient un seul changement de baseURL.