Alibaba Cloud Model Studio:Context cache

Penggunaan

Anda dapat menambahkan penanda "cache_control": {"type": "ephemeral"} ke dalam array `messages`. Sistem kemudian akan mencari mundur hingga 20 blok content dari posisi setiap penanda cache_control untuk mencoba mencocokkan cache.

Satu permintaan mendukung maksimal empat penanda cache.

• Cache miss

  Sistem membuat blok cache baru dari konten antara awal array messages hingga penanda cache_control. Blok cache tersebut berlaku selama 5 menit.

  Pembuatan cache terjadi setelah respons model. Lakukan upaya hit cache hanya setelah permintaan pembuatan selesai.

  Blok cache harus berisi minimal 1024 token.

• Cache hit

  Sistem memilih awalan yang paling panjang sebagai blok cache yang terkena hit dan mengatur ulang periode validitasnya menjadi 5 menit.

Contoh berikut menunjukkan cara menggunakan fitur ini:

1. Kirim permintaan pertama: Anda dapat mengirim pesan sistem yang berisi teks A dengan lebih dari 1024 token dan menambahkan penanda cache.

   [{"role": "system", "content": [{"type": "text", "text": A, "cache_control": {"type": "ephemeral"}}]}] 

   Sistem membuat blok cache pertama, yang disebut sebagai blok cache A.

2. Kirim permintaan kedua: Anda dapat mengirim permintaan dengan struktur berikut:

   [
       {"role": "system", "content": A},
       <other messages>
       {"role": "user","content": [{"type": "text", "text": B, "cache_control": {"type": "ephemeral"}}]}
   ]

   • Jika jumlah `other messages` tidak melebihi 20, blok cache A terkena hit dan periode validitasnya diatur ulang menjadi 5 menit. Sistem juga membuat blok cache baru berdasarkan A, `other messages`, dan B.

   • Jika jumlah `other messages` melebihi 20, blok cache A tidak terkena hit. Sistem membuat blok cache baru berdasarkan konteks lengkap (A + `other messages` + B).

Model yang didukung

Memulai

Contoh berikut menunjukkan cara blok cache dibuat dan terkena hit pada antarmuka kompatibel OpenAI dan protokol DashScope.

from openai import OpenAI
import os

