AI Engineering Academy · Pelajaran

Strategi agar Tetap dalam Batas Konteks

Terapkan memori jendela geser, peringkasan pesan, dan pemangkasan konteks secara selektif untuk menangani percakapan panjang tanpa melampaui batas token.

Strategi agar Tetap dalam Batas Konteks adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 4 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Engineering Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Masalah Percakapan yang Terus Membesar

Setiap pesan yang dipertukarkan dalam percakapan chat menambah jumlah token pada panggilan API berikutnya. Dalam sesi dukungan pelanggan yang panjang atau sesi pengodean selama berjam-jam, riwayat percakapan yang terkumpul dapat dengan mudah melampaui 20.000–50.000 token — semuanya harus Anda kirim ke API pada setiap giliran, sehingga Anda berulang kali membayar token yang sebelumnya sudah diproses.

Tanpa strategi pengelolaan konteks, aplikasi Anda akan mencapai batas konteks dan berhenti berfungsi, atau Anda akan memangkas pesan secara diam-diam sehingga model kehilangan konteks penting dari bagian percakapan sebelumnya. Setiap aplikasi LLM produksi memerlukan strategi yang jelas untuk mengelola pertumbuhan konteks.

Strategi 1: Jendela Geser (N Pesan Terakhir)

Strategi paling sederhana adalah menyimpan hanya N pesan terakhir dalam konteks dan membuang pesan yang lebih lama. Ini disebut jendela geser. Strategi ini mudah diterapkan, biayanya dapat diprediksi, dan memadai untuk banyak penggunaan yang lebih mementingkan konteks terbaru daripada pertukaran pesan sebelumnya.

import openai

client = openai.OpenAI()

class SlidingWindowConversation:
    def __init__(self, system_prompt, window_size=10):
        self.system = system_prompt
        self.window_size = window_size
        self.history = []

    def chat(self, user_message):
        self.history.append({'role': 'user', 'content': user_message})

        # Keep only the last N messages
        windowed = self.history[-self.window_size:]
        messages = [{'role': 'system', 'content': self.system}] + windowed

        response = client.chat.completions.create(
            model='gpt-4o-mini',
            messages=messages
        )
        reply = response.choices[0].message.content
        self.history.append({'role': 'assistant', 'content': reply})
        print(f'Context: {len(windowed)} messages ({len(self.history)} total)')
        return reply

conv = SlidingWindowConversation('You are a helpful assistant.', window_size=6)
print(conv.chat('Hello! My name is Alice.'))
print(conv.chat('What is the capital of France?'))
print(conv.chat('What is my name?'))  # Might forget if window is small

Strategi 2: Pemangkasan Berdasarkan Token

Alih-alih memangkas berdasarkan jumlah pesan, pemangkasan berdasarkan token menghapus pesan hingga jumlah total token berada di bawah ambang batas. Cara ini lebih presisi karena panjang pesan dapat sangat bervariasi — batas jumlah pesan mungkin mencakup 10 pesan pendek atau 3 pesan yang sangat panjang, dengan biaya token yang sangat berbeda.

import tiktoken

def trim_to_token_budget(
    messages, system_prompt, model='gpt-4o-mini', max_input_tokens=8000
):
    enc = tiktoken.encoding_for_model(model)

    def count(msgs):
        return sum(len(enc.encode(m.get('content',''))) + 4 for m in msgs) + 3

    # System prompt token count
    system_tokens = len(enc.encode(system_prompt)) + 4
    budget = max_input_tokens - system_tokens

    # Trim from the oldest messages until we fit
    trimmed = list(messages)
    while trimmed and count(trimmed) > budget:
        trimmed.pop(0)  # Remove oldest message

    removed = len(messages) - len(trimmed)
    if removed:
        print(f'Trimmed {removed} old messages to stay within {max_input_tokens} tokens')
    return trimmed

Strategi 3: Meringkas Percakapan

Perangkuman memadatkan giliran percakapan lama menjadi ringkasan singkat sambil mempertahankan fakta penting, keputusan, dan konteks yang disebutkan pengguna. Strategi ini lebih canggih daripada jendela geser karena mempertahankan inti pertukaran sebelumnya, bukan sekadar membuangnya.

Polanya bekerja sebagai berikut: ketika percakapan melampaui ambang batas, kirim N giliran paling awal kepada model dengan prompt 'Rangkum percakapan ini sejauh ini', ganti giliran tersebut dengan satu pesan sistem yang berisi ringkasan, lalu lanjutkan percakapan dengan riwayat baru yang telah dipadatkan.

import openai

client = openai.OpenAI()

def summarize_conversation(messages_to_summarize, model='gpt-4o-mini'):
    summary_prompt = [
        {'role': 'system', 'content': 'You summarize conversations. Be concise but preserve key facts, decisions, and any specific information the user shared (names, numbers, preferences).'},
        {'role': 'user', 'content': 'Summarize this conversation:\n' + '\n'.join(
            f"{m['role'].upper()}: {m['content']}" for m in messages_to_summarize
        )}
    ]
    resp = client.chat.completions.create(model=model, messages=summary_prompt, max_tokens=500)
    return resp.choices[0].message.content

