SSD Nodes Learn Hosting plans →
మార్గదర్శకాలు Matt Connorద్వారా Matt Connor · అప్‌డేట్ చేయబడింది 2026-10-24

Claude prompt cachingలో break-even లెక్క ఎలా వేయాలి

Cache writeకు 1.25x, readకు సాధారణంగా 0.1x ఖర్చవుతుంది. అందుకే prefix రెండో వినియోగంలోనే ఖర్చును తిరిగి ఇస్తుంది. API లెక్కలతో మీ break-even నిర్ధారించండి.

క్యాషింగ్ ద్వారా ఆదా ప్రారంభమయ్యే ముందు దాని ఖర్చు

Prompt caching వల్ల ప్రతి callలో మీ prompt ప్రారంభ భాగాన్ని మళ్లీ చదవాల్సిన అవసరం లేకుండా Claude దాన్ని తిరిగి ఉపయోగించగలదు. మొత్తం నిర్ణయం మీ model యొక్క base input price పై వర్తించే రెండు multipliers పై ఆధారపడి ఉంటుంది. October 2026 నాటికి, 5 minute lifetime కోసం cache write కు ప్రతి modelలో base input ధరకు 1.25x ఖర్చవుతుంది. 1 hour lifetime కోసం అది 2x అవుతుంది. చాలా modelsలో cache read కు 0.1x ఖర్చవుతుంది. అయితే ఇప్పుడు అన్ని modelsలో read multiplier ఒకేలా లేదు. Claude Fable 5.1 మరియు Claude Mythos 5.1లో ఇది 0.025x. ఈ models September 1, 2026న అదే rateతో విడుదలయ్యాయి. Claude Opus 5.5 మరియు Claude Sonnet 5.5లో ఇది 0.05x. Sonnet 5.5లో ఈ rateను October 7, 2026న 0.1x నుంచి తగ్గించారు. దిగువ ఉదాహరణ లెక్కల్లో సాధారణ 0.1x readను ఉపయోగించాం. తక్కువ read ఖర్చులు break-even స్థితిని మీకు కొద్దిగా అనుకూలంగా మారుస్తాయి. తదుపరి విభాగంలో ఆ తేడా ఎంత ఉంటుందో చూపిస్తాం.

ఇది ఇప్పుడు చెల్లించే surchargeకు బదులుగా తరువాత లభించే discount. Prefixను నిల్వ చేయడానికి మొదట ఒకసారి అదనపు ఖర్చు చెల్లించాలి. ఆ తరువాత అదే bytesతో కచ్చితంగా ప్రారంభమయ్యే ప్రతి requestలో, ఆ భాగానికి సాధారణ input ధరలో పదో వంతు మాత్రమే చెల్లించాలి. పై modelsలో ఈ ధర ఇంకా తక్కువగా ఉంటుంది. Prefix lifetimeలో ఒక్కసారి కూడా తిరిగి ఉపయోగించకపోతే, దాని కోసం 25 percent అదనంగా చెల్లించినట్టే అవుతుంది.

బ్రేక్-ఈవెన్‌ను ఒకే బీజగణిత సమీకరణంలో

క్యాష్ లేకుండా పంపితే prefix కోసం అయ్యే ప్రాథమిక input ఖర్చును Bగా తీసుకుందాం. క్యాషింగ్ లేకుండా N requests కు Bకి N రెట్లు ఖర్చవుతుంది. 5 minute cache ఉపయోగిస్తే, మొదటి request prefix ను 1.25B ఖర్చుతో రాస్తుంది. మిగిలిన N minus 1 requests దాన్ని 0.1B ఖర్చుతో చదువుతాయి. ఈ రెండు ఖర్చులను సమానం చేస్తే 0.9N = 1.15 వస్తుంది. అందువల్ల N = 1.28. అంటే రెండవ request నుంచే caching చేయడం, caching చేయకపోవడం కంటే చవకగా ఉంటుంది.

1 hour cache లో 2x write ను ఉపయోగించి ఇదే లెక్కను చేస్తే 0.9N = 1.9 వస్తుంది. అందువల్ల N = 2.11. దీర్ఘకాల cache break-even కావడానికి రెండు reads అవసరం. అందుకే ఇది default ఎంపిక కాదు.

