Vercel AI SDK: Vollständiger Entwicklerleitfaden für KI-Anwendungen

Das Vercel AI SDK ist ein TypeScript-Toolkit zum Erstellen von KI-Anwendungen. Es handhabt Textgenerierung, Streaming, strukturierte Ausgaben, Tool-Aufrufe und mehrstufige Agenten-Schleifen über eine einheitliche API – und funktioniert mit jedem großen LLM-Anbieter. Wenn Sie schon einmal versucht haben, OpenAI oder Anthropic direkt in eine Next.js-App einzubinden und dabei drei verschiedene Streaming-Implementierungen warten mussten, dann löst dieses SDK genau dieses Problem.

Dieser Leitfaden behandelt die Kernfunktionen des SDKs, wie Sie es mit der OpenAI-kompatiblen LLM-API von Novita AI verbinden und wo Agenten-Workflows für Entwickler ins Spiel kommen, die mehr als einen einfachen Chatbot bauen.

Was ist das Vercel AI SDK?

Das Vercel AI SDK (Paket: ai auf npm) ist eine Open-Source-Bibliothek, die die Unterschiede zwischen LLM-Anbietern abstrahiert. Anstatt separate Streaming-Protokolle für OpenAI, Anthropic und Google zu lernen, rufen Sie dieselben Funktionen generateText, streamText oder generateObject auf und tauschen den Anbieter durch Ändern eines einzigen Imports aus.

Das SDK besteht aus zwei Schichten:

• AI SDK Core kümmert sich um Modellinteraktionen: Textgenerierung, Streaming, strukturierte Objekte, Tool-Aufrufe, Embeddings und Agenten-Schleifen.
• AI SDK UI bietet React-Hooks (useChat, useCompletion, useObject, useAssistant) sowie Adapter für Next.js, SvelteKit und Nuxt, die den Streaming-Status im Browser verwalten.

Es gibt auch ein Paket @ai-sdk/openai-compatible zum Verbinden mit jedem Anbieter, der das OpenAI Chat Completions-Format implementiert – so integriert sich Novita AI.

Das SDK funktioniert in Node.js, Deno, Edge-Laufzeiten (Cloudflare Workers, Vercel Edge) und Browser-Umgebungen.

AI SDK Core: generateText, streamText und generateObject

Installieren Sie das SDK und ein Anbieterpaket:

npm install ai @ai-sdk/openai

generateText

Für nicht-streamende Vervollständigungen – Batch-Verarbeitung, Klassifikation, Einmal-Generierung:

import { generateText } from 'ai';
import { openai } from '@ai-sdk/openai';

const { text } = await generateText({
  model: openai('gpt-4o-mini'),
  prompt: 'Explain how LLM embeddings work in two sentences.',
});

console.log(text);

streamText

Für Chat-Schnittstellen, bei denen Latenz wichtig ist:

import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';

const result = streamText({
  model: openai('gpt-4o-mini'),
  messages: [
    { role: 'user', content: 'Walk me through setting up a Next.js app.' },
  ],
});

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

generateObject

Wenn Sie strukturierte JSON-Ausgabe statt Rohtext benötigen – Schema-Validierung erfolgt automatisch mit Zod:

import { generateObject } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';

const { object } = await generateObject({
  model: openai('gpt-4o-mini'),
  schema: z.object({
    name: z.string(),
    skills: z.array(z.string()),
    experienceLevel: z.enum(['junior', 'mid', 'senior']),
  }),
  prompt: 'Generate a fictional software engineer profile.',
});

console.log(object.name, object.skills);

Das SDK kümmert sich um die System-Prompt-Injektion, die das Modell zu gültigem JSON zwingt, und wiederholt bei fehlerhafter Ausgabe.

AI SDK Tools: Funktionsaufruf und Tool-Nutzung

Tools ermöglichen es Modellen, externe Funktionen aufzurufen – Such-APIs, Datenbankabfragen, Taschenrechner – während einer Generierung. Der tools-Parameter des SDKs nimmt ein Objekt entgegen, bei dem jeder Schlüssel zu einer aufrufbaren Funktion wird:

import { generateText, tool } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';

const { text, toolCalls } = await generateText({
  model: openai('gpt-4o-mini'),
  tools: {
    getWeather: tool({
      description: 'Get current weather for a location',
      parameters: z.object({
        city: z.string().describe('City name'),
        unit: z.enum(['celsius', 'fahrenheit']).default('celsius'),
      }),
      execute: async ({ city, unit }) => {
        // Replace with a real weather API call
        return { city, temperature: 22, unit, condition: 'sunny' };
      },
    }),
  },
  prompt: 'What is the weather in Tokyo right now?',
});

