Vercel AI SDK 5.0

# Install AI SDK with OpenAI provider
npm install ai @ai-sdk/openai

# Or with Anthropic (Claude)
npm install ai @ai-sdk/anthropic

# Or with Google (Gemini)
npm install ai @ai-sdk/google

1import { anthropic } from '@ai-sdk/anthropic';
2import { openai } from '@ai-sdk/openai';
3import { generateText } from 'ai';
4
5// Step 1: Research agent (Claude for reasoning)
6const researchResult = await generateText({
7  model: anthropic('claude-3-7-sonnet-20250219'),
8  prompt: `Research this topic: ${topic}`,
9  maxTokens: 500,
10});
11
12// Step 2: Writer agent (GPT-5 for creativity)
13const draftResult = await generateText({
14  model: openai('gpt-4o'),
15  prompt: `Write article based on research:\n${researchResult.text}`,
16  maxTokens: 800,
17});
18
19// Step 3: Review agent (Gemini for fast validation)
20const finalResult = await generateText({
21  model: google('gemini-2.0-flash-exp'),
22  prompt: `Review and improve:\n${draftResult.text}`,
23  maxTokens: 1000,
24});
25
26console.log('Sequential workflow cost:',
27  researchResult.usage.totalTokens +
28  draftResult.usage.totalTokens +
29  finalResult.usage.totalTokens
30);

1import { anthropic } from '@ai-sdk/anthropic';
2import { openai } from '@ai-sdk/openai';
3import { google } from '@ai-sdk/google';
4import { generateText } from 'ai';
5
6// Execute 3 agents in parallel
7const [technical, creative, practical] = await Promise.all([
8  generateText({
9    model: anthropic('claude-3-7-sonnet-20250219'),
10    prompt: `Technical analysis of: ${query}`,
11    maxTokens: 300,
12  }),
13  generateText({
14    model: openai('gpt-4o'),
15    prompt: `Creative analysis of: ${query}`,
16    maxTokens: 300,
17  }),
18  generateText({
19    model: google('gemini-2.0-flash-exp'),
20    prompt: `Practical analysis of: ${query}`,
21    maxTokens: 300,
22  }),
23]);
24
25// Synthesize results with cheap model
26const synthesis = await generateText({
27  model: openai('gpt-4o-mini'),
28  prompt: `Synthesize these analyses:\n${technical.text}\n${creative.text}\n${practical.text}`,
29  maxTokens: 500,
30});
31
32console.log('Parallel execution complete');
33console.log('Time savings: 66% (3x parallelization)');

1import { anthropic } from '@ai-sdk/anthropic';
2import { openai } from '@ai-sdk/openai';
3import { generateObject, generateText } from 'ai';
4import { z } from 'zod';
5
6// Step 1: Routing with cheap model (GPT-5 mini @ $0.15/1M tokens)
7const routing = await generateObject({
8  model: openai('gpt-4o-mini'),
9  schema: z.object({
10    complexity: z.enum(['simple', 'medium', 'complex']),
11    requiresReasoning: z.boolean(),
12  }),
13  prompt: `Analyze complexity: ${userQuery}`,
14});
15
16// Step 2: Route to appropriate model based on complexity
17const selectedModel =
18  routing.object.complexity === 'complex'
19    ? anthropic('claude-3-7-sonnet-20250219')  // $3/1M input
20    : routing.object.complexity === 'medium'
21    ? openai('gpt-4o')                          // $2.50/1M input
22    : openai('gpt-4o-mini');                   // $0.15/1M input
23
24const result = await generateText({
25  model: selectedModel,
26  prompt: userQuery,
27});
28
29console.log(`Routing cost: $0.0001, Execution cost: varies by model`);
30console.log(`Total savings vs always using Claude: 40-60%`);

1import { openai } from '@ai-sdk/openai';
2import { streamText } from 'ai';
3
4export async function POST(req: Request) {
5  const { messages } = await req.json();
6
7  const result = streamText({
8    model: openai('gpt-4'),
9    messages,
10  });
11
12  return result.toDataStreamResponse();
13}

1'use client'
2
3import { useChat } from 'ai/react';
4
5export function ChatInterface() {
6  const { messages, input, handleInputChange, handleSubmit, isLoading } = useChat({
7    api: '/api/chat',
8  });
9
10  return (
11    <div>
12      {messages.map(m => (
13        <div key={m.id}>
14          <strong>{m.role}:</strong> {m.content}
15        </div>
16      ))}
17
18      <form onSubmit={handleSubmit}>
19        <input
20          value={input}
21          onChange={handleInputChange}
22          disabled={isLoading}
23        />
24        <button type="submit" disabled={isLoading}>
25          Send
26        </button>
27      </form>
28    </div>
29  );
30}

1import { openai } from '@ai-sdk/openai';
2import { generateText, tool } from 'ai';
3import { z } from 'zod';
4
5const result = await generateText({
6  model: openai('gpt-4'),
7  prompt: 'What is the weather in San Francisco?',
8  tools: {
9    getWeather: tool({
10      description: 'Get the current weather for a location',
11      parameters: z.object({
12        location: z.string().describe('City name'),
13        unit: z.enum(['celsius', 'fahrenheit']).default('celsius'),
14      }),
15      execute: async ({ location, unit }) => {
16        // Call weather API
17        const weather = await fetchWeather(location, unit);
18        return {
19          location,
20          temperature: weather.temp,
21          conditions: weather.conditions,
22        };
23      },
24    }),
25  },
26});
27
28console.log(result.text); // "The weather in San Francisco is 18°C and sunny"

1import { Agent } from 'ai';
2import { anthropic } from '@ai-sdk/anthropic';
3
4const agent = new Agent({
5  model: anthropic('claude-sonnet-4.5'),
6  systemPrompt: 'You are a data analysis expert',
7  tools: {
8    analyzeData: tool({ /* ... */ }),
9    createVisualization: tool({ /* ... */ }),
10    generateReport: tool({ /* ... */ }),
11  },
12
13  // Stop when conditions are met
14  stopWhen: (step) =>
15    step.stepCount >= 5 ||
16    step.hasToolCall('generateReport') ||
17    step.context.confidence > 0.95,
18
19  // Dynamic step control
20  prepareStep: (step) => ({
21    model: step.context.complexity > 0.8
22      ? anthropic('claude-sonnet-4.5')
23      : anthropic('claude-haiku-3.5'),
24    tools: selectToolsBasedOnContext(step.context),
25  }),
26});
27
28const result = await agent.run({ input: 'Analyze Q3 sales data' });