Antigravity で Claude Opus 4 / Sonnet 4 を使う — モデル選択の思想と本番実装パターン

// .antigravity/mcp_settings.json
{
  "mcpServers": {
    "claude-integration": {
      "command": "node",
      "args": ["/path/to/claude-mcp-server/dist/index.js"],
      "env": {
        "ANTHROPIC_API_KEY": "${ANTHROPIC_API_KEY}",
        "DEFAULT_MODEL": "claude-sonnet-4-6",
        "FALLBACK_MODEL": "claude-haiku-4-5-20251001"
      }
    }
  }
}

// claude-mcp-server/src/index.ts
import Anthropic from "@anthropic-ai/sdk";
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 
const client = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});
 
// タスクの複雑度からモデルを自動選択する関数
function selectModel(taskComplexity: "low" | "medium" | "high"): string {
  const modelMap = {
    low: "claude-haiku-4-5-20251001",
    medium: "claude-sonnet-4-6",
    high: "claude-opus-4-6",
  };
  return modelMap[taskComplexity];
}
 
// トークン数からコストを推定する関数（事前チェック用）
function estimateCost(
  model: string,
  inputTokens: number,
  outputTokens: number
): number {
  const pricing: Record<string, { input: number; output: number }> = {
    "claude-opus-4-6": { input: 15, output: 75 },
    "claude-sonnet-4-6": { input: 3, output: 15 },
    "claude-haiku-4-5-20251001": { input: 0.8, output: 4 },
  };
  const p = pricing[model] || pricing["claude-sonnet-4-6"];
  return (inputTokens * p.input + outputTokens * p.output) / 1_000_000;
}
 
// Claude へのリクエスト（ストリーミング対応）
async function callClaude(params: {
  messages: Anthropic.MessageParam[];
  system?: string;
  taskComplexity?: "low" | "medium" | "high";
  maxTokens?: number;
}): Promise<{ content: string; usage: Anthropic.Usage }> {
  const model = selectModel(params.taskComplexity ?? "medium");
  const maxTokens = params.maxTokens ?? 4096;
 
  try {
    const response = await client.messages.create({
      model,
      max_tokens: maxTokens,
      system:
        params.system ??
        "あなたは熟練したソフトウェアエンジニアです。正確で実用的なコードを提供してください。",
      messages: params.messages,
    });
 
    const textContent = response.content.find((c) => c.type === "text");
    if (!textContent || textContent.type !== "text") {
      throw new Error("No text content in response");
    }
 
    // コスト記録（ログ出力）
    const cost = estimateCost(
      model,
      response.usage.input_tokens,
      response.usage.output_tokens
    );
    console.error(
      `[Claude] model=${model} cost=$${cost.toFixed(4)} tokens=${response.usage.input_tokens}+${response.usage.output_tokens}`
    );
 
    return { content: textContent.text, usage: response.usage };
  } catch (error) {
    // Opus 4 が失敗したら Sonnet 4 にフォールバック
    if (model === "claude-opus-4-6") {
      console.error("[Claude] Opus 4 failed, falling back to Sonnet 4");
      return callClaude({ ...params, taskComplexity: "medium" });
    }
    throw error;
  }
}

// structured-output-with-tools.ts
import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic();
 
// コードレビューツールの定義
const codeReviewTool: Anthropic.Tool = {
  name: "submit_code_review",
  description: "コードレビューの結果を構造化された形式で返す",
  input_schema: {
    type: "object" as const,
    properties: {
      severity: {
        type: "string",
        enum: ["critical", "warning", "info"],
        description: "問題の深刻度",
      },
      category: {
        type: "string",
        enum: [
          "security",
          "performance",
          "maintainability",
          "logic",
          "style",
        ],
        description: "問題のカテゴリ",
      },
      issues: {
        type: "array",
        items: {
          type: "object",
          properties: {
            line: { type: "number" },
            description: { type: "string" },
            suggestion: { type: "string" },
          },
          required: ["line", "description", "suggestion"],
        },
        description: "検出された問題のリスト",
      },
      overall_score: {
        type: "number",
        minimum: 0,
        maximum: 100,
        description: "コード品質スコア（0-100）",
      },
    },
    required: ["severity", "category", "issues", "overall_score"],
  },
};
 
async function reviewCode(code: string, language: string) {
  const response = await client.messages.create({
    // Opus 4 を使用（コードレビューは高精度が求められる）
    model: "claude-opus-4-6",
    max_tokens: 2048,
    tools: [codeReviewTool],
    tool_choice: { type: "tool", name: "submit_code_review" },
    messages: [
      {
        role: "user",
        content: `以下の${language}コードをレビューしてください:\n\n\`\`\`${language}\n${code}\n\`\`\``,
      },
    ],
  });
 
  // ツールコールの結果を抽出
  const toolUse = response.content.find((c) => c.type === "tool_use");
  if (!toolUse || toolUse.type !== "tool_use") {
    throw new Error("Expected tool use response");
  }
 
  return toolUse.input as {
    severity: string;
    category: string;
    issues: Array<{ line: number; description: string; suggestion: string }>;
    overall_score: number;
  };
}
 
// 使用例
async function main() {
  const sampleCode = `
async function fetchUserData(userId) {
  const result = await db.query('SELECT * FROM users WHERE id = ' + userId);
  return result;
}
  `;
 
  const review = await reviewCode(sampleCode, "javascript");
  console.log(`品質スコア: ${review.overall_score}/100`);
  console.log(`重大度: ${review.severity}`);
  review.issues.forEach((issue) => {
    console.log(`行${issue.line}: ${issue.description}`);
    console.log(`  → ${issue.suggestion}`);
  });
}

