SSD Nodes Learn Hosting plans →
Mga Gabay Matt ConnorNi Matt Connor · Na-update 2026-10-24

Claude prompt caching: kailan ito sulit

Alamin ang break-even: 1.25x ang cache write at 0.1x o mas mababa ang read, kaya nababawi ang Claude prefix sa ikalawang gamit. Patunayan ito sa API.

Ano ang gastos ng prompt caching bago ito makatipid

Hinahayaan ng prompt caching na gamitin muli ni Claude ang simula ng iyong prompt sa halip na basahin ito sa bawat call. Nakabatay ang buong desisyon sa dalawang multiplier sa base input price ng iyong model. Noong October 2026, ang cache write ay nagkakahalaga ng 1.25x ng base input para sa 5 minute lifetime, o 2x para sa 1 hour lifetime, sa lahat ng model. Ang cache read ay nagkakahalaga ng 0.1x sa karamihan ng model, pero hindi na pare-pareho ang read multiplier sa lahat ng model. Ito ay 0.025x sa Claude Fable 5.1 at Claude Mythos 5.1, na inilunsad sa rate na iyon noong September 1, 2026. Ito ay 0.05x sa Claude Opus 5.5 at Claude Sonnet 5.5. Ibinaba naman ang rate ng Sonnet 5.5 mula 0.1x sa rate na iyon noong October 7, 2026. Ginagamit ng mga halimbawa sa ibaba ang karaniwang 0.1x read. Bahagyang mas pabor sa iyo ang break-even kapag mas mura ang mga read, at ipinapakita ng susunod na seksyon kung gaano kalaki ang epekto nito.

Ang trade-off ay dagdag na bayad ngayon kapalit ng diskuwento sa susunod. Isang beses kang magbabayad nang higit para i-store ang isang prefix. Sa bawat kasunod na request na nagsisimula sa eksaktong parehong bytes, ikasampu lamang ng normal na input price ang babayaran para sa bahaging iyon, o mas kaunti sa mga model na nabanggit sa itaas. Kung hindi kailanman gagamitin muli ang isang prefix habang valid ang lifetime nito, nagbayad ka ng 25 percent na dagdag nang walang kapalit.

Ang break-even, sa isang linya ng algebra

Tawagin nating B ang base input cost ng prefix kung ipapadala mo ito nang walang cache. Kung walang caching, ang N requests ay nagkakahalaga ng N na beses ng B. Sa 5 minute cache, isinusulat ng unang request ang prefix sa halagang 1.25B, at binabasa ito ng natitirang N minus 1 requests sa halagang 0.1B. Ihambing ang dalawang halaga at makukuha ang 0.9N = 1.15, kaya N = 1.28. Mas mura na agad ang second request kaysa sa tuluyang walang caching.

Ulitin ito gamit ang 2x write ng 1 hour cache at makukuha ang 0.9N = 1.9, kaya N = 2.11. Kailangan ng long cache ng dalawang read bago ito mag-break even. Ito ang dahilan kung bakit hindi ito ang default na pagpipilian.

Sa mas murang reads, gumagalaw ang linya pero hindi nang malaki. Sa 0.05x read, ang 5 minute cache ay nagbibigay ng 0.95N = 1.2, kaya N = 1.26. Sa 0.025x, nagbibigay ito ng 0.975N = 1.225, na N = 1.26 din. Bumaba ang 1 hour cache sa N = 2.05 at N = 2.03. Pareho ang praktikal na sagot sa bawat model: sulit ang 5 minute cache mula sa second request, at ang 1 hour cache mula sa third request.

Ipinapakita ng chart sa ibaba ang presyo nito para sa 20,000 token prefix sa Claude Opus 5. Ang base input rate nito ay $5 bawat million tokens noong October 2026, at hindi ito nagbago mula August. Legacy model na ngayon ang Opus 5, bagama't available pa rin ito. Ang successor nito, ang Claude Opus 5.5, ay may presyong $4 bawat million na may 0.05x read. Kaya sa model na iyon, nagkakahalaga ang parehong prefix ng $0.10 para isulat at $0.004 para basahin. I-multiply sa 0.6 ang bawat halaga para sa $3 bawat million na model na gumagamit ng standard na 0.1x read. Hindi nagbabago ang hugis ng curve.

TsartCost of N requests sharing a 20,000 token prefix (Claude Opus 5, August 2026 prices)
Ang datos sa likod ng tsart na ito
[
  {
    "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"
  }
]

