AI Prompt Engineering · Pelajaran

Melampaui RAG Naif

Keterbatasan pengambilan dasar.

Melampaui RAG Naif adalah pelajaran AI Prompt Engineering gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar AI Prompt Engineering, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus AI Prompt Engineering mencakup 4 pelajaran total.

Cara Kerja RAG Naif

RAG Naif adalah dasar pembanding: bagi dokumen menjadi potongan, buat embedding, simpan vektor, buat embedding untuk kueri, ambil k teratas berdasarkan kemiripan kosinus, masukkan potongan ke dalam prompt, lalu hasilkan jawaban. Ini merupakan titik awal yang kuat dan mengalami kegagalan yang dapat diprediksi pada skala besar.

Memahami mode kegagalan tersebut merupakan prasyarat untuk teknik lanjutan (pemeringkatan ulang, kompresi, penulisan ulang kueri) yang dibahas dalam kursus ini.

def naive_rag(query, k=5):
    q = embed(query)
    chunks = vector_store.search(q, k)        # top-k by cosine
    context = '\n\n'.join(c.text for c in chunks)
    return llm('Context:\n' + context + '\n\nQ: ' + query)

Perolehan Kembali versus Presisi

Top-k naif mengoptimalkan kemiripan vektor mentah, yang mencampuradukkan relevansi dengan kedekatan semantik permukaan. Anda menghadapi pertukaran: nilai k kecil berisiko melewatkan jawaban (perolehan kembali rendah); nilai k besar membanjiri konteks dengan pengalih perhatian (presisi rendah).

Kemiripan embedding yang mendorong pengambilan hanyalah pendekatan kasar terhadap relevansi sebenarnya, dan menjadi akar dari beberapa masalah lanjutan.

# The core dilemma
# small k -> may miss the gold chunk (recall problem)
# large k -> distractors crowd context (precision + cost problem)
# Advanced RAG decouples 'retrieve many' from 'use few'

Masalah Ketidakcocokan Embedding

Kueri dan dokumen sering berada dalam ragam bahasa yang berbeda: pertanyaan singkat dibandingkan dengan bagian panjang yang bersifat deklaratif. Embedding bi-encoder dapat menempatkan jawaban yang relevan jauh dari pertanyaan karena keduanya dirumuskan secara berbeda (masalah ketidakcocokan kosakata).

Hal ini mendorong teknik seperti penulisan ulang kueri dan HyDE yang mengubah bentuk kueri agar sesuai dengan ruang dokumen sebelum pengambilan.

# Query:  'how do I revoke a token?'
# Doc:    'Token invalidation is performed via the /sessions endpoint.'
# Lexically and semantically distant -> bi-encoder may miss it
sim = cos(embed('how do I revoke a token?'),
          embed('Token invalidation via /sessions'))  # may be low

Hilang di Tengah

Bahkan ketika potongan yang tepat berhasil diambil, memasukkan banyak potongan memicu efek hilang di tengah: model kurang memperhatikan konten yang ditempatkan di tengah konteks yang panjang. Potongan yang benar dan berada pada peringkat 3 dari 10 mungkin pada praktiknya diabaikan.

Hal ini mendorong pemeringkatan ulang (menempatkan potongan terbaik di lokasi yang diperhatikan model) dan kompresi (menyusutkan konteks agar tidak ada bagian yang terkubur).

# Retrieval rank != attention rank
# Place the highest-relevance chunk at the START or END,
# never stranded in the middle of a large concatenation.

Sensitivitas terhadap Pengalih Perhatian

LLM sensitif terhadap konteks yang tidak relevan. Menambahkan potongan yang masuk akal tetapi salah dapat mengarahkan jawaban ke jalur yang keliru, bahkan ketika potongan yang benar juga tersedia. Lebih banyak konteks tidak selalu lebih baik.

Inilah alasan presisi penting: konteks yang ringkas, diperingkat ulang, dan dikompresi sering kali mengungguli kumpulan besar potongan yang hanya berkaitan secara longgar.

# Empirically: appending a single highly-similar but WRONG chunk
# can flip a previously-correct answer. RAG quality depends on
# keeping distractors OUT, not just getting the gold chunk IN.

Masalah Pemotongan Dokumen

Pemotongan berukuran tetap membagi ide di tengah kalimat, memisahkan klaim dari buktinya, dan menghilangkan konteks struktural (bagian mana, dokumen mana). Potongan yang terbaca secara koheren jika berdiri sendiri dapat menjadi tidak berguna atau menyesatkan tanpa konteks di sekitarnya.

Pipeline lanjutan menggunakan pemotongan yang sadar struktur, tumpang tindih, perluasan dokumen induk, dan metadata untuk mempertahankan makna.

def structure_aware_chunks(doc, max_tokens=400, overlap=50):
    sections = split_by_headings(doc)        # respect document structure
    chunks = []
    for sec in sections:
        for c in sliding_window(sec.text, max_tokens, overlap):
            chunks.append(Chunk(c, meta={'section': sec.title}))
    return chunks

Kesenjangan Pengambilan Semantik Saja

Pengambilan padat murni melewatkan kebutuhan pencocokan tepat: pengenal, kode kesalahan, nama khusus yang langka, dan nama API. Hal-hal inilah yang menuntut ketepatan harfiah dari pengguna. Pengambilan hibrida menggabungkan sinyal padat (semantik) dan renggang (BM25/kata kunci) untuk mencakup keduanya.

Penggabungan peringkat timbal balik adalah cara sederhana dan tangguh untuk menggabungkan dua daftar berperingkat tanpa menyesuaikan bobot.

