Claude Haiku / Sonnet / Opus 切替戦略で利益率を最大化する実装ガイド

// lib/model-router.ts
 
export type TaskType =
  | "classification"
  | "short_summary"
  | "data_extraction"
  | "faq"
  | "translation"
  | "long_content"
  | "code_review"
  | "analysis"
  | "expert_judgment"
  | "complex_reasoning";
 
export type ClaudeModel =
  | "claude-haiku-4-5-20251001"
  | "claude-sonnet-4-6"
  | "claude-opus-4-6";
 
// ルールベースの初期ルーティングテーブル
const ROUTING_TABLE: Record<TaskType, ClaudeModel> = {
  classification: "claude-haiku-4-5-20251001",
  short_summary: "claude-haiku-4-5-20251001",
  data_extraction: "claude-haiku-4-5-20251001",
  faq: "claude-haiku-4-5-20251001",
  translation: "claude-haiku-4-5-20251001",
  long_content: "claude-sonnet-4-6",
  code_review: "claude-sonnet-4-6",
  analysis: "claude-sonnet-4-6",
  expert_judgment: "claude-opus-4-6",
  complex_reasoning: "claude-opus-4-6",
};
 
// タスクタイプが不明な場合：Haikuに分類させる
async function classifyTaskWithHaiku(prompt: string): Promise<TaskType> {
  const classifier = new Anthropic();
 
  const response = await classifier.messages.create({
    model: "claude-haiku-4-5-20251001", // 分類自体は常にHaiku
    max_tokens: 50,
    system: `You are a task classifier. Given a user prompt, classify it into exactly one of these categories:
classification, short_summary, data_extraction, faq, translation,
long_content, code_review, analysis, expert_judgment, complex_reasoning.
Respond with ONLY the category name, nothing else.`,
    messages: [
      {
        role: "user",
        content: `Classify this task:\n\n${prompt.slice(0, 500)}`, // 先頭500文字で判断
      },
    ],
  });
 
  const taskType = (
    response.content[0] as { type: "text"; text: string }
  ).text
    .trim()
    .toLowerCase() as TaskType;
 
  return ROUTING_TABLE[taskType] ? taskType : "analysis"; // フォールバック
}
 
export async function routeToModel(
  prompt: string,
  explicitTaskType?: TaskType
): Promise<ClaudeModel> {
  const taskType = explicitTaskType ?? (await classifyTaskWithHaiku(prompt));
  return ROUTING_TABLE[taskType];
}

// lib/adaptive-claude-client.ts
import Anthropic from "@anthropic-ai/sdk";
import { routeToModel, TaskType, ClaudeModel } from "./model-router";
 
const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
 
interface CallOptions {
  taskType?: TaskType;
  maxTokens?: number;
  systemPrompt?: string;
  // 品質しきい値：スコアがこれ以下ならOpusで再試行
  qualityThreshold?: number;
  // コスト記録用
  userId?: string;
}
 
interface CallResult {
  text: string;
  model: ClaudeModel;
  inputTokens: number;
  outputTokens: number;
  costUsd: number;
  fallbackUsed: boolean;
}
 
// モデル別のコスト（$/100万トークン）
const COST_PER_MILLION: Record<ClaudeModel, { input: number; output: number }> = {
  "claude-haiku-4-5-20251001": { input: 0.8, output: 4.0 },
  "claude-sonnet-4-6": { input: 3.0, output: 15.0 },
  "claude-opus-4-6": { input: 15.0, output: 75.0 },
};
 
function calculateCost(
  model: ClaudeModel,
  inputTokens: number,
  outputTokens: number
): number {
  const rates = COST_PER_MILLION[model];
  return (
    (inputTokens / 1_000_000) * rates.input +
    (outputTokens / 1_000_000) * rates.output
  );
}
 