client = OpenAI(
    # Jika variabel lingkungan belum dikonfigurasi, ganti baris berikut dengan: api_key="sk-xxx"
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # Jika Anda menggunakan model di wilayah Beijing, ganti base_url dengan: https://dashscope.aliyuncs.com/compatible-mode/v1
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

# Konten repositori kode tiruan. Panjang prompt yang dapat di-cache minimal 1024 token.
long_text_content = "<Your Code Here>" * 400

# Fungsi untuk mengirim permintaan
def get_completion(user_input):
    messages = [
        {
            "role": "system",
            "content": [
                {
                    "type": "text",
                    "text": long_text_content,
                    # Tempatkan penanda cache_control di sini untuk membuat blok cache yang berisi semua konten dari awal array messages hingga posisi konten saat ini.
                    "cache_control": {"type": "ephemeral"},
                }
            ],
        },
        # Konten pertanyaan berbeda untuk setiap permintaan.
        {
            "role": "user",
            "content": user_input,
        },
    ]
    completion = client.chat.completions.create(
        # Pilih model yang mendukung explicit cache.
        model="qwen3-coder-plus",
        messages=messages,
    )
    return completion

# Permintaan pertama
first_completion = get_completion("What is the content of this code?")
print(f"First request cache creation tokens: {first_completion.usage.prompt_tokens_details.cache_creation_input_tokens}")
print(f"First request cached hit tokens: {first_completion.usage.prompt_tokens_details.cached_tokens}")
print("=" * 20)
# Permintaan kedua. Konten kode sama, hanya pertanyaannya yang berubah.
second_completion = get_completion("How can this code be optimized?")
print(f"Second request cache creation tokens: {second_completion.usage.prompt_tokens_details.cache_creation_input_tokens}")
print(f"Second request cached hit tokens: {second_completion.usage.prompt_tokens_details.cached_tokens}")

import os
from dashscope import Generation
# Jika Anda menggunakan model di wilayah Beijing, ganti base_url dengan: https://dashscope.aliyuncs.com/api/v1
dashscope.base_http_api_url = "https://dashscope-intl.aliyuncs.com/api/v1"

# Konten repositori kode tiruan. Panjang prompt yang dapat di-cache minimal 1024 token.
long_text_content = "<Your Code Here>" * 400

# Fungsi untuk mengirim permintaan
def get_completion(user_input):
    messages = [
        {
            "role": "system",
            "content": [
                {
                    "type": "text",
                    "text": long_text_content,
                    # Tempatkan penanda cache_control di sini untuk membuat blok cache yang berisi semua konten dari awal array messages hingga posisi konten saat ini.
                    "cache_control": {"type": "ephemeral"},
                }
            ],
        },
        # Konten pertanyaan berbeda untuk setiap permintaan.
        {
            "role": "user",
            "content": user_input,
        },
    ]
    response = Generation.call(
        # Jika variabel lingkungan belum dikonfigurasi, ganti baris berikut dengan Kunci API Model Studio Anda: api_key = "sk-xxx",
        api_key=os.getenv("DASHSCOPE_API_KEY"), 
        model="qwen3-coder-plus",
        messages=messages,
        result_format="message"
    )
    return response

# Permintaan pertama
first_completion = get_completion("What is the content of this code?")
print(f"First request cache creation tokens: {first_completion.usage.prompt_tokens_details['cache_creation_input_tokens']}")
print(f"First request cached hit tokens: {first_completion.usage.prompt_tokens_details['cached_tokens']}")
print("=" * 20)
# Permintaan kedua. Konten kode sama, hanya pertanyaannya yang berubah.
second_completion = get_completion("How can this code be optimized?")
print(f"Second request cache creation tokens: {second_completion.usage.prompt_tokens_details['cache_creation_input_tokens']}")
print(f"Second request cached hit tokens: {second_completion.usage.prompt_tokens_details['cached_tokens']}")

// Versi minimum Java SDK adalah 2.21.6
import com.alibaba.dashscope.aigc.generation.Generation;
import com.alibaba.dashscope.aigc.generation.GenerationParam;
import com.alibaba.dashscope.aigc.generation.GenerationResult;
import com.alibaba.dashscope.common.Message;
import com.alibaba.dashscope.common.MessageContentText;
import com.alibaba.dashscope.common.Role;
import com.alibaba.dashscope.exception.ApiException;
import com.alibaba.dashscope.exception.InputRequiredException;
import com.alibaba.dashscope.exception.NoApiKeyException;

import java.util.Arrays;
import java.util.Collections;

public class Main {
    private static final String MODEL = "qwen3-coder-plus";
    // Konten repositori kode tiruan (diulang 400 kali untuk memastikan melebihi 1024 token)
    private static final String LONG_TEXT_CONTENT = generateLongText(400);
    private static String generateLongText(int repeatCount) {
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < repeatCount; i++) {
            sb.append("<Your Code Here>");
        }
        return sb.toString();
    }
    private static GenerationResult getCompletion(String userQuestion)
            throws NoApiKeyException, ApiException, InputRequiredException {
        // Jika Anda menggunakan model di wilayah Beijing, ganti base_url dengan: https://dashscope.aliyuncs.com/api/v1
        Generation gen = new Generation("http", "https://dashscope-intl.aliyuncs.com/api/v1");

        // Bangun pesan sistem dengan kontrol cache
        MessageContentText systemContent = MessageContentText.builder()
                .type("text")
                .text(LONG_TEXT_CONTENT)
                .cacheControl(MessageContentText.CacheControl.builder()
                        .type("ephemeral") // Atur jenis cache
                        .build())
                .build();

        Message systemMsg = Message.builder()
                .role(Role.SYSTEM.getValue())
                .contents(Collections.singletonList(systemContent))
                .build();
        Message userMsg = Message.builder()
                .role(Role.USER.getValue())
                .content(userQuestion)
                .build();

        // Bangun parameter permintaan
        GenerationParam param = GenerationParam.builder()
                .model(MODEL)
                .messages(Arrays.asList(systemMsg, userMsg))
                .resultFormat(GenerationParam.ResultFormat.MESSAGE)
                .build();
        return gen.call(param);
    }

    private static void printCacheInfo(GenerationResult result, String requestLabel) {
        System.out.printf("%s cache creation tokens: %d%n", requestLabel, result.getUsage().getPromptTokensDetails().getCacheCreationInputTokens());
        System.out.printf("%s cached hit tokens: %d%n", requestLabel, result.getUsage().getPromptTokensDetails().getCachedTokens());
    }

    public static void main(String[] args) {
        try {
            // Permintaan pertama
            GenerationResult firstResult = getCompletion("What is the content of this code?");
            printCacheInfo(firstResult, "First request");
            System.out.println(new String(new char[20]).replace('\0', '='));            // Permintaan kedua
            GenerationResult secondResult = getCompletion("How can this code be optimized?");
            printCacheInfo(secondResult, "Second request");
        } catch (NoApiKeyException | ApiException | InputRequiredException e) {
            System.err.println("API call failed: " + e.getMessage());
            e.printStackTrace();
        }
    }
}

