Memahami Tokenisasi: Kunci Utama Cara Kerja LLM

Pendahuluan

Halo teman-teman developer! Senang sekali bisa bertemu kembali di seri panduan membangun Chatbot berbasis LLM ini. Di artikel sebelumnya, kita sudah membahas dasar-dasar apa itu Large Language Model (LLM) dan bagaimana teknologi ini mulai mengubah cara kita berinteraksi dengan mesin.

Namun, pernahkah kamu bertanya-tanya, bagaimana sebuah model AI yang sangat pintar bisa “membaca” teks yang kita kirimkan? Apakah ia membaca huruf demi huruf, atau kata demi kata? Jawabannya terletak pada sebuah proses krusial yang disebut Tokenisasi.

Dalam artikel kedua ini, kita akan membedah cara kerja tokenisasi secara mendalam. Kita akan mempelajari mengapa tokenisasi sangat penting dalam pengembangan chatbot, bagaimana ia memengaruhi biaya penggunaan API (seperti OpenAI atau Anthropic), dan bagaimana kita bisa mengelola jumlah token agar chatbot yang kita bangun tidak mengalami error “context window exceeded”. Pemahaman ini adalah fondasi sebelum kita masuk ke tahap prompt engineering di artikel selanjutnya.

Apa Itu Token?

Bayangkan kamu sedang menyusun sebuah kalimat menggunakan balok LEGO. Untuk membuat sebuah bangunan yang kompleks, kamu memerlukan potongan-potongan balok dengan berbagai ukuran. Di dalam dunia LLM, “balok-balok” ini disebut sebagai Token.

Token bukan selalu berarti satu kata utuh. Sebuah token bisa berupa satu kata (misalnya: Budi), sebagian kata (misalnya: makan dan an dari kata makanan), atau bahkan hanya satu karakter tunggal atau tanda baca (misalnya: !).

Secara teknis, LLM tidak memahami teks dalam bentuk string mentah seperti yang kita lihat di layar. LLM bekerja dengan angka. Proses tokenisasi adalah jembatan yang mengubah teks manusia (string) menjadi deretan angka (token IDs) yang dapat diproses secara matematis oleh model AI.

Mari kita lihat contoh sederhana berikut menggunakan logika pemisahan kata:

# Contoh simulasi sederhana tokenisasi berbasis kata
def simulasi_tokenisasi_kata(teks):
    # Memecah teks berdasarkan spasi (sangat sederhana, bukan cara asli LLM)
    tokens = teks.split(" ")
    return tokens

teks_input = "Budi sedang makan nasi goreng di Jakarta"
hasil_token = simulasi_tokenisasi_kata(teks_input)

print(f"Teks Asli: {teks_input}")
print(f"Hasil Token: {hasil_token}")
# Output: ['Budi', 'sedang', 'makan', 'nasi', 'goreng', 'di', 'Jakarta']

Meskipun contoh di atas terlihat seperti memecah kata, LLM modern menggunakan metode yang jauh lebih cerdas yang disebut Subword Tokenization.

Subword Tokenization: Mengapa Tidak Kata Saja?

Jika kita hanya menggunakan satu kata sebagai satu token, kita akan menghadapi dua masalah besar:

1. Vocabulary yang terlalu besar: Jika kita harus menyimpan setiap variasi kata (misalnya: makan, makanan, memakan, dimakan) sebagai token terpisah, daftar kamus (vocabulary) model akan menjadi sangat raksasa dan memakan banyak memori.
2. Out-of-Vocabulary (OOV) Problem: Bagaimana jika user mengetik kata baru yang tidak ada di kamus kita, seperti nama merek baru atau istilah gaul yang baru muncul? Model akan bingung.

Untuk mengatasi ini, digunakanlah teknik Subword Tokenization (seperti Byte Pair Encoding atau BPE). Teknik ini memecah kata-kata yang jarang muncul menjadi potongan-potongan kecil yang lebih umum.

Mari kita lihat contoh bagaimana sebuah kata kompleks dipecah:

# Simulasi Subword Tokenization
def simulasi_subword_tokenization(kata):
    # Dalam realitanya, ini ditentukan oleh algoritma BPE yang sudah dilatih
    # Di sini kita simulasikan pemecahan kata kompleks
    if "tokenisasi" in kata.lower():
        return ["token", "isasi"]
    return [kata]

kata_sulit = "Tokenisasi"
hasil = simulasi_subword_tokenization(kata_sulit)

print(f"Kata: {kata_sulit}")
print(f"Hasil Subword: {hasil}")
# Output: ['token', 'isasi']

