Zum Hauptinhalt springen
Deutsch— Sprache auswählen
Menü

Integration des Vercel AI SDK und des Frontends

Lektion 6 von 12 Aktualisiert am 3. November 2026 Entwickler
Auf dieser Seite
  1. Der Vercel AI SDK für Webanwendungen
  2. Installation
  3. Serverseitig: Generieren von Text
  4. Serverseitiges Streaming
  5. Clientseitig: Der useChat-Hook
  6. Die entsprechende API-Route
  7. Kernaussagen

Aktualisiert am 3. November 2026 basierend auf der AI SDK 7-Dokumentation (ai 7.0.x, @ai-sdk/react 4.x): useChat funktioniert mit DefaultChatTransport und sendMessage; Nachrichten werden über parts angezeigt; die Route gibt createUIMessageStreamResponse zurück; system wurde zu instructions; und der @ai-sdk/xai 5-Anbieter unterstützt Chat Completions nicht mehr: xai() nutzt das Responses API (Code wurde mit TypeScript-Compiler unter Verwendung von ai 7.0.162 und @ai-sdk/xai 5.0.38 verifiziert). Die vorherige Version nutzte die AI SDK 4-API (input, handleSubmit, isLoading, toDataStreamResponse). Quellen: AI SDK, Chatbot · AI SDK, xAI-Anbieter.

Der Vercel AI SDK für Webanwendungen

Der Vercel AI SDK ist ein TypeScript-Framework, das entwickelt wurde, um KI-Modelle in Webanwendungen zu integrieren. Er bietet React-Hooks, Streaming-Utilities und eine einheitliche Abstraktion, die xAI/Grok über das @ai-sdk/xai-Paket nativ unterstützt.

Wenn Sie eine Next.js-, Nuxt-, SvelteKit- oder jede andere React-Anwendung erstellen, die Streaming-Antworten anzeigt, vereinfacht der Vercel AI SDK die Arbeit erheblich.

Installation

Installieren Sie den Kern-SDK und den xAI-Anbieter:

npm install ai @ai-sdk/xai

Konfigurieren Sie Ihren API-Schlüssel in den Umgebungsvariablen:

# .env.local
XAI_API_KEY=your-api-key

Serverseitig: Generieren von Text

Die Funktion generateText ist der einfachste Äquivalent zu client.chat.create(). Eines hat sich geändert, und dies betrifft diesen Kurs direkt: Seit Version 5 des @ai-sdk/xai-Anbieters (September 2026), kompatibel mit AI SDK 7, unterstützt der Anbieter den Chat Completions-Endpunkt nicht mehr. xai(model) nutzt das Responses API, das xAI nun empfiehlt. Die Methode xai.chat(model), die einige Migrationsführungen noch zitieren, existierte nur im Anbieter-Version 4; für Code, der bei Chat Completions verbleiben muss, verwenden Sie stattdessen das OpenAI SDK, das auf xAI zeigt (Lektion 5).

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

const { text } = await generateText({
  model: xai("grok-4.7"), // xAI Responses API
  instructions: "Sie sind ein technischer Assistent.",
  prompt: "Erklären Sie das Konzept der Containerisierung.",
});

console.log(text);

Der xai-Anbieter liest automatisch XAI_API_KEY aus der Umgebung aus; createXai() ermöglicht es Ihnen, eine Instanz mit benutzerdefinierten Einstellungen zu erstellen. Die Option instructions ersetzt system, die zwar noch akzeptiert wird, aber in AI SDK 7 veraltet ist.

Serverseitiges Streaming

Für Streaming verwenden Sie streamText. Die Antwort wird Chunk für Chunk aus textStream gelesen:

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

const result = streamText({
  model: xai("grok-4.7"),
  instructions: "Sie sind ein Lehrassistent.",
  messages: [
    { role: "user", content: "Wie funktioniert eine relationale Datenbank?" },
  ],
});

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

Clientseitig: Der useChat-Hook