Konten repositori kode tiruan mengaktifkan explicit cache dengan menambahkan penanda cache_control. Untuk permintaan berikutnya tentang repositori ini, sistem dapat menggunakan kembali blok cache tanpa perlu menghitung ulang, sehingga menghasilkan respons yang lebih cepat dan biaya lebih rendah dibandingkan sebelum cache dibuat.

First request cache creation tokens: 1605
First request cached hit tokens: 0
====================
Second request cache creation tokens: 0
Second request cached hit tokens: 1605

Gunakan beberapa penanda cache untuk kontrol detail halus

Dalam skenario kompleks, prompt sering terdiri dari beberapa bagian dengan frekuensi penggunaan ulang yang berbeda. Anda dapat menggunakan beberapa penanda cache untuk kontrol detail halus.

Misalnya, prompt untuk agen layanan pelanggan cerdas biasanya mencakup:

• Persona sistem: Sangat stabil dan hampir tidak pernah berubah.

• Pengetahuan eksternal: Semi-stabil. Diambil dari basis pengetahuan atau dengan memanggil tool dan mungkin tetap tidak berubah selama percakapan berkelanjutan.

• Riwayat percakapan: Berkembang secara dinamis.

• Pertanyaan saat ini: Berbeda setiap kali.

Jika Anda menyimpan seluruh prompt sebagai satu unit, perubahan kecil apa pun, seperti perubahan pada pengetahuan eksternal, dapat menyebabkan cache miss.

Anda dapat menetapkan hingga empat penanda cache dalam satu permintaan untuk membuat blok cache terpisah untuk bagian-bagian berbeda dari prompt. Hal ini meningkatkan tingkat hit dan memberikan kontrol detail halus.

Penagihan

Explicit cache hanya memengaruhi metode penagihan untuk token input. Aturannya sebagai berikut:

• Pembuatan cache: Konten cache yang baru dibuat dikenai biaya 125% dari harga input standar. Jika konten cache permintaan baru mencakup cache yang sudah ada sebagai awalan, hanya bagian tambahannya yang dikenai biaya (jumlah token cache baru dikurangi jumlah token cache yang sudah ada).

  Misalnya, jika Anda memiliki cache A yang sudah ada sebanyak 1200 token dan permintaan baru perlu menyimpan konten AB sebanyak 1500 token, 1200 token pertama dikenai biaya sebagai hit cache (10% dari harga standar), dan 300 token baru dikenai biaya sebagai pembuatan cache (125% dari harga standar).

  Anda dapat melihat jumlah token yang digunakan untuk pembuatan cache pada parameter cache_creation_input_tokens.