Reads ఇంకా చవకగా ఉంటే రేఖ మారుతుంది, కానీ పెద్దగా కాదు. 0.05x read వద్ద 5 minute cache కు 0.95N = 1.2, కాబట్టి N = 1.26. 0.025x వద్ద 0.975N = 1.225, కాబట్టి N = 1.26. 1 hour cache కోసం ఇవి వరుసగా N = 2.05 మరియు N = 2.03 అవుతాయి. ప్రతి model లోనూ ఆచరణాత్మక ఫలితం ఒకటే: 5 minute cache రెండవ request నుంచే ఖర్చును తిరిగి పొందుతుంది; 1 hour cache మూడవ request నుంచే ఖర్చును తిరిగి పొందుతుంది.

క్రింది chart లో Claude Opus 5 పై 20,000 token prefix కు అయ్యే ఖర్చును చూపిస్తున్నాం. October 2026 నాటికి దాని ప్రాథమిక input rate ఒక million tokens కు $5. August నుంచి అది మారలేదు. Opus 5 ఇప్పుడు legacy model, అయినప్పటికీ ఇది ఇంకా అందుబాటులో ఉంది. దాని successor అయిన Claude Opus 5.5, 0.05x read తో ఒక million tokens కు $4గా జాబితా చేయబడింది. అందువల్ల అక్కడ అదే prefix ను రాయడానికి $0.10, చదవడానికి $0.004 ఖర్చవుతుంది. Standard 0.1x read ఉన్న ఒక million tokens కు $3 ధర గల model కోసం ప్రతి సంఖ్యను 0.6తో గుణించండి. Curve ఆకారం మారదు.

చార్ట్Cost of N requests sharing a 20,000 token prefix (Claude Opus 5, August 2026 prices)
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "requests": 1,
    "uncached_usd": "0.10",
    "cached_5m_usd": "0.125",
    "cached_1h_usd": "0.20"
  },
  {
    "requests": 2,
    "uncached_usd": "0.20",
    "cached_5m_usd": "0.135",
    "cached_1h_usd": "0.21"
  },
  {
    "requests": 3,
    "uncached_usd": "0.30",
    "cached_5m_usd": "0.145",
    "cached_1h_usd": "0.22"
  },
  {
    "requests": 5,
    "uncached_usd": "0.50",
    "cached_5m_usd": "0.165",
    "cached_1h_usd": "0.24"
  },
  {
    "requests": 10,
    "uncached_usd": "1.00",
    "cached_5m_usd": "0.215",
    "cached_1h_usd": "0.29"
  },
  {
    "requests": 20,
    "uncached_usd": "2.00",
    "cached_5m_usd": "0.315",
    "cached_1h_usd": "0.39"
  }
]

ఒక request కు మాత్రమే uncached ఖర్చు $0.10, cached ఖర్చు $0.125. అందువల్ల ఒక్కసారి మాత్రమే ఉపయోగించే prompt కు caching చేయడం వల్ల నికర నష్టం వస్తుంది. రెండవ request వద్ద 5 minute cache ఖర్చు $0.135, uncached ఖర్చు $0.20. ఆ సమయంలో 1 hour cache ఇంకా వెనుకబడే ఉంటుంది: $0.21, అదే uncached ఖర్చు $0.20. ఇది మూడవ request వద్ద మాత్రమే uncached రేఖను దాటుతుంది: $0.22, uncached ఖర్చు $0.30. 20 requests వద్ద తేడా $2.00కు వ్యతిరేకంగా $0.315గా ఉంటుంది.

Cache hit జరిగినప్పుడు entry మళ్లీ refresh అవుతుంది. అందుకే ప్రచురించిన price table లో ఆ column కు cache hits and refreshes అని పేరు పెట్టారు. అందువల్ల busy endpoint ఒక 5 minute entry ను read ధరలతో నిరవధికంగా సజీవంగా ఉంచగలదు. మీ network traffic లో నిజమైన విరామాలు ఉన్నప్పుడు మాత్రమే 1 hour lifetime యొక్క 2x write ఖర్చు ప్రయోజనకరంగా ఉంటుంది.

తక్కువ cache hit rate వల్ల కలిగే ఖర్చు

నిజమైన traffic లో cache misses జరుగుతాయి. Cache miss అయినా breakpoint ను కలిగి ఉన్న request ను write గా charge చేస్తారు. అందువల్ల hit rate ఆధారంగా cost ను model చేయడమే సరైన విధానం. దిగువ chart 1,000 requests కోసం ఈ లెక్కను చూపిస్తుంది. ప్రతి request లో ఒకే 20,000 token prefix ఉంటుంది.

