Vercel AI SDK

Provides a provider-agnostic interface (LanguageModel abstraction) that normalizes API differences across 15+ LLM providers (OpenAI, Anthropic, Google, Mistral, Azure, xAI, Fireworks, etc.) through a V4 specification. Each provider implements message conversion, response parsing, and usage tracking via provider-specific adapters that translate between the SDK's internal format and each provider's API contract, enabling single-codebase support for model switching without refactoring.

Implements streamText() function that returns an AsyncIterable of text chunks with integrated React/Vue/Svelte hooks (useChat, useCompletion) that automatically update UI state as tokens arrive. Uses server-sent events (SSE) or WebSocket transport to stream from server to client, with built-in backpressure handling and error recovery. The SDK manages message buffering, token accumulation, and re-render optimization to prevent UI thrashing while maintaining low latency.

Normalizes message content across providers using a unified message format with role (user, assistant, system) and content (text, tool calls, tool results, images). The SDK converts between the unified format and each provider's message schema (OpenAI's content arrays, Anthropic's content blocks, Google's parts). Supports role-based routing where different content types are handled differently (e.g., tool results only appear after assistant tool calls). Provides type-safe message builders to prevent invalid message sequences.

Provides utilities for selecting models based on cost, latency, and capability tradeoffs. Includes model metadata (pricing, context window, supported features) and helper functions to select the cheapest model that meets requirements (e.g., 'find the cheapest model with vision support'). Integrates with Vercel AI Gateway for automatic model selection based on request characteristics. Supports fine-tuned model selection (e.g., OpenAI fine-tuned models) with automatic cost calculation.

Provides built-in error handling and retry logic for transient failures (rate limits, network timeouts, provider outages). Implements exponential backoff with jitter to avoid thundering herd problems. Distinguishes between retryable errors (429, 5xx) and non-retryable errors (401, 400) to avoid wasting retries on permanent failures. Integrates with observability middleware to log retry attempts and failures.

Provides utilities for prompt engineering including prompt templates with variable substitution, prompt chaining (composing multiple prompts), and prompt versioning. Includes built-in system prompts for common tasks (summarization, extraction, classification). Supports dynamic prompt construction based on context (e.g., 'if user is premium, use detailed prompt'). Integrates with middleware for prompt injection and transformation.

Implements the Output API that accepts a Zod schema or JSON schema and instructs the model to generate JSON matching that schema. Uses provider-specific structured output modes (OpenAI's JSON mode, Anthropic's tool_choice: 'any', Google's response_mime_type) to enforce schema compliance at the model level rather than post-processing. The SDK validates responses against the schema and returns typed objects, with fallback to JSON parsing if the provider doesn't support native structured output.

Implements tool calling via a schema-based function registry where developers define tools as Zod schemas with descriptions. The SDK sends tool definitions to the model, receives tool calls with arguments, validates arguments against schemas, and executes registered handler functions. Provides agentic loop patterns (generateText with maxSteps, streamText with tool handling) that automatically iterate: model → tool call → execution → result → next model call, until the model stops requesting tools or reaches max iterations.

Provides @ai-sdk/rsc package that enables AI-generated content to be rendered as React Server Components (RSCs) directly on the server. Developers define generative UI components that call streamText() server-side and return JSX that streams to the client. Uses React's server-side streaming to interleave AI-generated content with component rendering, avoiding round-trips and keeping sensitive logic (API keys, database queries) server-side. Integrates with Next.js App Router for seamless server/client boundary management.

Provides useChat() hook (React) and equivalent composables (Vue, Svelte) that manage chat message history, loading state, error handling, and streaming in a single hook call. The hook abstracts the HTTP transport layer (POST to /api/chat endpoint) and handles message accumulation, automatic re-renders on new tokens, and error recovery. Developers define a single API route that calls streamText(), and the hook handles all client-side state synchronization without manual fetch/state management.

Supports multimodal inputs (images, video frames, audio transcription) via message content arrays that include image/video/audio data. Images can be passed as base64, URLs, or file buffers; the SDK converts them to each provider's format (OpenAI vision_detail, Anthropic image media types, Google inline data). For audio, the SDK integrates with speech-to-text providers (OpenAI Whisper, Google Speech-to-Text) to transcribe audio before sending to the model. Video is handled by extracting frames and passing them as image sequences.

Integrates with observability platforms (Vercel AI Gateway, Langfuse, OpenTelemetry) via a middleware system that intercepts all model calls and logs structured telemetry. Tracks token usage, latency, cost (calculated from token counts and model pricing), error rates, and tool calls. Provides hooks for custom telemetry (onFinish, onChunk callbacks) and supports distributed tracing via OpenTelemetry. The SDK normalizes cost calculation across providers using a pricing database.

Implements a middleware pipeline that intercepts all model calls before sending to the provider and after receiving responses. Middleware functions can transform prompts, inject system instructions, modify tool definitions, log telemetry, or enforce guardrails. Middleware runs in order and can short-circuit the pipeline (e.g., return cached responses). The SDK provides built-in middleware for observability, cost tracking, and error handling, and developers can add custom middleware for domain-specific logic.

Provides Vercel AI Gateway, a proprietary proxy service that sits between the SDK and LLM providers. Routes requests to the appropriate provider, enforces rate limits, caches responses, and provides observability. Developers configure the gateway with API keys for multiple providers, and the SDK sends requests to the gateway instead of directly to providers. The gateway handles provider failover, request deduplication, and cost tracking across providers.