def rrf(dense_ranks, sparse_ranks, k0=60):
    scores = {}
    for ranks in (dense_ranks, sparse_ranks):
        for rank, doc_id in enumerate(ranks):
            scores[doc_id] = scores.get(doc_id, 0) + 1.0 / (k0 + rank)
    return sorted(scores, key=scores.get, reverse=True)

Konteks Kedaluwarsa dan Tidak Dapat Diverifikasi

RAG naif tidak memiliki konsep kesegaran atau asal-usul. RAG naif dapat mengambil dokumen yang sudah usang dan tidak menyediakan cara bawaan untuk mengaitkan klaim dengan sumber, sehingga mengurangi kepercayaan dan menyulitkan pendeteksian halusinasi.

Sistem lanjutan melampirkan metadata (stempel waktu, sumber, versi), memfilternya, dan mengharuskan penghasil jawaban mencantumkan ID potongan agar jawaban dapat diverifikasi.

def filtered_retrieve(q, after_date):
    cands = vector_store.search(embed(q), k=50)
    fresh = [c for c in cands if c.meta['date'] >= after_date]
    return fresh  # then re-rank; generator must cite c.id

Tanpa Umpan Balik, Tanpa Adaptasi

RAG naif mengambil secara membabi buta: RAG naif tidak dapat mengetahui ketika pengambilan gagal, tidak dapat memutuskan bahwa tidak ada pengambilan yang diperlukan, dan tidak dapat mengulangi proses. Pola lanjutan menambahkan pemeriksaan relevansi, pengambilan kondisional, dan pengambilan multi-langkah (berbasis agen) yang merumuskan ulang kueri ketika hasilnya tampak lemah.

Pipeline berubah menjadi perulangan dengan penilaian mandiri, bukan satu lintasan maju.

def adaptive_rag(q):
    chunks = retrieve(q)
    if relevance_score(q, chunks) < 0.4:
        q2 = rewrite_query(q)            # reformulate and retry
        chunks = retrieve(q2)
    if relevance_score(q, chunks) < 0.4:
        return 'I could not find this in the sources.'
    return generate(q, chunks)

Susunan RAG Lanjutan

Jika berbagai kegagalan tersebut disatukan, pipeline lanjutan terdiri atas beberapa lapisan: pemotongan yang sadar struktur dengan metadata, pengambilan hibrida dengan perolehan kembali tinggi, pemeringkat ulang cross-encoder untuk presisi, kompresi konteks agar muat dan lebih terfokus, penulisan ulang kueri / HyDE untuk memperbaiki ketidakcocokan, serta gerbang relevansi dengan sitasi.

Pelajaran berikutnya membangun setiap lapisan. Benang merahnya: ambil secara luas, lalu filter dan sempurnakan secara agresif.

def advanced_rag(q):
    cands = hybrid_retrieve(rewrite_query(q), k=50)  # high recall
    top = rerank(q, cands)[:8]                       # precision
    ctx = compress(q, top)                            # focus + fit
    return generate_with_citations(q, ctx)            # verifiable

Ukur Sebelum Mengoptimalkan

Diagnosis kegagalan yang sebenarnya terjadi sebelum menambahkan berbagai mekanisme. Ukur recall@k pengambilan (apakah potongan acuan berhasil diambil) secara terpisah dari akurasi jawaban (apakah penghasil jawaban menggunakannya). Masalah perolehan kembali dan masalah presisi memerlukan perbaikan yang berbeda.

Lengkapi kedua bagian dengan instrumentasi; jangan menambahkan pemeringkat ulang jika masalah sebenarnya adalah pemotongan atau ketidakcocokan kueri.

def diagnose(eval_set):
    return {
        'recall@5':  recall_at_k(eval_set, k=5),     # retrieval health
        'recall@50': recall_at_k(eval_set, k=50),    # ceiling with rerank
        'answer_acc': answer_accuracy(eval_set),      # generation health
    }

Pemeriksaan Singkat

Diagnosis mode kegagalan RAG.

Rangkuman

Inti pembelajaran:

RAG naif (memotong, membuat embedding, top-k, memasukkan, menghasilkan) adalah dasar pembanding yang kuat dengan kegagalan yang dapat diprediksi.
Kemiripan bi-encoder merupakan pendekatan kasar terhadap relevansi; ketidakcocokan ragam bahasa kueri dan dokumen menurunkan perolehan kembali.
Lebih banyak konteks tidak selalu lebih baik: sensitivitas terhadap pengalih perhatian dan efek hilang di tengah menurunkan kualitas jawaban saat k bertambah.
Masalah pemotongan, kesenjangan semantik saja, keusangan, dan ketiadaan umpan balik semuanya membatasi RAG naif.
RAG lanjutan mengambil secara luas lalu memfilter: pengambilan hibrida, pemeringkatan ulang, kompresi, penulisan ulang kueri, dan penggerbangan relevansi. Ukur perolehan kembali dan akurasi jawaban secara terpisah sebelum mengoptimalkan.

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Melampaui RAG Naif” gratis?

Ya — teks lengkap “Melampaui RAG Naif” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus AI Prompt Engineering, upgrade ke CoddyKit PRO. Kursus AI Prompt Engineering mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Melampaui RAG Naif”?

Keterbatasan pengambilan dasar. Kamu berlatih AI Prompt Engineering dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai AI Prompt Engineering?

Tidak diperlukan pengalaman sebelumnya. AI Prompt Engineering di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Melampaui RAG Naif” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran AI Prompt Engineering ini?

Ya. Setiap pelajaran AI Prompt Engineering menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

← Kembali ke AI Prompt Engineering