AI Engineering Academy · Pelajaran

Memori Ringkasan dan Pemotongan yang Sadar Token

Pelajaran 3 dari 413 langkah

Memori Ringkasan dan Pemotongan yang Sadar Token adalah pelajaran AI Engineering Academy gratis di CoddyKit. Ini adalah pelajaran 3 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.

Biaya Token dari Seluruh Riwayat

Conversation Buffer Memory menyimpan setiap pesan yang pernah dipertukarkan, sehingga jendela konteks Anda cepat terpakai. Percakapan 100 giliran mungkin menggunakan 20.000 token hanya untuk riwayat, sehingga menyisakan sedikit ruang untuk respons sebenarnya. Summary Memory mengatasi hal ini dengan mengganti giliran lama menggunakan ringkasan terkompresi.

Cara Kerja Memori Ringkasan

Ketika total token melampaui ambang, ConversationSummaryMemory mengirimkan giliran percakapan terlama ke LLM dan memintanya merangkum poin-poin penting. Giliran lengkap tersebut dibuang dan diganti dengan ringkasan ringkas ini. Giliran berikutnya terus terakumulasi di atas ringkasan.

Giliran lama: diganti dengan ringkasan
Giliran terbaru: dipertahankan apa adanya
Hasil akhir: kompresi bermakna dengan kehilangan informasi minimal

ConversationSummaryMemory LangChain

LangChain menyediakan ConversationSummaryMemory yang secara otomatis membuat ringkasan setiap kali penyangga menjadi terlalu besar. Anda meneruskan LLM ke objek memori agar objek tersebut dapat memanggil model untuk membuat ringkasan sesuai kebutuhan.

from langchain.memory import ConversationSummaryMemory
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model='gpt-4o-mini')

memory = ConversationSummaryMemory(
    llm=llm,
    return_messages=True
)

# Add messages manually
memory.save_context(
    {'input': 'My name is Alice and I am building a RAG system.'},
    {'output': 'Great, I can help you build a RAG system, Alice.'}
)

print(memory.load_memory_variables({}))

Memori Penyangga Ringkasan: Menggabungkan yang Terbaik

ConversationSummaryBufferMemory adalah pendekatan hibrida: pendekatan ini mempertahankan giliran terbaru apa adanya demi akurasi dan hanya merangkum giliran lama yang melampaui batas_maksimal_token. Dengan demikian, Anda mendapatkan pengingatan konteks terbaru secara tepat sekaligus pengingatan konteks lama yang telah dikompresi.

from langchain.memory import ConversationSummaryBufferMemory
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model='gpt-4o-mini')

memory = ConversationSummaryBufferMemory(
    llm=llm,
    max_token_limit=500,  # Summarize when older turns exceed 500 tokens
    return_messages=True
)

# As the conversation grows, old turns get summarized automatically
print('Moving summary:', memory.moving_summary_buffer)

Menghitung Token sebelum Pemangkasan

Untuk membuat keputusan pemangkasan yang cerdas, Anda perlu mengetahui jumlah token yang digunakan pesan Anda. Pustaka tiktoken memungkinkan Anda menghitung token untuk model OpenAI apa pun. Dengan demikian, Anda dapat menerapkan pemangkasan yang memperhitungkan token dan tetap berada secara ketat di bawah anggaran.

import tiktoken

def count_tokens(messages: list, model: str = 'gpt-4o') -> int:
    encoding = tiktoken.encoding_for_model(model)
    total = 0
    for msg in messages:
        # Each message has overhead tokens for role framing
        total += 4
        total += len(encoding.encode(msg.get('content', '')))
    total += 2  # Reply primer
    return total

messages = [
    {'role': 'user', 'content': 'Explain RAG to me.'},
    {'role': 'assistant', 'content': 'RAG stands for Retrieval-Augmented Generation...'}
]
print('Token count:', count_tokens(messages))

Pemangkasan Manual yang Memperhitungkan Token

Terkadang Anda menginginkan kendali penuh atas pemangkasan tanpa kelas memori LangChain. Pendekatan sederhana: simpan semua pesan, lalu hapus pesan non-sistem yang paling lama satu per satu sampai jumlah total token sesuai dengan anggaran Anda.

def truncate_to_budget(messages: list, budget: int, model: str = 'gpt-4o') -> list:
    '''Remove oldest non-system messages until under budget.'''
    import tiktoken
    encoding = tiktoken.encoding_for_model(model)

    def token_count(msgs):
        total = 2
        for m in msgs:
            total += 4 + len(encoding.encode(m.get('content', '')))
        return total

    result = list(messages)
    while token_count(result) > budget and len(result) > 1:
        # Never remove the system prompt at index 0
        if result[0]['role'] == 'system':
            del result[1]
        else:
            del result[0]
    return result

Membuat Perintah Ringkasan

Saat membuat memori ringkasan sendiri, Anda menyusun perintah yang meminta LLM mengekstrak fakta-fakta penting. Perintah tersebut harus menginstruksikan model untuk mencatat preferensi pengguna, entitas bernama, dan pertanyaan yang belum terselesaikan — fakta-fakta yang paling mungkin penting pada giliran berikutnya.

from openai import OpenAI

client = OpenAI()