console.log(text);

Der tool()-Helper bietet Typinferenz vom Zod-Schema in die Parameter der execute-Funktion. Kein manuelles JSON-Parsing nötig.

Mehrstufige Tool-Aufrufe

Standardmäßig stoppt generateText nach einer Runde von Tool-Aufrufen. Setzen Sie maxSteps, damit das Modell Tool-Ergebnisse in nachfolgenden Überlegungen verwenden kann:

const { text } = await generateText({
  model: openai('gpt-4o'),
  maxSteps: 5,
  tools: { getWeather, searchWeb, lookupCalendar },
  prompt: 'Plan my outdoor activities for this weekend in Berlin.',
});

Das SDK handhabt die Schleife Tool-Aufruf → Ergebnis → Fortsetzung automatisch. Jeder Schritt wird über onStepFinish bereitgestellt, wenn Sie Einblick in die Zwischenüberlegungen benötigen.

KI-Agenten-Schleifen mit dem Vercel AI SDK erstellen

Ein Agent im AI SDK ist ein Modell, das in einer Schleife mit Tools läuft, bis es genügend Informationen für eine Antwort hat. Das Muster ist dasselbe wie bei mehrstufigen Tool-Aufrufen, jedoch mit mehr Tools und einem längeren maxSteps:

import { generateText, tool } from 'ai';
import { openai } from '@ai-sdk/openai';
import { z } from 'zod';

const result = await generateText({
  model: openai('gpt-4o'),
  maxSteps: 10,
  system: 'You are a research assistant. Use available tools to answer thoroughly.',
  prompt: 'What are the main differences between Llama 3.1 and Qwen3?',
  tools: {
    search: tool({
      description: 'Search the web for current information',
      parameters: z.object({ query: z.string() }),
      execute: async ({ query }) => searchWeb(query),
    }),
    summarize: tool({
      description: 'Summarize a URL',
      parameters: z.object({ url: z.string() }),
      execute: async ({ url }) => fetchAndSummarize(url),
    }),
  },
  onStepFinish({ stepType, toolCalls, toolResults }) {
    console.log('Step:', stepType, toolCalls?.map(t => t.toolName));
  },
});

Für Produktions-Agenten-Pipelines verbinden Sie Novita AI als Modell-Backend, um Kosten und Durchsatz im großen Maßstab zu kontrollieren – behandelt im nächsten Abschnitt.

AI SDK React: useChat-Hook und Next.js-Integration

Der useChat-Hook verwaltet den Streaming-Chat-Status ohne Boilerplate:

// app/chat/page.tsx
'use client';
import { useChat } from 'ai/react';

export default function Chat() {
  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
    api: '/api/chat',
  });

  return (
    <div>
      {messages.map(m => (
        <div key={m.id} className={m.role === 'user' ? 'user' : 'assistant'}>
          {m.content}
        </div>
      ))}
      <form onSubmit={handleSubmit}>
        <input
          value={input}
          onChange={handleInputChange}
          placeholder="Ask something..."
          disabled={isLoading}
        />
        <button type="submit" disabled={isLoading}>Send</button>
      </form>
    </div>
  );
}

Der zugehörige Route-Handler:

// app/api/chat/route.ts
import { streamText } from 'ai';
import { openai } from '@ai-sdk/openai';

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

  const result = streamText({
    model: openai('gpt-4o-mini'),
    messages,
  });

  return result.toDataStreamResponse();
}

toDataStreamResponse() handhabt das Vercel AI Stream-Protokoll, das useChat auf dem Client nativ versteht. Für das Streaming strukturierter Objekte von einer API tauschen Sie useChat gegen useObject und streamText gegen streamObject aus.

So verwenden Sie Novita AI mit dem Vercel AI SDK

Novita AI bietet eine OpenAI-kompatible API unter https://api.novita.ai/v3/openai, was es zu einem Drop-in-Ersatz für jedes SDK macht, das das OpenAI Chat Completions-Format verwendet – einschließlich des Vercel AI SDKs.

Warum Novita AI mit dem AI SDK verwenden

Novita AI hostet über 70 Open-Source-Modelle – Llama 3.3 70B, Qwen3, DeepSeek V3, Mistral und Gemma 3 – über einen einzigen API-Endpunkt. Keine GPU-Infrastruktur zu verwalten. Für Agenten-Workflows skaliert die serverlose API von kleinen 7B-Instruktionsmodellen bis hin zu großen Reasoning-Modellen ohne Konfigurationsänderungen.

Einrichtung

Installieren Sie das OpenAI-kompatible Anbieterpaket:

npm install ai @ai-sdk/openai-compatible