Dengan cara ini, jika model sudah tahu apa itu “token” dan apa itu “isasi”, ia bisa memahami kata “tokenisasi” meskipun ia belum pernah melihat kata utuhnya sebelumnya. Ini membuat LLM sangat adaptif terhadap bahasa baru atau typo ringan.

Token, Context Window, dan Biaya API

Sebagai developer yang membangun chatbot, memahami token bukan hanya soal teori, tapi soal biaya dan kapasitas.

1. Context Window (Batas Ingatan)

Setiap LLM memiliki batasan jumlah token yang dapat diproses dalam satu waktu, yang disebut Context Window. Jika kamu mengirimkan chat history yang terlalu panjang (misalnya riwayat percakapan Budi dan Andi yang sudah berlangsung berhari-hari), total tokennya bisa melebihi batas ini. Jika melebihi, model akan “lupa” bagian awal percakapan atau bahkan error.

2. Biaya (Cost)

Layanan API seperti OpenAI menagih biaya berdasarkan jumlah token yang digunakan (Input + Output). Misalkan kamu menggunakan layanan chatbot untuk bisnis di Indonesia. Jika satu token dihargai Rp 0,05, maka teks yang panjang akan membengkak biayanya.

Mari kita buat implementasi nyata menggunakan library tiktoken (library standar dari OpenAI) untuk menghitung token dalam proyek Chatbot kita.

# Pastikan sudah install: pip install tiktoken
import tiktoken

def hitung_biaya_dan_token(teks, harga_per_1k_token_idr=100):
    """
    Menghitung jumlah token dan estimasi biaya dalam Rupiah.
    harga_per_1k_token_idr: Biaya per 1000 token dalam Rupiah.
    """
    # Menggunakan encoding untuk model GPT-3.5/4
    encoding = tiktoken.get_encoding("cl100k_base")
    
    # Proses tokenisasi
    tokens = encoding.encode(teks)
    jumlah_token = len(tokens)
    
    # Hitung biaya (asumsi harga per 1000 token)
    biaya = (jumlah_token / 1000) * harga_per_1k_token_idr
    
    return jumlah_token, biaya, tokens

# Contoh penggunaan dalam proyek Chatbot
pesan_user = "Halo, saya Budi. Bisa bantu saya menghitung total belanja di Tokopedia sebesar Rp 150.000?"

jumlah, biaya, token_ids = hitung_biaya_dan_token(pesan_user)

print(f"Pesan: {pesan_user}")
print(f"Jumlah Token: {jumlah}")
print(f"Estimasi Biaya: Rp {biaya:.4f}")
print(f"Token IDs: {token_ids[:5]}... (tampilan singkat)")

Dengan kode di atas, kamu sebagai developer bisa membuat fitur “Budget Alert” atau membatasi input user agar tidak membengkakkan tagihan bulanan perusahaanmu.

Kesalahan Umum

Dalam perjalanan belajar tokenisasi, saya sering melihat developer pemula terjebak pada beberapa kesalahan berikut:

1. Mengasumsikan 1 Kata = 1 Token

Pesan error:

(Tidak ada error terminal, tapi logika program salah/biaya membengkak)

Penyebab: Menganggap jumlah kata sama dengan jumlah token. Padahal, satu kata panjang bisa terdiri dari 3-5 token. Solusi:

# Selalu gunakan library tokenizer resmi (seperti tiktoken atau transformers)
import tiktoken
encoding = tiktoken.get_encoding("cl100k_base")
token_count = len(encoding.encode(teks_anda))

2. Mengabaikan Karakter Spasi dan Simbol

Pesan error:

Token count mismatch error

Penyebab: Spasi, newline (\n), dan tanda baca dihitung sebagai token tersendiri atau bagian dari token. Menghapus spasi secara sembarangan saat menghitung token akan membuat estimasi biaya menjadi tidak akurat. Solusi: Hitunglah string mentah (raw string) yang akan dikirim ke API, jangan melakukan pembersihan string (preprocessing) sebelum perhitungan token.

3. Over-budgeting pada Context Window

Pesan error:

Error: context_length_exceeded (4096/4096)

Penyebab: Mengirimkan seluruh riwayat chat (history) tanpa melakukan pemotongan (truncation). Semakin lama percakapan, semakin besar jumlah tokennya. Solusi: Implementasikan strategi “Sliding Window”, yaitu hanya mengambil $N$ pesan terakhir dari riwayat chat agar total token tetap di bawah batas limit model.

Dengan memahami cara kerja token, kamu sekarang memiliki kendali lebih besar atas efisiensi biaya dan performa aplikasi AI yang kamu bangun. Di artikel berikutnya, kita akan membahas bagaimana cara melakukan Prompt Engineering agar instruksi kita dipahami dengan tepat oleh model!