SSD Nodes Learn Hosting plans →
मार्गदर्शक Matt Connorद्वारे Matt Connor · अपडेटेड 2026-10-24

Claude prompt caching: खर्च कधी वसूल होतो?

5 minute cache write साठी 1.25x, read साठी 0.1x किंवा कमी दर आहेत. Claude prefix दुसऱ्या वापरात कसा break-even होतो, याचे API मधून गणित तपासा.

कॅशिंगमुळे बचत होण्यापूर्वीचा Prompt caching खर्च

Prompt caching मुळे Claude ला प्रत्येक call वेळी prompt चा सुरुवातीचा भाग पुन्हा वाचण्याऐवजी तो पुन्हा वापरता येतो. संपूर्ण निर्णय model च्या base input price वरील दोन multipliers वर अवलंबून असतो. October 2026 पर्यंत, 5 minute lifetime साठी cache write ची किंमत base input च्या 1.25x इतकी असते. 1 hour lifetime साठी ती 2x असते. हे सर्व model वर लागू आहे. बहुतेक model मध्ये cache read ची किंमत 0.1x असते. मात्र आता सर्व model साठी read multiplier समान नाही. Claude Fable 5.1 आणि Claude Mythos 5.1 मध्ये तो 0.025x आहे. हे model September 1, 2026 रोजी याच rate सह launch झाले. Claude Opus 5.5 आणि Claude Sonnet 5.5 मध्ये तो 0.05x आहे. Sonnet 5.5 साठी हा rate October 7, 2026 रोजी 0.1x वरून कमी करून 0.05x करण्यात आला. खालील उदाहरणांमध्ये standard 0.1x read वापरला आहे. कमी read cost मुळे break-even थोडे तुमच्या बाजूने सरकते. पुढील section मध्ये त्याचे प्रमाण दाखवले आहे.

हा व्यवहार म्हणजे सध्या surcharge देऊन नंतर discount मिळवणे. Prefix साठवण्यासाठी तुम्ही एकदा अतिरिक्त पैसे देता. त्यानंतरच्या प्रत्येक request ची सुरुवात अगदी त्याच bytes ने होत असल्यास, त्या भागासाठी normal input price च्या एकदशांश इतकी किंमत द्यावी लागते. वर नमूद केलेल्या model मध्ये ही किंमत त्याहून कमी असते. Prefix त्याच्या lifetime मध्ये एकदाही पुन्हा वापरला गेला नाही, तर कोणत्याही बचतीशिवाय तुमचा खर्च 25 percent ने वाढतो.

बीजगणिताच्या एका ओळीत समतोल-बिंदू

कॅश न करता prefix पाठवला असता त्याची मूळ input किंमत B मानू. कॅशिंग नसल्यास N विनंत्यांची किंमत N पट B असते. 5 minute cache वापरल्यास पहिली विनंती prefix 1.25B किमतीत लिहिते आणि उर्वरित N minus 1 विनंत्या ते 0.1B किमतीत वाचतात. दोन्ही किंमती समान ठेवल्यास 0.9N = 1.15 मिळते, म्हणजे N = 1.28. कॅशिंग न करण्यापेक्षा दुसरी विनंतीच स्वस्त ठरते.

1 hour cache मध्ये write ची किंमत 2x धरून हीच गणना केल्यास 0.9N = 1.9 मिळते, म्हणजे N = 2.11. समतोल साधण्यापूर्वी long cache साठी दोन reads आवश्यक असतात. त्यामुळे तो default choice नाही.

स्वस्त 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 दुसऱ्या विनंतीपासून फायदेशीर ठरते आणि 1 hour cache तिसऱ्या विनंतीपासून.

खालील chart मध्ये Claude Opus 5 वरील 20,000 token prefix ची किंमत दाखवली आहे. October 2026 नुसार त्याचा base input rate प्रति million tokens $5 आहे. August पासून या दरात बदल झालेला नाही. Opus 5 आता legacy model आहे, तरी तो उपलब्ध आहे. त्याचा successor Claude Opus 5.5 प्रति million $4 आकारतो आणि त्याचा read rate 0.05x आहे. त्यामुळे तेथे समान prefix लिहिण्याची किंमत $0.10 आणि वाचण्याची किंमत $0.004 आहे. standard 0.1x read असलेल्या प्रति million $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"
  }
]