• Cache hit: Dikenakan biaya sebesar 10% dari harga input standar.

  Anda dapat melihat jumlah token cache yang terkena hit pada parameter cached_tokens.

• Token lainnya: Token yang tidak terkena hit atau tidak digunakan untuk membuat cache dikenai biaya sesuai harga aslinya.

Konten yang dapat di-cache

Hanya jenis pesan berikut dalam array messages yang mendukung penambahan penanda cache:

• Pesan Sistem

• Pesan Pengguna

  Saat Anda menggunakan model qwen3-vl-plus untuk membuat cache, penanda cache_control dapat ditempatkan setelah konten multimodal atau teks. Posisinya tidak memengaruhi caching seluruh pesan pengguna.

• Pesan Asisten

• Pesan Tool (hasil setelah tool dieksekusi)

  Jika permintaan mencakup parameter tools, menambahkan penanda cache dalam messages juga menyimpan deskripsi tool di dalamnya.

Untuk pesan sistem, Anda dapat mengubah bidang content menjadi array dan menambahkan bidang cache_control:

{
  "role": "system",
  "content": [
    {
      "type": "text",
      "text": "<Your specified prompt>",
      "cache_control": {
        "type": "ephemeral"
      }
    }
  ]
}

Struktur ini juga berlaku untuk jenis pesan lain dalam array messages.

Batas cache

• Panjang prompt minimum yang dapat di-cache adalah 1024 token.

• Cache menggunakan strategi pencocokan awalan mundur. Sistem secara otomatis memeriksa 20 blok konten terakhir. Jika konten yang akan dicocokkan dipisahkan dari pesan yang memiliki penanda cache_control oleh lebih dari 20 blok konten, hit cache tidak dapat terjadi.

• Hanya ephemeral yang didukung untuk parameter type, dengan periode validitas 5 menit.

• Satu permintaan dapat memiliki maksimal 4 penanda cache.

  Jika jumlah penanda cache lebih dari empat, hanya empat penanda cache terakhir yang berlaku.

Contoh penggunaan

from openai import OpenAI
import os

client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # Jika Anda menggunakan model di wilayah Beijing, ganti base_url dengan: https://dashscope.aliyuncs.com/compatible-mode/v1
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

# Konten repositori kode tiruan
long_text_content = "<Your Code Here>" * 400

# Fungsi untuk mengirim permintaan
def get_completion(user_input):
    messages = [
        {
            "role": "system",
            "content": [
                {
                    "type": "text",
                    "text": long_text_content,
                    # Tempatkan penanda cache_control di sini untuk membuat cache dari awal prompt hingga akhir blok konten ini (konten repositori kode tiruan).
                    "cache_control": {"type": "ephemeral"},
                }
            ],
        },
        {
            "role": "user",
            "content": user_input,
        },
    ]
    completion = client.chat.completions.create(
        # Pilih model yang mendukung explicit cache.
        model="qwen3-coder-plus",
        messages=messages,
    )
    return completion

# Permintaan pertama
first_completion = get_completion("What is the content of this code?")
created_cache_tokens = first_completion.usage.prompt_tokens_details.cache_creation_input_tokens
print(f"First request cache creation tokens: {created_cache_tokens}")
hit_cached_tokens = first_completion.usage.prompt_tokens_details.cached_tokens
print(f"First request cached hit tokens: {hit_cached_tokens}")
print(f"First request tokens not hit and not cached: {first_completion.usage.prompt_tokens-created_cache_tokens-hit_cached_tokens}")
print("=" * 20)
# Permintaan kedua. Konten kode sama, hanya pertanyaannya yang berubah.
second_completion = get_completion("What are some areas for optimization in this code?")
created_cache_tokens = second_completion.usage.prompt_tokens_details.cache_creation_input_tokens
print(f"Second request cache creation tokens: {created_cache_tokens}")
hit_cached_tokens = second_completion.usage.prompt_tokens_details.cached_tokens
print(f"Second request cached hit tokens: {hit_cached_tokens}")
print(f"Second request tokens not hit and not cached: {second_completion.usage.prompt_tokens-created_cache_tokens-hit_cached_tokens}")

