Anthropic APIコスト削減：月額費用を50〜70%削減する最適化技術

const selectModel = (taskType: string): string => {
  const modelMap = {
    // 簡単な分類・抽出
    'classify': 'claude-3-5-haiku-20241022',
    'extract': 'claude-3-5-haiku-20241022',
    'format': 'claude-3-5-haiku-20241022',
 
    // バランス型タスク（デフォルト）
    'summarize': 'claude-3-5-sonnet-20241022',
    'generate': 'claude-3-5-sonnet-20241022',
    'translate': 'claude-3-5-sonnet-20241022',
    'code_review': 'claude-3-5-sonnet-20241022',
 
    // 複雑なタスク
    'complex_reasoning': 'claude-opus-4-1-20250805',
    'research_synthesis': 'claude-opus-4-1-20250805',
    'creative_writing': 'claude-opus-4-1-20250805',
  };
 
  return modelMap[taskType] || 'claude-3-5-sonnet-20241022';
};
 
// 使用例
const model = selectModel('classify'); // → Haiku
const response = await anthropic.messages.create({
  model,
  max_tokens: 1024,
  messages: [{ role: 'user', content: 'Classify this email...' }]
});

const codeReviewSystemPrompt = `You are an expert code reviewer...
[長い400-2000行の詳細ガイド]`;
 
const reviewCode = async (code: string, language: string) => {
  const response = await anthropic.messages.create({
    model: 'claude-opus-4-1-20250805',
    max_tokens: 2048,
    system: [
      {
        type: 'text',
        text: codeReviewSystemPrompt,
        cache_control: { type: 'ephemeral' } // ← キャッシュ有効化
      }
    ],
    messages: [
      {
        role: 'user',
        content: `Review this ${language} code:\n\n${code}`
      }
    ]
  });
 
  return response.content[0].type === 'text' ? response.content[0].text : '';
};
 
// 使用例：同じシステムプロンプトで複数コードをレビュー
const codes = [
  'function foo() { ... }',
  'class Bar { ... }',
  'const baz = () => { ... }'
];
 
for (const code of codes) {
  const review = await reviewCode(code, 'javascript');
  console.log(review);
  // 2回目以降はシステムプロンプトがキャッシュされ、コスト90%削減
}

const createBatchRequest = async (
  items: { id: string; content: string }[]
): Promise<string> => {
  const requests = items.map((item, idx) => ({
    custom_id: item.id,
    params: {
      model: 'claude-3-5-sonnet-20241022',
      max_tokens: 256,
      messages: [
        {
          role: 'user',
          content: `Analyze this: ${item.content}`
        }
      ]
    }
  }));
 
  const batch = await anthropic.beta.messages.batches.create({
    requests
  });
 
  return batch.id;
};
 
// バッチ完了をポーリング
const waitForBatchCompletion = async (batchId: string) => {
  let batch = await anthropic.beta.messages.batches.retrieve(batchId);
 
  while (batch.processing_status === 'processing') {
    console.log('Batch still processing...');
    await new Promise(resolve => setTimeout(resolve, 5000)); // 5秒待機
    batch = await anthropic.beta.messages.batches.retrieve(batchId);
  }
 
  return batch;
};
 
// 結果取得
const getBatchResults = async (batchId: string) => {
  const batch = await waitForBatchCompletion(batchId);
 
  if (batch.processing_status === 'succeeded') {
    const results = await anthropic.beta.messages.batches.results(batchId);
    return results;
  } else {
    throw new Error(`Batch failed: ${batch.processing_status}`);
  }
};
 
// 使用例
const items = [
  { id: '1', content: 'Log entry 1...' },
  { id: '2', content: 'Log entry 2...' },
  // ... 5000 件以上
];
 
const batchId = await createBatchRequest(items);
const results = await getBatchResults(batchId);
 
// 料金: リアルタイム処理の 50% で処理完了

// Bad: 冗長なシステムプロンプト（800 tokens）
const systemPromptBad = `You are a customer support agent.
You should be helpful, harmless, and honest.
You should respond in a polite manner.
...
[さらに1000行の詳細説明]`;
 
// Good: 簡潔で直結的（200 tokens）
const systemPromptGood = `You are a customer support agent.
- Be concise and helpful
- Prioritize user satisfaction
- Clarify when unsure`;
 
// テクニック: システムプロンプトの「本当に必要な部分」だけに削減

// Bad: 全チャット履歴を送信（15,000 tokens）
const messages = allChatHistory; // 過去 6 ヶ月全て
 
// Good: 直近の会話とサマリーのみ（3,000 tokens）
const recentMessages = allChatHistory.slice(-20);
const summary = await generateSummary(allChatHistory.slice(0, -20));
 
const optimizedMessages = [
  {
    role: 'user',
    content: `Previous conversation summary: ${summary}`
  },
  ...recentMessages
];

