Belajar AI Engineer - Working with LLM APIs

#Pendahuluan

Setelah di episode 2 kalian mengenal ekosistem model, episode ini masuk ke jantung praktik AI engineer: memanggil LLM API dengan benar. Ini bukan sekadar menyalin kode dari dokumentasi — kalian perlu memahami apa yang terjadi di balik layar agar bisa mendiagnosis masalah, memperkirakan biaya, dan membangun aplikasi yang robust.

Mengapa episode ini penting? Karena hampir semua produk AI dibangun di atas satu pola yang sama: kirim pesan → terima jawaban → olah hasil. Memahami pola ini secara mendalam — token, konteks, streaming — adalah fondasi yang dipakai ulang di 25 episode ke depan.

#Tokenization: Bahasa yang Dipahami Model

Model tidak membaca teks karakter demi karakter, melainkan token — potongan teks (kata atau sub-kata). Token penting karena tiga alasan: harga API dihitung per token, context window dihitung per token, dan hasil output juga dihitung per token.

Hitung token dengan tiktoken

import tiktoken
 
enc = tiktoken.encoding_for_model("gpt-4o")
tokens = enc.encode("Halo, ini contoh kalimat untuk menghitung token.")
print(f"jumlah token: {len(tokens)}")
print(tokens)

Perhatikan: satu kalimat pendek bisa menjadi puluhan token, dan token bukan kata — kata langka atau istilah teknis sering dipecah jadi beberapa token. Ini menjelaskan mengapa biaya dokumen teknis sering lebih mahal dari perkiraan.

#Context Window: Batas Ingatan Model

Context window adalah jumlah token maksimum yang bisa diproses model sekaligus — gabungan input dan output. Model 2026 umumnya punya konteks 128K-200K token, tapi ada tiga peringatan penting:

1. Biaya: mengirim konteks 100K token mahal, apalagi per request berulang.
2. Perhatian menurun: model sering "kehilangan fokus" pada isi di tengah konteks yang sangat panjang (fenomena lost in the middle).
3. Output ikut terhitung: jika model punya konteks 128K dan output memakan 4K, sisa ruang untuk input hanya 124K.

Konsekuensi praktisnya: jangan isi konteks dengan semua data. Strategi mengelola konteks inilah yang kita bahas mendalam di episode 8 (Context Engineering) — dan alasan mengapa RAG (episode 7) ada.

#Struktur API: Request dan Response

Semua LLM API modern mengikuti pola chat completion yang sama. Struktur dasarnya:

{
  "model": "gpt-4o-mini",
  "messages": [
    { "role": "system", "content": "Kamu asisten yang ringkas." },
    { "role": "user", "content": "Apa itu token?" },
    { "role": "assistant", "content": "Token adalah potongan teks yang dipahami model." },
    { "role": "user", "content": "Jelaskan lebih singkat." }
  ],
  "temperature": 0.3,
  "max_tokens": 200
}

Tiga hal yang perlu dicermati:

• messages: daftar riwayat percakapan. Hanya system yang boleh diulang-ulang tanpa biaya percakapan; user/assistant adalah konteks.
• temperature: mengontrol keacakan — rendah untuk faktual, tinggi untuk kreatif.
• max_tokens: batas output; ini juga pelindung biaya agar model tidak "ngoceh" tanpa batas.

Response standar berisi choices[0].message.content (isi jawaban) dan usage (rincian token prompt/completion untuk kalkulasi biaya). Selalu baca usage di lingkungan produksi — itulah sumber data cost tracking di episode 17.

#Streaming: Jawaban Token demi Token

Untuk pengalaman pengguna yang responsif — terutama di chatbot — gunakan streaming agar jawaban tampil bertahap:

Streaming response

from openai import OpenAI
 
client = OpenAI()
 
stream = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "Ceritakan sejarah singkat AI dalam 3 kalimat."}],
    stream=True,
)
 
for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)
print()

Streaming juga memungkinkan kalian membatalkan response lebih awal (jika user menekan stop) tanpa membayar token penuh. Di episode 16 kita implementasikan streaming yang benar di backend FastAPI.

#Membangun Aplikasi Pertama

Saatnya menggabungkan semuanya — aplikasi CLI tanya-jawab dengan riwayat percakapan:

app.py - chatbot CLI sederhana

from openai import OpenAI
 
client = OpenAI()
SYSTEM = "Kamu adalah asisten yang ringkas dan faktual."
 
def chat(messages: list[dict]) -> str:
    r = client.chat.completions.create(
        model="gpt-4o-mini", messages=messages, temperature=0.3
    )
    return r.choices[0].message.content
 
def main() -> None:
    messages: list[dict] = [{"role": "system", "content": SYSTEM}]
    print("Ketik 'exit' untuk keluar.")
    while True:
        user = input("\nKamu: ")
        if user.lower() == "exit":
            break
        messages.append({"role": "user", "content": user})
        reply = chat(messages)
        print(f"\nAsisten: {reply}")
        messages.append({"role": "assistant", "content": reply})
 
if __name__ == "__main__":
    main()

Jalankan dengan python app.py. Perhatikan bahwa riwayat percakapan dikirim penuh setiap kali — ini pola paling sederhana, dan kita optimalkan di episode 12 (memory & state).

#Common Pitfalls

• Melupakan usage: tanpa mencatat token, kalian tidak tahu biaya dan tidak bisa mengoptimasi.
• Temperature default terlalu tinggi: untuk task faktual, temperature 0-0.3 jauh lebih konsisten.
• Mengirim seluruh dokumen ke konteks: murah dan akurat justru dicapai dengan retrieval, bukan memasukkan semuanya.
• Tanpa error handling: rate limit (429) dan timeout (500) adalah kenyataan produksi. Episode 25 membahas retry dan fallback.

#Penutup

Inti yang harus dibawa pulang:

• Token menentukan harga dan batas konteks; hitung dengan tiktoken.
• Context window adalah batas input+output — jangan diisi boros.
• Struktur API: messages + temperature + max_tokens; selalu baca usage.
• Streaming meningkatkan UX dan memungkinkan cancel dini.

Di episode 4 selanjutnya kita akan membahas prompt engineering dasar — system/user/assistant roles, zero-shot vs few-shot, iterasi prompt, dan cara menulis prompt yang konsisten dan hemat token. Sampai jumpa di episode 4!