First request cache creation tokens: 1605
First request cached hit tokens: 0
First request tokens not hit and not cached: 13
====================
Second request cache creation tokens: 0
Second request cached hit tokens: 1605
Second request tokens not hit and not cached: 15

from openai import OpenAI
import os
  
client = OpenAI(
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    # Jika Anda menggunakan model di wilayah Beijing, ganti base_url dengan: https://dashscope.aliyuncs.com/compatible-mode/v1
    base_url="https://dashscope-intl.aliyuncs.com/compatible-mode/v1",
)

system_prompt = "You are a witty person." * 400
messages = [{"role": "system", "content": system_prompt}]

def get_completion(messages):
    completion = client.chat.completions.create(
        model="qwen3-coder-plus",
        messages=messages,
    )
    return completion

while True:
    user_input = input("Please enter: ")
    messages.append({"role": "user", "content": [{"type": "text", "text": user_input, "cache_control": {"type": "ephemeral"}}]})
    completion = get_completion(messages)
    print(f"[AI Response] {completion.choices[0].message.content}")
    messages.append(completion.choices[0].message)
    created_cache_tokens = completion.usage.prompt_tokens_details.cache_creation_input_tokens
    hit_cached_tokens = completion.usage.prompt_tokens_details.cached_tokens
    uncached_tokens = completion.usage.prompt_tokens - created_cache_tokens - hit_cached_tokens
    print(f"[Cache Info] Cache creation tokens: {created_cache_tokens}")
    print(f"[Cache Info] Cached hit tokens: {hit_cached_tokens}")
    print(f"[Cache Info] Tokens not hit and not cached: {uncached_tokens}")

Model yang didukung

Cara kerja

Implicit cache diaktifkan secara otomatis untuk model yang didukung.

1. Temukan: Setelah menerima permintaan, sistem memeriksa cache untuk mencari awalan umum dalam array messages menggunakan pencocokan awalan.

2. Evaluasi:

   • Hit cache: Sistem menggunakan hasil cache untuk inferensi.

   • Miss cache: Sistem memproses permintaan secara normal dan menyimpan awalan prompt untuk permintaan mendatang.

Sistem secara berkala membersihkan entri cache yang tidak digunakan. Tingkat hit cache tidak dijamin — miss dapat terjadi meskipun konteksnya identik. Tingkat hit sebenarnya ditentukan oleh sistem.

Meningkatkan tingkat hit

Implicit caching mencocokkan permintaan dengan membandingkan awalan-nya. Untuk meningkatkan tingkat hit, tempatkan konten statis di awal dan konten variabel di akhir.

• Model teks saja: Jika sistem telah menyimpan cache “ABCD”, permintaan untuk “ABE” akan mencocokkan awalan “AB”, sedangkan permintaan untuk “BCD” tidak akan mencocokkan cache apa pun.

• Model pemahaman visual:

  • Saat mengajukan beberapa pertanyaan tentang gambar atau video yang sama, tempatkan gambar atau video sebelum teks untuk meningkatkan tingkat hit.

  • Saat mengajukan pertanyaan yang sama tentang gambar atau video yang berbeda, tempatkan teks sebelum gambar atau video untuk meningkatkan tingkat hit.

Penagihan

Mengaktifkan mode implicit cache tidak menimbulkan biaya tambahan.

Saat terjadi hit cache, token input yang cocok dikenai biaya sebagai cached_token sebesar 20% dari harga satuan input_token. Token input yang tidak terkena hit dikenai biaya sesuai harga input_token standar. Token output dikenai biaya sesuai harga standar.

