Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Izvērstā pieprasījumu kešošana

Nodarbība 13 no 20 Atjaunota 2026. gada 28. jūlijs Augstākais
Šajā lapā
  1. Pāri automātiskajai kešošanai
  2. Pieprasījumu arhitektūra kešošanas maksimizēšanai
  3. Trīs modeļi, kas rada atšķirību
  4. Ko tas nozīmē apjomā
  5. Galvenās atziņas

Pāri automātiskajai kešošanai

  1. nodarbībā tu apguvi pieprasījumu kešošanas pamatus. Tur kešošana parādījās kā automātisks mehānisms, kas tev palīdz bez īpašas piepūles, un tas ir patiess, kamēr tava lietotne nosūta labi sakārtotus pieprasījumus. Reālā ražošanas vide ir haotiskāka: vairāki lietotāji vienlaikus vēršas pie viena API, katram savs folders, dokumenti un jautājumi. Kopīgais prefikss tad sarūk gandrīz līdz nullei, un keša trāpījumu procents sabrūk, nevienam to nepamanot, jo nekas nesalūzt — tikai rēķins aug.

Daudzlietotāju, daudzdokumentu apstrādes cauruļvadi: mēs šos sarežģītos scenārijus izskatīsim pa vienam, lai maksimāli palielinātu keša trāpījumu procentu. Vadlīnija ietilpst vienā teikumā: kešošana nenotiek pati no sevis; tā ir jāprojektē.

Pieprasījumu arhitektūra kešošanas maksimizēšanai

Kešošana attiecas uz garāko kopīgo prefiksu visos tavos pieprasījumos. Jo garāks un stabilāks šis prefikss, jo vairāk ietaupi. Praktiskās sekas ir tādas, ka pieprasījumam jābūt organizētam no visstabilākā līdz mainīgākajam, tāpat kā grāmatai, kuras pirmās lappuses nekad nemainās, bet tikai pēdējā nodaļa tiek pārrakstīta katrā izdevumā.

Zemāk esošais piemērs piemēro šo principu dokumentu analīzes asistentam advokātu birojam. Trīs slāņi seko viens otram: globālās instrukcijas, kas ir iesaldētas; zināšanu bāze, kas tiek atjaunota reizi mēnesī; un lietas materiāli ar jautājumu, kas mainās ar katru izsaukumu.

import openai

client = openai.OpenAI()

# Slāņota arhitektūra: no visstabilākā līdz mainīgākajam

# 1. slānis: Globālās instrukcijas (nekad nemainās)
GLOBAL_INSTRUCTIONS = """
You are a document analysis assistant for a law firm.
Rules:
- Always respond in French
- Cite relevant legal articles
- Structure as: Analysis / Risks / Recommendations
- Be factual and precise
"""

# 2. slānis: Zināšanu bāze (mainās reti)
KNOWLEDGE_BASE = """
[Insert 5,000+ tokens of case law, legal articles,
 analysis templates here—this content changes at most once a month]
"""

# 3. slānis: Lietas konteksts (mainās katram klientam)
def build_prompt(case_context: str, question: str) -> str:
    return f"""{GLOBAL_INSTRUCTIONS}

{KNOWLEDGE_BASE}

--- Current Case ---
{case_context}

--- Question ---
{question}"""

Klasiskā kļūda ir klienta vārda vai šodienas datuma novietošana sistēmas pieprasījuma sākumā, lai to “personalizētu”. Viens mainīgs simbols sākotnējā pozīcijā ir pietiekams, lai padarītu prefiksu unikālu, samazinot keša trāpījumu procentu līdz nullei visiem turpmākajiem slāņiem. Viss, kas mainās, ir jānovieto beigās.

Protams, tev jāpārliecinās, ka teorija pārvēršas skaitļos. Turpmākais monitors katrā atbildē nolasī input_tokens_details.cached_tokens un uzkrāj mērījumus, dodot tev izmantojamu vidējo rādītāju, nevis tikai nojausmu.

class CacheMonitor:
    """Uzrauga pieprasījumu kešošanas efektivitāti."""

    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 "Nav izsaukumu."
        return (
            f"Izsaukumi: {len(self.calls)} | "
            f"Vidējais keša procents: {self.average_rate:.1%} | "
            f"Ietaupīti tokeni: "
            f"{sum(a['cached_tokens'] for a in self.calls):,}"
        )

monitor = CacheMonitor()

Trīs modeļi, kas rada atšķirību