// Bad: 自由形式で長いレスポンス（1000+ output tokens）
const query = 'Extract all important details from this email';
 
// Good: JSON 形式で構造化（200 output tokens）
const structuredQuery = `Extract data as JSON:
{
  "sender": "...",
  "subject": "...",
  "action_items": [...],
  "deadline": "..."
}`;
 
const response = await anthropic.messages.create({
  model: 'claude-3-5-sonnet-20241022',
  max_tokens: 256,
  messages: [
    {
      role: 'user',
      content: structuredQuery + '\n\n' + emailContent
    }
  ]
});
 
// JSON パースして必要なフィールドだけ使用
const extracted = JSON.parse(response.content[0].text);

import json
from anthropic import Anthropic
 
# Anthropic の usage メタデータを記録
usage_log = []
 
def log_usage(response):
    """API レスポンスのトークン使用量をログ"""
    usage = {
        'input_tokens': response.usage.input_tokens,
        'output_tokens': response.usage.output_tokens,
        'model': response.model,
        'timestamp': datetime.now().isoformat()
    }
    usage_log.append(usage)
    return usage
 
# API 呼び出し
client = Anthropic()
 
response = client.messages.create(
    model='claude-3-5-sonnet-20241022',
    max_tokens=1024,
    messages=[{
        'role': 'user',
        'content': 'Hello, Claude!'
    }]
)
 
# 使用量をログ
usage = log_usage(response)
print(f"Input: {usage['input_tokens']}, Output: {usage['output_tokens']}")

import json
from datetime import datetime, timedelta
from collections import defaultdict
 
def generate_cost_report(usage_log):
    """使用量ログからコストレポートを生成"""
 
    # モデル別集計
    model_stats = defaultdict(lambda: {
        'input_tokens': 0,
        'output_tokens': 0,
        'calls': 0
    })
 
    # 価格テーブル（2026年4月）
    pricing = {
        'claude-3-5-haiku-20241022': {
            'input': 0.048,
            'output': 0.24
        },
        'claude-3-5-sonnet-20241022': {
            'input': 0.96,
            'output': 4.8
        },
        'claude-opus-4-1-20250805': {
            'input': 3.6,
            'output': 18
        }
    }
 
    # ログを集計
    for entry in usage_log:
        model = entry['model']
        model_stats[model]['input_tokens'] += entry['input_tokens']
        model_stats[model]['output_tokens'] += entry['output_tokens']
        model_stats[model]['calls'] += 1
 
    # コスト計算
    total_cost = 0
    report = {'models': {}, 'total_cost': 0}
 
    for model, stats in model_stats.items():
        if model not in pricing:
            continue
 
        input_cost = stats['input_tokens'] * pricing[model]['input'] / 1000
        output_cost = stats['output_tokens'] * pricing[model]['output'] / 1000
        model_cost = input_cost + output_cost
        total_cost += model_cost
 
        report['models'][model] = {
            'input_tokens': stats['input_tokens'],
            'output_tokens': stats['output_tokens'],
            'calls': stats['calls'],
            'cost_jpy': round(model_cost, 2)
        }
 
    report['total_cost'] = round(total_cost, 2)
    return report
 
# レポート生成
report = generate_cost_report(usage_log)
print(json.dumps(report, indent=2, ensure_ascii=False))
 
# 出力例
# {
#   "models": {
#     "claude-3-5-haiku-20241022": {
#       "input_tokens": 50000,
#       "output_tokens": 10000,
#       "calls": 1000,
#       "cost_jpy": 4.8
#     },
#     "claude-3-5-sonnet-20241022": {
#       "input_tokens": 500000,
#       "output_tokens": 50000,
#       "calls": 100,
#       "cost_jpy": 576.0
#     }
#   },
#   "total_cost": 580.8
# }

from datetime import datetime, timedelta
 
def daily_cost_alert(report, threshold=500):
    """日次コストが閾値を超えた場合にアラート"""
    if report['total_cost'] > threshold:
        print(f"⚠️ Alert: Daily cost ¥{report['total_cost']} exceeds ¥{threshold}")
        print(f"Breakdown: {report['models']}")
        # Slack/Email で通知
        return True
    return False
 
# 毎日実行（Cron/Cloud Scheduler）
if __name__ == '__main__':
    report = generate_cost_report(usage_log)
    daily_cost_alert(report)

// Bad: キャッシュが効かない
const systemPrompt = `You are a helpful assistant: ${userId}`; // 動的
 
const response = await anthropic.messages.create({
  system: [{
    type: 'text',
    text: systemPrompt,
    cache_control: { type: 'ephemeral' }
  }],
  messages: [...]
});
 
// 理由: ユーザーごとに異なるプロンプトなので、キャッシュが全く効かない