Il-caching avvanzat tal-prompt
F'din il-paġna
Lil hinn mill-caching awtomatiku
Rajt il-bażiċi tal-caching tal-prompt fil-Lessun 3. Hemmhekk, il-caching deher bħala mekkaniżmu awtomatiku li jibbenefikak mingħajr sforz speċjali, u dan huwa veru sakemm l-applikazzjoni tiegħek tibgħat talbiet ordinati sewwa. Ir-realtà tal-produzzjoni hija aktar imħawda: utenti multipli jolqtu l-istess API fl-istess ħin, kull wieħed bil-folder, id-dokumenti u l-mistoqsijiet tiegħu stess. Il-prefiss komuni mbagħad jiċkien kważi għal xejn, u r-rata ta’ suċċess tal-cache (cache hit rate) tiġi ffollata mingħajr ma kulħadd jinnota, peress li xejn ma jinkiser—il-kont sempliċiment jogħla.
Utenti multipli, dokumenti multipli, pipelines tal-ipproċessar: se nittrattaw dawn ix-xenarji kumplessi wieħed wieħed biex timmassimizza r-rata ta’ suċċess tal-cache. Il-prinċipju gwida jidħol f’sentenza waħda: il-caching mhuwiex xi ħaġa li tiġrillek; huwa xi ħaġa li tiddisinja.
Arkitettura tal-prompt biex timmassimizza l-caching
Il-caching japplika għall-itwal prefiss komuni fost it-talbiet tiegħek. Itwal u aktar stabbli jkun dan il-prefiss, aktar tiffranka. Il-konsegwenza prattika hija li prompt irid jiġi organizzat mill-aktar stabbli għall-aktar varjabbli, bħal ktieb li l-ewwel paġni tiegħu qatt ma jinbidlu u biss il-kapitlu finali jiġi miktub mill-ġdid ma’ kull edizzjoni.
L-eżempju hawn taħt japplika dan il-prinċipju għal assistent tal-analiżi tad-dokumenti għal ditta tal-avukati. Tliet saffi jsegwu lil xulxin: istruzzjonijiet globali, li huma ffriżati; il-bażi tal-għarfien, riveduta darba fix-xahar; u l-fajl tal-każ u l-mistoqsija, li jinbidlu ma’ kull sejħa.
import openai
client = openai.OpenAI()
# Arkitettura f'saffi: mill-aktar stabbli għall-aktar varjabbli
# Saff 1: Istruzzjonijiet globali (qatt ma jinbidlu)
GLOBAL_INSTRUCTIONS = """
Inti assistent tal-analiżi tad-dokumenti għal ditta tal-avukati.
Regoli:
- Dejjem wieġeb bil-Franċiż
- Iċċita artikoli legali rilevanti
- Istruttura bħala: Analiżi / Riskji / Rakkomandazzjonijiet
- Kun fattwali u preċiż
"""
# Saff 2: Bażi tal-għarfien (tinbidel rarament)
KNOWLEDGE_BASE = """
[Daħħal aktar minn 5,000 token ta' ġurisprudenza, artikoli legali,
mudelli ta' analiżi hawn—dan il-kontent jinbidel l-aktar darba fix-xahar]
"""
# Saff 3: Kuntest tal-każ (jinbidel għal kull klijent)
def build_prompt(case_context: str, question: str) -> str:
return f"""{GLOBAL_INSTRUCTIONS}
{KNOWLEDGE_BASE}
--- Każ Attwali ---
{case_context}
--- Mistoqsija ---
{question}"""
L-iżball klassiku huwa li tpoġġi l-isem tal-klijent jew id-data tal-lum fil-bidu tal-prompt tas-sistema biex “tippersonalizzah”. Karattru varjabbli wieħed fil-pożizzjoni inizjali huwa biżżejjed biex jagħmel il-prefiss uniku, u jbaxxi r-rata ta’ suċċess tal-cache għal żero għas-saffi sussegwenti kollha. Kull ħaġa li tvarja trid tmur l-aħħar.
Naturalment, trid tivverifika li t-teorija tittraduċi fi numri. Il-monitor li ġej jaqra input_tokens_details.cached_tokens fuq kull risposta u jakkumula l-kejl, u jagħtik rata medja użabbli minflok sensazzjoni intuitiva.
class CacheMonitor:
"""Jimmonitorja l-effiċjenza tal-caching tal-prompt."""
def __init__(self):
self.calls: list[dict] = []
def record(self, usage) -> dict:
total_input = usage.input_tokens
cached_tokens = getattr(
usage.input_tokens_details, "cached_tokens", 0
)
rate = cached_tokens / total_input if total_input > 0 else 0
entry = {
"total_input": total_input,
"cached_tokens": cached_tokens,
"cache_rate": rate,
}
self.calls.append(entry)
return entry
@property
def average_rate(self) -> float:
if not self.calls:
return 0.0
return sum(a["cache_rate"] for a in self.calls) / len(self.calls)
def report(self) -> str:
if not self.calls:
return "L-ebda sejħa."
return (
f"Sejħiet: {len(self.calls)} | "
f"Rata medja tal-cache: {self.average_rate:.1%} | "
f"Tokens iffrankati: "
f"{sum(a['cached_tokens'] for a in self.calls):,}"
)
monitor = CacheMonitor()
Tliet mudelli li jagħmlu d-differenza
L-ewwel mudell jikkonċerna l-ordni tal-ipproċessar. Meta tipproċessa lott ta’ talbiet eteroġenji, it-tħaddim tagħhom fl-ordni ta’ wasla jalternaw il-prefissi u jipprevjeni lill-cache milli jibqa’ sħun. Il-grupp skont il-kuntest kondiviż isolvi l-problema: iggruppa l-ewwel, eżekwita wara, sabiex kull grupp jibbenefika mill-prefiss imħejji mill-ewwel talba tiegħu.
from collections import defaultdict
def group_by_context(
requests: list[dict],
) -> dict[str, list[dict]]:
"""Jiggruppa t-talbiet skont prefiss komuni."""
groups = defaultdict(list)
for request in requests:
# Ċavetta = hash tal-kuntest kondiviż
key = hash(request.get("shared_context", ""))
groups[key].append(request)
return dict(groups)
def process_by_cohort(requests: list[dict]):
"""Jipproċessa talbiet iggruppati biex jimmassimizza l-caching."""
groups = group_by_context(requests)
for key, group in groups.items():
# It-talbiet kollha fil-grupp jaqsmu l-istess prefiss
for request in group:
response = client.responses.create(
model="gpt-5.6-terra",
instructions=request["shared_context"],
input=request["question"],
)
monitor.record(response.usage)
It-tieni mudell jittratta l-bidwiet kesħin (cold starts). L-ewwel talba f’serje tħallas il-prezz sħiħ peress li xejn mhu cached għadu; jekk dik l-ewwel talba tiġi minn utent reali fi Tnejn fil-għodu fis-9 ta’ filgħodu, huwa jġorr il-latency. Talba ta’ tisħin (warm-up) mibgħuta qabel ma jiftaħ is-serviss iċaqlaq dik l-ispiża fejn ma tfastidx lil ħadd. Innota l-gwardja fil-bidu tal-funzjoni: taħt 1,024 token, il-caching ma japplikax, u t-tisħin minn qabel ikun sempliċiment nefqa.
def warm_up_cache(system_prompt: str):
"""Jibgħat talba minima biex iħejji l-cache."""
if len(system_prompt) // 4 < 1024:
print("Il-prompt huwa qasir wisq għall-caching (< 1,024 token)")
return
response = client.responses.create(
model="gpt-5.6-terra",
instructions=system_prompt,
input="Ikkonferma li inti lest.",
max_output_tokens=10,
)
usage = response.usage
print(
f"Il-cache tħejja: {usage.input_tokens} token tal-input, "
f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} cached"
)
It-tielet mudell jagħmel l-invalidazzjoni tal-cache viżibbli. It-tiswija ta’ virgola f’prompt tas-sistema ta’ 5,000 token tidher trivjali, madankollu dik il-virgola tnaddaf il-cache għal kulħadd. Billi tرفق fingerprint mal-kontenut, tiskopri l-bidla fid-distribuzzjoni minflok l-għada fuq il-kont, u tista’ immedjatament issegwi bit-tisħin minn qabel.
import hashlib
class VersionedPrompt:
"""Jimmaniġġja verżjonijiet tal-prompt biex jikkontrolla l-caching."""
def __init__(self, content: str):
self.content = content
self.version = hashlib.md5(content.encode()).hexdigest()[:8]
def is_same_version(self, other: "VersionedPrompt") -> bool:
return self.version == other.version
# Jekk il-verżjoni tinbidel, il-cache se tiġi invalidata
prompt_v1 = VersionedPrompt("Istruzzjonijiet v1...")
prompt_v2 = VersionedPrompt("Istruzzjonijiet v2 modifikati...")
if not prompt_v1.is_same_version(prompt_v2):
print("Twissija: il-prompt inbidel, il-cache se tiġi invalidata")
warm_up_cache(prompt_v2.content)
X’inifsed dan fil-volum
Ħu każ reali ta’ 10,000 sejħa kuljum b’prompt tas-sistema ta’ 3,000 token. Mingħajr caching, tifattura 10,000 × 3,000, jew 30M token tal-input kuljum. B’rata ta’ suċċess ta’ 80%, 6M token jibqgħu bil-prezz sħiħ u 24M jinżlu għal nofs il-prezz, u jġibu l-iffrankar għal madwar 40% fuq it-tokens tal-input. Iċ-ċifra tidher modesta relattivament għal sejħa waħda; fuq sena ta’ produzzjoni, din tbiddel l-istruttura tal-ispejjeż tal-applikazzjoni.
Punti Ewlenin
- Istruttura l-prompts tiegħek f’saffi mill-aktar stabbli għall-aktar varjabbli
- Iggruppa t-talbiet skont kuntest kondiviż biex iżżomm il-cache sħun
- Ħejji l-cache qabel il-quċċati tat-traffiku
- Immonitorja r-rata tal-cache b’
input_tokens_details.cached_tokens - Agħmel verżjoni tal-prompts tiegħek biex tbassar l-invalidazzjonijiet tal-cache