Pirmais modelis attiecas uz apstrādes secību. Apstrādājot neviendabīgu pieprasījumu partiju, to izpilde ierašanās secībā maina prefiksus un neļauj kešam palikt „siltam”. Problēmu atrisina grupēšana pēc kopīga konteksta: vispirms savāc, pēc tam izpildi, lai katra grupa gūtu labumu no prefiksa, ko sagatavojis tās pirmais pieprasījums.

from collections import defaultdict

def group_by_context(
    requests: list[dict],
) -> dict[str, list[dict]]:
    """Grupē pieprasījumus pēc kopīga prefiksa."""
    groups = defaultdict(list)

    for request in requests:
        # Atslēga = kopīgā konteksta hašs
        key = hash(request.get("shared_context", ""))
        groups[key].append(request)

    return dict(groups)

def process_by_cohort(requests: list[dict]):
    """Apstrādā grupētus pieprasījumus, lai maksimizētu kešošanu."""
    groups = group_by_context(requests)

    for key, group in groups.items():
        # Visiem grupas pieprasījumiem ir vienāds prefikss
        for request in group:
            response = client.responses.create(
                model="gpt-5.6-terra",
                instructions=request["shared_context"],
                input=request["question"],
            )
            monitor.record(response.usage)

Otrais modelis risina aukstās starta problēmu. Pirmais pieprasījums sērijā maksā pilnu cenu, jo vēl nekas nav kešots; ja šis pirmais pieprasījums nāk no īsta lietotāja pirmdienas rītā plkst. 9.00, viņš uzņemas latentces slogu. „Uzsildīšanas” pieprasījums, kas nosūtīts pirms servisa atvēršanas, pārceļ šīs izmaksas uz brīdi, kad tās nevienam netraucē. Ņem vērā aizsardzību funkcijas sākumā: zem 1024 tokeniem kešošana nedarbojas, un iepriekšēja uzsildīšana būtu tīri izdevumi.

def warm_up_cache(system_prompt: str):
    """Nosūta minimālu pieprasījumu, lai sagatavotu kešu."""
    if len(system_prompt) // 4 < 1024:
        print("Pieprasījums pārāk īss kešošanai (< 1024 tokeni)")
        return

    response = client.responses.create(
        model="gpt-5.6-terra",
        instructions=system_prompt,
        input="Confirm that you are ready.",
        max_output_tokens=10,
    )

    usage = response.usage
    print(
        f"Kešs sagatavots: {usage.input_tokens} ievades tokeni, "
        f"{getattr(usage.input_tokens_details, 'cached_tokens', 0)} kešoti"
    )

Trešais modelis padara keša anulēšanu redzamu. Komata labošana 5000 tokenu sistēmas pieprasījumā šķiet niecīga, taču šis komats iztīra kešu visiem. Pievienojot saturam pirkstnospiedumu, tu konstatē izmaiņas izvietošanas brīdī, nevis nākamajā dienā rēķinā, un vari nekavējoties veikt iepriekšēju uzsildīšanu.

import hashlib

class VersionedPrompt:
    """Pārvalda pieprasījumu versijas, lai kontrolētu kešošanu."""

    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

# Ja versija mainās, kešs tiks anulēts
prompt_v1 = VersionedPrompt("Instructions v1...")
prompt_v2 = VersionedPrompt("Instructions v2 modified...")

if not prompt_v1.is_same_version(prompt_v2):
    print("Brīdinājums: pieprasījums mainīts, kešs tiks anulēts")
    warm_up_cache(prompt_v2.content)

Ko tas nozīmē apjomā

Aplūkosim reālu gadījumu: 10 000 izsaukumu dienā ar 3000 tokenu sistēmas pieprasījumu. Bez kešošanas tu norēķinies par 10 000 × 3000, proti, 30 miljoniem ievades tokenu katru dienu. Ar 80 % trāpījumu procentu 6 miljoni tokenu paliek pilnā cenā, bet 24 miljoni nokrītas līdz pusei cenas, nodrošinot aptuveni 40 % ietaupījumu ievades tokenos. Skaitlis šķiet pieticīgs, raugoties uz vienu izsaukumu; taču gada ražošanas cikla laikā tas maina lietotnes izmaksu struktūru.

Galvenās atziņas

  • Strukturē savus pieprasījumus slāņos, sākot no visstabilākā līdz mainīgākajam
  • Grupē pieprasījumus pēc kopīga konteksta, lai uzturētu kešu „siltu”
  • Sagatavo kešu pirms satiksmes pieauguma
  • Uzraugi keša procentu, izmantojot input_tokens_details.cached_tokens
  • Versionē savus pieprasījumus, lai paredzētu keša anulējumus