చార్ట్Cost of 1,000 requests by cache hit rate, 20,000 token prefix
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "hit_rate_percent": 0,
    "cost_5m_usd": "125.00",
    "cost_1h_usd": "200.00",
    "uncached_usd": "100.00"
  },
  {
    "hit_rate_percent": 25,
    "cost_5m_usd": "96.25",
    "cost_1h_usd": "152.50",
    "uncached_usd": "100.00"
  },
  {
    "hit_rate_percent": 50,
    "cost_5m_usd": "67.50",
    "cost_1h_usd": "105.00",
    "uncached_usd": "100.00"
  },
  {
    "hit_rate_percent": 75,
    "cost_5m_usd": "38.75",
    "cost_1h_usd": "57.50",
    "uncached_usd": "100.00"
  },
  {
    "hit_rate_percent": 90,
    "cost_5m_usd": "21.50",
    "cost_1h_usd": "29.00",
    "uncached_usd": "100.00"
  },
  {
    "hit_rate_percent": 95,
    "cost_5m_usd": "15.75",
    "cost_1h_usd": "19.50",
    "uncached_usd": "100.00"
  },
  {
    "hit_rate_percent": 99,
    "cost_5m_usd": "11.15",
    "cost_1h_usd": "11.90",
    "uncached_usd": "100.00"
  }
]

0 percent hit rate వద్ద $125.00 చెల్లించాలి. ఇది $100.00 కంటే ఎక్కువ. 1 hour cache bill ను రెట్టింపు చేసి $200.00 కు చేరుస్తుంది. 1.25 minus 1.15h = 1 ను పరిష్కరిస్తే, 5 minute cache సుమారు 22 percent hit rate వద్ద డబ్బు ఆదా చేయడం ప్రారంభిస్తుంది. అందుకే 25 percent వద్దనే $96.25 కనిపిస్తుంది. 2x write పై ఇదే లెక్క 1 hour cache కోసం సుమారు 53 percent threshold ను ఇస్తుంది. అందువల్ల 50 percent hit rate వద్ద కూడా ఖర్చు $105.00 గా ఉంటుంది. ఇది uncached line కంటే ఎక్కువ. 90 percent వద్ద అవి వరుసగా $21.50 మరియు $29.00 కు చేరుతాయి. 99 percent వద్ద short cache $11.15 కు చేరుతుంది. ఇది uncached price లో one tenth అయిన floor కు దగ్గరగా ఉంటుంది.

0.05x read ఉన్న model లో thresholds 5 minute cache కోసం సుమారు 21 percentకు, 1 hour cache కోసం 51 percentకు తగ్గుతాయి. 0.025x read ఉన్న model లో అవి సుమారు 20 మరియు 51 percentకు తగ్గుతాయి. Read price తగ్గితే floor కూడా తగ్గుతుంది. అది uncached cost లో one twentieth లేదా one fortieth అవుతుంది.

Prefix size స్థిరంగా ఉన్న తర్వాత మీరు నియంత్రించగల ఏకైక input hit rate. అందువల్ల instrument చేయాల్సిన సంఖ్య కూడా hit rate.

ఏ prefixలకు breakpoint ఉపయోగకరంగా ఉంటుంది

ఒక request‌లో గరిష్ఠంగా నాలుగు cache breakpoints ఉండవచ్చు. కాబట్టి ఏ blocks‌కు breakpoint కేటాయించాలి అనేదే ప్రశ్న. Calls మధ్య byte స్థాయిలో ఒకేలా ఉండి, ఖర్చుపై ప్రభావం చూపేంత పెద్దవిగా ఉన్న blocks సరైన candidates. 5 minute cacheలో 90 percent hit rate వద్ద 1,000 requests‌కు సాధారణంగా కనిపించే నాలుగు ఆకృతుల ఖర్చును క్రింది chart చూపిస్తుంది.

