Belajar Generative AI - Prompt Engineering Dasar

#Pendahuluan

Setelah di episode 2 kalian memahami bahwa LLM hanyalah mesin next-token prediction, muncul pertanyaan kunci: bagaimana mengarahkan mesin itu agar menghasilkan output yang benar dan konsisten? Jawabannya adalah prompt engineering — dan episode ini adalah fondasinya.

Mengapa ini penting di dunia kerja? Karena kualitas aplikasi AI sangat ditentukan oleh kualitas prompt: prompt yang buruk menghasilkan output yang buruk, dan output yang buruk di produksi berarti bug, tagihan API membengkak (retry), dan pengalaman pengguna yang jelek. Prompt engineering adalah skill yang paling sering dipakai sehari-hari oleh AI Engineer — sebelum masuk ke arsitektur rumit seperti RAG atau agents.

#System Role, User Role, dan Prinsip Dasar

Model melihat percakapan sebagai daftar pesan berperan. Dua peran yang paling penting:

• system: instruksi tetap yang mengatur kepribadian, format, dan batasan model. Berisi "kontrak kerja" yang berlaku untuk seluruh percakapan.
• user: permintaan spesifik dari pengguna (atau aplikasi).

from openai import OpenAI
 
client = OpenAI()
 
resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system",
         "content": "Kamu adalah asisten ringkas berbahasa Indonesia. "
                    "Jawab maksimal 2 kalimat. Jangan pernah mengulang pertanyaan."},
        {"role": "user",
         "content": "Apa itu vector database?"},
    ],
)
print(resp.choices[0].message.content)

Prinsip dasar prompt yang baik:

1. Spesifik dan eksplisit: "ringkas 3 poin" lebih baik daripada "ringkas".
2. Beri konteks: untuk apa output ini dipakai.
3. Tentukan format: bullet, JSON, tabel — model akan mengikutinya.
4. Satu instruksi fokus per prompt untuk task sederhana.

#Few-Shot Prompting

Alih-alih menjelaskan aturan abstrak, berikan contoh (few-shot). Model sangat pandai meniru pola dari contoh. Semakin dekat contoh dengan kasus nyata, semakin baik hasilnya.

messages = [
    {"role": "system", "content": "Klasifikasikan sentimen menjadi POSITIF/NEGATIF/NEUTRAL."},
    {"role": "user", "content": "Aplikasi baru kami sangat lambat."},
    {"role": "assistant", "content": "NEGATIF"},
    {"role": "user", "content": "Fitur streaming-nya keren sekali!"},
    {"role": "assistant", "content": "POSITIF"},
    {"role": "user", "content": "Ada update di sore hari."},
    {"role": "assistant", "content": "NEUTRAL"},
    {"role": "user", "content": "Harga langganan naik dua kali lipat tahun ini."},
]

Perhatikan pola user → assistant berulang: itulah cara menyisipkan contoh ke dalam percakapan. Untuk task klasifikasi, 2-5 contoh biasanya sudah cukup dan jauh lebih hemat token daripada aturan panjang.

#Chain-of-Thought (CoT)

Untuk task yang butuh penalaran (aritmatika, logika, jawaban multi-langkah), minta model berpikir selangkah demi selangkah sebelum menjawab. Ini disebut chain-of-thought — salah satu temuan prompt engineering paling berpengaruh, dan merupakan cikal bakal reasoning models yang kita bahas di episode 19.

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {"role": "system",
         "content": "Selesaikan dengan langkah-langkah. Tuliskan proses berpikirmu, "
                    "lalu beri jawaban akhir di baris terakhir dengan format: JAWABAN: ..."},
        {"role": "user",
         "content": "Sebuah toko menjual 3 buku seharga 25 ribu per buku "
                    "dan 2 pena seharga 5 ribu per pena. Berapa totalnya?"},
    ],
)
print(resp.choices[0].message.content)

Perbedaan dramatis: tanpa CoT, model sering menjawab langsung dan salah (misal lupa salah satu item); dengan CoT, ia menyusun 75 + 10 = 85 secara eksplisit. Catatan: di produksi, gunakan CoT hanya jika butuh — ia memakan token dan latency (mengapa, dijelaskan di episode 4 dan 21).

#Structured Output

Untuk integrasi dengan aplikasi (backend, database), output bebas teks adalah musuh. Solusinya structured output: minta model menghasilkan JSON yang sesuai skema. Di episode 5 kita pakai mekanisme native (JSON schema), tapi pola prompt-nya bisa dikuasai sekarang:

resp = client.chat.completions.create(
    model="gpt-4o-mini",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system",
         "content": "Keluar hanya JSON valid dengan kunci: title, summary, tags."},
        {"role": "user",
         "content": "Ringkas artikel tentang RAG berikut: "
                    "RAG menggabungkan retrieval dan generation..."},
    ],
)
import json
data = json.loads(resp.choices[0].message.content)
print(data["title"], "|", data["tags"])

Dengan response_format={"type": "json_object"} dan instruksi JSON di system prompt, output dijamin bisa di-parse — ini pola wajib untuk API yang dikonsumsi aplikasi.

#Praktik: Tiga Task Nyata

#1. Summarization

def summarize(text, max_points=3):
    r = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "system",
                   "content": f"Ringkas menjadi {max_points} poin. "
                              "Gunakan bahasa Indonesia, format bullet."},
                  {"role": "user", "content": text}],
    )
    return r.choices[0].message.content

#2. Extraction

def extract_entities(text):
    r = client.chat.completions.create(
        model="gpt-4o-mini",
        response_format={"type": "json_object"},
        messages=[{"role": "system",
                   "content": "Ekstrak orang, organisasi, lokasi, tanggal. "
                              "Output JSON: {people, orgs, locations, dates}"},
                  {"role": "user", "content": text}],
    )
    return json.loads(r.choices[0].message.content)

#3. Code Generation

def gen_code(instruction):
    r = client.chat.completions.create(
        model="gpt-4o-mini",
        messages=[{"role": "system",
                   "content": "Tulis Python yang benar. Sertakan docstring, "
                              "tanpa penjelasan panjang di luar kode."},
                  {"role": "user", "content": instruction}],
    )
    return r.choices[0].message.content

#Common Pitfalls

• Prompt terlalu panjang tapi tidak spesifik: banyak kalimat sopan, sedikit instruksi operasional. Singkat dan eksplisit biasanya lebih baik.
• Tidak menentukan format output: output bebas → parsing gagal. Selalu tentukan format.
• Few-shot dengan contoh yang saling bertentangan: contoh tidak konsisten justru mengacaukan model.
• Menaruh instruksi di user sementara system kosong: gunakan system untuk aturan tetap, user untuk data per-permintaan.

#Penutup

Inti yang harus dibawa pulang:

• system role untuk aturan tetap, user role untuk permintaan spesifik.
• Few-shot = beri contoh pola; CoT = minta berpikir bertahap; structured output = paksa JSON.
• Tiga task dasar — summarization, extraction, code generation — punya pola prompt masing-masing.
• Kualitas prompt menentukan kualitas aplikasi, biaya, dan pengalaman pengguna.

Di episode 4 selanjutnya kita akan naik level ke Prompt Engineering Lanjutan & Model Selection — prompt chaining, meta-prompting, evaluasi prompt (LLM-as-judge, golden set), lalu bagaimana memilih model berdasarkan task, cost, latency, dan context window. Sampai jumpa di episode 4!