Claude Code のネイティブ1Mコンテキストを、いつ使い、いつ使わないか — コストで決める判断ルール

from dataclasses import dataclass
 
@dataclass
class Pricing:
    p_in: float          # 入力 $/1M tokens
    p_out: float         # 出力 $/1M tokens
    long_threshold: int  # この token 数を超えると長コンテキスト帯
    s_in_long: float     # 長帯の入力割増係数
    s_out_long: float    # 長帯の出力割増係数
    r_cache: float       # キャッシュ読取単価 / 通常入力単価
 
def _mult(total_ctx_tokens: int, pr: Pricing):
    """常駐量が長帯を超えるなら割増係数を返す。"""
    if total_ctx_tokens > pr.long_threshold:
        return pr.s_in_long, pr.s_out_long
    return 1.0, 1.0
 
def cost_resident(T_ctx, T_q, T_out, N, pr: Pricing, cache_hit=0.0):
    """窓に T_ctx を常駐させて N 往復した場合の概算コスト($)。"""
    s_in, s_out = _mult(T_ctx + T_q, pr)
    # 常駐分: キャッシュ非ヒットは通常単価、ヒットは r_cache 倍
    resident_factor = (1 - cache_hit) + cache_hit * pr.r_cache
    in_resident = N * T_ctx * pr.p_in * s_in * resident_factor
    in_query    = N * T_q   * pr.p_in * s_in
    out_cost    = N * T_out * pr.p_out * s_out
    return (in_resident + in_query + out_cost) / 1_000_000
 
def cost_sliced(slices, T_q, T_out, N, pr: Pricing):
    """各往復で slices[i] だけを送る場合の概算コスト($)。
    slices は長さ N のリスト（各ターンで送る関連トークン数）。"""
    total = 0.0
    for t_slice in slices:
        s_in, s_out = _mult(t_slice + T_q, pr)
        total += (t_slice + T_q) * pr.p_in * s_in
        total += T_out * pr.p_out * s_out
    return total / 1_000_000
 
# --- Sonnet 5 導入価格を例にした試算(単価は必ず最新を確認) ---
pr = Pricing(p_in=2.0, p_out=10.0,
             long_threshold=200_000,
             s_in_long=2.0, s_out_long=1.5,  # 上位帯の目安。要確認
             r_cache=0.1)
 
T_ctx = 260_000     # リポ全体を窓に載せる
slices = [30_000] * 12   # 分割なら毎回3万tokenだけ関連範囲を送る
args = dict(T_q=1_500, T_out=1_200, N=12)
 
resident = cost_resident(T_ctx, pr=pr, cache_hit=0.0, **args)
sliced   = cost_sliced(slices, pr=pr, **args)
print(f"常駐(キャッシュ無): ${resident:.2f}")
print(f"分割:             ${sliced:.2f}")
 
resident_cached = cost_resident(T_ctx, pr=pr, cache_hit=0.8, **args)
print(f"常駐(キャッシュ80%): ${resident_cached:.2f}")

def should_use_large_context(T_ctx, N, cache_expected, pr: Pricing,
                             slice_ratio=0.12) -> tuple[bool, str]:
    """1M級の常駐を使うべきかを判定して理由を返す。"""
    # 1) そもそも帯を超えないなら常駐でよい(割増が付かない)
    if T_ctx <= pr.long_threshold:
        return True, "帯を超えないため常駐が無難(割増なし)"
    # 2) 一度きりの読み取りは常駐が単純で安全
    if N <= 2:
        return True, "往復が少なく再送コストが小さい"
    # 3) 反復が多くキャッシュも期待できないなら分割
    if N >= 6 and cache_expected < 0.5:
        return False, "再訪多・低キャッシュで常駐の再送が高くつく"
    # 4) 関連範囲が全体のごく一部なら分割が効く
    if slice_ratio <= 0.2 and cache_expected < 0.8:
        return False, "毎ターンの関連範囲が狭く分割で帯を下回れる"
    # 5) それ以外はキャッシュ次第。境界は実測で
    return (cache_expected >= 0.6,
            "境界域。キャッシュ実測で常駐/分割を最終判断")
 
for scenario in [
    (260_000, 12, 0.0),
    (260_000, 12, 0.85),
    (260_000, 2, 0.0),
    (150_000, 20, 0.0),
]:
    ok, why = should_use_large_context(*scenario, pr=pr)
    print(scenario, "->", "常駐" if ok else "分割", "/", why)