ਪ੍ਰੋਂਪਟ ਕੈਸ਼ਿੰਗ

ਇਹ ਕਿਵੇਂ ਕੰਮ ਕਰਦਾ ਹੈ

• ਪ੍ਰੀਫਿਕਸ, ਕ੍ਰਮਵਾਰ — ਪ੍ਰੋਂਪਟ ਨੂੰ ਕ੍ਰਮਵਾਰ ਪੜ੍ਹਿਆ ਜਾਂਦਾ ਹੈ: ਸਿਸਟਮ ਪ੍ਰੋਂਪਟ, ਟੂਲ ਡੈਫੀਨੇਸ਼ਨਾਂ, ਅਤੇ ਫਿਰ ਸੰਦੇਸ਼। ਕੈਸ਼ ਉਸ ਸੀਕਵੈਂਸ ਦੀ ਸ਼ੁਰੂਆਤ ਤੋਂ ਲੈ ਕੇ ਪਹਿਲੇ ਟੋਕਨ ਤੱਕ ਮੈਚ ਕਰਦਾ ਹੈ ਜੋ ਵੱਖਰਾ ਹੁੰਦਾ ਹੈ।
• ਹਿੱਟ ਕੀ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ — ਇੱਕ ਰਿਕੁਇਸਟ ਜਿਸਦਾ ਪ੍ਰੋਂਪਟ ਹਾਲੀਆ ਰਿਕੁਇਸਟ ਦੇ ਸਮਾਨ ਸਮਗਰੀ ਨਾਲ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ — ਆਮ ਤੌਰ 'ਤੇ ਉਸੇ ਗੱਲਬਾਤ ਦਾ ਪਿਛਲਾ ਮੋੜ ਜਿਸ ਵਿੱਚ ਨਵੇਂ ਸੰਦੇਸ਼ ਜੋੜੇ ਗਏ ਹੋਣ। ਮੈਚਿੰਗ ਪ੍ਰੀਫਿਕਸ ਕੈਸ਼ਡ ਇਨਪੁਟ ਹੈ; ਇਸ ਤੋਂ ਬਾਅਦ ਸਭ ਕੁਝ ਰੈਗੂਲਰ ਇਨਪੁਟ ਹੈ।
• ਗ੍ਰੈਨੂਲਰਿਟੀ — ਕੈਸ਼ ਪ੍ਰੋਂਪਟ ਨੂੰ 1,568 tokens ਦੇ blocks ਵਿੱਚ ਰੱਖਦਾ ਹੈ, ਇਸ ਲਈ ਲਗਭਗ 1,500 tokens ਤੋਂ ਛੋਟਾ ਪ੍ਰੋਂਪਟ ਕੈਸ਼ ਨਹੀਂ ਹੁੰਦਾ। ਜਵਾਬ ਵਿੱਚ ਕੈਸ਼ਡ ਗਿਣਤੀ ਤੁਹਾਡੀ ਇਨਪੁਟ ਗਿਣਤੀ ਨੂੰ ਪ੍ਰੋਂਪਟ ਦੇ ਕੈਸ਼ਡ ਹਿੱਸੇ ਨਾਲ ਗੁਣਾ ਕਰ ਕੇ, ਹੇਠਾਂ ਵੱਲ ਗੋਲ ਕਰ ਕੇ ਮਿਲਦੀ ਹੈ। ਇਹ ਜ਼ਰੂਰੀ ਨਹੀਂ ਕਿ block ਦੇ ਆਕਾਰ ਦਾ ਗੁਣਜ ਹੋਵੇ।
• ਹਿੱਟ ਤੋਂ ਬਿਨਾਂ — ਜਿਸ ਰਿਕੁਐਸਟ ਦੀ ਸ਼ੁਰੂਆਤ ਕੈਸ਼ ਵਿੱਚ ਨਹੀਂ ਹੁੰਦੀ, ਉਸ ਦਾ ਬਿਲ ਆਮ ਇਨਪੁਟ ਦਰ ਨਾਲ ਬਣਦਾ ਹੈ। ਕੈਸ਼ ਕੀਤੇ ਪ੍ਰੋਂਪਟਾਂ ਲਈ ਕੋਈ ਮਿਆਦ ਪ੍ਰਕਾਸ਼ਿਤ ਨਹੀਂ ਕੀਤੀ ਜਾਂਦੀ ਅਤੇ ਹਿੱਟ ਦੀ ਗਾਰੰਟੀ ਨਹੀਂ ਹੈ: ਇਹ ਵੇਖਣ ਲਈ ਕਿ ਰਿਕੁਐਸਟ ਨੇ ਕੈਸ਼ ਤੋਂ ਕੀ ਲਿਆ, usage ਪੜ੍ਹੋ।
• ਕੋਈ ਸਵਿੱਚ ਨਹੀਂ — ਰਿਕੁਐਸਟ ਨੂੰ ਇਸ ਵਿੱਚ ਸ਼ਾਮਲ ਹੋਣ ਦੀ ਲੋੜ ਨਹੀਂ, ਅਤੇ ਕੋਈ ਫੀਲਡ ਕੈਸ਼ਿੰਗ ਨੂੰ ਬੰਦ ਨਹੀਂ ਕਰਦਾ।
• ਕਿਹੜੇ ਮਾਡਲ — ਹਰੇਕ ਹੋਸਟ ਕੀਤੇ ਓਪਨ-ਵੇਟ id। GET /v1/models ਉਨ੍ਹਾਂ ਲਈ capabilities.prompt_caching: true ਅਤੇ pricing.cached_input_per_million_usd ਦੀ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ। Shannon ਮਾਡਲ ਇੱਕ ਫਲੈਟ ਰੇਟ ਬਿਲ ਕਰਦੇ ਹਨ।