Ang isang request lamang ay nagkakahalaga ng $0.10 kapag walang cache at $0.125 kapag may cache. Kaya purong lugi ang pag-cache ng prompt na isang beses lang gagamitin. Sa second request, ang 5 minute cache ay nasa $0.135 kumpara sa $0.20. Mas mataas pa rin ang halaga ng 1 hour cache sa puntong iyon: $0.21 kumpara sa parehong $0.20. Nalampasan lamang nito ang uncached line sa third request: $0.22 kumpara sa $0.30. Sa 20 requests, ang agwat ay $2.00 kumpara sa $0.315.

Nire-refresh din ng cache hit ang entry. Ito ang dahilan kung bakit tinatawag ng published price table ang column na cache hits and refreshes. Kaya maaaring manatiling buhay nang walang takdang panahon ang 5 minute entry sa isang busy endpoint, sa read prices, habang kikitain lamang ng 1 hour lifetime ang 2x write nito kapag may tunay na pagitan ang iyong traffic.

Ano ang gastos ng mababang hit rate

May mga request na hindi tumatama sa cache sa aktuwal na traffic. Kapag hindi tumama sa cache ang isang request pero may dala pa rin itong breakpoint, sinisingil ito bilang write. Kaya ang tumpak na pagmomodelo ay ang pagkalkula ng gastos batay sa hit rate. Ipinapakita ito ng chart sa ibaba para sa 1,000 request, na bawat isa ay may parehong 20,000-token prefix.

TsartCost of 1,000 requests by cache hit rate, 20,000 token prefix
Ang datos sa likod ng tsart na ito
[
  {
    "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"
  }
]

Sa 0 percent na hit rate, magbabayad ka ng $125.00 sa halip na $100.00, at dinodoble ng 1 hour cache ang bill sa $200.00. Kapag sinolve ang 1.25 minus 1.15h = 1, magsisimulang makatipid ang 5 minute cache sa hit rate na humigit-kumulang 22 percent. Kaya sa 25 percent, lumalabas na agad ang $96.25. Kapag 2x write ang ginamit sa parehong kalkulasyon, humigit-kumulang 53 percent ang threshold para sa 1 hour cache. Kaya sa 50 percent na hit rate, nagkakahalaga pa rin ito ng $105.00, na mas mataas sa uncached line. Sa 90 percent, ang dalawang cache ay nagkakahalaga ng $21.50 at $29.00. Sa 99 percent, umaabot ang short cache sa $11.15, na malapit sa minimum na isang-kasampu ng uncached price.

Sa model na may 0.05x read, bumababa ang mga threshold sa humigit-kumulang 21 percent para sa 5 minute cache at 51 percent para sa 1 hour cache. Sa 0.025x read, bumababa ang mga ito sa humigit-kumulang 20 at 51 percent. Bumababa rin ang minimum kasabay ng read price, hanggang isang-kadalawampu o isang-kapatnapu ng uncached cost.

Ang hit rate ang kailangang i-instrument, dahil ito ang tanging input na makokontrol mo kapag naitakda na ang prefix size.

Aling prefix ang karapat-dapat sa breakpoint

Maaaring maglaman ang isang request ng hanggang apat na cache breakpoint, kaya ang tanong ay kung aling mga block ang dapat magkaroon nito. Ang mga kandidato ay mga block na byte-identical sa lahat ng call at sapat ang laki para maging mahalaga. Ipinapakita sa chart sa ibaba ang halaga ng apat na karaniwang anyo sa 1,000 request, na may 90 porsiyentong hit rate sa 5 minute cache.

TsartCost per 1,000 requests at a 90% hit rate, by cached prefix (Claude Opus 5)
Ang datos sa likod ng tsart na ito
[
  {
    "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"
  }
]

Ang isang bare na 2,000 token system prompt ay nakakatipid ng $7.85 sa bawat 1,000 request kumpara sa $10.00 kapag walang cache. Malaking halaga ito kapag mataas ang volume, pero hindi ito ang dahilan kung bakit kawili-wili ang caching. Idagdag ang tool definitions, at magiging 8,000 tokens ito at $31.40 ang matitipid. Ang 25,000 token policy document na tinatanungan sa bawat request ay nakakatipid ng $98.12. Ang huling row ang nagbabago sa architecture: ang 120,000 tokens ng codebase o transcript context ay nagkakahalaga ng $600.00 kapag walang cache at $129.00 kapag naka-cache, kaya $471.00 ang matitipid.

