How to Reduce AI API Costs by 60%: Developer's Guide for 2025

// Anthropic Claude with caching (saves 90% on system instructions)
const response = await anthropic.messages.create({
  model: "claude-3-5-sonnet-20241022",
  max_tokens: 1024,
  system: [
    {
      type: "text",
      text: "You are a customer support assistant...", // Long system prompt
      cache_control: { type: "ephemeral" }  // Cache this content
    }
  ],
  messages: [{ role: "user", content: "How do I reset my password?" }]
});

// OpenAI GPT-4 with caching (saves 50%)
const response = await openai.chat.completions.create({
  model: "gpt-4-turbo",
  messages: [
    {
      role: "system",
      content: "You are a customer support assistant...",
      cache: true  // Enable caching for system message
    },
    { role: "user", content: "How do I reset my password?" }
  ]
});

// Route requests based on complexity
function selectModel(requestType: string, complexity: string) {
  // Simple tasks → Cheapest models (95% savings)
  if (complexity === 'simple') {
    switch (requestType) {
      case 'classification':
      case 'extraction':
      case 'validation':
        return 'claude-3-5-haiku';  // $0.25-$1.25/M
      case 'faq':
      case 'translation':
        return 'gpt-3.5-turbo';     // $0.50-$1.50/M
    }
  }

  // Medium complexity → Balanced models (70% savings)
  if (complexity === 'medium') {
    return 'claude-3-5-sonnet';     // $3-$15/M
  }

  // Complex tasks → Premium models
  return 'gpt-4-turbo';              // $10-$30/M
}

// Real-world usage example
async function handleChatMessage(message: string, history: Array) {
  // Detect intent and complexity
  const intent = await classifyIntent(message);  // Uses Haiku
  const complexity = assessComplexity(message, history);

  // Route to appropriate model
  const model = selectModel(intent, complexity);
  const response = await callAI(model, message, history);

  return response;
}

// Set appropriate limits for different endpoints
const TOKEN_LIMITS = {
  classification: 20,
  faq: 250,
  summary: 300,
  code: 500,
  article: 1500
};

async function generateResponse(type: string, prompt: string) {
  const response = await openai.chat.completions.create({
    model: "gpt-4-turbo",
    messages: [{ role: "user", content: prompt }],
    max_tokens: TOKEN_LIMITS[type],  // Prevent excessive output
    temperature: 0.7
  });

  return response.choices[0].message.content;
}

// Batch processing implementation
async function classifyEmails(emails: string[]) {
  const BATCH_SIZE = 10;  // Process 10 at a time
  const results = [];

  for (let i = 0; i < emails.length; i += BATCH_SIZE) {
    const batch = emails.slice(i, i + BATCH_SIZE);

    // Single request for entire batch
    const prompt = `Classify these emails as spam/not_spam.
Return JSON array with same order:

${batch.map((email, idx) => `${idx + 1}. ${email}`).join('\n\n')}`;

    const response = await openai.chat.completions.create({
      model: "gpt-3.5-turbo",
      messages: [
        { role: "system", content: "You are an email classifier." },
        { role: "user", content: prompt }
      ],
      max_tokens: 100  // Brief JSON response
    });

    const batchResults = JSON.parse(response.choices[0].message.content);
    results.push(...batchResults);
  }

  return results;
}

// Usage
const emails = [...]; // 1000 emails
const classifications = await classifyEmails(emails);
// 100 batched requests instead of 1000 individual requests
// Saves 70%+ on system prompt repetition