ਜਵਾਬ ਵਿੱਚ ਕੈਸ਼ ਹਿੱਟ ਵੇਖੋ

ਇੱਕੋ ਲੰਮੇ system prompt ਨਾਲ ਸ਼ੁਰੂ ਹੋਣ ਵਾਲੀਆਂ ਦੋ ਰਿਕੁਐਸਟਾਂ ਭੇਜੋ ਅਤੇ ਹਰ ਇੱਕ ਦੀ usage ਪ੍ਰਿੰਟ ਕਰੋ। ਪਹਿਲੀ ਸੰਖਿਆ ਰਿਕੁਐਸਟ ਦਾ ਇਨਪੁਟ ਹੈ, ਦੂਜੀ ਉਸ ਦਾ ਉਹ ਹਿੱਸਾ ਹੈ ਜੋ ਕੈਸ਼ ਤੋਂ ਪੜ੍ਹਿਆ ਗਿਆ।

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 ਤੱਕ ਰਾਊਂਡ ਕੀਤੇ ਗਏ ਹਨ। ਕੈਸ਼ ਵਿੱਚ ਲਿਖਣ ਦੀ ਕੋਈ ਵਾਧੂ ਲਾਗਤ ਨਹੀਂ ਹੈ, ਅਤੇ ਆਉਟਪੁਟ ਆਮ ਤੌਰ 'ਤੇ ਬਿਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਹਰੇਕ id ਦੀ ਕੈਸ਼ਡ ਰੇਟ ਮਾਡਲ ਅਤੇ ਕੀਮਤ ਟੇਬਲ ਵਿੱਚ ਹੈ। ਮਾਡਲ ਅਤੇ ਕੀਮਤਾਂ

ਕਾਲ ਦਾ ਇਨਪੁਟ (ਇਨਪੁਟ − ਕੈਸ਼ਡ) × ਇਨਪੁਟ ਦਰ + ਕੈਸ਼ਡ × ਕੈਸ਼ਡ ਦਰ ਦੇ ਹਿਸਾਬ ਨਾਲ ਚਾਰਜ ਹੁੰਦਾ ਹੈ। ਕੈਸ਼ਡ ਗਿਣਤੀ ਕਦੇ ਵੀ ਇਨਪੁਟ ਗਿਣਤੀ ਤੋਂ ਵੱਡੀ ਨਹੀਂ ਹੁੰਦੀ।