Ang matitipid ay tumataas kasabay ng laki ng prefix at hit rate, at wala nang iba. Binabago nito kung ano ang sulit ilagay sa prompt: ang aktuwal na halaga ng isang milyong Claude token ay nagiging ikasampu ng sticker price, o mas mababa pa sa mga model na mas mura ang reads, para sa anumang ipinapadala mo nang higit sa isang beses.

Ano ang hitsura nito sa buwanang bill

Kinukuha ng chart sa ibaba ang 8,000 token prefix mula sa itaas, kasama ang isang system prompt at mga tool definition, sa 90 percent na hit rate, at ina-adjust ito para sa mga buwanang request volume.

TsartMonthly input cost, 8,000 token cached prefix at a 90% hit rate
Ang datos sa likod ng tsart na ito
[
  {
    "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"
  }
]

Sa 10,000 request bawat buwan, ang matitipid ay $314.00, ang diperensya sa pagitan ng $400.00 at $86.00. Sa 100,000 request, ito ay $3,140.00. Sa isang milyong request, ang uncached input bill ay $40,000.00, at inaalis ng caching ang $31,400.00 mula rito. Input tokens lamang ang kasama rito. Hiwalay ang pricing ng output, at walang epekto rito ang caching. Tandaan ito bago ka mangako sa sinuman ng 90 percent na bawas sa bill. Ang caching ay bahagi ng mas malawak na mga gawain sa pagpapanatiling kontrolado ng bill ng AI agent sa isang VPS.

Paano mapapatunayang gumagana ang cache

Huwag umasa sa disenyo lamang. Basahin ang usage block sa response. Iniuulat ng bawat Messages API (application programming interface) reply ang mga cached token na isinulat nito, ang mga cached token na binasa nito, at ang mga bagong token na kinailangan nitong i-process.

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)

Patakbuhin ito nang dalawang beses gamit ang parehong document at ibang tanong. Sa unang call, non-zero ang cache_creation_input_tokens at zero ang cache_read_input_tokens. Sa ikalawang call, kabaligtaran ang resulta dahil nakita ang prefix. Binibilang lamang ng input_tokens ang mga token pagkatapos ng huling breakpoint, kaya maliit ito sa maayos na ikalawang call—karaniwan, ang bagong user message lamang. Parehong may bayad ang dalawang call dahil walang libreng tier ang Claude API, bagama't ang pair para sa 20,000-token prefix na may presyong nakasaad sa itaas ay humigit-kumulang labing-apat na sentimo.

Pareho ring pagsusuri mula sa shell, gamit ang request body na na-save sa request.json:

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'

Ganito ang karaniwang ipinapakita ng maayos na ikalawang call:

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

Isang linya ang nagbibigay ng tunay na resulta. Kung nananatili sa 0 ang cache_read_input_tokens sa bawat call, binabayaran mo ang 1.25x write sa bawat pagkakataon at wala kang natatanggap na cache hit.

Para sa 1 hour na lifetime, may time to live (TTL) ang breakpoint:

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

May automatic caching din: maglagay ng isang cache_control field sa top level ng request, at pagkatapos nito, ang API na ang mamamahala sa mga breakpoint habang lumalaki ang conversation. Kumokonsumo ito ng isa sa apat mong breakpoint slot. Magsimula rito. Gumamit ng explicit breakpoint kapag kailangan mong eksaktong tukuyin kung saan ilalagay ang boundary.

Ang ordering rule na sumisira sa hit rate

Bina-match ng cache ang prefix byte by byte mula sa simula ng request. Binubuo ang request sa fixed na pagkakasunod-sunod: tools, pagkatapos ay system, at saka messages. Kapag may nagbago sa anumang level, ini-invalidate ang level na iyon at lahat ng kasunod nito. Kapag nag-edit ka ng isang tool description, mai-invalidate pati ang system prompt at buong message history, kahit hindi mo binago ang mga ito.

May isang rule ito na walang exception. Anumang nagbabago sa pagitan ng mga call ay dapat ilagay pagkatapos ng lahat ng hindi nagbabago.

Karaniwang sanhi nito ang timestamp. Ang linyang Current time: 2026-08-03T14:07:11Z sa itaas ng system prompt ay naggagarantiya ng 0 percent na hit rate, dahil naiiba ang prefix hash sa bawat call at walang naunang entry ang maaaring mag-match dito. Ilipat ito sa user message, sa pinakahuli. Pareho ring nakakasira ang session identifier o per-request nonce, at pareho rin ang solusyon. Ang mga retrieved document na nag-iiba sa bawat request ay dapat ding ilagay pagkatapos ng cached block. Kung hindi, itinutulak ng mga ito ang lahat ng stable token sa likod ng boundary na gumagalaw.