చార్ట్Cost per 1,000 requests at a 90% hit rate, by cached prefix (Claude Opus 5)
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "label": "System prompt",
    "prefix_size_tokens": "2,000",
    "uncached_usd": "10.00",
    "cached_usd": "2.15",
    "saved_usd": "7.85"
  },
  {
    "label": "System plus tools",
    "prefix_size_tokens": "8,000",
    "uncached_usd": "40.00",
    "cached_usd": "8.60",
    "saved_usd": "31.40"
  },
  {
    "label": "Policy document",
    "prefix_size_tokens": "25,000",
    "uncached_usd": "125.00",
    "cached_usd": "26.88",
    "saved_usd": "98.12"
  },
  {
    "label": "Codebase context",
    "prefix_size_tokens": "120,000",
    "uncached_usd": "600.00",
    "cached_usd": "129.00",
    "saved_usd": "471.00"
  }
]

కేవలం 2,000 token system prompt, cache లేకుండా ఉండే $10.00తో పోలిస్తే 1,000 requests‌కు $7.85 ఆదా చేస్తుంది. పెద్ద పరిమాణంలో ఇది నిజమైన ఆదాయమే. అయితే caching ఆసక్తికరంగా మారడానికి ఇదొక్కటే కారణం కాదు. Tool definitions‌ను జోడిస్తే మొత్తం 8,000 tokens అవుతాయి, ఆదా $31.40కు చేరుతుంది. ప్రతి request‌లో ప్రశ్నలు అడిగే 25,000 token policy document $98.12 ఆదా చేస్తుంది. Architecture‌ను మార్చగలిగేది చివరి row: codebase లేదా transcript context‌కు చెందిన 120,000 tokens cache లేకుండా $600.00, cacheతో $129.00 ఖర్చవుతాయి. అంటే $471.00 ఆదా.

Savings prefix size మరియు hit rateతో పెరుగుతాయి. ఇతర ఏ అంశంతోనూ అవి పెరగవు. అందువల్ల prompt‌లో ఏదైనా చేర్చడం విలువైనదేనా అనే విషయం మారుతుంది: మిలియన్ Claude tokens‌కు వాస్తవంగా ఎంత ఖర్చవుతుంది మీరు ఒకటి కంటే ఎక్కువసార్లు పంపే ఏ content‌కైనా జాబితా ధరలో పదో వంతుకు, reads తక్కువ ఖర్చయ్యే modelsలో అంతకంటే తక్కువకు చేరుతుంది.

నెలవారీ బిల్లులో ఇది ఎలా కనిపిస్తుంది

క్రింది చార్ట్ పైన పేర్కొన్న 8,000 token prefix, system prompt మరియు tool definitions ను 90 శాతం hit rate వద్ద తీసుకుని, వాటిని నెలవారీ request పరిమాణాలకు విస్తరిస్తుంది.

చార్ట్Monthly input cost, 8,000 token cached prefix at a 90% hit rate
ఈ చార్ట్ వెనుక ఉన్న డేటా
[
  {
    "label": "10k requests",
    "uncached_usd": "400.00",
    "cached_usd": "86.00",
    "saved_usd": "314.00"
  },
  {
    "label": "100k requests",
    "uncached_usd": "4,000.00",
    "cached_usd": "860.00",
    "saved_usd": "3,140.00"
  },
  {
    "label": "1M requests",
    "uncached_usd": "40,000.00",
    "cached_usd": "8,600.00",
    "saved_usd": "31,400.00"
  }
]

నెలకు 10,000 requests వద్ద ఆదా $314.00. ఇది $400.00 మరియు $86.00 మధ్య తేడా. 100,000 requests వద్ద ఆదా $3,140.00. ఒక million requests వద్ద caching లేకుండా input bill $40,000.00 ఉంటుంది. caching అందులోని $31,400.00 ను తొలగిస్తుంది. ఇవి input tokens కు మాత్రమే సంబంధించినవి. Output కు విడిగా ధర నిర్ణయించబడుతుంది. caching దానిపై ఎలాంటి ప్రభావం చూపదు. అందువల్ల ఎవరికైనా bill ను 90 శాతం తగ్గిస్తామని హామీ ఇచ్చే ముందు ఈ విషయాన్ని గుర్తుంచుకోవాలి. VPSలో AI agent bill ను నియంత్రణలో ఉంచే విస్తృత పద్ధతులతో పాటు caching కూడా ఉపయోగపడుతుంది. VPSలో AI agent bill ను నియంత్రణలో ఉంచడం

క్యాష్ పనిచేస్తోందని ఎలా నిరూపించాలి