ਵਰਤੋਂ ਦਾ ਲੌਗ ਹਰ ਕਾਲ ਦਾ ਕੈਸ਼ਡ ਇਨਪੁਟ ਦਿਖਾਉਂਦਾ ਹੈ। ਇਸ ਦੇ ਬਿਲ ਕੀਤੇ tokens ਅਤੇ ਲਾਗਤ ਵਿੱਚ ਕੈਸ਼ਡ ਦਰ ਪਹਿਲਾਂ ਹੀ ਸ਼ਾਮਲ ਹੈ। Keys ਅਤੇ ਵਰਤੋਂ

ਵਰਤੋਂ ਫੀਲਡਸ

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

stream ਕੀਤੇ ਜਵਾਬ ਦੀ ਆਖਰੀ usage ਵਿੱਚ ਇਹੀ ਫੀਲਡ ਹੁੰਦੇ ਹਨ। ਤੁਹਾਨੂੰ ਇਸ ਨੂੰ ਮੰਗਣ ਦੀ ਲੋੜ ਨਹੀਂ:

ਵਧੇਰੇ ਕੈਸ਼ ਹਿੱਟ ਪ੍ਰਾਪਤ ਕਰਨਾ

• ਕਾਲਾਂ ਦੇ ਦੌਰਾਨ ਸਿਸਟਮ ਪ੍ਰੋਂਪਟ ਅਤੇ ਟੂਲ ਡੈਫੀਨੇਸ਼ਨਾਂ ਨੂੰ ਬਾਈਟ-ਦਰ-ਬਾਈਟ ਸਥਿਰ ਰੱਖੋ। ਪ੍ਰਤੀ-ਕਾਲ ਮੁੱਲ ਜਿਵੇਂ ਕਿ ਟਾਈਮਸਟੈਂਪ ਜਾਂ ਰਿਕੁਇਸਟ ids ਨੂੰ ਸਿਸਟਮ ਪ੍ਰੋਂਪਟ ਵਿੱਚ ਨਹੀਂ, ਸਗੋਂ ਸਭ ਤੋਂ ਤਾਜ਼ਾ ਸੰਦੇਸ਼ ਦੇ ਅੰਤ ਵਿੱਚ ਰੱਖੋ।
• ਸਿਰਫ਼ ਹਿਸਟਰੀ ਵਿੱਚ ਜੋੜੋ। ਪਿਛਲੇ ਮੋੜਾਂ ਨੂੰ ਐਡਿਟ ਕਰਨਾ, ਛੋਟਾ ਕਰਨਾ ਜਾਂ ਸਾਰ ਕਰਨਾ ਪ੍ਰੀਫਿਕਸ ਨੂੰ ਬਦਲ ਦਿੰਦਾ ਹੈ, ਅਤੇ ਪਹਿਲੀ ਤਬਦੀਲੀ ਤੋਂ ਬਾਅਦ ਸਭ ਕੁਝ ਰੈਗੂਲਰ ਇਨਪੁਟ ਵਜੋਂ ਬਿਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
• ਕਾਲਾਂ ਦੇ ਵਿਚਕਾਰ ਟੂਲਸ, ਸੰਦੇਸ਼ਾਂ ਜਾਂ ਕੰਟੈਂਟ ਬਲਾਕਾਂ ਨੂੰ ਦੁਬਾਰਾ ਤਰਤੀਬ ਨਾ ਦਿਓ, ਅਤੇ JSON (ਟੂਲ ਸਕੀਮਾ, ਟੂਲ ਆਰਗਿਊਮੈਂਟਸ ਅਤੇ ਨਤੀਜੇ) ਨੂੰ ਹਰ ਵਾਰ ਇੱਕੋ ਤਰੀਕੇ ਨਾਲ ਸੀਰੀਅਲਾਈਜ਼ ਕਰੋ।
• ਇੱਕ ਗੱਲਬਾਤ ਲਈ ਇੱਕੋ ਮਾਡਲ id ਉੱਤੇ ਰਹੋ, ਅਤੇ ਅਗਲੀ ਕਾਲ ਪਿਛਲੀ ਕਾਲ ਤੋਂ ਜਲਦੀ ਬਾਅਦ ਭੇਜੋ।