Der useChat-Hook ist das Herzstück auf der Frontend-Seite. Er verwaltet die Konversationshistorie, das Streaming und den Anforderungszustand; das Eingabefeld bleibt jedoch ein einfacher React-Zustand, den Sie selbst verwalten:

"use client";
import { useChat } from "@ai-sdk/react";
import { DefaultChatTransport } from "ai";
import { useState } from "react";

export default function ChatPage() {
  const { messages, sendMessage, status } = useChat({
    transport: new DefaultChatTransport({ api: "/api/chat" }),
  });
  const [input, setInput] = useState("");

  return (
    <div>
      {messages.map((m) => (
        <div key={m.id}>
          <strong>{m.role === "user" ? "Sie" : "Grok"}</strong>
          {m.parts.map((part, i) =>
            part.type === "text" ? <p key={i}>{part.text}</p> : null
          )}
        </div>
      ))}

      <form
        onSubmit={(e) => {
          e.preventDefault();
          if (input.trim()) {
            sendMessage({ text: input });
            setInput("");
          }
        }}
      >
        <input
          value={input}
          onChange={(e) => setInput(e.target.value)}
          placeholder="Stellen Sie Ihre Frage..."
          disabled={status !== "ready"}
        />
        <button type="submit" disabled={status !== "ready"}>
          Senden
        </button>
      </form>
    </div>
  );
}

Was useChat automatisch verwaltet

  • Nachrichtenverlauf: Sammelt den Austausch; jede Nachricht trägt parts (Text, Tool-Aufrufe usw.), die angezeigt werden, anstatt des alten content-Felds
  • Streaming: Zeigt die Antwort an, während sie generiert wird
  • Anforderungszustand: status ist ready, wenn eine neue Nachricht gesendet werden kann
  • Fehlerbehandlung: Fängt Netzwerk- und API-Fehler ab
  • Abbruch: stop() unterbricht eine laufende Generierung

Die entsprechende API-Route

Der Hook erwartet eine Route, die einen Stream von UI-Nachrichten zurückgibt. Hier ist die Implementierung mit dem Next.js App Router, modelliert nach dem offiziellen AI SDK 7-Beispiel:

// app/api/chat/route.ts
import {
  convertToModelMessages,
  createUIMessageStreamResponse,
  streamText,
  toUIMessageStream,
  type UIMessage,
} from "ai";
import { xai } from "@ai-sdk/xai";

export async function POST(req: Request) {
  const { messages }: { messages: UIMessage[] } = await req.json();

  const result = streamText({
    model: xai("grok-4.7"),
    instructions: "Sie sind ein hilfreicher Assistent. Antworten Sie auf Englisch.",
    messages: await convertToModelMessages(messages),
  });

  return createUIMessageStreamResponse({
    stream: toUIMessageStream({ stream: result.stream }),
  });
}

Zwei Konvertierungen umhüllen den Austausch: convertToModelMessages wandelt UI-Nachrichten, die vom Client empfangen werden, in Modell-Nachrichten um, und toUIMessageStream macht das Gegenteil auf dem Antwort-Stream. Die Methoden toUIMessageStreamResponse() auf dem streamText-Ergebnis funktionieren in AI SDK 7 noch, sind aber veraltet; was die alte toDataStreamResponse() betrifft, so existiert diese nicht mehr.

Kernaussagen

  • Der Vercel AI SDK unterstützt xAI/Grok über das @ai-sdk/xai-Paket
  • generateText für synchrone Antworten, streamText für Streaming
  • Der useChat-Hook verwaltet den vollständigen Zustand einer Konversation auf dem Client
  • createUIMessageStreamResponse und toUIMessageStream geben den Stream zurück, den useChat erwartet; toDataStreamResponse() existiert nicht mehr
  • Seit @ai-sdk/xai 5 unterstützt der Anbieter Chat Completions nicht mehr: xai() nutzt das Responses API; um bei Chat Completions zu bleiben, verwenden Sie das OpenAI SDK
  • Der createXai()-Anbieter erkennt den API-Schlüssel in der Umgebung automatisch