def compress_history(history, keep_recent=4):
    if len(history) <= keep_recent:
        return history
    to_summarize = history[:-keep_recent]
    summary = summarize_conversation(to_summarize)
    summary_msg = {'role': 'system', 'content': f'Earlier conversation summary: {summary}'}
    return [summary_msg] + history[-keep_recent:]

print('Summarization strategy compresses old turns into a single summary message')

Strategi 4: Memori Entitas

Memori entitas mengekstrak dan memelihara representasi terstruktur dari fakta penting yang disebutkan dalam percakapan — preferensi pengguna, nama, detail proyek, serta keputusan yang telah dibuat — alih-alih menyimpan riwayat pesan mentah. Sebelum setiap giliran, fakta yang tersimpan disisipkan ke dalam prompt sistem.

Strategi ini lebih hemat token daripada riwayat lengkap karena Anda hanya menyertakan hal-hal yang penting secara semantik, bukan setiap kata dari setiap giliran. Memori entitas sangat cocok untuk asisten yang digunakan dalam jangka panjang, ketika pengguna merujuk kembali pada preferensi dan fakta yang ditetapkan jauh lebih awal dalam percakapan.

import openai
import json

client = openai.OpenAI()

def extract_entities(messages, model='gpt-4o-mini'):
    prompt = [
        {'role': 'system', 'content': 'Extract key facts from this conversation as JSON: {"user_name": null, "preferences": [], "key_facts": []}'},
        {'role': 'user', 'content': '\n'.join(f"{m['role']}: {m['content']}" for m in messages)}
    ]
    resp = client.chat.completions.create(
        model=model,
        messages=prompt,
        response_format={'type': 'json_object'}
    )
    return json.loads(resp.choices[0].message.content)

conversation = [
    {'role': 'user', 'content': 'Hi, I am Alice and I prefer Python over JavaScript.'},
    {'role': 'assistant', 'content': 'Great to meet you, Alice! Python is an excellent choice.'},
    {'role': 'user', 'content': 'I am building a REST API for my e-commerce startup.'}
]
entities = extract_entities(conversation)
print(json.dumps(entities, indent=2))

Kapan Menerapkan Setiap Strategi

Pilih strategi berdasarkan karakteristik aplikasi Anda:

Jendela geser: Aplikasi chat sederhana yang hanya memerlukan konteks terbaru dan penggunanya tidak merujuk kembali pada pertukaran pesan lama. Paling murah untuk diterapkan.
Pemangkasan berdasarkan token: Aplikasi produksi apa pun yang panjang pesannya sangat bervariasi. Selalu lebih baik daripada pemangkasan berdasarkan jumlah pesan.
Perangkuman: Asisten yang digunakan dalam jangka panjang, sesi dukungan pelanggan, bot manajemen proyek. Pengguna mengharapkan asisten mengingat fakta penting dari pertukaran pesan beberapa jam sebelumnya.
Memori entitas: Asisten pribadi, chatbot yang memahami preferensi pengguna, serta sistem bimbingan yang memerlukan profil pengguna sepanjang sesi.

Strategi-strategi ini juga dapat digabungkan: gunakan memori entitas untuk fakta inti dan jendela geser untuk percakapan terbaru.

RAG sebagai Alternatif untuk Memasukkan Konteks Secara Berlebihan

Untuk aplikasi yang sarat pengetahuan, strategi pengelolaan konteks terbaik bukanlah memasukkan dokumen ke dalam konteks sama sekali — sebagai gantinya, gunakan RAG (Retrieval-Augmented Generation) untuk mengambil hanya cuplikan tertentu yang relevan dengan kueri saat ini. Cara ini menjaga konteks tetap terarah, mengurangi biaya, dan sering menghasilkan jawaban yang lebih baik daripada menyisipkan seluruh dokumen.

Wawasan utamanya adalah bahwa jendela konteks yang panjang menyelesaikan masalah apakah semuanya dapat dimuat?, tetapi bukan masalah apakah model akan menggunakannya dengan baik?. Pengambilan yang presisi mengatasi keduanya dengan hanya memberikan informasi yang benar-benar diperlukan model untuk pertanyaan saat ini.

Menangani Error Batas Maksimum Konteks dengan Baik

Meskipun telah berusaha sebaik mungkin, Anda mungkin menjumpai error batas konteks dalam lingkungan produksi, terutama akibat konten buatan pengguna yang ternyata sangat panjang. Selalu tangani error context_length_exceeded secara eksplisit, bukan membiarkannya muncul sebagai pengecualian yang tidak ditangani kepada pengguna.

import openai
import tiktoken

client = openai.OpenAI()