export async function callClaude(
  prompt: string,
  options: CallOptions = {}
): Promise<CallResult> {
  const {
    taskType,
    maxTokens = 1024,
    systemPrompt,
    qualityThreshold,
    userId,
  } = options;
 
  // モデルを選択
  const selectedModel = await routeToModel(prompt, taskType);
 
  // Claude API を呼ぶ
  const response = await anthropic.messages.create({
    model: selectedModel,
    max_tokens: maxTokens,
    system: systemPrompt,
    messages: [{ role: "user", content: prompt }],
  });
 
  const inputTokens = response.usage.input_tokens;
  const outputTokens = response.usage.output_tokens;
  const costUsd = calculateCost(selectedModel, inputTokens, outputTokens);
  const text = (response.content[0] as { type: "text"; text: string }).text;
 
  // 品質チェックが必要な場合：Haikuで品質スコアを評価
  if (qualityThreshold && selectedModel !== "claude-opus-4-6") {
    const qualityScore = await evaluateQuality(text, prompt);
 
    if (qualityScore < qualityThreshold) {
      console.log(
        `[Fallback] Quality ${qualityScore} < threshold ${qualityThreshold}. Switching to Opus.`
      );
 
      // Opus で再試行
      const fallbackResponse = await anthropic.messages.create({
        model: "claude-opus-4-6",
        max_tokens: maxTokens,
        system: systemPrompt,
        messages: [{ role: "user", content: prompt }],
      });
 
      const fbInputTokens = fallbackResponse.usage.input_tokens;
      const fbOutputTokens = fallbackResponse.usage.output_tokens;
 
      return {
        text: (
          fallbackResponse.content[0] as { type: "text"; text: string }
        ).text,
        model: "claude-opus-4-6",
        inputTokens: fbInputTokens,
        outputTokens: fbOutputTokens,
        costUsd: calculateCost("claude-opus-4-6", fbInputTokens, fbOutputTokens),
        fallbackUsed: true,
      };
    }
  }
 
  // コストをログに記録（Stripe連携やDB保存はここで行う）
  if (userId) {
    void logUsage(userId, selectedModel, inputTokens, outputTokens, costUsd);
  }
 
  return {
    text,
    model: selectedModel,
    inputTokens,
    outputTokens,
    costUsd,
    fallbackUsed: false,
  };
}
 
// Haikuを使った軽量品質評価（0.0〜1.0）
async function evaluateQuality(
  response: string,
  originalPrompt: string
): Promise<number> {
  const evaluator = new Anthropic();
  const evalResponse = await evaluator.messages.create({
    model: "claude-haiku-4-5-20251001",
    max_tokens: 10,
    messages: [
      {
        role: "user",
        content: `Rate the quality of this AI response on a scale from 0.0 to 1.0.
Original question: "${originalPrompt.slice(0, 200)}"
Response: "${response.slice(0, 500)}"
Reply with only a decimal number between 0.0 and 1.0.`,
      },
    ],
  });
 
  const score = parseFloat(
    (evalResponse.content[0] as { type: "text"; text: string }).text
  );
  return isNaN(score) ? 0.5 : Math.min(1.0, Math.max(0.0, score));
}
 
async function logUsage(
  userId: string,
  model: ClaudeModel,
  inputTokens: number,
  outputTokens: number,
  costUsd: number
): Promise<void> {
  // DB保存・Stripe Usage Report・アナリティクス送信など
  console.log(
    `[Usage] user=${userId} model=${model} ` +
      `input=${inputTokens} output=${outputTokens} cost=$${costUsd.toFixed(6)}`
  );
}

// キャッシュ対応版のシステムプロンプト構築
function buildCachedSystemPrompt(
  baseInstructions: string,
  contextDocs: string[]
): Anthropic.MessageParam["content"] {
  return [
    {
      type: "text",
      text: baseInstructions,
      cache_control: { type: "ephemeral" }, // キャッシュマーク
    },
    ...contextDocs.map((doc) => ({
      type: "text" as const,
      text: doc,
      cache_control: { type: "ephemeral" as const },
    })),
  ];
}
 
// 実際の呼び出し例
async function callWithCache(userPrompt: string): Promise<string> {
  const cachedSystem = buildCachedSystemPrompt(
    "あなたは法律専門家AIアシスタントです。以下の法律文書に基づいて回答してください。",
    [longLegalDocument1, longLegalDocument2] // 各5,000トークン規模の文書
  );
 
  const response = await anthropic.messages.create({
    model: "claude-sonnet-4-6",
    max_tokens: 1024,
    system: cachedSystem as Anthropic.TextBlockParam[],
    messages: [{ role: "user", content: userPrompt }],
  });
 
  // cache_read_input_tokens が増えているか確認
  const usage = response.usage as Anthropic.Usage & {
    cache_read_input_tokens?: number;
    cache_creation_input_tokens?: number;
  };
  console.log("Cache hit tokens:", usage.cache_read_input_tokens ?? 0);
 
  return (response.content[0] as { type: "text"; text: string }).text;
}

// 全リクエストに routing_reason を付与してDB保存
interface UsageLog {
  userId: string;
  requestId: string;
  timestamp: Date;
  taskType: string;
  modelUsed: ClaudeModel;
  routingReason: "rule_based" | "llm_classified" | "quality_fallback";
  inputTokens: number;
  outputTokens: number;
  costUsd: number;
  qualityScore?: number;
  fallbackUsed: boolean;
}
 
// 週次でこのログを集計し、以下を確認する：
// - モデル別リクエスト割合（目標: Haiku 60-70% / Sonnet 25-35% / Opus 5-10%）
// - Fallback率（5%超なら品質しきい値を下げる）
// - コスト/リクエスト（対前週比で増減確認）