- Qu'est-ce que le SDK Vercel AI ?
- AI SDK Core : generateText, streamText et generateObject
- AI SDK Tools : Appels de fonction et utilisation d'outils
- Création de boucles d'agents IA avec le SDK Vercel AI
- AI SDK React : Hook useChat et intégration Next.js
- Comment utiliser Novita AI avec le SDK Vercel AI
- Choisir un fournisseur de LLM pour le SDK Vercel AI
- Conclusion
- FAQ
- Articles recommandés
Le SDK Vercel AI est une boîte à outils TypeScript pour créer des applications d’intelligence artificielle. Il gère la génération de texte, le streaming, les sorties structurées, les appels d’outils et les boucles d’agents en plusieurs étapes via une API unifiée — et fonctionne avec n’importe quel fournisseur LLM majeur. Si vous avez déjà essayé de connecter OpenAI ou Anthropic directement dans une application Next.js et que vous vous êtes retrouvé à maintenir trois implémentations de streaming différentes, ce SDK résout ce problème.
Ce guide couvre les capacités principales du SDK, comment le connecter à l’API compatible OpenAI de Novita AI, et où les workflows d’agents s’intègrent pour les développeurs qui construisent plus qu’un simple chatbot.
Qu’est-ce que le SDK Vercel AI ?
Le SDK Vercel AI (package : ai sur npm) est une bibliothèque open-source qui fait abstraction des différences entre les fournisseurs de LLM. Au lieu d’apprendre des protocoles de streaming séparés pour OpenAI, Anthropic et Google, vous appelez les mêmes fonctions generateText, streamText ou generateObject et changez de fournisseur en modifiant une seule importation.
Le SDK se décline en deux couches :
- AI SDK Core gère les interactions avec le modèle : génération de texte, streaming, objets structurés, appels d’outils, embeddings et boucles d’agents.
- AI SDK UI fournit des hooks React (
useChat,useCompletion,useObject,useAssistant) ainsi que des adaptateurs pour Next.js, SvelteKit et Nuxt qui gèrent l’état du streaming dans le navigateur.
Il existe également un package @ai-sdk/openai-compatible pour se connecter à tout fournisseur implémentant le format OpenAI Chat Completions — c’est ainsi que Novita AI s’intègre.
Le SDK fonctionne dans Node.js, Deno, les environnements d’exécution edge (Cloudflare Workers, Vercel Edge) et les environnements navigateur.
AI SDK Core : generateText, streamText et generateObject
Installez le SDK et un package fournisseur :
npm install ai @ai-sdk/openai
generateText
Pour les complétions sans streaming — traitement par lots, classification, génération unique :
import { generateText } from 'ai';
import { openai } from '@ai-sdk/openai';
const { text } = await generateText({
model: openai('gpt-4o-mini'),
prompt: 'Expliquez comment fonctionnent les embeddings LLM en deux phrases.',
});
console.log(text);
streamText
Pour les interfaces de chat où la latence compte :
import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';
const result = streamText({
model: openai('gpt-4o-mini'),
messages: [
{ role: 'user', content: 'Guide-moi pour configurer une application Next.js.' },
],
});
for await (const chunk of result.textStream) {
process.stdout.write(chunk);
}
generateObject
Lorsque vous avez besoin d’une sortie JSON structurée plutôt que de texte brut — la validation du schéma est gérée automatiquement avec Zod :
import { generateObject } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';
const { object } = await generateObject({
model: openai('gpt-4o-mini'),
schema: z.object({
name: z.string(),
skills: z.array(z.string()),
experienceLevel: z.enum(['junior', 'mid', 'senior']),
}),
prompt: 'Générez un profil d\'ingénieur logiciel fictif.',
});
console.log(object.name, object.skills);
Le SDK gère l’injection de l’invite système nécessaire pour contraindre le modèle à produire du JSON valide et réessaye en cas de sortie malformée.
AI SDK Tools : Appels de fonction et utilisation d’outils
Les outils permettent aux modèles d’appeler des fonctions externes — API de recherche, requêtes de base de données, calculatrices — pendant une génération. Le paramètre tools du SDK prend un objet où chaque clé devient une fonction appelable :
import { generateText, tool } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';
const { text, toolCalls } = await generateText({
model: openai('gpt-4o-mini'),
tools: {
getWeather: tool({
description: 'Obtenir la météo actuelle pour un lieu',
parameters: z.object({
city: z.string().describe('Nom de la ville'),
unit: z.enum(['celsius', 'fahrenheit']).default('celsius'),
}),
execute: async ({ city, unit }) => {
// Remplacez par un vrai appel API météo
return { city, temperature: 22, unit, condition: 'ensoleillé' };
},
}),
},
prompt: 'Quel temps fait-il à Tokyo en ce moment ?',
});
console.log(text);
L’assistant tool() fournit l’inférence de type depuis le schéma Zod vers les paramètres de la fonction execute. Pas besoin d’analyse JSON manuelle.
Appels d’outils en plusieurs étapes
Par défaut, generateText s’arrête après un tour d’appels d’outils. Définissez maxSteps pour permettre au modèle d’utiliser les résultats des outils dans un raisonnement ultérieur :
const { text } = await generateText({
model: openai('gpt-4o'),
maxSteps: 5,
tools: { getWeather, searchWeb, lookupCalendar },
prompt: 'Planifiez mes activités de plein air pour ce week-end à Berlin.',
});
Le SDK gère automatiquement la boucle appel d’outil → résultat → continuation. Chaque étape est exposée via onStepFinish si vous avez besoin de visibilité sur le raisonnement intermédiaire.
Création de boucles d’agents IA avec le SDK Vercel AI
Un agent dans le SDK AI est un modèle qui tourne en boucle avec des outils jusqu’à ce qu’il décide qu’il a suffisamment d’informations pour répondre. Le modèle est le même que celui des appels d’outils en plusieurs étapes, mais avec plus d’outils et un maxSteps plus long :
import { generateText, tool } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';
const result = await generateText({
model: openai('gpt-4o'),
maxSteps: 10,
system: 'Vous êtes un assistant de recherche. Utilisez les outils disponibles pour répondre de manière approfondie.',
prompt: 'Quelles sont les principales différences entre Llama 3.1 et Qwen3 ?',
tools: {
search: tool({
description: 'Rechercher sur le Web des informations actuelles',
parameters: z.object({ query: z.string() }),
execute: async ({ query }) => searchWeb(query),
}),
summarize: tool({
description: 'Résumer une URL',
parameters: z.object({ url: z.string() }),
execute: async ({ url }) => fetchAndSummarize(url),
}),
},
onStepFinish({ stepType, toolCalls, toolResults }) {
console.log('Étape :', stepType, toolCalls?.map(t => t.toolName));
},
});
Pour les pipelines d’agents en production, connectez Novita AI comme backend de modèle pour maîtriser les coûts et le débit à grande échelle — nous le verrons dans la section suivante.
AI SDK React : Hook useChat et intégration Next.js
Le hook useChat gère l’état du streaming de chat sans code passe-partout :
// app/chat/page.tsx
'use client';
import { useChat } from 'ai/react';
export default function Chat() {
const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
api: '/api/chat',
});
return (
<div>
{messages.map(m => (
<div key={m.id} className={m.role === 'user' ? 'user' : 'assistant'}>
{m.content}
</div>
))}
<form onSubmit={handleSubmit}>
<input
value={input}
onChange={handleInputChange}
placeholder="Demandez quelque chose..."
disabled={isLoading}
/>
<button type="submit" disabled={isLoading}>Envoyer</button>
</form>
</div>
);
}
Le gestionnaire de route correspondant :
// app/api/chat/route.ts
import { streamText } 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-4o-mini'),
messages,
});
return result.toDataStreamResponse();
}
toDataStreamResponse() gère le protocole de streaming Vercel AI, que useChat comprend nativement côté client. Pour streamer des objets structurés depuis une API, remplacez useChat par useObject et streamText par streamObject.
Comment utiliser Novita AI avec le SDK Vercel AI
Novita AI fournit une API compatible OpenAI à l’adresse https://api.novita.ai/v3/openai, ce qui en fait un remplacement direct pour tout SDK utilisant le format OpenAI Chat Completions — y compris le SDK Vercel AI.
Pourquoi utiliser Novita AI avec le SDK AI
Novita AI héberge plus de 70 modèles open-source — Llama 3.3 70B, Qwen3, DeepSeek V3, Mistral et Gemma 3 — via un seul point de terminaison API. Pas d’infrastructure GPU à gérer. Pour les workflows d’agents, l’API serverless passe facilement de petits modèles d’instruction 7B à de grands modèles de raisonnement sans changement de configuration.
Configuration
Installez le package fournisseur compatible OpenAI :
npm install ai @ai-sdk/openai-compatible
Configurez le fournisseur :
import { createOpenAICompatible } from '@ai-sdk/openai-compatible';
const novita = createOpenAICompatible({
name: 'novita',
baseURL: 'https://api.novita.ai/v3/openai',
apiKey: process.env.NOVITA_API_KEY,
});
C’est tout. Maintenant, utilisez-le exactement comme n’importe quel autre fournisseur du SDK AI :
import { generateText } from 'ai';
const { text } = await generateText({
model: novita('meta-llama/llama-3.3-70b-instruct'),
prompt: 'Quels sont les compromis entre le RAG et le fine-tuning pour un bot de support client ?',
});
Le streaming fonctionne de la même manière :
import { streamText } from 'ai';
const result = streamText({
model: novita('qwen/qwen3-235b-a22b-instruct-2507'),
messages: [
{ role: 'system', content: 'Vous êtes un assistant de codage utile.' },
{ role: 'user', content: 'Montrez-moi comment construire une API REST avec FastAPI.' },
],
});
for await (const chunk of result.textStream) {
process.stdout.write(chunk);
}
Appels d’outils avec Novita AI
Les modèles qui prennent en charge les appels de fonction fonctionnent avec l’interface tool() du SDK AI sans configuration supplémentaire. Llama 3.3 70B Instruct et Qwen3 prennent en charge les appels d’outils via l’API de Novita :
import { generateText, tool } from 'ai';
import { z } from 'zod';
const { text } = await generateText({
model: novita('meta-llama/llama-3.3-70b-instruct'),
maxSteps: 5,
tools: {
calculator: tool({
description: 'Évaluer une expression mathématique',
parameters: z.object({ expression: z.string() }),
execute: async ({ expression }) => {
return { result: eval(expression) }; // utiliser un analyseur sécurisé en production
},
}),
},
prompt: 'Que représente 12 % de 847, puis divisé par 3,14 ?',
});
Configuration de l’environnement
Ajoutez votre clé API Novita dans .env.local :
NOVITA_API_KEY=votre_cle_api_novita_ici
Obtenez une clé sur novita.ai — les nouveaux comptes incluent des crédits gratuits pour tester l’API.
Agent Sandbox pour les charges de travail longues
Pour les tâches d’agents qui exécutent du code, accèdent au système de fichiers ou réalisent des workflows de plusieurs minutes, l’Agent Sandbox de Novita AI fournit des environnements d’exécution isolés en plus de l’API LLM. Le SDK AI gère la couche de raisonnement du modèle. Le sandbox gère l’exécution avec état qui ne peut pas s’exécuter dans un délai d’attente de fonction edge.
Choisir un fournisseur de LLM pour le SDK Vercel AI
Le SDK AI facilite le changement de fournisseur, ce qui est utile — mais il est bon de comprendre les compromis avant d’en choisir un pour la production.
Latence : Le délai avant le premier token est plus important que la vitesse totale de génération pour le streaming de chat. Les modèles plus petits (8B–14B) produisent les premiers tokens plus rapidement. Les points de terminaison serverless de Novita AI sont optimisés pour une faible latence de démarrage à froid sur les modèles ouverts.
Coût à grande échelle : GPT-4o est excellent, mais avec des volumes de requêtes élevés, l’écart de prix entre un modèle de pointe et un modèle ouvert bien ajusté (par exemple, Llama 3.3 70B) devient significatif. Le SDK AI vous permet d’expérimenter avec les deux sans réécrire la logique applicative.
Prise en charge des appels d’outils : Tous les modèles ne prennent pas en charge les appels de fonction de manière fiable. Testez votre modèle spécifique par rapport à vos schémas d’outils — le comportement varie selon les fournisseurs, même pour la même famille de modèles.
Fenêtre de contexte : Pour le RAG avec beaucoup de documents ou les historiques de conversation longs, vérifiez les limites de contexte. De nombreux modèles ouverts prennent en charge 128K tokens, ce qui couvre la plupart des cas d’utilisation pratiques.
Verrouillage fournisseur : L’abstraction de fournisseur du SDK AI avec le point de terminaison compatible OpenAI de Novita AI signifie que vous pouvez changer de modèle ou ajouter un fournisseur de secours sans toucher au code de l’application.
Conclusion
Le SDK Vercel AI élimine le code passe-partout de la création d’applications IA — une API pour la génération de texte, le streaming, les appels d’outils et les boucles d’agents, et ce pour n’importe quel fournisseur de LLM. Que vous construisiez une interface de chat en streaming avec useChat, extrayiez des données structurées avec generateObject, ou exécutiez un agent en plusieurs étapes qui appelle des outils externes, le SDK gère la tuyauterie pour que vous puissiez vous concentrer sur la logique applicative.
Pour l’inférence avec des modèles ouverts, l’API compatible OpenAI de Novita AI s’intègre directement dans le SDK via @ai-sdk/openai-compatible. Vous accédez à plus de 70 modèles — Llama, Qwen3, DeepSeek, Mistral — sans gérer d’infrastructure GPU, et vous pouvez changer de modèle ou ajouter des fournisseurs de secours sans toucher au code de votre application.
Commencez sur novita.ai — les nouveaux comptes incluent des crédits gratuits.
FAQ
Qu’est-ce que l’AI SDK React ?
L’intégration React du SDK AI se trouve dans le package ai/react. Elle fournit des hooks — useChat, useCompletion, useObject, useAssistant — qui connectent un frontend React à une route de streaming côté serveur. Les hooks gèrent l’état du streaming, l’historique des messages, les indicateurs de chargement et la gestion des erreurs, évitant ainsi d’avoir à gérer ReadableStream dans l’état du composant.
Qu’apporte l’AI SDK 5 ?
L’AI SDK 5 (publié en version bêta mi-2025) a redessiné la spécification du fournisseur pour une meilleure sécurité des types, séparé la gestion de l’état de l’interface utilisateur de la logique d’interaction avec le modèle, et introduit un format de message révisé qui facilite la sérialisation de l’état de l’interface utilisateur agentique. Si vous démarrez un nouveau projet en 2026, consultez ai-sdk.dev pour la dernière version stable — le SDK a continué d’évoluer à travers les versions 6 et 7.
Existe-t-il une documentation AI SDK que je puisse consulter ?
La documentation officielle se trouve sur ai-sdk.dev. Elle comprend des guides de configuration des fournisseurs, des références API pour toutes les fonctions principales, des tutoriels d’intégration de frameworks (Next.js, Nuxt, SvelteKit) et des exemples de recettes pour des modèles courants comme le RAG, les boucles d’agents et l’extraction structurée.
Puis-je utiliser les outils AI SDK avec des modèles non OpenAI ?
Oui. Tout fournisseur prenant en charge les appels de fonction fonctionne avec l’interface tool() du SDK AI. Novita AI héberge plusieurs modèles ouverts avec prise en charge des appels de fonction. La qualité du comportement varie — Llama 3.3 70B et Qwen3 sont les plus fiables pour l’utilisation d’outils en plusieurs étapes parmi les modèles ouverts disponibles via l’API de Novita.
Quelle est la différence entre la documentation de Vercel AI SDK et celle de ai-sdk.dev ?
C’est le même produit. La documentation se trouvait auparavant sur sdk.vercel.ai et redirige vers ai-sdk.dev. Le SDK est maintenu par l’équipe Vercel mais est open-source et n’est pas lié au déploiement sur l’infrastructure Vercel.
Comment les SDK d’intelligence artificielle se comparent-ils à l’appel direct de l’API LLM ?
Les appels API directs conviennent pour des requêtes simples ponctuelles. Un SDK devient utile dès que vous avez besoin de plusieurs choses à la fois : streaming intégré à un framework d’interface utilisateur, boucles d’appels d’outils en plusieurs étapes, validation des sorties structurées, changement unifié de fournisseur, et gestion cohérente des tentatives et des erreurs entre fournisseurs. Le SDK AI gère tout cela au niveau de la bibliothèque, évitant de le reconstruire pour chaque projet.
