AI SDK

The AI SDK is Vercel's TypeScript toolkit for building AI-powered applications with React, Next.js, Vue, Svelte, Node.js, and more.

When to Use This Skill

Use this skill when:

• Generating text or structured data with LLMs
• Building chatbot UIs with streaming
• Implementing tool calling and function execution
• Creating AI agents that use tools in a loop
• Integrating with AI providers (OpenAI, Anthropic, Google, etc.)
• Working with useChat, useCompletion, or useObject hooks

Documentation

See the

docs/2025-12-02/

directory for complete AI SDK documentation:

Getting Started

• 00-introduction/index.mdx

  - Overview and core concepts

• 02-getting-started/

  - Framework-specific quickstarts (Next.js, Svelte, Vue, Node.js)

• 02-foundations/

  - Prompts, providers, tools, streaming fundamentals

AI SDK Core

• 03-ai-sdk-core/01-overview.mdx

  - Core API overview

• 03-ai-sdk-core/05-generating-text.mdx

  - Text generation with generateText/streamText

• 03-ai-sdk-core/10-generating-structured-data.mdx

  - Structured output with generateObject/streamObject

• 03-ai-sdk-core/15-tools-and-tool-calling.mdx

  - Tool definitions and execution

• 03-ai-sdk-core/16-mcp-tools.mdx

  - MCP (Model Context Protocol) tools

• 03-ai-sdk-core/40-middleware.mdx

  - Request/response middleware

Agents

• 03-agents/01-overview.mdx

  - Agent fundamentals

• 03-agents/02-building-agents.mdx

  - Building agents with ToolLoopAgent

• 03-agents/03-workflows.mdx

  - Structured workflow patterns

• 03-agents/04-loop-control.mdx

  - stopWhen and prepareStep control

AI SDK UI (React/Vue/Svelte Hooks)

• 04-ai-sdk-ui/01-overview.mdx

  - UI hooks overview

• 04-ai-sdk-ui/02-chatbot.mdx

  - useChat hook for chat interfaces

• 04-ai-sdk-ui/03-chatbot-tool-usage.mdx

  - Tools in chatbots

• 04-ai-sdk-ui/05-completion.mdx

  - useCompletion for text completion

• 04-ai-sdk-ui/08-object-generation.mdx

  - useObject for streaming JSON

• 04-ai-sdk-ui/50-stream-protocol.mdx

  - Stream protocol details

AI SDK RSC (React Server Components)

• 05-ai-sdk-rsc/01-overview.mdx

  - RSC overview

• 05-ai-sdk-rsc/02-streaming-react-components.mdx

  - Streaming components

Reference

• 07-reference/01-ai-sdk-core/

  - Core API reference

• 07-reference/02-ai-sdk-ui/

  - UI hooks reference

• 07-reference/05-ai-sdk-errors/

  - Error types

Quick Reference

Core Functions

import { generateText, streamText, generateObject, streamObject } from 'ai';

// Generate text
const { text } = await generateText({
  model: anthropic('claude-sonnet-4-5-20241022'),
  prompt: 'Write a haiku about coding',
});

// Stream text
const result = streamText({
  model: anthropic('claude-sonnet-4-5-20241022'),
  prompt: 'Write a story',
});
for await (const chunk of result.textStream) {
  console.log(chunk);
}

// Generate structured data
const { object } = await generateObject({
  model: anthropic('claude-sonnet-4-5-20241022'),
  schema: z.object({
    name: z.string(),
    age: z.number(),
  }),
  prompt: 'Generate a person',
});

// Stream structured data
const { partialObjectStream } = streamObject({
  model: anthropic('claude-sonnet-4-5-20241022'),
  schema: z.object({ items: z.array(z.string()) }),
  prompt: 'List 5 fruits',
});

Tool Definition

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

const weatherTool = tool({
  description: 'Get the weather for a location',
  inputSchema: z.object({
    location: z.string().describe('City name'),
  }),
  execute: async ({ location }) => {
    return { temperature: 72, condition: 'sunny' };
  },
});

// Use with generateText/streamText
const result = await generateText({
  model: anthropic('claude-sonnet-4-5-20241022'),
  tools: { weather: weatherTool },
  prompt: 'What is the weather in San Francisco?',
});

Agent (ToolLoopAgent)

import { ToolLoopAgent, stepCountIs, tool } from 'ai';

const agent = new ToolLoopAgent({
  model: anthropic('claude-sonnet-4-5-20241022'),
  tools: {
    search: tool({ /* ... */ }),
    calculate: tool({ /* ... */ }),
  },
  stopWhen: stepCountIs(10), // Max 10 steps
});

const result = await agent.generate({
  prompt: 'Research and calculate...',
});

useChat Hook (React)

import { useChat } from '@ai-sdk/react';
import { DefaultChatTransport } from 'ai';

function Chat() {
  const { messages, sendMessage, status, stop } = useChat({
    transport: new DefaultChatTransport({ api: '/api/chat' }),
  });

  return (
    <>
      {messages.map(m => (
        <div key={m.id}>
          {m.role}: {m.parts.map(p => p.type === 'text' ? p.text : null)}
        </div>
      ))}
      <form onSubmit={e => {
        e.preventDefault();
        sendMessage({ text: input });
      }}>
        <input disabled={status !== 'ready'} />
      </form>
    </>
  );
}

API Route (Next.js)

import { streamText, convertToModelMessages, UIMessage } from 'ai';
import { anthropic } from '@ai-sdk/anthropic';

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

  const result = streamText({
    model: anthropic('claude-sonnet-4-5-20241022'),
    system: 'You are a helpful assistant.',
    messages: convertToModelMessages(messages),
  });

  return result.toUIMessageStreamResponse();
}

Providers

// Official providers
import { anthropic } from '@ai-sdk/anthropic';
import { openai } from '@ai-sdk/openai';
import { google } from '@ai-sdk/google';
import { mistral } from '@ai-sdk/mistral';

// Use models
const model = anthropic('claude-sonnet-4-5-20241022');
const model = openai('gpt-4o');
const model = google('gemini-1.5-flash');

Prompt Types

// Text prompt
await generateText({
  model,
  prompt: 'Hello!',
});

// System + prompt
await generateText({
  model,
  system: 'You are a helpful assistant.',
  prompt: 'Hello!',
});

// Message array
await generateText({
  model,
  messages: [
    { role: 'user', content: 'Hi!' },
    { role: 'assistant', content: 'Hello!' },
    { role: 'user', content: 'How are you?' },
  ],
});

// Multi-modal (images)
await generateText({
  model,
  messages: [{
    role: 'user',
    content: [
      { type: 'text', text: 'Describe this image' },
      { type: 'image', image: fs.readFileSync('./image.png') },
    ],
  }],
});

Status Values (useChat)

• submitted

  - Message sent, awaiting response stream

• streaming

  - Response actively streaming

• ready

  - Complete, ready for new message

• error

  - Error occurred

Stream Result Properties

const result = streamText({ model, prompt });

// Async iterables
result.textStream      // Stream of text chunks
result.fullStream      // Full event stream with types

// Promises (resolve when complete)
result.text            // Full generated text
result.toolCalls       // Tool calls made
result.toolResults     // Tool execution results
result.usage           // Token usage
result.finishReason    // Why generation stopped

// Response helpers
result.toUIMessageStreamResponse() // For useChat
result.toTextStreamResponse()      // Plain text stream

Source

Documentation downloaded from: https://github.com/vercel/ai/tree/main/content/docs