Belajar Generative AI - Prompt Engineering Lanjutan & Model Selection

#Pendahuluan

Setelah di episode 3 kalian menguasai fondasi prompt engineering — role, few-shot, CoT, structured output — episode ini menjawab dua pertanyaan yang muncul begitu aplikasi mulai serius: bagaimana mengelola prompt yang kompleks dan model mana yang harus dipakai. Keduanya adalah keputusan engineering, bukan sekadar keterampilan mengetik.

Mengapa penting? Di produksi, satu prompt tunggal sering tidak cukup — workflow nyata terdiri dari banyak langkah yang saling terkait. Dan kesalahan memilih model bisa berarti selisih biaya puluhan kali lipat untuk hasil yang sama. Episode ini membekali kalian kerangka berpikir untuk keduanya.

#Prompt Chaining: Memecah Task Besar

Alih-alih satu prompt raksasa yang menangani semuanya (dan sering gagal), pecah task menjadi rantai langkah kecil. Setiap langkah mengonsumsi output langkah sebelumnya.

from openai import OpenAI
 
client = OpenAI()
 
def call(system, user, fmt=None):
    kwargs = {"response_format": fmt} if fmt else {}
    r = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "system", "content": system},
                  {"role": "user", "content": user}],
        **kwargs,
    )
    return r.choices[0].message.content
 
transcript = "Hari ini kita membahas roadmap Q3. Fokus utama: migrasi database, ..."
 
# Langkah 1: transkrip → ringkasan kasar
summary = call(
    "Ringkas transkrip menjadi 3 kalimat.",
    transcript,
)
 
# Langkah 2: ringkasan → keputusan terstruktur
decisions = call(
    "Ekstrak keputusan & pemilik tugas dari ringkasan. Output JSON.",
    summary,
    fmt={"type": "json_object"},
)
print(decisions)

Keunggulan chaining: tiap langkah punya prompt kecil yang mudah di-debug dan dievaluasi, output antar-langkah bisa dipakai sebagai log, dan kalian bisa menyisipkan validasi (misal cek format) di tengah rantai. Trade-off: lebih banyak request → biaya dan latency lebih tinggi. Detail optimasi dibahas di episode 21.

#Meta-Prompting: Meminta Prompt yang Baik

Meta-prompting adalah teknik meminta model menyusun prompt yang baik untuk sebuah task, alih-alih menulisnya sendiri. Berguna saat kalian tidak yakin prompt terbaik untuk task baru, atau saat ingin menstandarkan pola internal.

meta = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "system",
               "content": "Kamu adalah ahli prompt engineering. Hasilkan prompt "
                          "system singkat untuk task yang diminta, sertakan contoh format output."},
              {"role": "user",
               "content": "Buat prompt untuk menilai kualitas jawaban RAG "
                          "dalam skala 1-5 dengan alasan."}],
)
print(meta.choices[0].message.content)

Meta-prompting juga jadi dasar teknik self-refine dan LLM-as-judge (di bawah) — model yang dievaluasi bisa sekaligus mengevaluasi.

#Evaluasi Prompt: LLM-as-Judge & Golden Set

Prompt tidak "selesai" setelah ditulis — ia harus dievaluasi agar perubahannya bisa diukur. Dua alat utamanya:

#Golden Set

Kumpulan contoh (input → output yang diharapkan) yang di-review manusia. Setiap kali prompt/versi model berubah, jalankan golden set dan bandingkan hasilnya. Ini adalah regression test untuk prompt.

[
  {"input": "Ringkas artikel tentang RAG", "expected_keywords": ["retrieval", "generation"]},
  {"input": "Ekstrak nama orang dari teks", "expected_keywords": ["Budi", "Siti"]},
  {"input": "Buat JSON order", "expected_keywords": ["total", "items"]}
]

#LLM-as-Judge

Karena label manusia mahal, gunakan model lain untuk menilai output — misal GPT-4o menilai output GPT-4o-mini. Aturannya: beri kriteria jelas, minta skor + alasan, dan selalu validasi judge dengan sampel yang dinilai manusia (bias bisa menyelinap).

judge = client.chat.completions.create(
    model="gpt-4o-mini",
    response_format={"type": "json_object"},
    messages=[{"role": "system",
               "content": "Nilai jawaban berikut untuk pertanyaan RAG. "
                          "Skor 1-5 berdasarkan: keterkaitan (relevansi), "
                          "kebenaran (groundedness), kelengkapan. "
                          "Output JSON: {score, reason}"},
              {"role": "user",
               "content": f"Pertanyaan: {question}\nJawaban: {answer}\n"
                          f"Konteks: {context}"}],
)
print(judge.choices[0].message.content)

Pola evaluasi ini kita perdalam di episode 15 (Evaluasi LLM & LLMOps) dengan framework seperti RAGAS dan DeepEval — mulai dari sini, biasakan setiap perubahan prompt diukur, bukan ditebak.

#Model Selection: Memilih Model yang Tepat

Tidak ada "model terbaik" — yang ada adalah model terbaik untuk task, budget, dan kebutuhan kalian. Empat dimensi yang dievaluasi:

#Context Window: Angka Paling Sering Salah Diinterpretasi

Context window (misal 128K token) adalah kapasitas input + output model dalam satu request — bukan "dokumen sebesar itu bisa diproses dengan baik". Performa model menurun drastis pada isian tengah jendela konteks (lost-in-the-middle). Konsekuensi praktisnya: untuk dokumen panjang, gunakan RAG (episode 7) atau map-reduce chunking, bukan sekadar memasukkan semuanya.

#Strategi Routing

Kombinasikan beberapa model untuk biaya optimal:

• Model kecil (gpt-4o-mini, gemini-2.0-flash) untuk task rutin: klasifikasi, ekstraksi, ringkasan.
• Model besar (gpt-4o, claude-4-sonnet) untuk task kompleks: kode, reasoning, penulisan.
• Reasoning model (o-series, R1) hanya untuk soal yang benar-benar butuh penalaran mendalam — ia membakar token.

def route(task_type: str) -> str:
    if task_type in {"extraction", "classification"}:
        return "gpt-4o-mini"
    if task_type in {"codegen", "reasoning"}:
        return "gpt-4o"
    return "gpt-4o-mini"

Pola routing dan caching yang lebih canggih kita bahas di episode 21 (Cost Optimization & Scaling).

#Penutup

Inti yang harus dibawa pulang:

• Prompt chaining memecah task kompleks jadi langkah kecil yang mudah di-debug.
• Meta-prompting meminta model menyusun prompt untuk kita.
• Evaluasi dengan golden set dan LLM-as-judge; selalu ukur perubahan prompt.
• Model selection = trade-off task, cost, latency, context window; mulai dengan model kecil, naik hanya jika perlu.

Di episode 5 selanjutnya kita akan masuk ke API Integration & Structured Output — OpenAI-compatible API, streaming, function/tool calling, dan JSON schema — lalu mengintegrasikan LLM ke aplikasi web (FastAPI/Next.js) dengan streaming UI. Sampai jumpa di episode 5!