Mengenal Large Language Model (LLM): Dasar-Dasar AI Modern

Pendahuluan

Halo, teman-teman developer! Selamat datang di artikel pertama dari seri pengembangan Chatbot Sederhana. Jika kamu sering menggunakan ChatGPT, Gemini, atau Claude, kamu sebenarnya sudah berinteraksi langsung dengan teknologi yang disebut Large Language Model (LLM).

Dalam artikel ini, kita tidak akan langsung menulis kode yang rumit menggunakan API berbayar. Fokus utama kita adalah memahami “otak” di balik teknologi ini. Kita akan membedah apa itu LLM, bagaimana ia memproses kata demi kata, dan bagaimana kita bisa berkomunikasi dengannya secara efektif.

Tujuan akhir dari seri ini adalah membuat sebuah chatbot berbasis API yang bisa menjawab pertanyaan pengguna dengan cerdas. Namun, sebelum kita menyentuh kode API, kamu harus paham dulu konsep dasarnya agar tidak bingarkan saat menghadapi masalah seperti token limit atau hallucination di kemudian hari. Mari kita mulai!

Apa itu Large Language Model (LLM)?

Secara sederhana, Large Language Model (LLM) adalah model kecerdasan buatan yang dilatih menggunakan data teks dalam skala yang sangat masif—bisa berupa seluruh isi Wikipedia, buku digital, hingga artikel berita. Kata “Large” merujuk pada dua hal: jumlah data yang digunakan untuk pelatihan dan jumlah parameter (bobot matematis) yang ada di dalam model tersebut.

Bayangkan kamu memiliki seorang teman bernama Budi yang telah membaca seluruh buku di Perpustakaan Nasional Indonesia. Budi tidak sekadar menghafal, tetapi ia memahami pola bahasa. Jika kamu bertanya, “Ibu sedang memasak…”, Budi secara otomatis bisa menebak kata berikutnya adalah “nasi” atau “sayur” karena ia telah melihat pola tersebut jutaan kali.

LLM bekerja dengan prinsip probabilitas. Ia tidak “berpikir” seperti manusia, melainkan menghitung kemungkinan kata apa yang paling masuk akal muncul setelah urutan kata sebelumnya.

Berikut adalah simulasi sangat sederhana dalam Python untuk menunjukkan bagaimana sebuah model mencoba memprediksi kata berikutnya berdasarkan probabilitas sederhana:

# simulasi_prediksi.py

import random

def prediksi_kata_berikutnya(input_teks):
    # Database sederhana (sebagai pengganti model LLM asli)
    knowledge_base = {
        "saya sedang": ["makan", "belajar", "tidur"],
        "budi pergi ke": ["pasar", "kantor", "sekolah"],
        "harga nasi goreng adalah": ["sepuluh ribu", "lima belas ribu", "dua puluh ribu"]
    }

    # Mencari kecocokan pola di dalam knowledge_base
    for pattern, possibilities in knowledge_base.items():
        if input_teks.lower() in pattern.lower():
            return random.choice(possibilities)
    
    return "..." # Jika tidak ditemukan pola

# Contoh penggunaan
input_user = "saya sedang"
prediksi = prediksi_kata_berikutnya(input_user)

print(f"Input: {input_user}")
print(f"Prediksi LLM: {prediksi}")
# Output: Prediksi LLM: makan (atau kemungkinan lainnya)

Tokenization: Bagaimana AI Membaca Teks

Salah satu konsep paling krusial dalam LLM adalah Tokenization. Komputer tidak memahami kata seperti kita. Komputer hanya memahami angka. Oleh karena itu, teks harus dipecah menjadi unit-unit kecil yang disebut token.

Token bisa berupa satu kata utuh, satu suku kata, atau bahkan hanya satu karakter. Sebagai contoh, kata “Indonesia” mungkin dipecah menjadi dua token: ["Indo", "nesia"].

Mengapa ini penting bagi kita sebagai developer?

1. Biaya (Cost): Saat menggunakan API seperti OpenAI, kamu dibayar berdasarkan jumlah token yang digunakan, bukan jumlah karakter.
2. Context Window: Setiap model memiliki batas maksimal token yang bisa diproses dalam satu waktu (misalnya 4.096 token). Jika inputmu terlalu panjang, teks akan terpotong.

Mari kita lihat cara kerja pemecahan teks sederhana menggunakan Python:

# tokenisasi_sederhana.py

def sederhana_tokenizer(teks):
    # Simulasi tokenizer: memecah berdasarkan spasi dan tanda baca
    # Dalam dunia nyata, ini melibatkan algoritasi kompleks seperti Byte Pair Encoding (BPE)
    tokens = teks.replace(".", "").replace(",", "").split(" ")
    return tokens

