Apa arti model_context_window_exceeded
String model_context_window_exceeded adalah cara beberapa klien, SDK, dan API menandai satu kegagalan spesifik: teks yang Anda kirim, ditambah ruang yang dibutuhkan untuk jawaban, lebih besar dari yang dapat ditampung model dalam satu permintaan. Penulisan pesan ini berbeda di setiap alat, jadi baca seluruh body error yang ditampilkan klien Anda daripada mengandalkan nama. Penyebabnya selalu sama.
Pada API ini, context window adalah 100.000 token, dan angka itu mencakup prompt dan completion secara bersama. Jika prompt Anda menggunakan 95.000 token, tersisa paling banyak sekitar 5.000 untuk balasan. Jika Anda juga mengatur max_tokens ke 8.000, permintaan meminta lebih dari yang diizinkan jendela konteks. Bidang max_tokens bersifat opsional, dan ketika Anda tidak mengisinya, balasan hanya menggunakan sisa ruang yang ada.
Permintaan yang gagal dengan cara ini mengembalikan error alih-alih completion. Permintaan yang gagal tidak dikenakan biaya, sehingga mencapai batas tidak membebani Anda selain biaya perjalanan bolak-balik. Solusinya ada di sisi Anda: kirim lebih sedikit, atau minta lebih sedikit.
Seberapa besar 100.000 token?
Token adalah potongan teks, sering berupa kata pendek atau bagian dari kata yang lebih panjang. Untuk prosa bahasa Inggris biasa, aturan kasar adalah satu token per empat karakter, atau sekitar tiga perempat kata. Berdasarkan aturan itu, 100.000 token adalah sekitar 75.000 kata, yang setara dengan novel tebal. Kode, JSON, tabel, dan teks non-Inggris terpecah menjadi lebih banyak token per karakter, sehingga jumlah karakter yang sama bisa jauh lebih besar. Anggap aturan praktis ini sebagai angka perencanaan, bukan jaminan.
Perhitungan tepat berasal dari tokenizer model itu sendiri. API melaporkan penggunaan nyata dalam respons: objek usage mencantumkan token prompt dan completion, dan respons streaming mengirimkan usage di akhir. Itu adalah data paling andal yang Anda miliki, jadi catatlah.
| Konten | Ukuran kasar |
|---|---|
| Pesan obrolan dua kalimat | 40 hingga 60 token |
| Satu halaman teks bahasa Inggris, 500 kata | sekitar 670 token |
| Dokumen 10.000 kata | sekitar 13.000 token |
| Ekspor JSON 3 MB | sering lebih dari 100.000 token, terlalu besar untuk dikirim mentah |
Body permintaan juga memiliki batas ukuran 8 MB, yang merupakan batas terpisah dari token. Input besar dapat gagal karena salah satu dari keduanya, dan batas token hampir selalu yang pertama Anda capai.
Mengapa aplikasi obrolan mencapai batas ini
API tidak menyimpan memori antar panggilan. Untuk melanjutkan percakapan, kode Anda mengirim seluruh daftar pesan setiap kali. Setiap giliran menambahkan pesan pengguna dan balasan, sehingga prompt tumbuh dengan setiap pertukaran. Bot yang berfungsi baik selama satu jam lalu mulai gagal adalah tanda klasik.
Hal yang sama terjadi pada agen. Setiap hasil alat ditambahkan ke riwayat, dan satu fungsi yang mengembalikan catatan besar dapat menambahkan ribuan token dalam satu langkah. Pengaturan retrieval menambahkan sumber ketiga: jika Anda menempelkan dua puluh potongan dokumen ke setiap prompt, biaya dasar per permintaan sudah besar sebelum riwayat apa pun ada.
Sebelum memperbaiki apa pun, cari tahu mana dari tiga hal yang tumbuh. Cetak jumlah token prompt dari usage setelah setiap panggilan. Jika jumlahnya naik sekitar jumlah yang sama setiap giliran, itu adalah riwayat. Jika jumlahnya melonjak setelah langkah tertentu, itu adalah output alat atau teks yang diambil.
Pangkas riwayat sebelum mengirimkannya
Solusi andal paling sederhana adalah fungsi yang menghapus giliran tertua hingga estimasi sesuai dengan anggaran. Selalu pertahankan pesan sistem, dan selalu pertahankan pesan pengguna terbaru. Anggaran harus menyisakan ruang untuk balasan, jadi gunakan sekitar 80.000 token untuk prompt dan biarkan sisanya menjadi ruang completion.
from openai import OpenAI
client = OpenAI(
base_url="https://api.uncensoredmodelhub.com/v1",
api_key="YOUR_API_KEY",
)
def estimate_tokens(text: str) -> int:
return len(text) // 4 + 4 # rough: 4 characters per token plus overhead
def trim(messages, budget=80_000):
system = [m for m in messages if m["role"] == "system"]
rest = [m for m in messages if m["role"] not in ("system",)]
total = sum(estimate_tokens(m["content"]) for m in system + rest)
while total > budget and len(rest) > 1:
dropped = rest.pop(0) # oldest turn goes first
total -= estimate_tokens(dropped["content"])
return system + rest
history = [{"role": "system", "content": "You are a helpful assistant."}]
def ask(user_text):
history.append({"role": "user", "content": user_text})
resp = client.chat.completions.create(
model="uncensored",
messages=trim(history),
max_tokens=2000,
)
reply = resp.choices[0].message.content
history.append({"role": "assistant", "content": reply})
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)
return reply
Pertahankan giliran pengguna dan asisten berpasangan jika memungkinkan; menghapus separuh pasangan dapat membingungkan model. Pesan alat serupa: pesan role: "tool" harus tetap bersama giliran asisten yang memintanya, jadi hapus bersamaan. Karena estimasi bersifat kasar, celah 20 persen antara anggaran Anda dan jendela konteks sebenarnya adalah margin keamanan yang nyaman.
Opsi lebih baik daripada menghapus giliran lama
Ringkaskan, lalu lanjutkan
Ketika riwayat melewati ambang batas, kirim setengah tertua ke model dengan instruksi untuk meringkasnya dalam beberapa ratus kata, lalu ganti giliran tersebut dengan ringkasan sebagai pesan sistem atau pengguna. Anda kehilangan detail tetapi menjaga alur. Jalankan langkah ini di luar jalur balasan langsung agar pengguna tidak menunggu.
Pin fakta yang harus bertahan
Pertahankan blok catatan kecil yang tahan lama, seperti nama, keputusan, dan pengaturan, dan sisipkan kembali di awal setiap permintaan. Ini bekerja lebih baik daripada berharap giliran lama masih terlihat.
Perkecil input yang Anda berikan
Potong hasil alat ke bidang yang penting. Ambil potongan lebih sedikit, dan potong setiap potongan ke paragraf yang relevan. Untuk dokumen yang sangat panjang, bagi menjadi bagian-bagian, proses setiap bagian, dan gabungkan hasilnya dalam panggilan singkat terakhir.
Atur max_tokens dengan sengaja
Jika jawaban biasanya pendek, atur max_tokens pada nilai yang sesuai dengan produk Anda. Batas melindungi anggaran, tetapi batas yang terlalu rendah memotong balasan di tengah kalimat, jadi lihat panjang jawaban sebenarnya di log terlebih dahulu.
Memangkas juga menghemat uang
Token input berharga $0,15 per 1 juta, token output $0,50 per 1 juta, dibebankan dari saldo prabayar. Karena obrolan mengirim ulang riwayat, biaya per percakapan tumbuh lebih cepat daripada panjangnya. Ambil obrolan di mana setiap pertukaran menambahkan 500 token ke riwayat dan percakapan berjalan 100 giliran.
- Tanpa pemangkasan, giliran n mengirim 500 x n token. Jumlah selama 100 giliran adalah 500 x 5.050 = 2.525.000 token input, yang berharga 2,525 x $0,15 = $0,379.
- Dengan batas 20.000 token, 40 giliran pertama sama (500 x 820 = 410.000 token). 60 giliran sisanya mengirim 20.000 masing-masing, yang berjumlah 1.200.000. Totalnya adalah 1.610.000 token, atau 1,61 x $0,15 = $0,242.
Batas ini menghemat sekitar sepertiga di sini, dan kesenjangan melebar saat obrolan menjadi lebih panjang. Pada ekstrem, prompt 100.000 token penuh berharga 0,1 x $0,15 = $0,015 per permintaan. Itu murah secara mandiri, tetapi jumlahnya bertambah pada bot yang melayani banyak pengguna. Detail harga dan bonus isi saldo ada di halaman harga, dan saldo prabayar tidak pernah kedaluwarsa.
Menangani error dalam kode
Meskipun sudah dipangkas, rencanakan kegagalan. Tangkap error API, periksa apakah pesan mengacu pada panjang konteks, perkecil permintaan, dan coba lagi sekali. Jangan coba ulang permintaan yang sama persis, karena akan gagal dengan cara yang sama.
from openai import BadRequestError
def safe_ask(messages, budget=80_000):
try:
return client.chat.completions.create(
model="uncensored", messages=trim(messages, budget)
)
except BadRequestError as err:
if "context" in str(err).lower() and budget > 10_000:
return safe_ask(messages, budget // 2)
raise
Periksa kode status dan pesan aktual yang diterima klien Anda untuk permintaan yang terlalu besar dan sesuaikan pengujian; pencocokan string di atas adalah titik awal. Batas laju adalah hal terpisah: HTTP 429 dengan rate_limited atau concurrency berarti terlalu banyak permintaan, bukan terlalu banyak token, dan 429 dengan Retry-After: 5 berarti kelebihan beban sementara. dokumentasi mencantumkan bidang permintaan, penjelasan tentang model tanpa sensor mencakup apa itu model, dan Anda dapat mendapatkan kunci untuk menguji ini dengan angka penggunaan nyata.
