Vercel AI SDK - Provider-Agnostic TypeScript Toolkit

AI SDK Core provides a standardized way to integrate Large Language Models (LLMs) into your applications, allowing you to focus on building AI features rather than handling technical integration details. It offers a unified API for text generation, structured data output, and tool usage across different model providers.

The core functions are:

• generateText: Generates text and tool calls. Ideal for non-interactive automation tasks like drafting emails or summarizing content.
• streamText: Streams text and tool calls. Designed for interactive use cases like chat bots and content streaming.

Both functions support structured output via the output property (e.g., Output.object(), Output.array()), enabling typed, schema-validated data generation for extraction, classification, and streaming UIs.

// Example: Using generateText for automation
import { generateText } from 'ai';

const { text, toolCalls } = await generateText({
  model: myModel,
  prompt: 'Summarize this article: ...',
  output: 'object',
  schema: z.object({ summary: z.string() })
});

// Example: Using streamText for interactive chat
import { streamText } from 'ai';

const stream = await streamText({
  model: myModel,
  prompt: 'Hello, how can I help?',
});

for await (const chunk of stream.textStream) {
  console.log(chunk);
}

AI SDK UI is a framework-agnostic toolkit designed to help you build interactive chat, completion, and assistant applications. It provides a set of hooks and utilities for integrating advanced AI functionalities into your applications.

The core hooks available are:

• useChat: Interact with language models in a chat interface.
• useCompletion: Interact with language models in a completion interface.
• useObject: Consume streamed JSON objects.

Additional utilities include:

• convertToModelMessages: Convert useChat messages to ModelMessage format for use with AI functions.
• pruneMessages: Prune model messages from a list to optimize context.
• createUIMessageStream: Create a stream to send additional data to the client.
• createUIMessageStreamResponse: Create a response object to stream UI messages to the client.
• pipeUIMessageStreamToResponse: Pipe a UI message stream to a Node.js ServerResponse object.
• readUIMessageStream: Transform a stream of UIMessageChunk objects into an AsyncIterableStream of UIMessage objects.

AI SDK UI is a framework-agnostic toolkit for building interactive chat, completion, and assistant applications. It provides three main hooks to simplify state management and UI updates:

• useChat: Handles real-time streaming of chat messages, managing inputs, messages, loading states, and errors. Ideal for chatbot interfaces.
• useCompletion: Manages text completions, handling prompt inputs and automatically updating the UI as new text is streamed.
• useObject: Consumes streamed JSON objects, allowing you to handle and display structured data (like generated objects) in your application.

Supported Frameworks:

• React (@ai-sdk/react)
• Vue.js (@ai-sdk/vue)
• Svelte (@ai-sdk/svelte)
• Angular (@ai-sdk/angular)
• SolidJS (community package)

All three hooks are available in React, Vue, and Svelte. Svelte and Angular use slightly different naming conventions for the object hook (StructuredObject vs useObject).

AI SDK Core provides a unified set of functions for interacting with AI models across different providers. It enables text generation, tool calling, structured output, embeddings, image generation, video generation, transcription, and speech synthesis.

Main Functions:

• generateText(): Generate text and call tools from a language model.
• streamText(): Stream text and call tools from a language model.
• embed(): Generate an embedding for a single value using an embedding model.
• embedMany(): Generate embeddings for several values using an embedding model (batch embedding).
• generateImage(): Generate images based on a given prompt using an image model.
• experimental_generateVideo(): Generate videos based on a given prompt using a video model.
• experimental_transcribe(): Generate a transcript from an audio file.
• experimental_generateSpeech(): Generate speech audio from text.
• uploadFile(): Upload a file to a provider and get a provider reference.
• uploadSkill(): Upload a skill to a provider and get a provider reference.

Helper Functions:

• tool(): Type inference helper function for tools.
• experimental_filterActiveTools(): Filters a tool set to only the currently active tools.
• createMCPClient(): Creates a client for connecting to MCP servers.
• jsonSchema(): Creates AI SDK compatible JSON schema objects.
• zodSchema(): Creates AI SDK compatible Zod schema objects.
• createProviderRegistry(): Creates a registry for using models from multiple providers.
• cosineSimilarity(): Calculates the cosine similarity between two vectors, e.g. embeddings.
• simulateReadableStream(): Creates a ReadableStream that emits values with configurable delays.
• wrapLanguageModel(): Wraps a language model with middleware.
• wrapImageModel(): Wraps an image model with middleware.
• extractReasoningMiddleware(): Extracts reasoning from the generated text and exposes it as a reasoning property on the result.
• extractJsonMiddleware(): Extracts JSON from text content by stripping markdown code fences.
• isStepCount(): Creates a stop condition that triggers after a specified number of steps.
• hasToolCall(): Creates a stop condition that triggers when any specified tool is called.
• isLoopFinished(): Creates a stop condition that lets the agent loop run until it naturally finishes.
• simulateStreamingMiddleware(): Simulates streaming behavior with responses from non-streaming language models.
• defaultSettingsMiddleware(): Applies default settings to a language model.
• smoothStream(): Smooths text and reasoning streaming output.
• generateId(): Helper function for generating unique IDs.
• createIdGenerator(): Creates an ID generator.

Before building with the AI SDK, understand these core concepts:

• Generative AI: Models that predict and generate outputs (text, images, audio) based on patterns learned from training data. Examples include generating captions from photos or transcriptions from audio.
• Large Language Models (LLMs): A subset of generative models focused on text. LLMs take a sequence of words as input and predict the most likely next sequence. They are trained on massive text collections, making them better suited for some use cases than others. Be aware of limitations like "hallucinations" (making up information) when asked about data not well-represented in their training.
• Embedding Models: Models that convert complex data (words, images) into dense vector representations (lists of numbers). Unlike generative models, they do not generate new content but provide semantic and syntactic relationship representations useful for other NLP tasks.

For practical implementation, skip to the quickstarts or review supported models and providers.