Automatisk API-cache
På denne side
Cache som et værktøj til omkostningsreduktion
Automatisk cache har den største indvirkning på din regning – til det bedre eller værre. Hos mange udbydere skal du eksplicit erklære den i anmodningen, markere de blokke, der skal beholdes, og administrere deres levetid. xAI har valgt en anden tilgang: cachen anvendes automatisk på alle anmodninger uden parametre eller annotationer. Du behøver ikke aktivere noget, men du har alt at vinde ved at forstå, hvad der udløser den, for en dårligt struktureret prompt giver ingen gevinst og betales til fuld pris for hele inputtet.
Sådan fungerer cachen
Cachen opererer kun på input-tokens: generering af svar faktureres altid til standardtaksten. Når starten af din prompt nøjagtigt reproducerer starten af en tidligere behandlet prompt, serveres den identiske del fra cachen til den reducerede takst, og kun den nye del afregnes til standardtaksten.
Tre anvendelsestyper drager øjeblikkelig fordel af dette. For det første en samtale: systemprompten og alle tidligere turer er strengt identiske fra det ene kald til det næste; kun det sidste spørgsmål ændrer sig, så cache-andelen stiger naturligt, efterhånden som udvekslingen forlænges. Dernæst en prompt med fast kontekst – en kontrakt, en teknisk manual eller et produktrepository efterfulgt af et variabelt spørgsmål – hvor dokumentblokken caches fra andet kald og frem. Endelig holder en RAG-pipeline systeminstruktionerne konstante; kun den hentede kontekst ændrer sig, og hvis du placerer den efter instruktionerne, forbliver præfikset cachebart.
På xAIs prisliste er forskellen betydelig. På grok-4.3 og grok-4.20-0309 koster én million cachet input-tokens $0,20 mod $1,25 til standardtaksten. På grok-4.5 løber den samme million op i $0,30 i stedet for $2,00. Med andre ord koster et stabilt præfiks på 5.000 tokens, der genbruges tusind gange om dagen, fem til syv gange mindre end en prompt, der genopbygges ved hvert kald – for et strengt taget identisk resultat.
Headeren x-grok-conv-id
For at hjælpe infrastrukturen med at sammenkæde anmodninger, der hører sammen, accepterer API’en en dedikeret header:
curl -X POST "https://api.x.ai/v1/chat/completions" \
-H "Authorization: Bearer $XAI_API_KEY" \
-H "x-grok-conv-id: 550e8400-e29b-41d4-a716-446655440000" \
-H "Content-Type: application/json" \
-d '{
"model": "grok-4.20",
"messages": [...]
}'
Headeren x-grok-conv-id forventer et UUID v4. Reglen for brug er enkel: ét identifikator per samtale eller behandlingsflow, genbrugt til alle kald, der er en del af det. Dette signalerer, at disse anmodninger er forbundne, hvilket øger sandsynligheden for cache-genbrug. Den typiske fejl er at generere UUID’et ved hvert kald i stedet for ved sessionens start – så modtager hver tur et forskelligt identifikator, og fordelen forsvinder. Generér det én gang, og gem det sammen med samtalestatussen:
import uuid
# Ét UUID per samtale
conv_id = str(uuid.uuid4())
# Brug samme UUID til alle ture i samtalen
headers = {
"Authorization": f"Bearer {api_key}",
"x-grok-conv-id": conv_id,
"Content-Type": "application/json"
}
Kontrol af cache-effektivitet
Intet slår måling. Feltet cached_tokens i usage-objektet, som vi dækkede i den forrige lektion, fortæller dig præcis, hvad der blev serveret fra cachen:
{
"usage": {
"prompt_tokens": 5000,
"cached_tokens": 4200,
"completion_tokens": 300
}
}
Her kommer 4.200 tokens ud af 5.000 fra cachen, hvilket giver en rate på 84 %; kun 800 tokens blev faktureret til standardtaksten. Gør det til en vane at tjekke denne ratio på en stikprøve af rigtige anmodninger efter hver udrulning: Hvis du ser en rate nær nul i en samtaleapplikation, varierer noget i starten af prompten, og næste lektion vil vise dig hvad.
Vigtige pointer
- Cachen er automatisk: ingen konfiguration nødvendig
- Brug headeren
x-grok-conv-idmed et UUID v4 til at gruppere forbundne anmodninger - Feltet
cached_tokensiusage-objektet angiver antallet af tokens serveret fra cachen - Cachet input koster 5 til 7 gange mindre: $0,20/M på grok-4.3, $0,30/M på grok-4.5
- Jo mere stabil din prompt er i starten af sekvensen, jo højere bliver cache-raten