డిజైన్‌ను నమ్మి ఆగిపోవద్దు. Response లోని usage block ను చదవండి. ప్రతి Messages API (application programming interface) reply అది రాసిన cached tokens, చదివిన cached tokens, అలాగే కొత్తగా process చేయాల్సి వచ్చిన fresh tokens సంఖ్యలను చూపిస్తుంది.

from anthropic import Anthropic

client = Anthropic()

resp = client.messages.create(
    model="claude-opus-5",
    max_tokens=512,
    system=[
        {
            "type": "text",
            "text": POLICY_DOCUMENT,
            "cache_control": {"type": "ephemeral"},
        }
    ],
    messages=[{"role": "user", "content": question}],
)

u = resp.usage
print("write:", u.cache_creation_input_tokens)
print("read: ", u.cache_read_input_tokens)
print("fresh:", u.input_tokens)

అదే document తో, వేరే question ఉపయోగించి దీన్ని రెండుసార్లు run చేయండి. మొదటి call లో non-zero cache_creation_input_tokens మరియు zero cache_read_input_tokens కనిపిస్తాయి. Prefix కనుగొనబడినందున, రెండో call లో ఇది తారుమారవుతుంది. చివరి breakpoint తర్వాత ఉన్న tokens ను మాత్రమే input_tokens లెక్కిస్తుంది. అందువల్ల సక్రమంగా పనిచేసే రెండో call లో ఇది చిన్నదిగా ఉంటుంది. సాధారణంగా కొత్త user message మాత్రమే ఉంటుంది. రెండు calls కు billing జరుగుతుంది, ఎందుకంటే Claude APIలో ఉచిత tier లేదు. అయితే పై ధర ప్రకారం 20,000 token prefix కు ఈ రెండు calls కలిపి సుమారు పద్నాలుగు cents ఖర్చవుతుంది.

మీరు request.json లో సేవ్ చేసిన request body కు వ్యతిరేకంగా shell నుంచి ఇదే తనిఖీ చేయవచ్చు:

curl -s https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d @request.json | jq '.usage'

సక్రమంగా పనిచేసే రెండో call లో ఇలాంటిది print అవుతుంది:

{
  "input_tokens": 42,
  "cache_creation_input_tokens": 0,
  "cache_read_input_tokens": 20143,
  "output_tokens": 187
}

ఒక line వాస్తవాన్ని తెలియజేస్తుంది. Calls మధ్య cache_read_input_tokens 0గానే ఉంటే, ప్రతి సారి 1.25x write కోసం చెల్లిస్తున్నారు. దానికి బదులుగా ఏ cache data తిరిగి పొందడం లేదు.

1 hour lifetime కోసం breakpoint లో time to live (TTL) ఉంటుంది:

{
  "type": "text",
  "text": "your stable prefix",
  "cache_control": {"type": "ephemeral", "ttl": "1h"}
}

Automatic caching కూడా ఉంది. Request యొక్క top level లో ఒకే cache_control field ను ఉంచిన తర్వాత, conversation పెరుగుతున్న కొద్దీ API breakpoints ను నిర్వహిస్తుంది. ఇది మీ నాలుగు breakpoint slots లో ఒకదాన్ని ఉపయోగిస్తుంది. ముందుగా దీన్నే ఉపయోగించండి. Boundary ఖచ్చితంగా ఎక్కడ ఉండాలో నిర్ణయించాల్సినప్పుడు explicit breakpoints కు మారండి.

హిట్ రేట్లను తగ్గించే క్రమ నియమం

Cache, request ప్రారంభం నుంచి prefix ను byte కు byte సరిపోల్చుతుంది. Request ఒక స్థిర క్రమంలో రూపొందుతుంది: tools, తరువాత system, తరువాత messages. ఏ స్థాయిలోనైనా మార్పు జరిగితే ఆ స్థాయి మరియు దాని తరువాతి మొత్తం invalid అవుతుంది. ఒక tool description ను మాత్రమే సవరించినా system prompt మరియు మొత్తం message history కూడా invalid అవుతాయి. వాటిలో మార్పు చేయకపోయినా ఇదే జరుగుతుంది.

దీనివల్ల మినహాయింపులేని ఒక నియమం ఏర్పడుతుంది. Calls మధ్య మారే ప్రతిదీ, మారని ప్రతిదాని తరువాత ఉండాలి.

