Model Selection Guide

Choosing the right AI model is one of the most impactful decisions you'll make. The wrong choice can mean significantly higher costs, slower responses, or worse output quality.

Quick Decision Matrix

Model Categories

Flagship Models

Best models from each provider — use when quality matters most.

Fast & Cheap Models

For high-volume applications where cost and speed matter more than peak quality.

Reasoning Models

For complex multi-step problems, math, and scientific analysis.

Use Case Recommendations

Chat Applications

Primary: GPT-4o

• Good balance of quality, speed, and instruction following
• Handles conversation well

Budget: GPT-4o Mini

• Much cheaper, still reasonable for most conversations

Speed: Groq Llama 3.3 70B

• Fastest inference available
• Open source, no vendor lock-in

Copy
import { openai } from "@ai-sdk/openai"
 
const result = await streamText({
  model: openai("gpt-4o"), // or "gpt-4o-mini" for volume
  messages,
  maxTokens: 1000,
})

Code Generation

Primary: Claude 3.5 Sonnet

• Consistently performs well on coding benchmarks
• 200K context fits large codebases

Budget: DeepSeek V3

• Strong coding capability at lower cost

Copy
import { anthropic } from "@ai-sdk/anthropic"
 
const result = await generateText({
  model: anthropic("claude-3-5-sonnet-20241022"),
  prompt: "Implement a rate limiter in TypeScript...",
  maxTokens: 4000,
})

Long Document Processing

Primary: Gemini 1.5 Pro

• 2M token context — entire codebases fit
• Good at long-range retrieval

Copy
import { google } from "@ai-sdk/google"
 
const result = await generateText({
  model: google("gemini-1.5-pro"),
  prompt: `Analyze this codebase:\n\n${entireCodebase}`,
})

Structured Data Extraction

Primary: GPT-4o

• Reliable JSON schema following
• Structured output mode guarantees valid JSON

Copy
import { openai } from "@ai-sdk/openai"
import { z } from "zod"
 
const result = await generateObject({
  model: openai("gpt-4o"),
  schema: z.object({
    name: z.string(),
    email: z.string().email(),
    company: z.string().optional(),
  }),
  prompt: "Extract contact info from: ...",
})

Cost Optimization

1. Match Model to Task

Don't use flagship models for simple tasks.

Copy
// Simple classification doesn't need GPT-4o
const sentiment = await generateText({
  model: openai("gpt-4o-mini"), // much cheaper
  prompt: "Is this positive or negative: 'Great product!'",
})

2. Set Max Tokens

Always cap output to avoid runaway responses.

Copy
const result = await generateText({
  model: openai("gpt-4o"),
  prompt: "Summarize this article...",
  maxTokens: 500, // cap output
})

3. Cache Responses

For repeated prompts, cache results.

Copy
const cacheKey = hash(prompt)
const cached = await db.cache.get(cacheKey)
if (cached) return cached
 
const result = await generateText({ model, prompt })
await db.cache.set(cacheKey, result.text, { ttl: 3600 })

4. Batch When Possible

One large request is often cheaper than many small ones.

Copy
// Better: single API call
const result = await generateText({
  model,
  prompt: `Classify each item:\n${items.join("\n")}`,
})

Provider Notes

OpenAI

• Most reliable, widest adoption
• Best for structured output

Anthropic

• Strong reasoning and coding
• 200K context

Google

• Cheapest at scale
• Massive context windows

Groq

• Fastest inference
• Open-source models only

DeepSeek

• Strong value
• Good for code and reasoning

External Resources

For real-time benchmarks and pricing:

• Artificial Analysis — Benchmarks and pricing comparison
• LMSYS Chatbot Arena — Human preference rankings
• OpenRouter — Model rankings
• Vercel AI SDK Providers — Supported providers