# Contoh penggunaan
kalimat = "Halo, saya Budi dari Jakarta. Saya senang belajar AI."
hasil_token = sederhana_tokenizer(kalimat)

print(f"Kalimat Asli: {kalimat}")
print(f"Hasil Token: {hasil_token}")
print(f"Jumlah Token: {len(hasil_token)}")

# Output:
# Hasil Token: ['Halo', 'saya', 'Budi', 'dari', 'Jakarta', 'Saya', 'senang', 'belajar', 'AI']
# Jumlah Token: 9

Prompt Engineering: Seni Memberi Instruksi

Setelah memahami apa itu LLM dan bagaimana ia memproses teks, sekarang kita masuk ke bagian yang paling bisa kita kendalikan: Prompt Engineering.

Prompt adalah instruksi atau input yang kita berikan kepada LLM. Kualitas jawaban LLM sangat bergantung pada seberapa jelas instruksi yang kita berikan. Prompt yang buruk akan menghasilkan jawaban yang tidak relevan (sering disebut hallucination).

Ada tiga komponen utama dalam prompt yang baik:

1. Instruction (Instruksi): Apa yang kamu ingin AI lakukan? (Misal: “Terjemahkan”, “Ringkas”, “Buatlah kode”).
2. Context (Konteks): Memberikan latar belakang. (Misal: “Kamu adalah seorang ahli gizi”).
3. Input Data: Data yang ingin diproses. (Misal: “Teks: Makan buah itu sehat”).

Contoh perbandingan prompt:

# prompt_engineering.py

def simulasi_ai_response(prompt_template, input_data):
    # Simulasi logika AI yang merespon instruksi
    full_prompt = prompt_template.format(data=input_data)
    
    print(f"--- Prompt yang dikirim ke AI ---")
    print(full_prompt)
    print(f"----------------------------------\n")
    
    # Logika simulasi respon
    if "ringkas" in full_prompt.lower():
        return f"Ringkasan dari '{input_data}': [Isi ringkasan otomatis]"
    elif "terjemahkan" in full_prompt.lower():
        return f"Terjemahan dari '{input_data}' ke Bahasa Inggris: [Hasil terjemahan]"
    else:
        return "Maaf, saya tidak mengerti instruksi Anda."

# 1. Prompt Buruk (Terlalu ambigu)
prompt_buruk = "Proses ini: {data}"
print("Respon Prompt Buruk:")
print(simulasi_ai_format(prompt_buruk, "Hari ini cuaca sangat cerah"))

print("\n" + "="*30 + "\n")

# 2. Prompt Baik (Spesifik dengan instruksi jelas)
prompt_baik = "Tolong ringkas teks berikut menjadi satu kalimat pendek: {data}"
print("Respon Prompt Baik:")
print(simulasi_ai_format(prompt_baik, "Hari ini cuaca sangat cerah dan matahari bersinar dengan terang tanpa awan sedikitpun"))

# Helper function untuk simulasi
def simulasi_ai_format(template, data):
    # Menggunakan fungsi yang sama dengan di atas
    return simulasi_ai_format_logic(template, data)

def simulasi_ai_format_logic(template, data):
    prompt = template.format(data=data)
    if "ringkas" in prompt.lower():
        return "Hari ini cuaca cerah."
    return "Tidak ada instruksi spesifik."

(Catatan: Kode di atas hanyalah simulasi logika untuk menunjukkan perbedaan struktur prompt).

Kesimpulan

Dalam artikel ini, kita telah mempelajari:

1. LLM bekerja dengan memprediksi kata berikutnya berdasarkan pola statistik.
2. Token adalah unit dasar yang diproses oleh model (bisa berupa kata atau bagian dari kata).
3. Prompt Engineering adalah kunci untuk mendapatkan hasil maksimal dari model AI.

Pada artikel berikutnya, kita akan mulai masuk ke ranah teknis yang lebih dalam, yaitu bagaimana cara memanggil API dari penyedia model bahasa (seperti OpenAI atau Google Gemini) menggunakan Python untuk membuat chatbot sederhana!

Persiapan untuk artikel selanjutnya: Pastikan kamu sudah menginstal Python di komputermu dan memiliki koneksi internet yang stabil.

Langkah berikutnya: Cara Memanggil API LLM dengan Python — tutorial langsung praktek memanggil API OpenAI/Gemini menggunakan Python. Atau mulai dari dasar Python dulu: Pengenalan Python.