एकट्या एका विनंतीची uncached किंमत $0.10 आणि cached किंमत $0.125 असते. त्यामुळे one-shot prompt कॅश करणे म्हणजे निव्वळ तोटा आहे. दुसऱ्या विनंतीपर्यंत 5 minute cache ची किंमत $0.135 होते, तर uncached किंमत $0.20 असते. त्या टप्प्यावर 1 hour cache अजूनही मागे असते: त्याची किंमत $0.21, तर uncached किंमत $0.20 असते. तिसऱ्या विनंतीवरच ते uncached रेषेपेक्षा पुढे जाते: $0.22, त्या तुलनेत uncached किंमत $0.30. 20 विनंत्यांपर्यंत फरक $2.00 विरुद्ध $0.315 इतका असतो.

Cache hit मुळे entry पुन्हा refresh होते. म्हणून प्रकाशित price table मध्ये त्या column ला cache hits and refreshes असे नाव दिले आहे. त्यामुळे व्यस्त endpoint 5 minute entry read prices वर अनिश्चित काळ टिकवू शकतो. तुमच्या traffic मध्ये प्रत्यक्ष gaps असतील तेव्हाच 1 hour lifetime मुळे त्याची 2x write किंमत भरून निघते.

कमी hit rate ची किंमत

प्रत्यक्ष network traffic मध्ये cache miss होतात. Cache miss झालेल्या request मध्ये breakpoint असला, तरी तिचे write म्हणून शुल्क आकारले जाते. त्यामुळे cost चे hit rate वरील अवलंबित्व मांडणे ही योग्य पद्धत आहे. खालील 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 एवढा uncached cost असतो. 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 मिळते. त्यामुळे 50 percent hit rate वरही cost $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 वर ते अनुक्रमे सुमारे 20 आणि 51 percent होतात. Read price कमी झाल्यावर floor देखील कमी होतो. तो uncached cost च्या twentieth किंवा fortieth पर्यंत येतो.

Prefix size निश्चित झाल्यानंतर तुम्ही नियंत्रित करू शकता असे एकमेव input म्हणजे hit rate. त्यामुळे instrument करण्यासाठी hit rate हाच महत्त्वाचा आकडा आहे.

कोणत्या prefix साठी breakpoint ठेवणे उपयुक्त आहे

एका request मध्ये जास्तीत जास्त चार cache breakpoint असू शकतात. त्यामुळे कोणत्या block साठी breakpoint ठेवणे योग्य आहे, हा प्रश्न महत्त्वाचा ठरतो. प्रत्येक call मध्ये byte स्तरावर अगदी समान राहणारे आणि पुरेसे मोठे असलेले block हे योग्य उमेदवार आहेत. खालील chart मध्ये 5 minute cache वर 90 percent hit rate गृहीत धरून 1,000 requests साठी चार सामान्य आकारांची किंमत दाखवली आहे.

तक्ता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 tokens असलेला system prompt, cache न वापरल्यास लागणाऱ्या $10.00 च्या तुलनेत 1,000 requests मागे $7.85 वाचवतो. मोठ्या प्रमाणावर ही वास्तविक बचत आहे; परंतु caching महत्त्वाचे ठरण्याचे हे मुख्य कारण नाही. Tool definitions जोडल्यास एकूण आकार 8,000 tokens होतो आणि बचत $31.40 होते. प्रत्येक request ज्याबद्दल प्रश्न विचारते अशा 25,000 tokens च्या policy document मुळे $98.12 बचत होते. शेवटची row architecture मध्ये बदल घडवते: codebase किंवा transcript context चे 120,000 tokens cache न वापरल्यास $600.00, तर cache वापरल्यास $129.00 खर्च होतात. म्हणजे $471.00 बचत होते.

