Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Intégration avec le Vercel AI SDK

Õppetund 7 / 14 Värskendatud 29. juuli 2026 Arendajatele
Sellel lehel
  1. Le multi-agent dans l’écosystème JavaScript
  2. Installation
  3. Configuration de base
  4. Contrôle du nombre d’agents
  5. Streaming avec streamText
  6. Gestion des erreurs
  7. Cas d’usage dans une application web
  8. Peamised punktid

Mis à jour le 3 novembre 2026, sur la base de la documentation de l’AI SDK 7 et de la page Multi-agent de xAI : xai() utilise désormais l’API Responses (l’avertissement de la version précédente ne s’applique plus), la route Next.js n’utilise plus la fonction supprimée toDataStreamResponse(), et le repli cible grok-4.7. La correspondance low/medium → 4 agents, high/xhigh → 16 agents provient de la documentation de xAI. Sources : AI SDK, fournisseur xAI · xAI, Multi-agent.

Le multi-agent dans l’écosystème JavaScript

Le Vercel AI SDK (ai) est devenu la norme pour intégrer des modèles d’IA dans les applications web JavaScript et TypeScript. Couplé au fournisseur @ai-sdk/xai, il te donne accès au mode multi-agent de Grok depuis Next.js, SvelteKit ou tout autre framework JavaScript, sans quitter les abstractions que ton équipe front-end connaît déjà.

Installation

Tu as besoin de deux paquets :

npm install ai @ai-sdk/xai

Ils se partagent le travail : @ai-sdk/xai gère la communication avec l’API xAI, tandis que ai fournit les fonctions génériques generateText et streamText que tu utilises quel que soit le fournisseur.

Configuration de base

import { xai } from "@ai-sdk/xai";
import { generateText } from "ai";

const { text } = await generateText({
  model: xai.responses("grok-4.20-multi-agent-0309"),
  prompt: "Quels sont les derniers frameworks JavaScript de 2026 ?",
  providerOptions: {
    xai: { reasoningEffort: "low" },
  },
});

console.log(text);

Le multi-agent nécessite l’API Responses de xAI. Avec les versions actuelles (AI SDK 7 et @ai-sdk/xai 5), c’est la seule API que le fournisseur utilise : xai(model) passe déjà par elle. Écrire xai.responses() rend ce choix explicite, ce qui protège également le code s’exécutant contre une version plus ancienne du SDK où xai() passait par Chat Completions.

Contrôle du nombre d’agents

Tu définis le nombre d’agents avec providerOptions.xai.reasoningEffort :

// À passer comme providerOptions à generateText ou streamText
const rapide = { xai: { reasoningEffort: "low" } };       // 4 agents
const approfondie = { xai: { reasoningEffort: "high" } }; // 16 agents

La correspondance est la même que celle que tu as vue avec le SDK OpenAI : low et medium utilisent 4 agents, tandis que high et xhigh en utilisent 16. Tu obtiens donc les deux mêmes modes sous un nom de paramètre différent.

Streaming avec streamText

Dans une application web, le streaming devient obligatoire : une exécution de recherche multi-agent peut prendre une minute, et personne ne reste devant un écran vide aussi longtemps.

import { xai } from "@ai-sdk/xai";
import { streamText } from "ai";

const result = streamText({
  model: xai.responses("grok-4.20-multi-agent-0309"),
  prompt: "Analyse les tendances du marché de l'IA en Europe",
  providerOptions: {
    xai: { reasoningEffort: "medium" },
  },
});

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

Dans une application Next.js utilisant l’App Router, tu n’as même pas besoin de consommer le flux côté serveur : une route API peut le renvoyer directement au navigateur.

// app/api/research/route.ts
import { xai } from "@ai-sdk/xai";
import { createTextStreamResponse, streamText, toTextStream } from "ai";

export async function POST(req: Request) {
  const { query } = await req.json();

  const result = streamText({
    model: xai.responses("grok-4.20-multi-agent-0309"),
    prompt: query,
    providerOptions: {
      xai: { reasoningEffort: "low" },
    },
  });

  // Flux de texte brut : côté client, lis-le avec fetch,
  // ou avec useChat et un TextStreamChatTransport
  return createTextStreamResponse({
    stream: toTextStream({ stream: result.stream }),
  });
}

Le reasoningEffort: "low" dans cet exemple est un choix délibéré : sur une route appelée directement depuis l’interface utilisateur, la latence de 16 agents serait difficile à soutenir.

Gestion des erreurs

Parce que le multi-agent est en bêta, une panne ne doit pas se transformer en page cassée. Le motif ci-dessous montre le repli le plus simple : attraper l’erreur et rejouer la même question sur un modèle standard :

try {
  const { text } = await generateText({
    model: xai.responses("grok-4.20-multi-agent-0309"),
    prompt: "Ma question",
    providerOptions: {
      xai: { reasoningEffort: "low" },
    },
  });
  return text;
} catch (error) {
  console.error("Erreur multi-agent :", error);
  // Repli vers un modèle standard
  const { text } = await generateText({
    model: xai("grok-4.7"),
    prompt: "Ma question",
  });
  return text;
}

Le repli bascule vers un modèle standard, grok-4.7, qui n’a pas les contraintes du multi-agent (avec l’AI SDK 7, xai() utilise également l’API Responses). Préviens aussi ton utilisateur d’une manière ou d’une autre, car la réponse de repli sera moins approfondie que celle qu’il attendait.

Cas d’usage dans une application web

Le cas d’usage qui tire le meilleur parti de cette intégration est l’interface de recherche avancée : l’utilisateur pose une question complexe, ton application ouvre le flux, et la réponse s’écrit elle-même à l’écran pendant que les agents continuent de travailler en arrière-plan.

L’expérience qui en résulte est étonnamment naturelle. Le texte avance, fait parfois pause lorsque les agents lancent une recherche web, puis reprend. Ces pauses sont loin d’être un défaut : elles indiquent à l’utilisateur qu’une véritable recherche est en cours, à condition que ton interface les associe à un indicateur au lieu de donner l’impression d’un blocage.

Peamised punktid

  • Utilise @ai-sdk/xai avec xai.responses() pour le multi-agent
  • Contrôle le nombre d’agents avec providerOptions.xai.reasoningEffort
  • streamText est idéal pour les applications web interactives
  • Le Vercel AI SDK s’intègre nativement avec Next.js et d’autres frameworks
  • Prévois un repli vers un modèle standard en cas d’erreur