同時リクエスト数はいくつまで持つのか — Little の法則と実測メモリで決める Claude API 本番デプロイのインフラ要件

// capacity.ts — 必要同時実行数とレート予算を1か所で検算する計算機
type CapacityInput = {
  qps: number;            // ピーク到着率（リクエスト/秒）
  meanStreamSec: number;  // ストリーム1本の平均継続時間 W（秒）
  retryRate: number;      // 再試行率 r（0.08 = 8%）
  peakFactor: number;     // 到着の揺らぎ係数（私は 1.5〜2 で見ます）
  avgInputTokens: number;
  avgOutputTokens: number;
  rpmLimit: number;       // 組織の RPM 上限
  itpmLimit: number;      // 入力 TPM 上限
  otpmLimit: number;      // 出力 TPM 上限
};
 
export function sizeCapacity(c: CapacityInput) {
  // 再試行とピーク係数を織り込んだ「実効到着率」で全てを計算する
  const effectiveQps = c.qps * (1 + c.retryRate) * c.peakFactor;
 
  // Little の法則: 同時実行数 L = 到着率 λ × 滞在時間 W
  const concurrent = Math.ceil(effectiveQps * c.meanStreamSec);
 
  // 待ち行列は「60秒我慢すれば捌ける量」を上限にし、超えたら受付で断る
  const queueDepth = Math.ceil(effectiveQps * 60);
 
  const rpm = effectiveQps * 60;
  const itpm = rpm * c.avgInputTokens;
  const otpm = rpm * c.avgOutputTokens;
 
  return {
    concurrent,
    queueDepth,
    budget: {
      rpm:  { used: Math.round(rpm),  limit: c.rpmLimit,  ok: rpm  <= c.rpmLimit },
      itpm: { used: Math.round(itpm), limit: c.itpmLimit, ok: itpm <= c.itpmLimit },
      otpm: { used: Math.round(otpm), limit: c.otpmLimit, ok: otpm <= c.otpmLimit },
    },
  };
}
 
// 例: チャット UI（ピーク 2.5 QPS・平均ストリーム 12 秒・再試行 8%）
console.log(sizeCapacity({
  qps: 2.5, meanStreamSec: 12, retryRate: 0.08, peakFactor: 1.5,
  avgInputTokens: 2200, avgOutputTokens: 900,
  rpmLimit: 4000, itpmLimit: 2000000, otpmLimit: 400000,
}));
// 期待出力:
// {
//   concurrent: 49,
//   queueDepth: 243,
//   budget: {
//     rpm:  { used: 243,    limit: 4000,    ok: true },
//     itpm: { used: 534600, limit: 2000000, ok: true },
//     otpm: { used: 218700, limit: 400000,  ok: true }
//   }
// }

// stream-memory-probe.ts — 同時ストリーミング N 本の RSS 増分を実測する
// 実行例: PROBE_STREAMS=24 PROBE_RETAIN=1 npx tsx stream-memory-probe.ts
import Anthropic from "@anthropic-ai/sdk";
 
const client = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });
const N = Number(process.env.PROBE_STREAMS ?? 8);
const RETAIN = process.env.PROBE_RETAIN === "1"; // 1: チャンクを配列に保持（悪い例の再現）
 
const retained: string[][] = [];
 
async function oneStream(): Promise<void> {
  const chunks: string[] = [];
  const stream = client.messages.stream({
    model: "claude-sonnet-5",
    max_tokens: 8000,
    // 長文を出させるプロンプト（実測では約6万字の日本語記事を生成させました）
    messages: [{ role: "user", content: "YOUR_LONG_FORM_PROMPT" }],
  });
  for await (const event of stream) {
    if (event.type === "content_block_delta" && event.delta.type === "text_delta") {
      if (RETAIN) chunks.push(event.delta.text); // 悪い例: 全チャンクをヒープに保持
      else void event.delta.text.length;          // 良い例: 逐次処理して参照を残さない
    }
  }
  if (RETAIN) retained.push(chunks);
}
 
const before = process.memoryUsage().rss;
const timer = setInterval(() => {
  const mb = (process.memoryUsage().rss - before) / 1024 / 1024;
  console.log(`rss delta: ${mb.toFixed(1)} MB`);
}, 2000);
 
await Promise.all(Array.from({ length: N }, () => oneStream()));
clearInterval(timer);
const finalMb = (process.memoryUsage().rss - before) / 1024 / 1024;
console.log(`final delta: ${finalMb.toFixed(1)} MB / ${N} streams`);
// 期待出力（例・RETAIN=1 / N=24）: final delta: 166.3 MB / 24 streams

// bounded-gate.ts — 決めた同時実行数と待ち行列長を強制する最小ゲート
export class BoundedGate {
  private running = 0;
  private waiting: Array<() => void> = [];
 
  constructor(
    private maxConcurrent: number, // sizeCapacity() の concurrent をそのまま渡す
    private maxQueue: number,      // 同じく queueDepth
  ) {}
 
  async run<T>(task: () => Promise<T>): Promise<T> {
    if (this.running >= this.maxConcurrent) {
      if (this.waiting.length >= this.maxQueue) {
        // 待たせるより先に断る（load shedding）。呼び出し側が後で再投入する
        throw new Error("shed: queue is full");
      }
      // 空きが出るまで待機（解放側が1件だけ起こすので追い越しは起きない）
      await new Promise<void>((resolve) => this.waiting.push(resolve));
    }
    this.running++;
    try {
      return await task();
    } finally {
      this.running--;
      this.waiting.shift()?.(); // 待ち行列の先頭を1件だけ起こす
    }
  }
 
  // 監視用ゲージ。定期的にログに書き出して見積もりと突き合わせる
  get gauge() {
    return { running: this.running, queued: this.waiting.length };
  }
}
 
// 使い方:
// const gate = new BoundedGate(49, 243);
// const msg = await gate.run(() => client.messages.create({ /* ... */ }));
// setInterval(() => console.log(gate.gauge), 5000);
// 期待出力（ピーク時）: { running: 49, queued: 87 } のように上限で頭打ちになる