API ਇਨ੍ਹਾਂ ਮਾਮਲਿਆਂ ਵਿੱਚ ਗੱਲਬਾਤ ਦੀ ਸ਼ੁਰੂਆਤ ਨੂੰ ਸਥਿਰ ਰੱਖਦੀ ਹੈ:

• ਗੱਲਬਾਤ ਵਿੱਚ ਬਾਅਦ ਵਿੱਚ ਭੇਜਿਆ system ਜਾਂ developer message ਆਪਣੀ ਥਾਂ ਉੱਤੇ ਰਹਿੰਦਾ ਹੈ। ਇਹ ਪ੍ਰੋਂਪਟ ਦੀ ਸ਼ੁਰੂਆਤ ਨਹੀਂ ਬਦਲਦਾ, ਇਸ ਲਈ ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਦੇ turns ਕੈਸ਼ ਰਹਿੰਦੇ ਹਨ।
• ਪਿਛਲੇ assistant turns ਵਿੱਚ tool calls ਦੇ arguments ਦੀ ਤੁਲਨਾ ਮੁੱਲ ਦੁਆਰਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਉਸ JSON ਦੀਆਂ keys ਦਾ ਕ੍ਰਮ ਅਤੇ ਖਾਲੀ ਥਾਵਾਂ ਮਾਇਨੇ ਨਹੀਂ ਰੱਖਦੀਆਂ।
• ਤਿੰਨੇ endpoints ਗੱਲਬਾਤ ਨੂੰ ਇੱਕੋ ਤਰੀਕੇ ਨਾਲ ਪੜ੍ਹਦੇ ਹਨ। ਕਿਸੇ ਹੋਰ endpoint ਉੱਤੇ ਜਾਰੀ ਰੱਖੀ ਗੱਲਬਾਤ, ਸਮੱਗਰੀ ਇੱਕੋ ਹੋਣ ਉੱਤੇ, ਆਪਣਾ ਸਾਂਝਾ ਪ੍ਰੀਫਿਕਸ ਬਣਾਈ ਰੱਖਦੀ ਹੈ।

ਰਿਕੁਏਸਟ ਫੀਲਡਸ

prompt_cache_key (Chat Completions ਅਤੇ Responses) ਅਤੇ Messages ਕੰਟੈਂਟ ਬਲਾਕਾਂ 'ਤੇ cache_control ਸਵੀਕਾਰ ਕੀਤੇ ਜਾਂਦੇ ਹਨ, ਤਾਂ ਜੋ ਮੌਜੂਦਾ ਕਲਾਇੰਟ ਕੋਡ ਬਿਨਾਂ ਕਿਸੇ ਬਦਲਾਅ ਦੇ ਚੱਲ ਸਕੇ। ਇਹਨਾਂ ਵਿੱਚੋਂ ਕੋਈ ਵੀ ਜ਼ਰੂਰੀ ਨਹੀਂ ਹੈ: ਕੈਸ਼ਿੰਗ ਆਟੋਮੈਟਿਕ ਹੈ ਅਤੇ ਇਹਨਾਂ ਤੋਂ ਬਿਨਾਂ ਵੀ ਉਸੇ ਤਰ੍ਹਾਂ ਕੰਮ ਕਰਦੀ ਹੈ।

ਟੋਕਨਾਂ ਦੀ ਗਿਣਤੀ

ਦੋ ਮੁਫ਼ਤ endpoints, POST /v1/tokenize ਅਤੇ POST /v1/messages/count_tokens, ਤੁਹਾਡੇ ਭੇਜਣ ਤੋਂ ਪਹਿਲਾਂ ਹੋਸਟ ਕੀਤੇ open-weight ਮਾਡਲਾਂ ਲਈ ਕਿਸੇ ਟੈਕਸਟ ਜਾਂ ਪੂਰੀ ਰਿਕੁਐਸਟ ਦੇ tokens ਗਿਣਦੇ ਹਨ। ਇਨ੍ਹਾਂ ਦਾ ਆਪਣਾ ਪੰਨਾ ਹੈ: ਟੋਕਨ ਗਿਣਤੀ