def summarize_history(old_summary: str, new_turns: list) -> str:
    turns_text = '\n'.join(
        f'{m["role"].capitalize()}: {m["content"]}' for m in new_turns
    )
    prompt = f'''Current summary:\n{old_summary}\n\nNew conversation turns:\n{turns_text}\n\nWrite an updated summary that captures key facts, user preferences, and open questions.'''

    resp = client.chat.completions.create(
        model='gpt-4o-mini',
        messages=[{'role': 'user', 'content': prompt}]
    )
    return resp.choices[0].message.content

Mengintegrasikan Ringkasan ke dalam Perintah Sistem

Setelah memiliki ringkasan, sisipkan ringkasan tersebut ke dalam perintah sistem agar LLM selalu memiliki konteks tentang riwayat percakapan. Letakkan ringkasan di awal sebagai blok konteks singkat sebelum instruksi persona utama.

def build_messages_with_summary(summary: str, recent_turns: list, user_input: str) -> list:
    system_content = (
        'You are a helpful AI assistant.'
        + ('\n\n[Conversation summary]\n' + summary if summary else '')
    )

    messages = [{'role': 'system', 'content': system_content}]
    messages.extend(recent_turns)
    messages.append({'role': 'user', 'content': user_input})
    return messages

Memicu Pembuatan Ringkasan secara Otomatis

Pola yang umum adalah memicu pembuatan ringkasan ketika percakapan melampaui ambang token — misalnya, saat riwayat yang terus berjalan melewati 2.000 token. Pada saat itu, rangkum semua giliran kecuali dua giliran terakhir dan ganti giliran tersebut dengan ringkasan.

class SummaryBufferChat:
    def __init__(self, max_tokens=2000):
        self.summary = ''
        self.recent_turns = []
        self.max_tokens = max_tokens

    def chat(self, user_message: str) -> str:
        from openai import OpenAI
        client = OpenAI()

        messages = build_messages_with_summary(self.summary, self.recent_turns, user_message)
        resp = client.chat.completions.create(model='gpt-4o', messages=messages)
        reply = resp.choices[0].message.content

        self.recent_turns.append({'role': 'user', 'content': user_message})
        self.recent_turns.append({'role': 'assistant', 'content': reply})

        if count_tokens(self.recent_turns) > self.max_tokens:
            to_summarize = self.recent_turns[:-2]
            self.recent_turns = self.recent_turns[-2:]
            self.summary = summarize_history(self.summary, to_summarize)

        return reply

Mempertahankan Entitas Bernama dalam Ringkasan

Kualitas ringkasan sangat bergantung pada perintah peringkasan. Jika pengguna menyebutkan nama, lokasi, preferensi, atau tenggat waktu, perintah Anda harus secara eksplisit menginstruksikan model untuk menyertakan fakta-fakta tersebut. Ringkasan umum sering menghilangkan nama diri yang paling penting untuk personalisasi.

Sertakan: nama, tanggal, pilihan teknis yang dibuat, pertanyaan terbuka
Kecualikan: percakapan pengisi, pengakuan, basa-basi yang berulang

Pertukaran: Memori Ringkasan vs Memori Jendela

Memilih antara memori ringkasan dan memori jendela bergantung pada kasus penggunaan Anda. Memori jendela mempertahankan susunan kata yang tepat, yang penting untuk pengingatan presisi tetapi memboroskan token untuk konteks yang tidak relevan. Memori ringkasan melakukan kompresi secara agresif, tetapi menambahkan satu panggilan LLM dan mungkin kehilangan detail kasus khusus. Sebagian besar bot percakapan produksi menggunakan pendekatan hibrida: giliran terbaru yang tepat ditambah ringkasan bergulir dari giliran yang lebih lama.

Pemeriksaan Singkat

Uji pemahaman Anda tentang konsep memori ringkasan dan pemangkasan yang memperhitungkan token.

Jawab di pelajaran interaktif

Ringkasan Pelajaran

Dalam pelajaran ini, Anda telah mempelajari bahwa: memori ringkasan memampatkan giliran lama melalui panggilan LLM, ConversationSummaryBufferMemory menggabungkan giliran terbaru yang tepat dengan giliran lama yang diringkas, dan tiktoken memungkinkan pemangkasan yang memperhitungkan token agar percakapan tetap sesuai anggaran. Selanjutnya, kita akan membahas penyimpanan riwayat percakapan di Redis dan PostgreSQL untuk penyimpanan yang tahan lama dan dapat diskalakan.

Gratis untuk memulai

Belajar Python dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus: 30
Pelajaran: 120

Mulai belajar gratis Lihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Memori Ringkasan dan Pemotongan yang Sadar Token” gratis?

Ya — teks lengkap “Memori Ringkasan dan Pemotongan yang Sadar Token” 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 “Memori Ringkasan dan Pemotongan yang Sadar Token”?

Gunakan ConversationSummaryMemory untuk meringkas giliran percakapan yang lebih lama secara otomatis, sehingga percakapan tetap ringkas sambil mempertahankan fakta penting yang disebutkan pengguna se… 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 3 dari 4.

Berapa lama pelajaran “Memori Ringkasan dan Pemotongan yang Sadar Token” 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

Mengapa LLM Tanpa Status Membutuhkan Memori Eksternal
Memori Penyangga dan Jendela
Memori Ringkasan dan Pemotongan yang Sadar Token
Menyimpan Riwayat Obrolan di Redis dan PostgreSQL

← Kembali ke AI Engineering Academy