പ്രോംപ്റ്റ് കാഷിംഗ്

ഇത് എങ്ങനെ പ്രവർത്തിക്കുന്നു

• ക്രമത്തിലുള്ള പ്രിഫിക്സ് — പ്രോംപ്റ്റ് ക്രമത്തിൽ വായിക്കുന്നു: സിസ്റ്റം പ്രോംപ്റ്റ്, ടൂൾ ഡെഫിനിഷനുകൾ, തുടർന്ന് സന്ദേശങ്ങൾ. ഈ ക്രമത്തിന്റെ തുടക്കം മുതൽ ആദ്യത്തെ വ്യത്യാസമുള്ള ടോക്കൺ വരെയുള്ള ഭാഗം കാഷെയുമായി പൊരുത്തപ്പെടുന്നു.
• എന്താണ് ഒരു ഹിറ്റ് ആയി കണക്കാക്കുന്നത് — സമീപകാല റിക്വസ്റ്റിന്റെ അതേ ഉള്ളടക്കത്തിൽ ആരംഭിക്കുന്ന ഒരു റിക്വസ്റ്റ് — സാധാരണയായി പുതിയ സന്ദേശങ്ങൾ ചേർക്കപ്പെട്ട അതേ സംഭാഷണത്തിന്റെ മുൻപത്തെ ഘട്ടം. പൊരുത്തപ്പെടുന്ന പ്രിഫിക്സ് cached input ആണ്; അതിനുശേഷമുള്ളതെല്ലാം സാധാരണ ഇൻപുട്ടാണ്.
• ഗ്രാന്യുലാരിറ്റി — കാഷ് ഒരു പ്രോംപ്റ്റിനെ 1,568 ടോക്കണുകളുടെ ബ്ലോക്കുകളായി സൂക്ഷിക്കുന്നു, അതിനാൽ ഏകദേശം 1,500 ടോക്കണുകളേക്കാൾ ചെറിയ പ്രോംപ്റ്റ് കാഷ് ചെയ്യില്ല. മറുപടിയിലെ കാഷ്ഡ് എണ്ണം, നിങ്ങളുടെ ഇൻപുട്ട് എണ്ണത്തെ പ്രോംപ്റ്റിലെ കാഷ്ഡ് ഭാഗം കൊണ്ട് ഗുണിച്ച് താഴേക്ക് റൗണ്ട് ചെയ്തതാണ്. ഇത് ബ്ലോക്ക് വലിപ്പത്തിന്റെ ഗുണിതമായിരിക്കണമെന്നില്ല.
• ഹിറ്റ് ഇല്ലാത്തപ്പോൾ — ആരംഭം കാഷിൽ ഇല്ലാത്ത റിക്വസ്റ്റ് സാധാരണ ഇൻപുട്ട് നിരക്കിൽ ബിൽ ചെയ്യുന്നു. കാഷ് ചെയ്ത പ്രോംപ്റ്റുകൾക്ക് ആയുസ്സ് പ്രസിദ്ധീകരിച്ചിട്ടില്ല, ഹിറ്റ് ഉറപ്പുമില്ല: ഒരു റിക്വസ്റ്റ് കാഷിൽ നിന്ന് എന്ത് എടുത്തു എന്നറിയാൻ usage വായിക്കുക.
• സ്വിച്ച് ഇല്ല — റിക്വസ്റ്റ് ഒപ്റ്റ്-ഇൻ ചെയ്യേണ്ടതില്ല, കാഷിംഗ് ഓഫ് ചെയ്യാൻ ഫീൽഡും ഇല്ല.
• ഏതൊക്കെ മോഡലുകൾ — എല്ലാ ഹോസ്റ്റഡ് ഓപ്പൺ-വെയ്റ്റ് ഐഡികളും. GET /v1/models ഇവയുടെ capabilities.prompt_caching: true എന്നും pricing.cached_input_per_million_usd എന്നും റിപ്പോർട്ട് ചെയ്യുന്നു. Shannon മോഡലുകൾ ഒരു ഫ്ലാറ്റ് നിരക്കാണ് ഈടാക്കുന്നത്.