Ang ikalawang sanhi ay ang paglalagay ng breakpoint sa block na nagbabago. Sa breakpoint nagaganap ang cache writes. Kaya kung nag-iiba ang block sa bawat pagkakataon, walang stable na content ang nase-save, at ang lookback ay nakakahanap lamang ng mga entry na isinulat ng mas naunang requests sa sarili nilang gumagalaw na breakpoint. Ilagay ang cache_control sa huling block na pareho ang content sa lahat ng requests.

Ang ikatlong sanhi ay parameter change na hindi mo itinuturing na prompt content. May hiwalay na cache ang ibang model. Kapag binago ang tool_choice, mai-invalidate ang message history, kahit mananatiling cached ang tools at system prompt. Kapag nagdagdag o nag-alis ka ng tool, mai-invalidate ang lahat.

Ang minimum prefix, at ang tahimik na walang epekto

Hindi naka-cache ang prefix na mas maikli kaysa sa minimum ng model, at walang magsasabi nito sa iyo. Walang error o warning. Matagumpay ang request, at parehong 0 ang dalawang counter. Noong October 2026, ang mga minimum na inilathala ay:

  • 512 tokens sa Claude Opus 5 at Claude Fable 5, pati sa mas bagong Opus 5.5, Sonnet 5.5, Fable 5.1, at Haiku 5.5
  • 1,024 tokens sa Claude Sonnet 5 at Claude Opus 4.8
  • 4,096 tokens sa Claude Haiku 4.5

Kung parehong 0 ang dalawang counter sa isang request na inaakala mong naka-cache, tingnan muna ang haba ng prefix bago ang iba pang bagay. Ito rin ang dahilan kung bakit hindi awtomatikong pinakamura para sa caching workload ang pinakamurang model. Kailangan ng Haiku 4.5 ng prefix na walong beses na mas mahaba kaysa sa Opus 5 bago tuluyang gumana ang caching. Kaya ang 2,000-token system prompt ay naka-cache sa isa, pero tahimik na binabalewala sa isa pa.

Saan nagca-cache ang Claude Code para sa iyo, at saan ito hindi makakatulong

Sini-cache ng Claude Code ang sarili nitong prefix. Nasa unahan ng bawat request ang system prompt at mga tool definition at hindi nagbabago ang posisyon ng mga ito, kaya isinusulat ang mga ito nang isang beses at binabasa muli sa natitirang bahagi ng session. Kaya mas mababa nang malaki ang cost sa bawat turn ng mahabang session kaysa sa ipinahihiwatig ng context size. Lumalabas din ito sa mga counter na inilalarawan sa kung paano iniuulat ng Claude Code ang paggamit ng token.

Hindi ito makakatulong kapag may pagbabago malapit sa simula ng context. Append-only ang conversation history, kaya ang mga ordinaryong bagong turn ay nagdaragdag sa prefix na naka-cache na. Hindi ito nasisira kapag nag-edit ka ng file na binasa nang maaga sa session, dahil nagdaragdag ang Claude Code ng note na nagbago ang file sa halip na muling isulat ang naunang read. Ang nakakasira rito ay ang paglipat ng model, dahil may sariling cache ang bawat model. Nakakasira rin ang pagkonekta ng MCP server na naglo-load ng mga tool nito sa prefix, pati ang pagko-compact ng conversation. Dahil sa bawat isa sa mga ito, isinusulat muli ang prefix sa susunod na turn. Pareho rin ang epekto ng mahabang idle gap, dahil nag-e-expire ang entry at kailangang bayaran ng susunod na turn ang full write. Wala sa mga ito ang bug. Ipinatutupad lamang ng mga ito ang prefix rule ayon sa pagkakalarawan nito.

Kung sarili mong client ang sinusulat mo, gamitin ang layout mula sa unang request sa halip na idagdag ito sa bandang huli. Buuin ang call gaya ng ginagawa sa unang Claude API app sa isang VPS, kung saan nauuna ang stable blocks at nasa hulihan ang volatile blocks.

Mga failure mode at kung ano ang makikita mo