// streaming-claude-in-antigravity.ts
import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic();
 
async function* streamClaudeResponse(
  userMessage: string,
  conversationHistory: Anthropic.MessageParam[] = []
): AsyncGenerator<string> {
  const messages: Anthropic.MessageParam[] = [
    ...conversationHistory,
    { role: "user", content: userMessage },
  ];
 
  // ストリーミングで Sonnet 4 を呼び出す
  const stream = await client.messages.stream({
    model: "claude-sonnet-4-6",
    max_tokens: 1024,
    messages,
    system:
      "あなたは Antigravity IDE の開発をサポートするアシスタントです。簡潔で実用的な回答を提供してください。",
  });
 
  let inputTokens = 0;
  let outputTokens = 0;
 
  for await (const chunk of stream) {
    if (
      chunk.type === "content_block_delta" &&
      chunk.delta.type === "text_delta"
    ) {
      yield chunk.delta.text;
    } else if (chunk.type === "message_start") {
      inputTokens = chunk.message.usage.input_tokens;
    } else if (chunk.type === "message_delta") {
      outputTokens = chunk.usage.output_tokens;
    }
  }
 
  // コストログ
  const cost =
    (inputTokens * 3 + outputTokens * 15) / 1_000_000;
  console.error(`[Streaming] tokens=${inputTokens}+${outputTokens} cost=$${cost.toFixed(4)}`);
}
 
// Antigravity エージェントスクリプトでの使用例
async function runInteractiveSession() {
  const history: Anthropic.MessageParam[] = [];
 
  const userInput = "このTypeScriptコードのパフォーマンスを改善するには？";
  process.stdout.write("Claude: ");
 
  let fullResponse = "";
  for await (const chunk of streamClaudeResponse(userInput, history)) {
    process.stdout.write(chunk);
    fullResponse += chunk;
  }
  console.log();
 
  // 会話履歴を更新
  history.push({ role: "user", content: userInput });
  history.push({ role: "assistant", content: fullResponse });
}

// cost-aware-model-router.ts
interface TaskConfig {
  systemPrompt: string;
  userMessage: string;
  // タスクの特性を指定
  requiresDeepReasoning: boolean;
  isRepetitive: boolean;
  latencyRequirement: "realtime" | "normal" | "batch";
}
 
function chooseModel(config: TaskConfig): string {
  // リアルタイム応答が必要 → Haiku
  if (config.latencyRequirement === "realtime") {
    return "claude-haiku-4-5-20251001";
  }
 
  // 深い推論が必要 → Opus 4
  if (config.requiresDeepReasoning && !config.isRepetitive) {
    return "claude-opus-4-6";
  }
 
  // バッチ処理の反復タスク → Haiku でコスト削減
  if (config.isRepetitive && config.latencyRequirement === "batch") {
    return "claude-haiku-4-5-20251001";
  }
 
  // それ以外 → Sonnet 4 がデフォルト
  return "claude-sonnet-4-6";
}
 
// 月次コスト予測
function estimateMonthlyBudget(dailyTasks: {
  deepAnalysis: number;    // Opus 4 タスク数
  codeGeneration: number;  // Sonnet 4 タスク数
  quickQueries: number;    // Haiku タスク数
}): number {
  // 平均トークン数を仮定
  const avgTokensOpus = 3000;
  const avgTokensSonnet = 1500;
  const avgTokensHaiku = 500;
 
  const dailyCost =
    (dailyTasks.deepAnalysis * avgTokensOpus * (15 + 75)) / 1_000_000 +
    (dailyTasks.codeGeneration * avgTokensSonnet * (3 + 15)) / 1_000_000 +
    (dailyTasks.quickQueries * avgTokensHaiku * (0.8 + 4)) / 1_000_000;
 
  return dailyCost * 30;
}
 
// 実際の使用量例
const monthlyBudget = estimateMonthlyBudget({
  deepAnalysis: 5,      // 1日5回の設計相談
  codeGeneration: 50,   // 1日50回のコード生成
  quickQueries: 200,    // 1日200回のインライン補完
});
 
console.log(`月次予測コスト: $${monthlyBudget.toFixed(2)}`);
// → 約 $12〜18 / 月（個人開発の範囲内）

// rate-limit-retry.ts
import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic();
 
async function callWithRetry(
  params: Anthropic.MessageCreateParamsNonStreaming,
  maxRetries = 3
): Promise<Anthropic.Message> {
  let lastError: Error | null = null;
 
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await client.messages.create(params);
    } catch (error) {
      if (error instanceof Anthropic.RateLimitError) {
        // レート制限: エクスポネンシャルバックオフで待機
        const waitMs = Math.pow(2, attempt) * 1000 + Math.random() * 500;
        console.warn(`Rate limited. Retrying in ${waitMs}ms... (attempt ${attempt + 1}/${maxRetries})`);
        await new Promise((resolve) => setTimeout(resolve, waitMs));
        lastError = error;
        continue;
      }
 
      if (error instanceof Anthropic.APIError && error.status === 529) {
        // API過負荷: より長い待機
        const waitMs = 5000 + Math.random() * 3000;
        console.warn(`API overloaded. Retrying in ${waitMs}ms...`);
        await new Promise((resolve) => setTimeout(resolve, waitMs));
        lastError = error;
        continue;
      }
 
      // その他のエラーは即座に throw
      throw error;
    }
  }
 
  throw lastError ?? new Error("Max retries exceeded");
}