മറുപടിയിൽ കാഷ് ഹിറ്റ് കാണുക

ഒരേ നീണ്ട സിസ്റ്റം പ്രോംപ്റ്റിൽ തുടങ്ങുന്ന രണ്ട് റിക്വസ്റ്റുകൾ അയച്ച് ഓരോന്നിന്റെയും ഉപയോഗ വിവരം പ്രിന്റ് ചെയ്യുക. ആദ്യ സംഖ്യ റിക്വസ്റ്റിന്റെ ഇൻപുട്ടാണ്, രണ്ടാമത്തേത് അതിൽ കാഷിൽ നിന്ന് വായിച്ച ഭാഗമാണ്.

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

വില

കാഷെഡ് ഇൻപുട്ട് ടോക്കണുകൾ മോഡലിന്റെ ഇൻപുട്ട് നിരക്കിന്റെ 25% ആയി ഈടാക്കുന്നു, ഇത് 1M-ന് $0.001 ആയി റൗണ്ട് ചെയ്യുന്നു. കാഷെയിലേക്ക് എഴുതുന്നതിന് അധിക ചിലവില്ല, ഔട്ട്പുട്ട് സാധാരണ പോലെ ഈടാക്കുന്നു. ഓരോ ഐഡിയുടെയും കാഷെ നിരക്ക് Models & pricing ടേബിളിലുണ്ട്. മോഡലുകളും വിലയും

ഒരു കോളിന്റെ ഇൻപുട്ട് ഈടാക്കുന്നത് (ഇൻപുട്ട് − കാഷ്ഡ്) × ഇൻപുട്ട് നിരക്ക് + കാഷ്ഡ് × കാഷ്ഡ് നിരക്ക് എന്ന രീതിയിലാണ്. കാഷ്ഡ് എണ്ണം ഒരിക്കലും ഇൻപുട്ട് എണ്ണത്തേക്കാൾ വലുതല്ല.

ഉപയോഗ ലോഗ് ഓരോ കോളിന്റെയും കാഷ്ഡ് ഇൻപുട്ട് പട്ടികപ്പെടുത്തുന്നു. അതിലെ ബിൽ ചെയ്ത ടോക്കണുകളിലും ചെലവിലും കാഷ്ഡ് നിരക്ക് ഇതിനകം ഉൾപ്പെട്ടിട്ടുണ്ട്. കീകളും ഉപയോഗവും

ഉപയോഗ ഫീൽഡുകൾ

{
  "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
  }
}

സ്ട്രീം ചെയ്ത മറുപടിയുടെ അവസാന ഉപയോഗ വിവരത്തിൽ അതേ ഫീൽഡുകൾ ഉണ്ടാകും. നിങ്ങൾ ആവശ്യപ്പെടേണ്ടതില്ല:

കൂടുതൽ കാഷെ ഹിറ്റുകൾ ലഭിക്കാൻ

• സിസ്റ്റം പ്രോംപ്റ്റും ടൂൾ ഡെഫിനിഷനുകളും കോളുകൾക്കിടയിൽ കൃത്യമായി മാറ്റമില്ലാതെ നിലനിർത്തുക. ടൈംസ്റ്റാമ്പുകൾ അല്ലെങ്കിൽ റിക്വസ്റ്റ് ഐഡികൾ പോലുള്ള ഓരോ കോളിലുമുള്ള മൂല്യങ്ങൾ ഏറ്റവും പുതിയ സന്ദേശത്തിന്റെ അവസാനം നൽകുക, സിസ്റ്റം പ്രോംപ്റ്റിൽ അല്ല.
• ഹിസ്റ്ററിയിലേക്ക് പുതിയവ ചേർക്കുക (append) മാത്രം ചെയ്യുക. മുൻപത്തെ ഘട്ടങ്ങൾ എഡിറ്റ് ചെയ്യുന്നതോ, ട്രിം ചെയ്യുന്നതോ അല്ലെങ്കിൽ സംഗ്രഹിക്കുന്നതോ പ്രിഫിക്സിനെ മാറ്റുന്നു, തുടർന്ന് ആദ്യത്തെ മാറ്റത്തിന് ശേഷമുള്ളതെല്ലാം സാധാരണ ഇൻപുട്ടായി ഈടാക്കുന്നു.
• കോളുകൾക്കിടയിൽ ടൂളുകൾ, സന്ദേശങ്ങൾ അല്ലെങ്കിൽ കണ്ടന്റ് ബ്ലോക്കുകൾ എന്നിവയുടെ ക്രമം മാറ്റരുത്, കൂടാതെ JSON (ടൂൾ സ്കീമകൾ, ടൂൾ ആർഗ്യുമെന്റുകൾ, റിസൾട്ടുകൾ) എല്ലാ തവണയും ഒരേ രീതിയിൽ സീരിയലൈസ് ചെയ്യുക.
• ഒരു സംഭാഷണത്തിന് ഒരേ മോഡൽ ഐഡി ഉപയോഗിക്കുക, തുടർ കോൾ തൊട്ടുമുമ്പത്തേതിന് ഉടനെ അയയ്ക്കുക.

