Przejdź do głównej treści
Polski— Wybierz język
Menu

Integracja z Vercel AI SDK

Lekcja 7 z 14 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Multi-agent w ekosystemie JavaScript
  2. Instalacja
  3. Podstawowa konfiguracja
  4. Kontrolowanie liczby agentów
  5. Strumieniowanie z streamText
  6. Obsługa błędów
  7. Przypadek użycia w aplikacji internetowej
  8. Kluczowe wnioski

Zaktualizowano 3 listopada 2026 r. na podstawie dokumentacji AI SDK 7 oraz strony Multi-agent od xAI: xai() korzysta teraz z Responses API (ostrzeżenie z poprzedniej wersji nie ma już zastosowania), trasa Next.js nie używa już usuniętej funkcji toDataStreamResponse(), a mechanizm awaryjny celuje w model grok-4.7. Mapowanie low/medium → 4 agenci, high/xhigh → 16 agentów pochodzi z dokumentacji xAI. Źródła: AI SDK, dostawca xAI · xAI, Multi-agent.

Multi-agent w ekosystemie JavaScript

Vercel AI SDK (ai) stało się standardem integrowania modeli AI z aplikacjami internetowymi w JavaScript i TypeScript. W połączeniu z dostawcą @ai-sdk/xai uzyskujesz dostęp do trybu multi-agent Groka bezpośrednio z Next.js, SvelteKit lub dowolnego innego frameworka JavaScript, nie wychodząc poza abstrakcje znane Twojemu zespołowi front-endowemu.

Instalacja

Potrzebujesz dwóch pakietów:

npm install ai @ai-sdk/xai

Dzielą one pracę: @ai-sdk/xai obsługuje komunikację z API xAI, podczas gdy ai udostępnia ogólne funkcje generateText i streamText, z których korzystasz niezależnie od dostawcy.

Podstawowa konfiguracja

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

const { text } = await generateText({
  model: xai.responses("grok-4.20-multi-agent-0309"),
  prompt: "Jakie są najnowsze frameworki JavaScript z 2026 roku?",
  providerOptions: {
    xai: { reasoningEffort: "low" },
  },
});

console.log(text);

Tryb multi-agent wymaga API Responses od xAI. W obecnych wersjach (AI SDK 7 oraz @ai-sdk/xai 5) jest to jedyne API, z którego korzysta ten dostawca: wywołanie xai(model) już przez nie przechodzi. Zapis xai.responses() czyni ten wybór explicitnym, co dodatkowo chroni kod uruchamiany przeciwko starszej wersji SDK, gdzie xai() korzystało z Chat Completions.

Kontrolowanie liczby agentów

Liczbę agentów ustawiasz za pomocą providerOptions.xai.reasoningEffort:

// Przekaż jako providerOptions do generateText lub streamText
const rapide = { xai: { reasoningEffort: "low" } };       // 4 agenci
const approfondie = { xai: { reasoningEffort: "high" } }; // 16 agentów

Mapowanie jest takie samo, jakie widziałeś w SDK OpenAI: low i medium używają 4 agentów, podczas gdy high i xhigh używają 16. Otrzymujesz więc te same dwa tryby pod inną nazwą parametru.

Strumieniowanie z streamText

W aplikacji internetowej strumieniowanie staje się koniecznością: uruchomienie badania multi-agent może zająć minutę, a nikt nie będzie tak długo wpatrywał się w pusty ekran.

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

const result = streamText({
  model: xai.responses("grok-4.20-multi-agent-0309"),
  prompt: "Przeanalizuj trendy rynkowe AI w Europie",
  providerOptions: {
    xai: { reasoningEffort: "medium" },
  },
});

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

W aplikacji Next.js korzystającej z App Router nie musisz nawet konsumować strumienia po stronie serwera: trasa API może zwrócić go bezpośrednio do przeglądarki.

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

  // Surowy strumień tekstowy: po stronie klienta odczytaj go przez fetch
  // lub użyj useChat z TextStreamChatTransport
  return createTextStreamResponse({
    stream: toTextStream({ stream: result.stream }),
  });
}

Wartość reasoningEffort: "low" w tym przykładzie jest wyborem świadomym: na trasie wywoływanej bezpośrednio z interfejsu użytkownika opóźnienie generowane przez 16 agentów byłoby trudne do utrzymania.

Obsługa błędów

Ponieważ multi-agent znajduje się w fazie beta, awaria nie powinna prowadzić do wyświetlenia błędu na stronie. Poniższy wzorzec pokazuje najprostsze rozwiązanie awaryjne: przechwyć błąd i ponów to samo pytanie na standardowym modelu:

try {
  const { text } = await generateText({
    model: xai.responses("grok-4.20-multi-agent-0309"),
    prompt: "Moje pytanie",
    providerOptions: {
      xai: { reasoningEffort: "low" },
    },
  });
  return text;
} catch (error) {
  console.error("Błąd multi-agent:", error);
  // Przełącz się na model standardowy
  const { text } = await generateText({
    model: xai("grok-4.7"),
    prompt: "Moje pytanie",
  });
  return text;
}

Mechanizm awaryjny przełącza się na standardowy model grok-4.7, który nie posiada ograniczeń trybu multi-agent (w AI SDK 7 xai() również korzysta z Responses API). Poinformuj użytkownika w jakiś sposób o tej zmianie, ponieważ odpowiedź zastępcza będzie mniej szczegółowa niż ta, której się spodziewał.

Przypadek użycia w aplikacji internetowej

Przypadkiem użycia, który najlepiej wykorzystuje tę integrację, jest zaawansowany interfejs badawczy: użytkownik zadaje złożone pytanie, Twoja aplikacja otwiera strumień, a odpowiedź wpisuje się na ekran, podczas gdy agenci nadal pracują w tle.

Efekt końcowy jest zaskakująco naturalny. Tekst postępuje naprzód, czasem pauzuje, gdy agenci uruchamiają wyszukiwanie w sieci, a następnie wznawia działanie. Te pauzy wcale nie są wadą: informują użytkownika, że trwają rzeczywiste badania – pod warunkiem, że Twój interfejs połączy je z odpowiednim wskaźnikiem, zamiast sprawiać wrażenie zawieszenia.

Kluczowe wnioski

  • Używaj @ai-sdk/xai z xai.responses() dla trybu multi-agent
  • Kontroluj liczbę agentów za pomocą providerOptions.xai.reasoningEffort
  • streamText jest idealne dla interaktywnych aplikacji internetowych
  • Vercel AI SDK integruje się natywnie z Next.js i innymi frameworkami
  • Zaplanuj mechanizm awaryjny przełączający na standardowy model w przypadku błędu