Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Integratie met de Vercel AI SDK

Les 7 van 14 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Multi-agent in het JavaScript-ecosysteem
  2. Installatie
  3. Basisconfiguratie
  4. Het aantal agents sturen
  5. Streamen met streamText
  6. Foutafhandeling
  7. Use case in een webapplicatie
  8. Belangrijkste punten

Bijgewerkt op 3 november 2026, gebaseerd op de AI SDK 7-documentatie en de Multi-agent-pagina van xAI: xai() maakt nu gebruik van de Responses API (de waarschuwing uit de vorige versie is niet langer van toepassing), de Next.js-route gebruikt de verwijderde toDataStreamResponse() niet meer, en de fallback richt zich op grok-4.7. De toewijzing low/medium → 4 agents, high/xhigh → 16 agents komt uit de documentatie van xAI. Bronnen: AI SDK, xAI provider · xAI, Multi-agent.

Multi-agent in het JavaScript-ecosysteem

De Vercel AI SDK (ai) is uitgegroeid tot een standaard voor het integreren van AI-modellen in JavaScript- en TypeScript-webapplicaties. In combinatie met de @ai-sdk/xai-provider krijgt u toegang tot de multi-agent-modus van Grok vanuit Next.js, SvelteKit of elk ander JavaScript-framework, zonder dat u de abstracties hoeft te verlaten die uw front-endteam al kent.

Installatie

U heeft twee pakketten nodig:

npm install ai @ai-sdk/xai

Ze verdelen het werk: @ai-sdk/xai regelt de communicatie met de xAI API, terwijl ai de algemene functies generateText en streamText biedt die u ongeacht de provider gebruikt.

Basisconfiguratie

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

const { text } = await generateText({
  model: xai.responses("grok-4.20-multi-agent-0309"),
  prompt: "What are the latest JavaScript frameworks of 2026?",
  providerOptions: {
    xai: { reasoningEffort: "low" },
  },
});

console.log(text);

Multi-agent vereist de Responses API van xAI. Met de huidige versies (AI SDK 7 en @ai-sdk/xai 5) is dit de enige API die de provider gebruikt: xai(model) maakt er al gebruik van. Het schrijven van xai.responses() maakt deze keuze expliciet, wat ook code beschermt die draait tegen een oudere SDK-versie waarbij xai() nog via Chat Completions ging.

Het aantal agents sturen

U stelt het aantal agents in met providerOptions.xai.reasoningEffort:

// Geef door als providerOptions aan generateText of streamText
const rapide = { xai: { reasoningEffort: "low" } };       // 4 agents
const approfondie = { xai: { reasoningEffort: "high" } }; // 16 agents

De toewijzing is dezelfde als u bij de OpenAI SDK heeft gezien: low en medium gebruiken 4 agents, terwijl high en xhigh er 16 gebruiken. U krijgt dus dezelfde twee modi onder een andere parameternaam.

Streamen met streamText

In een webapplicatie wordt streamen verplicht: een multi-agent onderzoekssessie kan een minuut duren, en niemand blijft zo lang voor een leeg scherm zitten.

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

const result = streamText({
  model: xai.responses("grok-4.20-multi-agent-0309"),
  prompt: "Analyze AI market trends in Europe",
  providerOptions: {
    xai: { reasoningEffort: "medium" },
  },
});

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

In een Next.js-applicatie die gebruikmaakt van de App Router, hoeft u de stream niet eens aan de serverkant te consumeren: een API-route kan deze direct naar de browser retourneren.

// 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" },
    },
  });

  // Ruwe tekststream: lees deze aan de clientkant met fetch,
  // of met useChat en een TextStreamChatTransport
  return createTextStreamResponse({
    stream: toTextStream({ stream: result.stream }),
  });
}

De reasoningEffort: "low" in dit voorbeeld is een bewuste keuze: bij een route die direct vanuit de UI wordt aangeroepen, zou de latentie van 16 agents moeilijk vol te houden zijn.

Foutafhandeling

Omdat multi-agent zich in bètafase bevindt, mag een storing niet leiden tot een gebroken pagina. Het onderstaande patroon toont de eenvoudigste fallback: vang de fout op en stel dezelfde vraag opnieuw aan een standaardmodel:

try {
  const { text } = await generateText({
    model: xai.responses("grok-4.20-multi-agent-0309"),
    prompt: "My question",
    providerOptions: {
      xai: { reasoningEffort: "low" },
    },
  });
  return text;
} catch (error) {
  console.error("Multi-agent error:", error);
  // Fallback naar een standaardmodel
  const { text } = await generateText({
    model: xai("grok-4.7"),
    prompt: "My question",
  });
  return text;
}

De fallback schakelt over naar een standaardmodel, grok-4.7, dat niet te maken heeft met de beperkingen van multi-agent (met AI SDK 7 gebruikt xai() ook de Responses API). Laat uw gebruiker dit ook op de een of andere manier weten, omdat het antwoord bij de fallback minder grondig zal zijn dan verwacht.

Use case in een webapplicatie

De use case die het meeste haalt uit deze integratie is de geavanceerde onderzoeksinterface: de gebruiker stelt een complexe vraag, uw applicatie opent de stream, en het antwoord schrijft zichzelf naar het scherm terwijl de agents op de achtergrond blijven werken.

De resulterende ervaring is verrassend natuurlijk. De tekst vordert, pauzeert soms wanneer de agents een webzoekopdracht starten, en gaat dan weer verder. Deze pauzes zijn verre van een fout: ze vertellen de gebruiker dat er echt onderzoek plaatsvindt—op voorwaarde dat uw interface ze koppelt aan een indicator in plaats van de indruk te wekken dat het vastloopt.

Belangrijkste punten

  • Gebruik @ai-sdk/xai met xai.responses() voor multi-agent
  • Stuur het aantal agents met providerOptions.xai.reasoningEffort
  • streamText is ideaal voor interactieve webapplicaties
  • De Vercel AI SDK integreert native met Next.js en andere frameworks
  • Voorzie een fallback naar een standaardmodel voor het geval er een fout optreedt