ഈ സാഹചര്യങ്ങളിൽ API സംഭാഷണത്തിന്റെ ആരംഭം സ്ഥിരമായി നിലനിർത്തുന്നു:

• സംഭാഷണത്തിൽ പിന്നീട് അയയ്ക്കുന്ന system അല്ലെങ്കിൽ developer സന്ദേശം അതിന്റെ സ്ഥാനത്ത് തന്നെ തുടരും. ഇത് പ്രോംപ്റ്റിന്റെ ആരംഭത്തെ മാറ്റില്ല, അതിനാൽ അതിനു മുമ്പുള്ള ടേണുകൾ കാഷിൽ തുടരും.
• മുൻ അസിസ്റ്റന്റ് ടേണുകളിലെ ടൂൾ കോളുകളുടെ ആർഗ്യുമെന്റുകൾ മൂല്യം നോക്കിയാണ് താരതമ്യം ചെയ്യുന്നത്. ആ JSON-ലെ കീ ക്രമവും സ്പേസിംഗും പ്രശ്നമല്ല.
• മൂന്ന് എൻഡ്‌പോയിന്റുകളും ഒരു സംഭാഷണം ഒരേ രീതിയിൽ വായിക്കുന്നു. മറ്റൊരു എൻഡ്‌പോയിന്റിൽ തുടരുന്ന സംഭാഷണം, ഉള്ളടക്കം ഒന്നുതന്നെയാണെങ്കിൽ, പങ്കിട്ട പ്രിഫിക്സ് നിലനിർത്തുന്നു.

റിക്വസ്റ്റ് ഫീൽഡുകൾ

prompt_cache_key (Chat Completions, Responses), Messages കണ്ടെന്റ് ബ്ലോക്കുകളിലെ cache_control എന്നിവ സ്വീകാര്യമാണ്, അതിനാൽ നിലവിലുള്ള ക്ലയന്റ് കോഡുകൾ മാറ്റമില്ലാതെ പ്രവർത്തിക്കും. ഇവ രണ്ടും നിർബന്ധമല്ല: കാഷിംഗ് ഓട്ടോമാറ്റിക്കായി നടക്കുന്നു, ഇവയില്ലാതെയും അത് ഒരുപോലെ പ്രവർത്തിക്കും.

ടോക്കണുകൾ കണക്കാക്കുന്നു

രണ്ട് സൗജന്യ എൻഡ്‌പോയിന്റുകൾ, POST /v1/tokenize, POST /v1/messages/count_tokens, നിങ്ങൾ അയയ്ക്കുംമുമ്പ് ഒരു ടെക്സ്റ്റിന്റെയോ മുഴുവൻ റിക്വസ്റ്റിന്റെയോ ടോക്കണുകൾ ഹോസ്റ്റ് ചെയ്ത ഓപ്പൺ-വെയിറ്റ് മോഡലുകൾക്കായി എണ്ണുന്നു. അവയ്ക്ക് സ്വന്തം പേജ് ഉണ്ട്: ടോക്കൺ എണ്ണൽ