Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Il-caching avvanzat tal-prompt

Lezzjoni 13 / 20 Aġġornat 28 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. Lil hinn mill-caching awtomatiku
  2. Arkitettura tal-prompt biex timmassimizza l-caching
  3. Tliet mudelli li jagħmlu d-differenza
  4. X’inifsed dan fil-volum
  5. Punti Ewlenin

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