Vercel AI SDK

Provides a standardized LanguageModel interface that abstracts away provider-specific API differences (OpenAI, Anthropic, Google, Mistral, Azure, xAI, Fireworks, etc.) through a V4 specification. Internally normalizes request/response formats, handles provider-specific parameter mapping, and implements provider-utils infrastructure for common operations like message conversion and usage tracking. Developers write once against the unified interface and swap providers via configuration without code changes.

Implements streamText() for server-side streaming and useChat()/useCompletion() hooks for client-side consumption, with built-in streaming UI helpers for React, Vue, Svelte, and SolidJS. Uses Server-Sent Events (SSE) or streaming response bodies to push tokens to the client in real-time. The @ai-sdk/react package provides reactive hooks that manage message state, loading states, and automatic re-rendering as tokens arrive, eliminating manual streaming plumbing.

Provides adapters (@ai-sdk/langchain, @ai-sdk/llamaindex) that integrate Vercel AI SDK with LangChain and LlamaIndex ecosystems. Allows using AI SDK providers (OpenAI, Anthropic, etc.) within LangChain chains and LlamaIndex agents. Enables mixing AI SDK streaming UI with LangChain/LlamaIndex orchestration logic. Handles type conversions between SDK and framework message formats.

Implements a middleware system that allows intercepting and transforming requests before they reach providers and responses before they return to the application. Middleware functions receive request context (model, messages, parameters) and can modify them, add logging, implement custom validation, or inject telemetry. Supports both synchronous and async middleware with ordered execution. Enables cross-cutting concerns like rate limiting, request validation, and response filtering without modifying core logic.

Provides TypeScript-first provider configuration with type safety for model IDs, parameters, and options. Each provider package exports typed model constructors (e.g., openai('gpt-4-turbo'), anthropic('claude-3-opus')) that enforce valid model names and parameters at compile time. Configuration is validated at initialization, catching errors before runtime. Supports environment variable-based configuration with type inference.

Enables composing prompts that mix text, images, and tool definitions in a single request. Provides a fluent API for building complex prompts with multiple content types (text blocks, image blocks, tool definitions). Automatically handles content serialization, image encoding, and tool schema formatting per provider. Supports conditional content inclusion and dynamic prompt building.

Implements the Output API for generating structured data (JSON, TypeScript objects) that conform to a provided Zod or JSON schema. Uses provider-native structured output features (OpenAI's JSON mode, Anthropic's tool_choice: 'required', Google's schema parameter) when available, falling back to prompt-based generation + client-side validation for providers without native support. Automatically handles schema serialization, validation errors, and retry logic.

Implements tool calling via a schema-based function registry that maps tool definitions (name, description, parameters as Zod schemas) to handler functions. Supports native tool-calling APIs (OpenAI functions, Anthropic tools, Google function calling) with automatic request/response normalization. Provides toolUseLoop() for multi-step agent orchestration: model calls tool → handler executes → result fed back to model → repeat until done. Handles tool result formatting, error propagation, and conversation context management across steps.

Provides @ai-sdk/rsc package enabling AI-generated content to be rendered as React Server Components directly on the server. Allows streamUI() to return RSC-compatible components that stream from server to client, enabling server-side LLM calls with client-side rendering without exposing API keys to the browser. Integrates with Next.js App Router's streaming capabilities to send component trees incrementally as the model generates content.

Implements a unified Message type and content normalization layer that handles diverse content types (text, images, tool calls, tool results) across providers with different message formats. Converts between provider-specific message structures (OpenAI's content arrays, Anthropic's blocks, Google's parts) automatically. Handles image encoding (base64, URLs), tool result formatting, and message role standardization (user, assistant, system, tool).

Integrates with observability platforms (Vercel Analytics, Langfuse, OpenTelemetry) to track LLM usage, latency, errors, and costs. Automatically captures token counts from provider responses, calculates costs based on provider pricing, and emits structured telemetry events. Middleware system allows custom telemetry handlers to intercept requests/responses. Supports distributed tracing with span context propagation.

Supports vision capabilities (image analysis, OCR) via provider APIs (OpenAI Vision, Google Vision, Claude Vision) with automatic image encoding and format conversion. Includes audio transcription via provider speech-to-text APIs (OpenAI Whisper, Google Speech-to-Text). Handles image URL resolution, base64 encoding, and format validation. Provides unified interfaces for vision and transcription across providers.

Provides Vercel AI Gateway as a proxy layer that routes requests to multiple LLM providers, implements rate limiting, request caching, and fallback logic. Allows switching providers without code changes via configuration. Includes request deduplication, response caching, and automatic failover to backup providers on errors. Integrates with Vercel's infrastructure for low-latency routing.

Provides a framework-agnostic chat abstraction (useChat hook in React, composables in Vue/Svelte) that manages message state, loading states, and error handling. Implements optimistic UI updates (immediate local message display before server confirmation), automatic request deduplication, and conversation persistence. Abstracts HTTP transport (fetch, streaming responses) from UI logic, enabling easy framework switching.