Prompt-caching

Slik fungerer det

• Prefiks, i rekkefølge — Prompten dechiffreres i rekkefølge: system-prompt, verktøydefinisjoner, og deretter meldingene. Cachen matcher fra starten av denne sekvensen opp til den første tokenen som avviker.
• Hva teller som en hit — En forespørsel der prompten starter med samme innhold som en nylig forespørsel — typisk forrige vending i samme samtale med nye meldinger lagt til. Det matchende prefikset er cached input; alt etter dette er vanlig input.
• Granularitet — Cachen lagrer en prompt i blokker på 1,568 tokens, så en prompt som er kortere enn ca. 1,500 tokens, caches ikke. Det cachede antallet i et svar er input-antallet ditt multiplisert med den cachede andelen av prompten, rundet ned. Det er ikke nødvendigvis et multiplum av blokkstørrelsen.
• Uten hit — En forespørsel der starten ikke finnes i cachen, faktureres til vanlig inputpris. Ingen levetid er oppgitt for cachede prompter, og en hit er ikke garantert: les usage for å se hva en forespørsel hentet fra cachen.
• Ingen bryter — En forespørsel melder seg ikke på, og ingen felt slår cachingen av.
• Hvilke modeller — Alle hosted open-weight-id-er. GET /v1/models rapporterer capabilities.prompt_caching: true og pricing.cached_input_per_million_usd for disse. Shannon-modeller fakturerer én flat pris.

Se en cache-hit i et svar

Send to forespørsler som begynner med den samme lange systemprompten, og skriv ut bruksdataene for hver. Det første tallet er inputen i forespørselen, det andre er den delen av den som ble lest fra cachen.

from openai import OpenAI

client = OpenAI(api_key="YOUR_API_KEY", base_url="https://api.shannon-ai.com/v1")

handbook = open("handbook.txt").read()  # a long text that stays the same


def ask(question):
    response = client.chat.completions.create(
        model="Kimi-K3-3BIT-REAP",
        messages=[
            {"role": "system", "content": handbook},
            {"role": "user", "content": question},
        ],
    )
    usage = response.usage
    print(usage.prompt_tokens, usage.prompt_tokens_details.cached_tokens)


ask("What is the refund policy?")
ask("Who approves travel?")  # same start: read the second number

import { readFileSync } from "node:fs";
import OpenAI from "openai";

const client = new OpenAI({ apiKey: "YOUR_API_KEY", baseURL: "https://api.shannon-ai.com/v1" });

const handbook = readFileSync("handbook.txt", "utf8"); // a long text that stays the same

async function ask(question) {
  const response = await client.chat.completions.create({
    model: "Kimi-K3-3BIT-REAP",
    messages: [
      { role: "system", content: handbook },
      { role: "user", content: question },
    ],
  });
  const usage = response.usage;
  console.log(usage.prompt_tokens, usage.prompt_tokens_details.cached_tokens);
}

await ask("What is the refund policy?");
await ask("Who approves travel?"); // same start: read the second number

# handbook.txt is a long text that stays the same. jq builds the JSON body from it
# and prints the usage object of the reply. Run it twice with different questions.
jq -Rs '{
    model: "Kimi-K3-3BIT-REAP",
    messages: [
      {role: "system", content: .},
      {role: "user", content: "What is the refund policy?"}
    ]
  }' handbook.txt \
  | curl -s https://api.shannon-ai.com/v1/chat/completions \
      -H "Authorization: Bearer YOUR_API_KEY" \
      -H "Content-Type: application/json" \
      -d @- \
  | jq .usage

Prising

Cached input-tokens faktureres til 25 % av modellens input-rate, avrundet til $0,001 per 1M. Skriving til cache koster ingenting ekstra, og output faktureres som vanlig. Hver ids cached-rate finnes i tabellen for Modeller & prising. Modeller og priser

Inputen i et kall belastes som (input − cachet) × inputpris + cachet × cachepris. Det cachede antallet er aldri større enn input-antallet.

Bruksloggen viser den cachede inputen for hvert kall. De fakturerte tokens og kostnaden inkluderer allerede cacheprisen. Nøkler og bruk

Brukfelt

{
  "usage": {
    "prompt_tokens": 20000,
    "completion_tokens": 812,
    "total_tokens": 20812,
    "prompt_tokens_details": {
      "cached_tokens": 18000
    },
    "completion_tokens_details": {
      "reasoning_tokens": 604
    }
  }
}

{
  "usage": {
    "input_tokens": 20000,
    "input_tokens_details": {
      "cached_tokens": 18000
    },
    "output_tokens": 812,
    "output_tokens_details": {
      "reasoning_tokens": 604
    },
    "total_tokens": 20812
  }
}

{
  "usage": {
    "input_tokens": 2000,
    "cache_read_input_tokens": 18000,
    "cache_creation_input_tokens": 0,
    "output_tokens": 812
  }
}

Et strømmet svar har de samme feltene i sine endelige bruksdata. Du trenger ikke be om dem:

Slik får du flere cache-hits

• Hold system-prompt og verktøydefinisjoner byte-for-byte stabile mellom kall. Plasser verdier som endres per kall, som tidsstempler eller forespørsels-id-er, på slutten av den siste meldingen, ikke i system-prompten.
• Kun append til historikken. Redigering, trimming eller oppsummering av tidligere vendinger endrer prefikset, og alt etter den første endringen faktureres som vanlig input.
• Ikke endre rekkefølgen på verktøy, meldinger eller innholdsblokker mellom kall, og serialiser JSON (verktøy-skjemaer, argumenter og resultater) likt hver gang.
• Bli på én modell-id gjennom en samtale, og send oppfølgingskallet kort tid etter det forrige.

API-et holder starten på en samtale stabil i disse tilfellene:

• En system- eller developer-melding som sendes senere i en samtale, blir stående på sin plass. Den endrer ikke starten på prompten, så replikkene før den forblir cachet.
• Argumentene til verktøykall i tidligere assistentreplikker sammenlignes etter verdi. Nøkkelrekkefølge og mellomrom i den JSON-en spiller ingen rolle.
• De tre endepunktene leser en samtale på samme måte. En samtale som fortsetter på et annet endepunkt, beholder det delte prefikset når innholdet er det samme.

Forespørselsfelt

prompt_cache_key (Chat Completions og Responses) og cache_control på Messages-innholdskblokker støttes, slik at eksisterende klientkode kjører uendret. Ingen av dem er påkrevd: caching er automatisk og fungerer likt uten dem.

Telle tokens

To gratis endepunkter, POST /v1/tokenize og POST /v1/messages/count_tokens, teller tokens i en tekst eller en hel forespørsel for de hostede åpne vektmodellene før du sender den. De har sin egen side: Token-telling