సాధారణంగా సమస్య timestamp వల్ల వస్తుంది. system prompt పైభాగంలో Current time: 2026-08-03T14:07:11Z ఉన్న ఒక line ప్రతి call లో 0 percent hit rate ను నిర్ధారిస్తుంది. ప్రతి call లో prefix hash మారుతుంది కాబట్టి, అంతకుముందు ఉన్న ఏ entry కూడా దానితో ఎప్పటికీ సరిపోలదు. దాన్ని user message చివరికి తరలించండి. Session identifier లేదా ప్రతి request కు ప్రత్యేకమైన nonce కూడా ఇదే విధంగా సమస్యను కలిగిస్తుంది. వాటికీ ఇదే పరిష్కారం వర్తిస్తుంది. ప్రతి request లో మారే retrieved documents కూడా cached block తరువాత ఉండాలి. లేకపోతే మారే boundary తరువాత ఉన్న ప్రతి స్థిర token cache కు వెలుపలికి నెట్టబడుతుంది.

రెండవ సమస్య మారే block పైనే breakpoint ఉంచడం. Breakpoint వద్ద cache writes జరుగుతాయి. కాబట్టి ఆ block ప్రతి సారి భిన్నంగా ఉంటే, స్థిరమైన content ఏదీ ఎప్పటికీ నిల్వ చేయబడదు. Lookback కు, మునుపటి requests తమ తమ మారే breakpoints వద్ద రాసిన entries మాత్రమే కనిపిస్తాయి. Requests మధ్య content ఒకేలా ఉండే చివరి block పై cache_control ఉంచండి.

మూడవది prompt content గా పరిగణించని parameter మార్పు. వేరే model కు వేరే cache ఉంటుంది. tool_choice ను మార్చితే message history invalid అవుతుంది. అయితే tools మరియు system prompt cached గానే ఉంటాయి. ఒక tool ను జోడించినా లేదా తొలగించినా మొత్తం invalid అవుతుంది.

కనిష్ట prefix, మరియు ఎలాంటి సూచన లేని no-op

మోడల్‌కు అవసరమైన కనిష్ట పరిమాణం కంటే చిన్న prefix cache చేయబడదు. దీనిని తెలియజేసే ఎలాంటి సూచన ఉండదు. error లేదా warning ఏదీ కనిపించదు. request విజయవంతంగా పూర్తవుతుంది, కానీ రెండు counters విలువలు 0గానే ఉంటాయి. October 2026 నాటికి ప్రచురితమైన కనిష్ట పరిమాణాలు ఇవి:

  • Claude Opus 5, Claude Fable 5, అలాగే కొత్త Opus 5.5, Sonnet 5.5, Fable 5.1 మరియు Haiku 5.5 పై 512 tokens
  • Claude Sonnet 5 మరియు Claude Opus 4.8 పై 1,024 tokens
  • Claude Haiku 4.5 పై 4,096 tokens

Cache అయిందని మీరు భావిస్తున్న request లో రెండు counters విలువలు 0గా ఉంటే, మిగతా దేనికంటే ముందుగా prefix పొడవును తనిఖీ చేయండి. Caching workload కోసం అత్యంత చవకైన model స్వయంచాలకంగా తక్కువ ఖర్చుతో కూడుకున్నదిగా ఉండకపోవడానికి ఇదే కారణం. Caching ప్రారంభం కావాలంటే Haiku 4.5కు Opus 5 కంటే ఎనిమిది రెట్లు పొడవైన prefix అవసరం. అందువల్ల 2,000 tokenల system prompt ఒకదానిలో cache అవుతుంది, మరొకదానిలో మాత్రం ఎలాంటి సూచన లేకుండా విస్మరించబడుతుంది.

Claude Code మీ కోసం cache చేసే ప్రదేశం, అది సహాయపడలేని ప్రదేశం

Claude Code తన స్వంత prefix ను cache చేస్తుంది. System prompt మరియు tool definitions ప్రతి request ప్రారంభంలోనే ఉంటాయి. అవి మారవు. అందువల్ల వాటిని ఒక్కసారి రాసి, session మిగతా సమయంలో తిరిగి చదువుతుంది. దీని కారణంగా, context size సూచించే పరిమాణంతో పోలిస్తే దీర్ఘ session లో ప్రతి turn కు అయ్యే ఖర్చు చాలా తక్కువగా ఉంటుంది. ఇది Claude Code token వినియోగాన్ని ఎలా నివేదిస్తుంది లో వివరించిన counters లో కనిపిస్తుంది.