Konfigurieren Sie den Anbieter:

import { createOpenAICompatible } from '@ai-sdk/openai-compatible';

const novita = createOpenAICompatible({
  name: 'novita',
  baseURL: 'https://api.novita.ai/v3/openai',
  apiKey: process.env.NOVITA_API_KEY,
});

Das ist die gesamte Einrichtung. Jetzt verwenden Sie es genau wie jeden anderen AI SDK-Anbieter:

import { generateText } from 'ai';

const { text } = await generateText({
  model: novita('meta-llama/llama-3.3-70b-instruct'),
  prompt: 'Was sind die Kompromisse zwischen RAG und Fine-Tuning für einen Kundensupport-Bot?',
});

Streaming funktioniert genauso:

import { streamText } from 'ai';

const result = streamText({
  model: novita('qwen/qwen3-235b-a22b-instruct-2507'),
  messages: [
    { role: 'system', content: 'Du bist ein hilfreicher Programmier-Assistent.' },
    { role: 'user', content: 'Zeig mir, wie ich eine REST-API mit FastAPI erstelle.' },
  ],
});

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

Tool-Aufrufe mit Novita AI

Modelle, die Funktionsaufrufe unterstützen, funktionieren mit der Tool-Schnittstelle des AI SDKs ohne zusätzliche Konfiguration. Llama 3.3 70B Instruct und Qwen3 unterstützen Tool-Aufrufe über die API von Novita:

import { generateText, tool } from 'ai';
import { z } from 'zod';

const { text } = await generateText({
  model: novita('meta-llama/llama-3.3-70b-instruct'),
  maxSteps: 5,
  tools: {
    calculator: tool({
      description: 'Werte einen mathematischen Ausdruck aus',
      parameters: z.object({ expression: z.string() }),
      execute: async ({ expression }) => {
        return { result: eval(expression) }; // Verwenden Sie in der Produktion einen sicheren Math-Parser
      },
    }),
  },
  prompt: 'Was ist 12% von 847, dann geteilt durch 3.14?',
});

Umgebungsvariablen

Fügen Sie Ihren Novita-API-Schlüssel zu .env.local hinzu:

NOVITA_API_KEY=ihr_novita_api_key_hier

Holen Sie sich einen Schlüssel auf novita.ai – neue Konten erhalten kostenlose Guthaben zum Testen der API.

Agent-Sandbox für länger laufende Workloads

Für Agenten-Aufgaben, die Code ausführen, auf Dateisysteme zugreifen oder mehrminütige Workflows ausführen, bietet Novita AI’s Agent Sandbox isolierte Ausführungsumgebungen auf Basis der LLM-API. Das AI SDK übernimmt die Modellüberlegungsschicht. Die Sandbox übernimmt die zustandsbehaftete Ausführung, die nicht innerhalb eines Edge-Funktions-Timeouts laufen kann.

Auswahl eines LLM-Anbieters für das Vercel AI SDK

Das AI SDK macht den Wechsel zwischen Anbietern einfach, was nützlich ist – aber es lohnt sich, die Kompromisse zu verstehen, bevor man sich für die Produktion entscheidet.

Latenz: Die Zeit bis zum ersten Token ist wichtiger als die Gesamtgenerierungsgeschwindigkeit für Streaming-Chat. Kleinere Modelle (8B–14B) produzieren erste Tokens schneller. Novita AIs serverlose Endpunkte sind für geringe Kaltstart-Latenz bei offenen Modellen optimiert.

Kosten im großen Maßstab: GPT-4o ist exzellent, aber bei hohen Abfragevolumen wird der Preisunterschied zwischen einem Frontier-Modell und einem gut abgestimmten offenen Modell (z.B. Llama 3.3 70B) signifikant. Das AI SDK ermöglicht es Ihnen, mit beiden zu experimentieren, ohne die Anwendungslogik umzuschreiben.

Tool-Aufruf-Unterstützung: Nicht alle Modelle unterstützen Funktionsaufrufe zuverlässig. Testen Sie Ihr spezifisches Modell gegen Ihre Tool-Schemas – das Verhalten variiert zwischen Anbietern, selbst bei derselben Modellfamilie.

Kontextfenster: Für dokumentenlastiges RAG oder lange Gesprächsverläufe überprüfen Sie die Kontextlimits. Viele offene Modelle unterstützen 128K Tokens, was die meisten praktischen Anwendungsfälle abdeckt.

Anbieterbindung: Die Anbieterabstraktion des AI SDKs zusammen mit Novita AIs OpenAI-kompatiblem Endpunkt bedeutet, dass Sie Modelle wechseln oder einen Fallback-Anbieter hinzufügen können, ohne die Anwendungscodebasis zu berühren.