Write ang bawat call. Ang cache_creation_input_tokens ay non-zero sa bawat request habang nananatiling 0 ang cache_read_input_tokens. May nagbabago sa o bago ang breakpoint sa pagitan ng mga call. I-print ang unang 200 character ng binuo mong prefix sa dalawang magkakasunod na request at paghambingin ang mga ito nang biswal.

Parehong 0 ang dalawang counter. Mas maikli sa minimum ng model ang prefix, o hindi nakarating sa API ang field na cache_control. Bilangin muna ang mga token ng prefix, pagkatapos ay i-log ang request body na aktuwal mong ipinadala.

Gumagana ang reads, pagkatapos ay humihinto. May sunod-sunod na hits, pagkatapos ay isang write, at muli ay may hits. Mas mahaba sa lifetime ang pagitan ng mga request. Tanggapin ang write, o lumipat sa 1 hour TTL kapag nakumpirma mong lumalagpas sa 53 percent ang hit rate mo, o humigit-kumulang 51 percent sa model na may 0.05x o 0.025x na read.

Bumababa ang hit rate pagkatapos ng deploy. Na-edit ang tool description o nagbago ang model. Parehong nag-i-invalidate sa buong prefix. Asahan ang isang magastos na round ng writes pagkatapos ng bawat deploy na nakaaapekto sa prompt.

Tumaas ang bill pagkatapos mong i-enable ang caching. Mas mababa sa break-even ang hit rate mo. Sa mas mababa sa humigit-kumulang 22 percent sa 5 minute cache, mas mura ang pagpapadala ng prefix nang walang cache; ganoon din sa mas mababa sa humigit-kumulang 53 percent para sa 1 hour cache. Sa mga model na mas mura ang read, nasa humigit-kumulang 20 hanggang 21 percent at 51 percent ang mga threshold na ito.

FAQ

Ilang beses kailangang gamitin muli ang isang prompt bago sulit ang caching?

Isang beses lang, para sa 5 minute cache. Ang write ay nagkakahalaga ng 1.25x ng base input, at ang read ay 0.1x sa karamihan ng mga modelo. Kaya ang N uncached request ay nagkakahalaga ng N, samantalang ang N cached request ay nagkakahalaga ng 1.25 plus 0.1 times N minus 1. Nagkakasinghalaga ang dalawa sa N = 1.28, kaya mas sulit na agad ang second request. Sa mga modelong may 0.05x o 0.025x na read, N = 1.26 ang punto ng pagkapantay, kaya pareho pa rin ang sagot. Ang 1 hour cache ay may write cost na 2x at nagkakasinghalaga sa N = 2.11, o humigit-kumulang 2.05 kapag mas mura ang read. Kaya kailangan nito ng dalawang read.

Bakit laging zero ang cache_read_input_tokens?

Suriin muna ang haba ng prefix. Kapag mas mababa ito sa minimum ng model—512 tokens sa Claude Opus 5 at 4,096 sa Claude Haiku 4.5 noong October 2026—tahimik na nilalaktawan ang caching, at parehong 0 ang nababasang counter. Kung sapat ang haba ng prefix, hanapin ang content na nagbabago sa pagitan ng mga call at nasa breakpoint o bago nito, gaya ng timestamp o session identifier sa system prompt. Kung gumagana dati ang mga counter at bigla itong tumigil, mas mahaba sa cache lifetime ang pagitan ng mga request.

Binabago ba ng prompt caching ang mga sagot ni Claude?

Hindi. Ini-store ng cache ang naprosesong anyo ng mga token na naipadala mo na, at pareho pa rin ang prompt na nakikita ng model. Feature ito para sa billing at latency, hindi para baguhin ang behaviour. Ibig sabihin, maaari mo itong i-enable sa gumaganang prompt nang hindi inuulit ang iyong evaluations.

Dapat ba akong magbayad para sa 1 hour cache?

Oo lamang kapag may mga gap na mas mahaba sa 5 minutes ang iyong traffic at mananatiling humigit-kumulang 53 percent ang hit rate mo, o mga 51 percent sa modelong mas mura ang read. Kapag miss, ang 2x write ay apat na beses ang halaga ng 1.25x write. Ang na-miss na 1 hour write ay nagsasayang ng buong base input price ng prefix, samantalang isang-kapat lamang nito ang nasasayang sa na-miss na 5 minute write. Nare-refresh ang 5 minute entry sa bawat hit, kaya napapanatili ito ng tuloy-tuloy na traffic sa read prices nang hindi kailanman nagbabayad para sa mas mahabang lifetime.

Nakatulong ba ang artikulong ito?

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