बचत prefix च्या आकारासोबत आणि hit rate सोबत वाढते. याशिवाय इतर कोणत्याही घटकामुळे ती वाढत नाही. त्यामुळे prompt मध्ये कोणती माहिती ठेवणे योग्य आहे, याचा निर्णय बदलतो: एक दशलक्ष Claude tokens ची वास्तविक किंमत तुम्ही एकापेक्षा जास्त वेळा पाठवलेल्या कोणत्याही सामग्रीसाठी दर्शविलेल्या किमतीच्या एक-दशांशपर्यंत कमी होते; ज्या models मध्ये reads स्वस्त आहेत, तेथे ती त्याहूनही कमी असू शकते.

मासिक बिलावर याचा परिणाम

खालील चार्ट वरील 8,000 token prefix, system prompt आणि tool definitions यांचा 90 टक्के hit rate गृहीत धरतो आणि तो मासिक request volumes वर लागू करतो.

तक्ता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 इतकी आहे. 1 million requests असताना uncached input bill $40,000.00 इतके असते आणि caching त्यातील $31,400.00 इतकी रक्कम वाचवते. हे आकडे फक्त input tokens साठी आहेत. Output ची किंमत स्वतंत्रपणे आकारली जाते आणि caching चा त्यावर कोणताही परिणाम होत नाही. त्यामुळे कोणालाही बिलात 90 टक्के कपात होईल असे आश्वासन देण्यापूर्वी ही बाब लक्षात ठेवा. VPS वरील AI agent चा बिलावरील खर्च नियंत्रणात ठेवण्यासाठी caching ही व्यापक पद्धतींसोबत वापरता येणारी एक स्वतंत्र पद्धत आहे.

कॅश कार्यरत असल्याचे कसे सिद्ध करावे

रचनेवर आंधळा विश्वास ठेवू नका. प्रतिसादातील usage block वाचा. प्रत्येक Messages API (application programming interface) प्रतिसादात त्याने लिहिलेले 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 आणि वेगळ्या प्रश्नासह ते दोनदा चालवा. पहिल्या call मध्ये cache_creation_input_tokens शून्यापेक्षा मोठे आणि cache_read_input_tokens शून्य असल्याचे दिसते. prefix सापडल्यामुळे दुसऱ्या call मध्ये याउलट परिणाम दिसतो. input_tokens मध्ये फक्त शेवटच्या breakpoint नंतरचे tokens मोजले जातात. त्यामुळे निरोगी दुसऱ्या call मध्ये त्याची संख्या कमी असते; सामान्यतः त्यात फक्त नवीन user message असतो. दोन्ही calls साठी शुल्क आकारले जाते, कारण Claude API मध्ये free tier नाही, तरी वर नमूद केलेल्या 20,000 token prefix साठी ही जोडी सुमारे चौदा 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 साधारणपणे असा output दाखवतो:

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

एक ओळ सत्य स्पष्ट करते. calls दरम्यान cache_read_input_tokens 0 राहिला, तर प्रत्येक वेळी तुम्ही 1.25x write साठी शुल्क देत आहात आणि त्या बदल्यात काहीही परत मिळवत नाही.

1 hour lifetime साठी breakpoint मध्ये time to live (TTL) असतो:

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

स्वयंचलित caching देखील उपलब्ध आहे: request च्या top level वर एकच cache_control field दिल्यानंतर API conversation वाढत असताना breakpoints स्वतः व्यवस्थापित करते. यासाठी तुमच्या चार breakpoint slots पैकी एक वापरला जातो. सुरुवात यापासून करा. boundary नेमकी कुठे असावी हे ठरवण्याची गरज असल्यास explicit breakpoints वापरा.

हिट रेट कमी करणारा क्रम नियम

कॅशे विनंतीच्या सुरुवातीपासून byte-by-byte prefix जुळवतो. विनंतीचा क्रम निश्चित असतो: आधी tools, त्यानंतर system, आणि शेवटी messages. कोणत्याही स्तरावर बदल झाल्यास तो स्तर आणि त्यानंतरचे सर्व स्तर invalid होतात. एका tool चे वर्णन संपादित केल्यास system prompt आणि संपूर्ण message history देखील invalid होतात, जरी त्यांच्यात कोणताही बदल केलेला नसला तरी.

यातून अपवाद नसलेला एक नियम मिळतो. प्रत्येक call दरम्यान बदलणारी कोणतीही गोष्ट, न बदलणाऱ्या सर्व गोष्टींनंतर आली पाहिजे.