Contoh: Sebuah permintaan berisi 10.000 token input, di mana 5.000 di antaranya terkena hit cache:

• Token yang tidak terkena hit (5.000): Dikenai biaya 100% dari harga satuan

• Token yang terkena hit (5.000): Dikenai biaya 20% dari harga satuan

Total biaya input = 60% dari biaya tanpa caching: (50% × 100%) + (50% × 20%) = 60%.

Anda dapat mengambil jumlah token yang di-cache dari atribut cached_tokens pada hasil yang dikembalikan.

OpenAI compatible-Batch (file input) tidak memenuhi syarat untuk diskon cache.

Skenario umum

Jika permintaan Anda memiliki awalan yang sama, context cache dapat meningkatkan kecepatan inferensi, mengurangi biaya, dan menurunkan waktu hingga token pertama. Berikut adalah skenario umum:

1. Tanya jawab berdasarkan teks panjang

   Ini berlaku untuk skenario di mana Anda mengirim beberapa permintaan tentang teks panjang tetap, seperti novel, buku pelajaran, atau dokumen hukum.

   Array pesan untuk permintaan pertama

   messages = [{"role": "system","content": "You are a language teacher. You can help students with reading comprehension."},
             {"role": "user","content": "<Article content> What are the author's thoughts and feelings expressed in this text?"}]

   Array pesan untuk permintaan berikutnya

   messages = [{"role": "system","content": "You are a language teacher. You can help students with reading comprehension."},
             {"role": "user","content": "<Article content> Please analyze the third paragraph of this text."}]

   Meskipun pertanyaannya berbeda, semuanya didasarkan pada artikel yang sama. Prompt sistem dan konten artikel yang identik menciptakan awalan besar yang berulang, yang meningkatkan probabilitas hit cache.

2. Penyelesaian Kode Otomatis

   Dalam skenario penyelesaian kode otomatis, Large Language Model (LLM) menyelesaikan kode berdasarkan kode yang ada dalam konteks. Saat pengguna terus menulis kode, awalan kode tetap tidak berubah. Context cache menyimpan kode sebelumnya untuk meningkatkan kecepatan penyelesaian.

3. Percakapan multi-putaran

   Untuk mengimplementasikan percakapan multi-putaran, tambahkan informasi percakapan dari setiap putaran ke array messages. Oleh karena itu, setiap putaran memiliki awalan yang sama dengan putaran sebelumnya, yang meningkatkan probabilitas hit cache.

   Array pesan untuk putaran pertama percakapan

   messages=[{"role": "system","content": "You are a helpful assistant."},
             {"role": "user","content": "Who are you?"}]

   Array pesan untuk putaran kedua percakapan

   messages=[{"role": "system","content": "You are a helpful assistant."},
             {"role": "user","content": "Who are you?"},
             {"role": "assistant","content": "I am Qwen, developed by Alibaba Cloud."},
             {"role": "user","content": "What can you do?"}]

   Saat jumlah putaran percakapan meningkat, manfaat caching—seperti inferensi lebih cepat dan biaya lebih rendah—menjadi lebih signifikan.

4. Role-playing atau pembelajaran few-shot

   Dalam skenario role-playing atau pembelajaran few-shot, Anda biasanya menambahkan sejumlah besar informasi ke prompt untuk memandu format output LLM. Hal ini menciptakan awalan besar yang berulang di berbagai permintaan.

   Misalnya, agar LLM bertindak sebagai ahli pemasaran, prompt sistem berisi banyak teks. Berikut adalah contoh pesan untuk dua permintaan:

   system_prompt = """You are an experienced marketing expert. Provide detailed marketing suggestions for different products in the following format:
   
   1. Target audience: xxx
   
   2. Main selling points: xxx
   
   3. Marketing channels: xxx
   ...
   12. Long-term development strategy: xxx
   
   Ensure your suggestions are specific, actionable, and highly relevant to the product features."""
   
   # Pesan pengguna untuk permintaan pertama, menanyakan tentang jam tangan pintar
   messages_1=[
     {"role": "system", "content": system_prompt},
     {"role": "user", "content": "Provide marketing suggestions for a newly launched smartwatch."}
   ]
   
   # Pesan pengguna untuk permintaan kedua, menanyakan tentang laptop. Karena system_prompt sama, hit cache sangat mungkin terjadi.
   messages_2=[
     {"role": "system", "content": system_prompt},
     {"role": "user", "content": "Provide marketing suggestions for a newly launched laptop."}
   ]

   Dengan menggunakan context cache, sistem dapat merespons dengan cepat setelah hit cache, bahkan jika pengguna sering mengubah jenis produk dalam kuerinya, seperti dari jam tangan pintar ke laptop.

