Belajar Generative AI - Advanced RAG & Reasoning Models

#Pendahuluan

Dua tren besar kita kenali di episode 1: reasoning models dan agentic RAG. Episode ini memenuhi janji itu dengan membedah keduanya secara teknis. Setelah kalian menguasai RAG dasar (episode 7-8) dan agent (episode 10), sekarang saatnya menggabungkannya — dan memahami paradigma baru di mana model "menghabiskan waktu berpikir" sebelum menjawab.

Mengapa penting di 2026? Karena aplikasi produksi yang menangani pertanyaan sulit tidak lagi cukup dengan satu-shot retrieval. Ada pertanyaan yang butuh beberapa putaran pencarian, verifikasi silang, dan penalaran bertingkat. Reasoning models mengubah keseimbangan antara parameter dan compute — dan kalian perlu tahu kapan memakainya.

#Reasoning Models: Berpikir Sebelum Menjawab

Sejak episode 2 kita tahu LLM memprediksi token berikutnya. Reasoning models menambahkan satu langkah: sebelum jawaban final, model menghasilkan rantai thinking tokens internal — mengeksplorasi pendekatan, memeriksa, mengoreksi diri. Dua hal yang membedakannya:

• Inference-time scaling: semakin banyak "waktu berpikir" (compute), semakin baik hasil — menggantikan sebagian scaling parameter.
• Chain-of-thought yang dilatih: bukan sekadar prompt "berpikir bertahap" (episode 3), tetapi perilaku berpikir yang dilatih dengan reinforcement learning.

Contoh produk: OpenAI o-series, DeepSeek-R1, Gemini 2.x thinking mode, Claude extended thinking.

resp = client.chat.completions.create(
    model="gpt-5-mini",          # reasoning-capable model
    reasoning_effort="medium",   # low / medium / high
    messages=[{"role": "user",
               "content": "Dua kereta berangkat dari kota yang sama. Kereta A "
                          "60 km/jam pukul 8, kereta B 90 km/jam pukul 9. "
                          "Kapan B menyusul A?"}],
)
print(resp.choices[0].message.content)

Kunci penggunaannya di produksi:

• reasoning_effort = dial "seberapa banyak berpikir" → sebanding biaya & latency. Mulai rendah, naikkan hanya jika jawaban kurang akurat.
• Reasoning token dikenakan biaya dan menambah latency (detik, bukan milidetik) — jangan dipakai untuk task trivial.
• Output reasoning biasanya disembunyikan atau ditampilkan sebagai "langkah berpikir" — desain UI mempertimbangkan ini.

#Kapan Memakai Reasoning Model: Trade-off

Aturan praktis: routing (episode 4) — arahkan pertanyaan sulit ke reasoning model, sisanya ke model murah. Ini topik yang sama kita optimalkan di episode 21.

#Advanced RAG: Dari Statis Menjadi Adaptif

RAG klasik (episode 7) statis: retrieve → generate, sekali. RAG lanjutan 2026 menambahkan umpan balik ke dalam loop. Tiga pola utamanya:

#1. Agentic RAG

Agentic RAG meletakkan retrieval di dalam agent loop (episode 10): model memutuskan kapan mencari, query apa, apakah hasilnya cukup, atau perlu cari lagi. Ini mengatasi pertanyaan yang butuh beberapa pencarian dengan sudut berbeda.

def agentic_rag(question):
    # LangGraph: node retrieve → node answer → conditional edge
    # model bisa memutuskan "retrieve lagi" jika jawaban belum lengkap
    state = {"question": question, "retrievals": 0}
    while state["retrievals"] < 3:
        docs = retrieve(state["question"])
        verdict = judge_sufficiency(question, docs)
        if verdict["sufficient"]:
            return generate(question, docs)
        state["question"] = verdict["refined_query"]   # perbaiki query
        state["retrievals"] += 1
    return generate(question, retrieve(question))      # fallback

#2. Adaptive Retrieval

Daripada selalu retrieve, sistem memutuskan kapan retrieval diperlukan:

• Pertanyaan faktual umum → langsung jawab tanpa retrieval (hemat biaya).
• Pertanyaan dengan istilah domain / data privat → retrieve.
• Klasifikasinya bisa LLM-as-judge sederhana atau model klasifikasi terpisah.

#3. Self-Critique & Self-Refine

Setelah jawaban dibuat, model menilai jawabannya sendiri terhadap konteks, lalu memperbaiki bila perlu:

def self_refine(question, docs):
    answer = generate(question, docs)
 
    critique = client.chat.completions.create(
        model="gpt-4o-mini",
        response_format={"type": "json_object"},
        messages=[{"role": "system",
                   "content": "Temukan bagian jawaban yang tidak didukung konteks "
                              "atau tidak menjawab pertanyaan. Output JSON: "
                              "{issues: [...], needs_revision: bool}"},
                  {"role": "user",
                   "content": f"Pertanyaan: {question}\nKonteks: {docs}\nJawaban: {answer}"}],
    ).choices[0].message.content
 
    verdict = json.loads(critique)
    if verdict["needs_revision"]:
        # loop maksimal 2x; gabungkan kritik ke prompt revisi
        answer = generate(question, docs, critique=str(verdict["issues"]))
    return answer

Self-refine bukan jaminan kebenaran (kritik juga bisa salah), tapi nyata menaikkan skor faithfulness pada banyak benchmark.

#Hybrid Reasoning + RAG: Pola Produksi 2026

Gabungan yang sering dipakai di produksi untuk pertanyaan kompleks:

Alur ini menggabungkan keempat pelajaran: routing (episode 4), RAG (7-8), agent (10), reasoning (episode ini). Hasilnya: biaya efisien, jawaban grounded, dan penalaran untuk kasus sulit.

#Common Pitfalls

• Memakai reasoning model untuk semua request — biaya & latency meledak tanpa manfaat.
• Menganggap reasoning = anti-hallucination — grounding tetap wajib untuk fakta.
• Agentic RAG tanpa batas retrieval — query loop tak berujung; selalu set batas (max 3-5 retrieval).
• Self-refine tanpa verifikasi eksternal — kritik diri bisa berputar-putar; batasi iterasi & ukur dengan evaluasi (episode 15).

#Penutup

Inti yang harus dibawa pulang:

• Reasoning models = inference-time scaling via chain-of-thought; kontrol dengan reasoning_effort; untuk soal penalaran, bukan fakta.
• Agentic RAG = retrieval sebagai keputusan model (query refine, batas putaran).
• Adaptive retrieval & self-critique menaikkan kualitas & efisiensi.
• Pola produksi 2026: routing → RAG/reasoning → verifikasi.

Di episode 20 selanjutnya kita akan membangun Multi-Agent Systems — orkestrasi dengan LangGraph, CrewAI, dan AutoGen; peran planner/executor/verifier; human-in-the-loop; dan praktik sistem agent untuk research & automation workflow. Sampai jumpa di episode 20!