सामान्य समस्या timestamp मुळे निर्माण होते. system prompt च्या सुरुवातीला Current time: 2026-08-03T14:07:11Z असलेली ओळ असल्यास hit rate 0 percent राहण्याची खात्री असते. कारण प्रत्येक call मध्ये prefix hash बदलतो आणि त्यापूर्वीची कोणतीही entry कधीही जुळू शकत नाही. तो भाग user message मध्ये, शेवटी हलवा. session identifier किंवा प्रत्येक request साठीचा nonce देखील याच प्रकारे अडथळा निर्माण करतो आणि त्यावर हाच उपाय लागू होतो. प्रत्येक request नुसार बदलणारे retrieved documents देखील cached block नंतर ठेवा. अन्यथा बदलणाऱ्या boundary मागे येणारे सर्व स्थिर tokens cache मधून बाहेर पडतात.

दुसरी समस्या बदलणाऱ्या block वर breakpoint ठेवण्याची आहे. breakpoint वर cache writes होतात. त्यामुळे तो block प्रत्येक वेळी वेगळा असल्यास कोणतीही स्थिर माहिती साठवली जात नाही. lookback ला फक्त आधीच्या requests ने त्यांच्या बदलत्या breakpoints वर लिहिलेल्या entries आढळतात. requests मध्ये ज्याची content समान असते अशा शेवटच्या block वर cache_control ठेवा.

तिसरी समस्या prompt content मानली जात नसलेली parameter change आहे. वेगळ्या model साठी वेगळा cache असतो. tool_choice बदलल्यास message history invalid होते, परंतु tools आणि system prompt cache मध्ये राहतात. एखादा tool जोडल्यास किंवा काढल्यास सर्व काही invalid होते.

किमान prefix आणि शांतपणे होणारे no-op

मॉडेलच्या किमान मर्यादेपेक्षा लहान prefix कॅश केला जात नाही आणि याची कोणतीही माहिती दिली जात नाही. कोणतीही 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

एखादी request cached असल्याचा तुम्हाला विश्वास असेल, पण दोन्ही counters 0 दाखवत असतील, तर इतर कोणतीही तपासणी करण्यापूर्वी prefix ची लांबी तपासा. Caching workload साठी सर्वात स्वस्त model आपोआप सर्वात कमी खर्चिक असेलच असे नाही, याचे हेही एक कारण आहे. Caching सुरू होण्यासाठी Haiku 4.5 ला Opus 5 पेक्षा आठपट लांब prefix आवश्यक असतो. त्यामुळे 2,000 tokens चा system prompt एका model वर 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 आधीच cached असलेल्या prefix मध्ये पुढील मजकूर जोडतात. Session च्या सुरुवातीला वाचलेली file संपादित केल्याने ही cache तुटत नाही. Claude Code आधी वाचलेला मजकूर पुन्हा लिहिण्याऐवजी file बदलल्याची note जोडते. मात्र model बदलल्यास cache तुटते, कारण प्रत्येक model ची cache स्वतंत्र असते. ज्यांची tools prefix मध्ये load होतात असा MCP server connect केल्यानेही cache तुटते. Conversation compact केल्यानेही तेच होते. या प्रत्येक कृतीमुळे पुढील turn मध्ये prefix पुन्हा लिहिला जातो. बराच वेळ session निष्क्रिय राहिल्यासही असेच होते, कारण cache entry expire होते आणि पुढील turn मध्ये पूर्ण write cost लागू होतो. यापैकी कोणतीही गोष्ट bug नाही. Prefix rule जसे सांगते तसेच ते कार्य करत आहे.

त्याऐवजी तुम्ही स्वतःचा client लिहित असाल, तर layout नंतर बदलून बसवण्याऐवजी पहिल्या request पासूनच लागू करा. VPS वर पहिले Claude API app तयार करणे ज्या पद्धतीने call तयार करते, त्याच पद्धतीने stable blocks आधी आणि volatile blocks शेवटी ठेवा.

अपयशाची कारणे आणि तुम्हाला दिसणारे संकेत

