- Qu'est-ce que le SDK Vercel AI ?
- AI SDK Core : generateText, streamText et generateObject
- Outils du SDK AI : Appels de fonctions et utilisation d'outils
- Construction de boucles d'agents IA avec le SDK Vercel AI
- SDK AI 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’IA. Il gère la génération de texte, le streaming, les sorties structurées, les appels d’outils et les boucles d’agents multi-étapes via une seule API unifiée — et il fonctionne avec la plupart des fournisseurs de LLM majeurs. Si vous avez déjà essayé de connecter directement OpenAI ou Anthropic à 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 construisant 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 un seul import.
Le SDK est livré en deux couches :
- AI SDK Core gère les interactions avec les modèles : 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 est importante :
import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';
const result = streamText({
model: openai('gpt-4o-mini'),
messages: [
{ role: 'user', content: 'Guide-moi dans la configuration d\'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 à l’aide de 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 prompt système nécessaire pour contraindre le modèle à produire du JSON valide et réessaye en cas de sortie malformée.
Outils du SDK AI : Appels de fonctions 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 d'API météo
return { city, temperature: 22, unit, condition: 'ensoleillé' };
},
}),
},
prompt: 'Quel temps fait-il à Tokyo en ce moment ?',
});
console.log(text);
Le helper tool() fournit une inférence de type du schéma Zod vers les paramètres de la fonction execute. Pas besoin d’analyse JSON manuelle.
Appels d’outils multi-é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 de suivi :
const { text } = await generateText({
model: openai('gpt-4o'),
maxSteps: 5,
tools: { getWeather, searchWeb, lookupCalendar },
prompt: 'Planifie 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.
Construction de boucles d’agents IA avec le SDK Vercel AI
Un agent dans le SDK AI est un modèle fonctionnant 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 multi-é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 contrôler le coût et le débit à grande échelle — couvert dans la section suivante.
SDK AI React : Hook useChat et intégration Next.js
Le hook useChat gère l’état du chat en streaming 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 flux Vercel AI, que useChat côté client comprend nativement. Pour diffuser 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 à 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 d’accès API. Aucune infrastructure GPU à gérer. Pour les workflows d’agents, l’API serverless évolue des petits modèles d’instruction 7B jusqu’aux 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 toute la configuration. Utilisez-le maintenant 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 RAG et 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: 'Montre-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 prenant 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) }; // utilisez un analyseur mathématique sécurisé en production
},
}),
},
prompt: 'Quel est 12 % de 847, puis divisé par 3,14 ?',
});
Configuration de l’environnement
Ajoutez votre clé API Novita à .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 de longue durée
Pour les tâches d’agents qui exécutent du code, accèdent aux systèmes de fichiers ou exécutent des workflows de plusieurs minutes, l’Agent Sandbox de Novita AI fournit des environnements d’exécution isolés au-dessus 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’expiration 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 important de comprendre les compromis avant d’en choisir un pour la production.
Latence : Le délai avant le premier token compte plus que la vitesse de génération totale pour le chat en streaming. Les modèles plus petits (8B–14B) produisent les premiers tokens plus rapidement. Les points d’accès serverless de Novita AI sont optimisés pour une faible latence de démarrage à froid sur les modèles ouverts.
Coût à l’échelle : GPT-4o est excellent, mais à des volumes de requêtes élevés, l’écart de prix entre un modèle de pointe et un modèle ouvert bien réglé (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 avec 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 les 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 d’accès compatible OpenAI de Novita AI signifie que vous pouvez changer de modèle ou ajouter un fournisseur de secours sans toucher au code applicatif.
Conclusion
Le SDK Vercel AI élimine le code passe-partout de la création d’applications d’IA — une API pour la génération de texte, le streaming, les appels d’outils et les boucles d’agents sur 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 multi-étapes qui appelle des outils externes, le SDK gère la plomberie pour que vous puissiez vous concentrer sur la logique applicative.
Pour l’inférence de modèles ouverts, l’API compatible OpenAI de Novita AI s’intègre directement dans le SDK via @ai-sdk/openai-compatible. Vous avez accès à 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 à votre code applicatif.
Commencez sur novita.ai — les nouveaux comptes incluent des crédits gratuits.
FAQ
Qu’est-ce que 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 afin que vous n’ayez pas à gérer ReadableStream dans l’état du composant.
Qu’apporte ai sdk 5 ?
Le SDK AI 5 (sorti en version bêta mi-2025) a repensé la spécification du fournisseur pour une meilleure sécurité des types, a séparé la gestion de l’état de l’interface utilisateur de la logique d’interaction avec le modèle, et a 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 canonique 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 les modèles courants comme 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 une utilisation multi-étapes des outils parmi les modèles ouverts disponibles via l’API de Novita.
Quelle est la différence entre la documentation vercel ai sdk et la documentation ai-sdk.dev ?
C’est le même produit. La documentation se trouvait auparavant sur sdk.vercel.ai et redirige désormais 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 sont acceptables pour des requêtes uniques simples. Un SDK devient intéressant dès que vous avez besoin de plusieurs choses à la fois : streaming intégré à un framework UI, boucles d’appels d’outils multi-étapes, validation de sortie structurée, changement unifié de fournisseur, et gestion cohérente des tentatives et des erreurs entre les fournisseurs. Le SDK AI gère tout cela au niveau de la bibliothèque afin que vous n’ayez pas à le reconstruire pour chaque projet.