Fazit

Das Vercel AI SDK entfernt die Boilerplate beim Erstellen von KI-Anwendungen – eine API für Textgenerierung, Streaming, Tool-Aufrufe und Agenten-Schleifen über alle LLM-Anbieter hinweg. Ob Sie eine Streaming-Chat-Schnittstelle mit useChat bauen, strukturierte Daten mit generateObject extrahieren oder einen mehrstufigen Agenten betreiben, der externe Tools aufruft – das SDK kümmert sich um die Infrastruktur, sodass Sie sich auf die Anwendungslogik konzentrieren können.

Für offene Modell-Inferenz fügt sich Novita AIs OpenAI-kompatible API direkt über @ai-sdk/openai-compatible in das SDK ein. Sie erhalten Zugriff auf über 70 Modelle – Llama, Qwen3, DeepSeek, Mistral – ohne GPU-Infrastruktur verwalten zu müssen, und Sie können Modelle wechseln oder Anbieter-Fallbacks hinzufügen, ohne Ihren Anwendungscode zu berühren.

Starten Sie auf novita.ai – neue Konten erhalten kostenlose Guthaben.

FAQ

Was ist das ai sdk react?

Die React-Integration des AI SDKs befindet sich im Paket ai/react. Es stellt Hooks bereit – useChat, useCompletion, useObject, useAssistant – die ein React-Frontend mit einer serverseitigen Streaming-Route verbinden. Die Hooks verwalten Streaming-Status, Nachrichtenverlauf, Ladeanzeigen und Fehlerbehandlung, sodass Sie ReadableStream nicht im Komponentenstatus verwalten müssen.

Was fügt ai sdk 5 hinzu?

AI SDK 5 (als Beta Mitte 2025 veröffentlicht) hat die Anbieterspezifikation für bessere Typsicherheit neu gestaltet, das UI-Statusmanagement von der Modellinteraktionslogik getrennt und ein überarbeitetes Nachrichtenformat eingeführt, das die Serialisierung von agentischem UI-Status erleichtert. Wenn Sie 2026 ein neues Projekt starten, überprüfen Sie ai-sdk.dev auf die neueste stabile Version – das SDK hat sich durch die Versionen 6 und 7 weiterentwickelt.

Gibt es ai sdk docs, die ich verwenden kann?

Die offizielle Dokumentation finden Sie unter ai-sdk.dev. Sie enthält Anleitungen zur Anbieterkonfiguration, API-Referenzen für alle Kernfunktionen, Framework-Integrations-Walkthroughs (Next.js, Nuxt, SvelteKit) und Kochbuchbeispiele für gängige Muster wie RAG, Agenten-Schleifen und strukturierte Extraktion.

Kann ich die ai sdk tools mit Nicht-OpenAI-Modellen verwenden?

Ja. Jeder Anbieter, der Funktionsaufrufe unterstützt, funktioniert mit der tool()-Schnittstelle des AI SDKs. Novita AI hostet mehrere offene Modelle mit Funktionsaufruf-Unterstützung. Die Qualität variiert – Llama 3.3 70B und Qwen3 sind die zuverlässigsten für mehrstufige Tool-Nutzung unter den offenen Modellen, die über Novitas API verfügbar sind.

Was ist der Unterschied zwischen den vercel ai sdk docs und der ai-sdk.dev Dokumentation?

Es ist dasselbe Produkt. Die Dokumentation lag früher unter sdk.vercel.ai und leitet nun auf ai-sdk.dev weiter. Das SDK wird vom Vercel-Team gewartet, ist aber Open-Source und nicht an die Bereitstellung auf der Vercel-Infrastruktur gebunden.

Wie vergleichen sich künstliche Intelligenz SDKs mit dem direkten Aufruf der LLM-API?

Direkte API-Aufrufe sind für einfache einmalige Anfragen in Ordnung. Ein SDK wird lohnenswert, sobald Sie mehrere Dinge gleichzeitig benötigen: Streaming in ein UI-Framework integriert, mehrstufige Tool-Aufruf-Schleifen, strukturierte Ausgabevalidierung, einheitlichen Anbieterwechsel und konsistente Wiederholungs-/Fehlerbehandlung über Anbieter hinweg. Das AI SDK kümmert sich um all das auf Bibliotheksebene, sodass Sie es nicht für jedes Projekt neu aufbauen müssen.

Empfohlene Artikel

• Welcher Inferenzanbieter ist der richtige für KI-Agenten
• Erstellen Sie ein Multi-Agenten-System mit Novita und CrewAI
• Die besten LLM-API-Anbieter 2026