5. Pemahaman video

   Dalam skenario pemahaman video, jika Anda mengajukan beberapa pertanyaan tentang video yang sama, menempatkan video sebelum teks meningkatkan probabilitas hit cache. Jika Anda mengajukan pertanyaan yang sama tentang video yang berbeda, menempatkan teks sebelum video meningkatkan probabilitas hit cache. Berikut adalah contoh dua permintaan untuk video yang sama:

   # Pesan pengguna untuk permintaan pertama, menanyakan tentang konten video.
   messages1 = [
       {"role":"system","content":[{"text": "You are a helpful assistant."}]},
       {"role": "user",
           "content": [
               {"video": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250328/eepdcq/phase_change_480p.mov"},
               {"text": "What is the content of this video?"}
           ]
       }
   ]
   
   # Pesan pengguna untuk permintaan kedua, menanyakan tentang cap waktu video. Karena kueri tentang video yang sama, menempatkan video sebelum teks membuat hit cache sangat mungkin terjadi.
   messages2 = [
       {"role":"system","content":[{"text": "You are a helpful assistant."}]},
       {"role": "user",
           "content": [
               {"video": "https://help-static-aliyun-doc.aliyuncs.com/file-manage-files/zh-CN/20250328/eepdcq/phase_change_480p.mov"},
               {"text": "Describe the series of events in the video. Output the start time (start_time), end time (end_time), and event (event) in JSON format. Do not include the ```json``` code segment."}
           ]
       }
   ]

T: Bagaimana cara menonaktifkan implicit cache?

Anda tidak dapat menonaktifkan implicit cache. Fitur ini selalu diaktifkan untuk model yang didukung dan tidak berdampak pada kualitas output, sekaligus mengurangi biaya dan meningkatkan kecepatan respons.

P: Mengapa cache eksplisit tidak tercapai setelah saya membuatnya?

Kemungkinan penyebabnya:

• Cache kedaluwarsa karena tidak terkena hit dalam waktu 5 menit.

• Jika blok content terakhir dipisahkan dari cache yang sudah ada oleh lebih dari 20 blok content, cache tidak akan terkena hit. Buat blok cache baru sebagai gantinya.

Q: Apakah mengakses cache eksplisit mengatur ulang periode validitasnya?

Ya. Setiap hit mengatur ulang periode validitas blok cache menjadi 5 menit.

T: Apakah explicit cache dibagi antar akun berbeda?

Tidak. Data cache implicit maupun explicit diisolasi berdasarkan akun dan tidak dibagi lintas akun.

Q: Apakah cache eksplisit dibagikan antara model-model berbeda di bawah akun yang sama?

Tidak. Data cache diisolasi antar model dan tidak dibagi.

T: Mengapa usage's input_tokens tidak sama dengan jumlah cache_creation_input_tokens dan cached_tokens?

Untuk memastikan kualitas output model, layanan backend menambahkan sejumlah kecil token—biasanya kurang dari 10—setelah prompt yang disediakan pengguna. Token ini muncul setelah penanda cache_control. Token tersebut tidak dihitung sebagai pembuatan cache atau hit cache, tetapi termasuk dalam total input_tokens.