Context ప్రారంభానికి సమీపంలో మార్పు జరిగితే cache మీకు సహాయపడదు. Conversation history append-only గా ఉంటుంది. అందువల్ల సాధారణ కొత్త turns ఇప్పటికే cache అయిన prefix కు మరింత కంటెంట్‌ను జతచేస్తాయి. Session ప్రారంభంలో చదివిన file ను edit చేసినా ఈ విధానం భంగం చెందదు. ఎందుకంటే Claude Code ముందుగా చదివిన కంటెంట్‌ను మళ్లీ రాయదు. దాని బదులుగా file మారిందని ఒక note ను జతచేస్తుంది. అయితే models మార్చితే cache భంగం చెందుతుంది. ప్రతి model కు వేర్వేరు cache ఉంటుంది. Tools prefix లోకి load అయ్యే MCP server కు connect చేసినా ఇదే జరుగుతుంది. Conversation ను compact చేసినా cache భంగం చెందుతుంది. వీటిలో ప్రతి చర్య తర్వాతి turn లో prefix ను మళ్లీ రాయాల్సి వచ్చేలా చేస్తుంది. చాలా సేపు idle గా ఉంటే కూడా ఇదే జరుగుతుంది. Entry expire అవుతుంది. తర్వాతి turn లో పూర్తి write ఖర్చు చెల్లించాలి. ఇవేవీ bug కాదు. Prefix rule చెప్పిన విధంగానే పనిచేస్తోంది.

బదులుగా మీరు స్వంత client రాస్తుంటే, layout ను తరువాత మార్చి అమర్చకుండా మొదటి request నుంచే సరిగ్గా అమలు చేయండి. VPS పై మొదటి Claude API app చూపిన విధంగా call ను రూపొందించండి. Stable blocks ను ముందుగా, మారే blocks ను చివరగా ఉంచండి.

విఫల పరిస్థితులు, మీరు చూసే లక్షణాలు

ప్రతి call ఒక write. ప్రతి requestలో cache_creation_input_tokens non-zeroగా ఉంటుంది, అయితే cache_read_input_tokens 0గానే ఉంటుంది. Breakpoint వద్ద లేదా దానికి ముందు ఉన్న ఏదో అంశం calls మధ్య మారుతోంది. వరుసగా చేసిన రెండు requestsలో assembled prefix లోని మొదటి 200 characters ను print చేసి, వాటిని ప్రత్యక్షంగా సరిపోల్చండి.

రెండు counters 0గా ఉన్నాయి. Prefix model minimum కంటే చిన్నదిగా ఉంది, లేదా cache_control field APIకి చేరలేదు. ముందుగా prefix tokens ను లెక్కించండి. తరువాత మీరు వాస్తవంగా పంపిన request body ను log చేయండి.

Reads పనిచేసి, తరువాత ఆగిపోతాయి. వరుసగా కొన్ని hits వస్తాయి, తరువాత ఒక write, ఆపై మళ్లీ hits వస్తాయి. Requests మధ్య విరామం lifetime కంటే ఎక్కువగా ఉంది. ఆ write ను అంగీకరించండి. లేదా hit rate 53 percent కంటే ఎక్కువగా ఉందని నిర్ధారించుకున్న తరువాత 1 hour TTL కు మారండి. 0.05x లేదా 0.025x read ధర కలిగిన modelలో ఈ పరిమితి సుమారు 51 percent.

Deploy తర్వాత hit rate తగ్గుతుంది. Tool description మార్చబడింది లేదా model మార్చబడింది. ఈ రెండూ మొత్తం prefix ను invalidate చేస్తాయి. Prompt ను ప్రభావితం చేసే ప్రతి deploy తర్వాత ఖరీదైన writes యొక్క ఒక పూర్తి దశ జరుగుతుందని అంచనా వేయండి.

