Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Integration med Vercel AI SDK

Lektion 7 af 14 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Multi-agent i JavaScript-økosystemet
  2. Installation
  3. Grundlæggende konfiguration
  4. Styring af antal agenter
  5. Streaming med streamText
  6. Fejlhåndtering
  7. Use case i en webapplikation
  8. Vigtige pointer

Opdateret 3. november 2026 baseret på AI SDK 7-dokumentationen og xAIs side om Multi-agent: xai() bruger nu Responses API (advarslen fra den tidligere version gælder ikke længere), Next.js-ruten bruger ikke længere den fjernede toDataStreamResponse(), og fallback-målet er grok-4.7. Mappingen low/medium → 4 agenter, high/xhigh → 16 agenter stammer fra xAIs dokumentation. Kilder: AI SDK, xAI-provider · xAI, Multi-agent.

Multi-agent i JavaScript-økosystemet

Vercel AI SDK (ai) er blevet standarden for at integrere AI-modeller i JavaScript- og TypeScript-webapplikationer. Sammen med @ai-sdk/xai-provideren får du adgang til Groks multi-agent-tilstand fra Next.js, SvelteKit eller ethvert andet JavaScript-framework, uden at skulle forlade de abstraktioner, dit front-end-team allerede kender.

Installation

Du har brug for to pakker:

npm install ai @ai-sdk/xai

De deler arbejdet: @ai-sdk/xai håndterer kommunikationen med xAI-API’et, mens ai leverer de generiske funktioner generateText og streamText, som du bruger uanset provider.

Grundlæggende konfiguration

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 kræver xAIs Responses API. Med nuværende versioner (AI SDK 7 og @ai-sdk/xai 5) er det den eneste API, provideren bruger: xai(model) går allerede igennem den. At skrive xai.responses() gør dette valg eksplicit, hvilket også beskytter kode, der kører mod en ældre SDK-version, hvor xai() gik via Chat Completions.

Styring af antal agenter

Du angiver antallet af agenter med providerOptions.xai.reasoningEffort:

// Sendes som providerOptions til generateText eller streamText
const rapide = { xai: { reasoningEffort: "low" } };       // 4 agenter
const approfondie = { xai: { reasoningEffort: "high" } }; // 16 agenter

Mappingen er den samme, som du så med OpenAI SDK: low og medium bruger 4 agenter, mens high og xhigh bruger 16. Du får altså de samme to tilstande under et andet parameternavn.

Streaming med streamText

I en webapplikation bliver streaming obligatorisk: En multi-agent-researchkørsel kan tage et minut, og ingen sidder foran en tom skærm så længe.

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);
}

I en Next.js-applikation, der bruger App Router, behøver du ikke engang at forbruge strømmen på serveren: En API-rute kan returnere den direkte til browseren.

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

  // Rå tekststream: På klienten læses den med fetch,
  // eller med useChat og en TextStreamChatTransport
  return createTextStreamResponse({
    stream: toTextStream({ stream: result.stream }),
  });
}

reasoningEffort: "low" i dette eksempel er et bevidst valg: På en rute, der kaldes direkte fra UI’et, vil latensen ved 16 agenter være svær at opretholde.

Fejlhåndtering

Da multi-agent er i beta, bør en nedetid ikke resultere i en ødelagt side. Mønsteret nedenfor viser den enkleste fallback-løsning: Fang fejlen og gentag det samme spørgsmål på en standardmodel:

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 til en standardmodel
  const { text } = await generateText({
    model: xai("grok-4.7"),
    prompt: "My question",
  });
  return text;
}

Fallbacket skifter til en standardmodel, grok-4.7, som ikke har multi-agents begrænsninger (med AI SDK 7 bruger xai() også Responses API). Sørg også for at informere din bruger på en eller anden måde, da fallback-svaret vil være mindre grundigt end det, de forventede.

Use case i en webapplikation

Det use case, der får mest ud af denne integration, er den avancerede research-grænseflade: Brugeren stiller et komplekst spørgsmål, din applikation åbner strømmen, og svaret skriver sig selv på skærmen, mens agenterne fortsætter arbejdet i baggrunden.

Den resulterende oplevelse er overraskende naturlig. Teksten skrider frem, pauses nogle gange, når agenterne iværksætter en websøgning, og genoptages derefter. Disse pauser er langt fra en fejl: De fortæller brugeren, at der foregår rigtig research – forudsat at din grænseflade parter dem med en indikator i stedet for at få det til at ligne en standsning.

Vigtige pointer

  • Brug @ai-sdk/xai med xai.responses() til multi-agent
  • Styr antallet af agenter med providerOptions.xai.reasoningEffort
  • streamText er ideel til interaktive webapplikationer
  • Vercel AI SDK integrerer nativt med Next.js og andre frameworks
  • Planlæg en fallback til en standardmodel i tilfælde af fejl