Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Integrering med Vercel AI SDK

Lektion 7 av 14 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Multi-agent i JavaScript-ekosystemet
  2. Installation
  3. Grundkonfiguration
  4. Styrning av antal agenter
  5. Strömning med streamText
  6. Felhantering
  7. Användningsfall i en webbapplikation
  8. Viktiga punkter

Uppdaterat den 3 november 2026, baserat på dokumentationen för AI SDK 7 och xAIs sida om Multi-agent: xai() använder nu Responses API (varningen från föregående version gäller inte längre), Next.js-rutten använder inte längre den borttagna funktionen toDataStreamResponse(), och reservlösningen riktar sig mot grok-4.7. Mappningen low/medium → 4 agenter, high/xhigh → 16 agenter kommer från xAIs dokumentation. Källor: AI SDK, xAI provider · xAI, Multi-agent.

Multi-agent i JavaScript-ekosystemet

Vercel AI SDK (ai) har blivit en standard för att integrera AI-modeller i webbapplikationer skrivna i JavaScript och TypeScript. Tillsammans med providern @ai-sdk/xai får du tillgång till Groks multi-agent-läge direkt från Next.js, SvelteKit eller valfritt annat JavaScript-ramverk, utan att behöva lämna de abstraktioner ditt front-end-team redan känner till.

Installation

Du behöver två paket:

npm install ai @ai-sdk/xai

De delar på arbetet: @ai-sdk/xai hanterar kommunikationen med xAI:s API, medan ai tillhandahåller de generiska funktionerna generateText och streamText som du använder oavsett vilken provider det gäller.

Grundkonfiguration

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 xAI:s Responses API. Med nuvarande versioner (AI SDK 7 och @ai-sdk/xai 5) är detta det enda API som providern använder: xai(model) går redan genom det. Att skriva xai.responses() gör detta val explicit, vilket också skyddar kod som körs mot en äldre SDK-version där xai() gick via Chat Completions.

Styrning av antal agenter

Du anger antalet agenter med providerOptions.xai.reasoningEffort:

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

Mappningen är densamma som du såg med OpenAI SDK: low och medium använder 4 agenter, medan high och xhigh använder 16. Du får alltså samma två lägen under ett annat parameternamn.

Strömning med streamText

I en webbapplikation blir strömning obligatorisk: en forskningskörning med flera agenter kan ta en minut, och ingen sitter kvar framför 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 som använder App Router behöver du inte ens konsumera strömmen på servern: en API-rutt kan returnera den direkt till webbläsaren.

// 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å textström: på klienten läser du den med fetch,
  // eller med useChat och en TextStreamChatTransport
  return createTextStreamResponse({
    stream: toTextStream({ stream: result.stream }),
  });
}

reasoningEffort: "low" i detta exempel är ett medvetet val: på en rutt som anropas direkt från användargränssnittet skulle latensen för 16 agenter vara svår att upprätthålla.

Felhantering

Eftersom multi-agent är i beta bör ett driftstopp inte leda till en trasig sida. Mönstret nedan visar den enklaste reservlösningen: fånga felet och kör samma fråga igen på en standardmodell:

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);
  // Växla till en standardmodell som reserv
  const { text } = await generateText({
    model: xai("grok-4.7"),
    prompt: "My question",
  });
  return text;
}

Reservlösningen växlar till en standardmodell, grok-4.7, som inte har multi-agent-begränsningarna (med AI SDK 7 använder även xai() Responses API). Informera också din användare på något sätt, eftersom svaret från reservlösningen kommer att vara mindre utförligt än det de förväntade sig.

Användningsfall i en webbapplikation

Det användningsfall som får mest ut av denna integration är det avancerade forskningsgränssnittet: användaren ställer en komplex fråga, din applikation öppnar strömmen och svaret skriver sig självt på skärmen medan agenterna fortsätter arbeta i bakgrunden.

Den resulterande upplevelsen är överraskande naturlig. Texten avancerar, pausar ibland när agenterna startar en webbsökning, och fortsätter sedan. Dessa pauser är långt ifrån ett fel: de talar om för användaren att riktig forskning pågår – förutsatt att ditt gränssnitt parar ihop dem med en indikator istället för att få det att se ut som att systemet har hängt sig.

Viktiga punkter

  • Använd @ai-sdk/xai med xai.responses() för multi-agent
  • Styr antalet agenter med providerOptions.xai.reasoningEffort
  • streamText är idealiskt för interaktiva webbapplikationer
  • Vercel AI SDK integreras nativt med Next.js och andra ramverk
  • Planera en reservlösning till en standardmodell vid fel