Caching ప్రారంభించిన తర్వాత bill పెరిగింది. మీ hit rate break-even కంటే తక్కువగా ఉంది. 5 minute cacheలో సుమారు 22 percent కంటే తక్కువగా ఉంటే prefix ను uncachedగా పంపడం చవకగా ఉంటుంది. 1 hour cacheలో సుమారు 53 percent కంటే తక్కువగా ఉంటే ఇదే వర్తిస్తుంది. తక్కువ read ధర కలిగిన modelsలో ఈ పరిమితులు సుమారు 20 నుంచి 21 percent మరియు 51 percent వద్ద ఉంటాయి.

FAQ

Caching ద్వారా ప్రయోజనం పొందడానికి ఒక prompt ను ఎన్నిసార్లు తిరిగి ఉపయోగించాలి?

5 minute cache లో ఒక్కసారి ఉపయోగించినా సరిపోతుంది. Write కు base input ధరకు 1.25x ఖర్చవుతుంది. Read కు చాలా models లో 0.1x ఖర్చవుతుంది. అందువల్ల cache లేకుండా N requests కు N ఖర్చవుతుంది. Cache తో N requests కు 1.25 plus 0.1 times N minus 1 ఖర్చవుతుంది. N = 1.28 వద్ద రెండు ఖర్చులు సమానమవుతాయి. కాబట్టి రెండో request నుంచే caching ప్రయోజనకరంగా ఉంటుంది. 0.05x లేదా 0.025x read ధర ఉన్న models లో ఈ సమానం N = 1.26 వద్ద వస్తుంది. ఫలితం అదే. 1 hour cache లో write ధర 2x ఉంటుంది. ఇది N = 2.11 వద్ద సమానమవుతుంది. తక్కువ read ధర ఉన్నప్పుడు సుమారు 2.05 వద్ద సమానమవుతుంది. కాబట్టి దీనికి రెండు reads అవసరం.

cache_read_input_tokens ఎల్లప్పుడూ zero ఎందుకు చూపిస్తుంది?

ముందుగా prefix length ను తనిఖీ చేయండి. Model minimum కంటే prefix చిన్నగా ఉంటే caching నిశ్శబ్దంగా skip అవుతుంది. October 2026 నాటికి ఈ పరిమితి Claude Opus 5 కోసం 512 tokens, Claude Haiku 4.5 కోసం 4,096. అప్పుడు రెండు counters కూడా 0 చూపిస్తాయి. Prefix తగినంత పొడవుగా ఉంటే, calls మధ్య మారే content breakpoint వద్ద లేదా దాని ముందు ఉందా చూడండి. ఉదాహరణకు system prompt లో timestamp లేదా session identifier ఉండవచ్చు. Counters ముందుగా పనిచేసి తరువాత ఆగిపోతే, requests మధ్య విరామం cache lifetime కంటే ఎక్కువగా ఉంది.

prompt caching Claude సమాధానాలను మార్చుతుందా?

లేదు. మీరు ఇప్పటికే పంపిన tokens యొక్క processed form ను cache నిల్వ చేస్తుంది. ఏ పరిస్థితిలోనైనా model కు అదే prompt కనిపిస్తుంది. ఇది billing మరియు latency కోసం ఉపయోగించే feature మాత్రమే. Behaviour ను మార్చదు. అందువల్ల పనిచేస్తున్న prompt పై దీన్ని enable చేసినా evaluations ను మళ్లీ run చేయాల్సిన అవసరం లేదు.

1 hour cache కోసం చెల్లించాలా?

మీ traffic మధ్య విరామాలు 5 minutes కంటే ఎక్కువగా ఉన్నప్పుడు మాత్రమే చెల్లించండి. అలాగే hit rate సుమారు 53 percent కంటే ఎక్కువగా ఉండాలి. Read ధర తక్కువగా ఉన్న model లో ఇది సుమారు 51 percent. Cache miss సమయంలో 2x write, 1.25x write కంటే నాలుగు రెట్లు ఖరీదైనది. 1 hour write miss అయితే prefix యొక్క పూర్తి base input ధర వృథా అవుతుంది. 5 minute write miss అయితే దాని పావు భాగం మాత్రమే వృథా అవుతుంది. ప్రతి hit పై 5 minute entry refresh అవుతుంది. కాబట్టి నిరంతర traffic ఉన్నప్పుడు దీర్ఘ lifetime కోసం అదనపు ధర చెల్లించకుండా read ధరలకే cache కొనసాగుతుంది.

ఈ వ్యాసం ఉపయోగకరంగా ఉందా?

#claude#prompt-caching#api#token-costs#optimization