प्रत्येक call ही write असते. प्रत्येक request वेळी cache_creation_input_tokens non-zero असते, तर cache_read_input_tokens 0 राहते. Breakpoint पर्यंत किंवा त्यापूर्वीच्या भागात प्रत्येक call दरम्यान काहीतरी बदलते. सलग दोन 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 मधील अंतर cache 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 enable केल्यानंतर bill वाढले. तुमचा hit rate break-even पेक्षा कमी आहे. 5 minute cache वर सुमारे 22 percent पेक्षा कमी hit rate असल्यास prefix uncached पाठवणे स्वस्त पडते. 1 hour cache साठी हीच मर्यादा सुमारे 53 percent आहे. कमी read cost असलेल्या models वर या मर्यादा सुमारे 20 ते 21 percent आणि 51 percent असतात.

FAQ

caching चा खर्च भरून निघण्यासाठी prompt किती वेळा पुन्हा वापरावा लागतो?

5 minute cache मध्ये एकदाच. बहुतेक models मध्ये write साठी base input च्या 1.25x इतका खर्च येतो आणि read साठी 0.1x खर्च येतो. त्यामुळे cache न वापरता केलेल्या N requests चा खर्च N इतका असतो, तर cache वापरलेल्या N requests चा खर्च 1.25 plus 0.1 times N minus 1 इतका असतो. हे दोन खर्च N = 1.28 येथे समान होतात. त्यामुळे दुसरी request आधीच फायदेशीर ठरते. 0.05x किंवा 0.025x read असलेल्या models मध्ये हे समानता-बिंदू N = 1.26 असतो. त्यामुळे निष्कर्ष तोच राहतो. 1 hour cache मध्ये write साठी 2x खर्च येतो आणि समानता-बिंदू N = 2.11 येथे येतो. स्वस्त read असलेल्या models मध्ये तो सुमारे 2.05 असतो. त्यामुळे त्यासाठी दोन reads आवश्यक आहेत.

cache_read_input_tokens नेहमी zero का असते?

प्रथम prefix ची लांबी तपासा. model minimum पेक्षा कमी असल्यास, October 2026 नुसार Claude Opus 5 साठी 512 tokens आणि Claude Haiku 4.5 साठी 4,096 tokens, caching शांतपणे वगळले जाते आणि दोन्ही counters 0 दाखवतात. Prefix पुरेसा लांब असल्यास, breakpoint वर किंवा त्यापूर्वी calls दरम्यान बदलणारा content आहे का ते तपासा. उदाहरणार्थ, system prompt मधील timestamp किंवा session identifier तपासा. Counters आधी काम करत होते आणि नंतर थांबले असल्यास, requests मधील अंतर cache lifetime पेक्षा जास्त होते.

prompt caching मुळे Claude ची उत्तरे बदलतात का?

नाही. Cache मध्ये तुम्ही आधी पाठवलेल्या tokens चे processed form साठवले जाते. त्यामुळे दोन्ही स्थितींमध्ये model ला तोच prompt दिसतो. हे billing आणि latency यांसाठीचे feature आहे; behaviour बदलण्यासाठीचे नाही. त्यामुळे कार्यरत prompt वर ते enable करून evaluations पुन्हा चालवण्याची गरज नसते.

1 hour cache साठी पैसे द्यावेत का?

तुमच्या traffic मध्ये 5 minutes पेक्षा जास्त gaps असतील आणि hit rate साधारण 53 percent पेक्षा जास्त राहणार असेल, किंवा स्वस्त read असलेल्या model मध्ये सुमारे 51 percent पेक्षा जास्त राहणार असेल, तेव्हाच. Cache miss झाल्यास 2x write चा खर्च 1.25x write पेक्षा चारपट असतो. 1 hour write miss झाल्यास prefix च्या पूर्ण base input price इतका खर्च वाया जातो. 5 minute write miss झाल्यास त्याच्या फक्त एक चतुर्थांश खर्च वाया जातो. 5 minute entry प्रत्येक hit वेळी refresh होते. त्यामुळे सततचा traffic अधिक दीर्घ lifetime साठी अतिरिक्त पैसे न देता read prices वर cache जिवंत ठेवतो.

हा लेख उपयुक्त होता का?

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