def chat_with_context_guard(messages, model='gpt-4o-mini', max_tokens=100000):
    enc = tiktoken.encoding_for_model(model)
    total = sum(len(enc.encode(m.get('content',''))) + 4 for m in messages) + 3

    while total > max_tokens and len(messages) > 2:
        # Remove the second message (keep system prompt)
        removed = messages.pop(1)
        total -= len(enc.encode(removed.get('content',''))) + 4
        print(f'Trimmed a message. New total: {total} tokens')

    try:
        return client.chat.completions.create(model=model, messages=messages)
    except openai.BadRequestError as e:
        if 'context_length' in str(e):
            return {'error': 'Message history too long. Please start a new conversation.'}
        raise

Mempertahankan Konteks Antar-Sesi

Dalam aplikasi nyata, pengguna menutup dan membuka kembali aplikasi. Server dimulai ulang. Pengelolaan konteks harus memperhitungkan persistensi antar-sesi, bukan hanya dalam satu sesi. Ini berarti menyimpan riwayat percakapan dalam basis data dan memuatnya pada awal setiap sesi.

Pola yang masuk akal adalah menyimpan seluruh riwayat mentah di PostgreSQL untuk keperluan audit dan penyetelan halus, tetapi saat memuat konteks untuk panggilan API baru, menerapkan strategi perangkuman atau pemangkasan agar sesuai dengan anggaran token. Dengan cara ini, Anda tidak pernah kehilangan data, tetapi juga tidak membayar untuk seluruh riwayat pada setiap permintaan.

Memantau Pertumbuhan Konteks dalam Produksi

Catat jumlah token dari setiap panggilan API dan lacak perubahannya dari waktu ke waktu berdasarkan ID percakapan. Percakapan yang sehat seharusnya menunjukkan pertumbuhan bertahap yang kemudian mendatar ketika perangkuman mulai diterapkan. Percakapan yang terus tumbuh tanpa batas hingga mencapai batas konteks menunjukkan bahwa logika pemangkasan Anda tidak bekerja dengan benar.

Pantau juga panjang konteks rata-rata di seluruh percakapan. Jika terus meningkat seiring waktu, hal ini mungkin menunjukkan bahwa prompt sistem bawaan Anda semakin panjang (akibat penambahan fitur), pengguna menempelkan input yang lebih panjang, atau RAG mengembalikan potongan yang semakin besar. Masing-masing penyebab ini memerlukan perbaikan yang berbeda.

Menggabungkan Strategi: Pola Produksi

Sistem pengelolaan konteks produksi yang andal menggabungkan beberapa strategi dalam beberapa lapisan:

Sebelum menyusun konteks: periksa anggaran token dan catat hasilnya
Terapkan ekstraksi entitas: sisipkan blok memori terstruktur yang berisi fakta penting
Tambahkan riwayat terbaru: sertakan 6–10 pesan terakhir secara apa adanya
Ringkas riwayat lama: jika ada riwayat lama, sisipkan ringkasan yang terus diperbarui
Pemeriksaan penjagaan: jika totalnya masih melampaui anggaran, pangkas pesan apa adanya yang paling lama

Pendekatan berlapis ini mempertahankan informasi paling penting (memori entitas dan konteks terbaru), sekaligus secara bertahap menyederhanakan riwayat lama menjadi ringkasan, lalu melakukan pemangkasan hanya sebagai upaya terakhir.

Pemeriksaan Singkat

Uji pemahaman Anda tentang konsep Rekayasa AI dari pelajaran ini.

Rangkuman Pelajaran

Dalam pelajaran ini Anda mempelajari bahwa: jendela geser dan pemangkasan berdasarkan token merupakan strategi sederhana yang membuang konteks lama agar tetap berada dalam batas, perangkuman memadatkan giliran lama menjadi representasi ringkas yang mempertahankan fakta penting, dan memori entitas mengekstrak fakta terstruktur untuk menyediakan memori jangka panjang yang hemat token sepanjang percakapan. Selanjutnya, kita akan membahas cara membuat LLM mengembalikan JSON yang andal menggunakan mode JSON dan keluaran terstruktur.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Strategi agar Tetap dalam Batas Konteks” gratis?

Ya — teks lengkap “Strategi agar Tetap dalam Batas Konteks” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Engineering Academy, upgrade ke CoddyKit PRO. Kursus AI Engineering Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Strategi agar Tetap dalam Batas Konteks”?

Terapkan memori jendela geser, peringkasan pesan, dan pemangkasan konteks secara selektif untuk menangani percakapan panjang tanpa melampaui batas token. Kamu berlatih AI Engineering Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai AI Engineering Academy?

Tidak diperlukan pengalaman sebelumnya. AI Engineering Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 4 dari 4.

Berapa lama pelajaran “Strategi agar Tetap dalam Batas Konteks” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Engineering Academy ini?

Ya. Setiap pelajaran AI Engineering Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

Apa Itu Token?
Jendela Konteks: Ukuran dan Implikasinya
Menghitung dan Memprediksi Biaya API
Strategi agar Tetap dalam Batas Konteks

← Kembali ke AI Engineering Academy