Apa keuntungan utama LongRAG dibandingkan RAG standar?

LongRAG unggul dalam menangani dokumen panjang dengan memproses seluruh dokumen atau potongan besar sebagai konteks, mengurangi fragmentasi informasi dan mempertahankan koherensi semantik yang lebih baik dalam ketergantungan jangka panjang. Pendekatan ini terutama efektif saat menggunakan LLM dengan jendela konteks yang diperpanjang (32K+ token).

Bagaimana Self-RAG meningkatkan kualitas pencarian?

Self-RAG memperkenalkan mekanisme refleksi diri yang memungkinkan model untuk mengkritik proses pencarian dan pembuatannya sendiri. Model dapat memutuskan kapan harus mencari informasi, mengevaluasi relevansi dokumen yang ditemukan, serta menilai kualitas respons yang dihasilkan, sehingga menghasilkan output yang lebih akurat dan dapat dipercaya.

Kapan saya sebaiknya menggunakan GraphRAG dibandingkan RAG tradisional?

GraphRAG sangat ideal untuk domain dengan hubungan kompleks antar entitas, seperti kertas penelitian, dokumen hukum, atau basis pengetahuan. Ia unggul dalam menangani pertanyaan yang memerlukan pemahaman tentang koneksi antar entitas, hubungan temporal, atau struktur hierarkis yang tidak dapat ditangkap secara efektif oleh kesamaan vektor standar.

Dapatkah variasi RAG ini dikombinasikan?

Ya, pendekatan hybrid semakin umum. Anda dapat menggabungkan representasi pengetahuan terstruktur GraphRAG dengan mekanisme refleksi Self-RAG, atau menggunakan strategi chunking LongRAG dengan pencarian berbasis graf. Kuncinya adalah menyesuaikan kombinasi tersebut dengan kebutuhan spesifik dan batasan komputasi Anda.

Apa saja biaya komputasi dari variasi RAG canggih ini?

GraphRAG biasanya memiliki biaya indeks yang lebih tinggi karena ekstraksi entitas dan konstruksi graf, tetapi waktu kueri dapat sebanding dengan RAG standar. Self-RAG menambahkan beban dari langkah refleksi (20-40% peningkatan waktu inferensi). LongRAG memerlukan model dengan jendela konteks besar, yang meningkatkan penggunaan memori dan latensi inferensi.

Advanced RAG: LongRAG, Self-RAG dan GraphRAG Dijelaskan

LongRAG, Self-RAG, GraphRAG - Teknik generasi berikutnya

Konten Halaman

Retrieval-Augmented Generation (RAG) telah berkembang jauh melampaui pencarian kesamaan vektor sederhana. LongRAG, Self-RAG, dan GraphRAG mewakili ujung tombak dari kemampuan-kemampuan ini.

Sistem RAG modern perlu menangani dokumen-dokumen besar, memahami hubungan entitas yang kompleks, dan banyak hal lainnya.

a-pirate-captain Gambar yang menarik ini dihasilkan oleh AI model Flux 1 dev.

Evolusi di Lepas RAG Dasar

Sistem RAG tradisional mengikuti pola sederhana: potong dokumen, masukkan ke dalam vektor, cari bagian-bagian yang mirip melalui kesamaan kosinus, dan masukkan ke dalam LLM. Meskipun efektif untuk banyak kasus penggunaan, pendekatan ini kesulitan menghadapi tiga skenario kritis:

Ketergantungan jangka panjang: Konteks penting mungkin mencakup ribuan token di seluruh beberapa potongan
Keyakinan pencarian: Sistem tidak memiliki cara untuk menilai apakah konten yang ditemukan benar-benar relevan
Kompleksitas hubungan: Kesamaan vektor tidak dapat menangkap koneksi yang rumit antar entitas

Varian RAG lanjutan mengatasi keterbatasan ini dengan arsitektur khusus yang dirancang untuk tantangan tertentu.

LongRAG: Mengatasi Konteks yang Lebar

Gambaran Arsitektur

LongRAG secara mendasar merevisi strategi pemotongan dengan memanfaatkan LLM dengan jendela konteks yang diperpanjang (32K, 100K, atau bahkan 1M token). Sebaliknya dari memecah dokumen menjadi potongan kecil 512-token, LongRAG menggunakan pendekatan hierarkis:

Pemrosesan Pembenaman Tingkat Dokumen: Seluruh dokumen (atau bagian besar) diproses sebagai satu unit. Pembenaman tingkat dokumen menangkap makna semantik secara keseluruhan, sambil mempertahankan teks lengkap untuk pemrosesan berikutnya.

Fragmentasi Minimal: Ketika pemotongan diperlukan, LongRAG menggunakan potongan yang jauh lebih besar (4K-8K token) dengan tumpang tindih yang signifikan (20-30%). Ini mempertahankan alur narasi dan mengurangi fragmentasi konteks.

Penggabungan Konteks: Saat pencarian dilakukan, LongRAG mengembalikan dokumen lengkap atau bagian yang koheren besar, bukan fragmen yang terpecah. LLM menerima konteks yang kontinu yang mempertahankan hubungan struktural dan semantik.

Strategi Implementasi

Berikut adalah implementasi konseptual menggunakan Python dan model pembenaman modern:

from typing import List, Dict
import numpy as np

class LongRAGRetriever:
    def __init__(self, model, chunk_size=8000, overlap=1600):
        self.model = model
        self.chunk_size = chunk_size
        self.overlap = overlap
        self.doc_embeddings = []
        self.documents = []
    
    def create_long_chunks(self, text: str) -> List[str]:
        """Buat potongan besar dengan tumpang tindih"""
        chunks = []
        start = 0
        while start < len(text):
            end = start + self.chunk_size
            chunk = text[start:end]
            chunks.append(chunk)
            start += (self.chunk_size - self.overlap)
        return chunks
    
    def index_document(self, doc: str, metadata: Dict):
        """Indeks dokumen dengan pembenaman hierarkis"""
        # Pembenaman seluruh dokumen
        doc_embedding = self.model.embed(doc)
        
        # Membuat potongan besar dengan tumpang tindih
        chunks = self.create_long_chunks(doc)
        chunk_embeddings = [self.model.embed(c) for c in chunks]
        
        self.doc_embeddings.append({
            'doc_id': len(self.documents),
            'doc_embedding': doc_embedding,
            'chunk_embeddings': chunk_embeddings,
            'chunks': chunks,
            'full_text': doc,
            'metadata': metadata
        })
        self.documents.append(doc)
    
    def retrieve(self, query: str, top_k: int = 3) -> List[Dict]:
        """Mengambil konten berbentuk panjang yang relevan"""
        query_embedding = self.model.embed(query)
        
        # Nilai skor terlebih dahulu pada tingkat dokumen
        doc_scores = [
            np.dot(query_embedding, doc['doc_embedding'])
            for doc in self.doc_embeddings
        ]
        
        # Mendapatkan dokumen teratas
        top_doc_indices = np.argsort(doc_scores)[-top_k:][::-1]
        
        results = []
        for idx in top_doc_indices:
            doc_data = self.doc_embeddings[idx]
            
            # Untuk setiap dokumen, cari potongan terbaik
            chunk_scores = [
                np.dot(query_embedding, emb)
                for emb in doc_data['chunk_embeddings']
            ]
            best_chunk_idx = np.argmax(chunk_scores)
            
            # Kembalikan konteks yang diperluas di sekitar potongan terbaik
            context_chunks = self._get_extended_context(
                doc_data['chunks'], 
                best_chunk_idx
            )
            
            results.append({
                'text': ''.join(context_chunks),
                'score': doc_scores[idx],
                'metadata': doc_data['metadata']
            })
        
        return results
    
    def _get_extended_context(self, chunks: List[str], 
                             center_idx: int) -> List[str]:
        """Dapatkan konteks yang diperluas di sekitar potongan relevan"""
        start = max(0, center_idx - 1)
        end = min(len(chunks), center_idx + 2)
        return chunks[start:end]

Kasus Penggunaan dan Kinerja

LongRAG unggul dalam skenario di mana konteks penting:

Analisis dokumen hukum: Kontrak dan surat-surat hukum sering memiliki ketergantungan yang mencakup puluhan halaman
Pencarian kertas penelitian: Memahami metodologi memerlukan bagian yang koheren, bukan paragraf terisolasi
Repositori kode: Fungsi dan kelas harus dipahami dalam konteks modulnya

Karakteristik kinerja:

Latensi: Lebih tinggi karena memproses potongan besar (2-5x lebih lambat dari RAG standar)
Akurasi: Peningkatan 15-25% pada benchmark QA berbasis teks panjang
Memori: Memerlukan 3-4x lebih banyak memori untuk jendela konteks

Self-RAG: Pencarian Reflektif

Prinsip Dasar

Self-RAG memperkenalkan lapisan metakognitif ke sistem RAG. Sebaliknya dari mencari dan menghasilkan secara buta, sistem secara aktif merefleksikan prosesnya sendiri melalui token refleksi khusus:

Token Pencarian: Memutuskan apakah pencarian diperlukan untuk pertanyaan tertentu Token Relevansi: Mengevaluasi apakah dokumen yang ditemukan benar-benar relevan Token Dukungan: Memeriksa apakah jawaban yang dihasilkan didukung oleh konten yang ditemukan Token Kritik: Mengevaluasi kualitas keseluruhan jawaban yang dihasilkan

Komponen Arsitektur

Arsitektur Self-RAG terdiri dari tiga fase yang saling berdampingan:

class SelfRAGSystem:
    def __init__(self, retriever, generator, critic):
        self.retriever = retriever
        self.generator = generator
        self.critic = critic
    
    def generate_with_reflection(self, query: str, 
                                 max_iterations: int = 3):
        """Hasilkan jawaban dengan refleksi diri"""
        
        # Fase 1: Memutuskan apakah pencarian diperlukan
        retrieve_decision = self.critic.should_retrieve(query)
        
        if not retrieve_decision:
            # Hasilkan tanpa pencarian
            return self.generator.generate(query)
        
        # Fase 2: Pencarian dan evaluasi relevansi
        retrieved_docs = self.retriever.retrieve(query)
        relevant_docs = []
        
        for doc in retrieved_docs:
            relevance_score = self.critic.assess_relevance(
                query, doc
            )
            if relevance_score > 0.7:  # Ambang batas
                relevant_docs.append(doc)
        
        if not relevant_docs:
            # Jatuh kembali ke pembuatan tanpa pencarian
            return self.generator.generate(query)
        
        # Fase 3: Hasilkan dan verifikasi dukungan
        best_answer = None
        best_score = -1
        
        for _ in range(max_iterations):
            # Hasilkan jawaban kandidat
            answer = self.generator.generate(
                query, context=relevant_docs
            )
            
            # Evaluasi dukungan dan kualitas
            support_score = self.critic.check_support(
                answer, relevant_docs
            )
            quality_score = self.critic.assess_quality(answer)
            
            total_score = 0.6 * support_score + 0.4 * quality_score
            
            if total_score > best_score:
                best_score = total_score
                best_answer = answer
            
            # Berhenti dini jika kualitas tinggi tercapai
            if total_score > 0.9:
                break
        
        return {
            'answer': best_answer,
            'confidence': best_score,
            'sources': relevant_docs,
            'reflections': {
                'retrieved': retrieve_decision,
                'relevance': len(relevant_docs),
                'support': support_score
            }
        }

Pelatihan Mekanisme Refleksi

Self-RAG memerlukan pelatihan komponen kritik untuk membuat penilaian yang andal. Ini biasanya melibatkan:

Pelatihan halus terawasi pada dataset yang dianotasi dengan penilaian relevansi
Pembelajaran penguatan dengan hadiah untuk prediksi akurat
Pembelajaran kontrasif untuk membedakan klaim yang didukung dan tidak didukung

Token refleksi dapat diimplementasikan sebagai:

Token khusus dalam kosakata (seperti [RETRIEVE], [RELEVANT])
Kepala klasifikasi terpisah pada model
Model kritik eksternal (pendekatan ensembel)

Pertimbangan Produksi

Ketika mengimplementasikan Self-RAG dalam sistem produksi:

Perdagangan Latensi: Setiap langkah refleksi menambahkan 20-40% beban inferensi. Seimbangkan kecermatan dengan kebutuhan waktu respons.

Ambang Batas Keyakinan: Atur ambang batas refleksi berdasarkan kasus penggunaan Anda. Aplikasi hukum atau medis membutuhkan keyakinan yang lebih tinggi daripada chatbot umum.

Pemantauan: Lacak keputusan refleksi untuk mengidentifikasi pola. Jika pencarian jarang diperlukan, Anda mungkin mendapatkan manfaat dari arsitektur yang lebih sederhana.

GraphRAG: Pencarian yang Diperkuat oleh Grafik Pengetahuan

Fondasi Konseptual

GraphRAG mengubah masalah pencarian dari kesamaan vektor menjadi perjalanan grafik. Sebaliknya dari mencari bagian teks yang mirip secara semantik, GraphRAG mengidentifikasi subgrafik yang relevan dari entitas dan hubungan yang terhubung.

Ekstraksi Entitas: Identifikasi entitas bernama, konsep, dan jenisnya Pemetaan Hubungan: Ekstrak hubungan antar entitas (waktu, sebab-akibat, hierarkis) Konstruksi Grafik: Bangun grafik pengetahuan dengan entitas sebagai node dan hubungan sebagai edge Pencarian Subgrafik: Diberikan pertanyaan, temukan subgrafik yang terhubung yang relevan

Pipa Konstruksi Grafik

Membangun grafik pengetahuan dari teks tidak terstruktur melibatkan beberapa tahap:

class GraphRAGBuilder:
    def __init__(self, entity_extractor, relation_extractor):
        self.entity_extractor = entity_extractor
        self.relation_extractor = relation_extractor
        self.graph = NetworkGraph()
    
    def build_graph(self, documents: List[str]):
        """Bangun grafik pengetahuan dari dokumen"""
        for doc in documents:
            # Ekstraksi entitas
            entities = self.entity_extractor.extract(doc)
            
            # Tambahkan entitas sebagai node
            for entity in entities:
                self.graph.add_node(
                    entity['text'],
                    entity_type=entity['type'],
                    context=entity['surrounding_text']
                )
            
            # Ekstraksi hubungan
            relations = self.relation_extractor.extract(
                doc, entities
            )
            
            # Tambahkan hubungan sebagai edge
            for rel in relations:
                self.graph.add_edge(
                    rel['source'],
                    rel['target'],
                    relation_type=rel['type'],
                    confidence=rel['score'],
                    evidence=rel['text_span']
                )
    
    def enrich_graph(self):
        """Tambahkan hubungan terurain dan metadata"""
        # Hitung pentingnya node (PageRank, dll.)
        self.graph.compute_centrality()
        
        # Identifikasi komunitas/kelompok
        self.graph.detect_communities()
        
        # Tambahkan urutan waktu jika timestamp tersedia
        self.graph.add_temporal_edges()

Pemrosesan Pertanyaan dengan Grafik

Pertanyaan GraphRAG melibatkan penalaran multi-hop melintasi grafik pengetahuan:

class GraphRAGRetriever:
    def __init__(self, graph, embedder):
        self.graph = graph
        self.embedder = embedder
    
    def retrieve_subgraph(self, query: str, 
                         max_hops: int = 2,
                         max_nodes: int = 50):
        """Mengambil subgrafik yang relevan untuk pertanyaan"""
        
        # Identifikasi entitas seed dalam pertanyaan
        query_entities = self.entity_extractor.extract(query)
        
        # Cari node yang cocok dalam grafik
        seed_nodes = []
        for entity in query_entities:
            matches = self.graph.find_similar_nodes(
                entity['text'],
                similarity_threshold=0.85
            )
            seed_nodes.extend(matches)
        
        # Perluas subgrafik melalui perjalanan
        subgraph = self.graph.create_subgraph()
        visited = set()
        
        for seed in seed_nodes:
            self._expand_from_node(
                seed, 
                subgraph, 
                visited,
                current_hop=0,
                max_hops=max_hops
            )
        
        # Peringkat node berdasarkan relevansi
        ranked_nodes = self._rank_subgraph_nodes(
            subgraph, query
        )
        
        # Ekstrak dan format konteks
        context = self._format_graph_context(
            ranked_nodes[:max_nodes],
            subgraph
        )
        
        return context
    
    def _expand_from_node(self, node, subgraph, visited,
                         current_hop, max_hops):
        """Ekspansi rekursif subgrafik"""
        if current_hop >= max_hops or node in visited:
            return
        
        visited.add(node)
        subgraph.add_node(node)
        
        # Dapatkan tetangga
        neighbors = self.graph.get_neighbors(node)
        
        for neighbor, edge_data in neighbors:
            # Tambahkan edge ke subgrafik
            subgraph.add_edge(node, neighbor, edge_data)
            
            # Ekspansi rekursif
            self._expand_from_node(
                neighbor,
                subgraph,
                visited,
                current_hop + 1,
                max_hops
            )
    
    def _format_graph_context(self, nodes, subgraph):
        """Konversi subgrafik ke konteks teks"""
        context_parts = []
        
        for node in nodes:
            # Tambahkan konteks node
            context_parts.append(f"Entitas: {node.text}")
            context_parts.append(f"Jenis: {node.entity_type}")
            
            # Tambahkan informasi hubungan
            edges = subgraph.get_edges(node)
            for edge in edges:
                context_parts.append(
                    f"- {edge.relation_type} -> {edge.target.text}"
                )
        
        return "\n".join(context_parts)

Implementasi GraphRAG dari Microsoft

Microsoft’s GraphRAG mengambil pendekatan unik dengan menghasilkan ringkasan komunitas:

Bangun grafik awal dari dokumen menggunakan ekstraksi entitas/hubungan berbasis LLM
Deteksi komunitas menggunakan algoritma Leiden atau yang serupa
Hasilkan ringkasan untuk setiap komunitas menggunakan LLM
Struktur hierarkis: Bangun beberapa tingkat abstraksi komunitas
Waktu pencarian: Ambil komunitas yang relevan dan jelajahi ke entitas tertentu

Pendekatan ini sangat efektif untuk:

Pertanyaan eksploratif (“Apa tema utama dalam kumpulan dokumen ini?”)
Penalaran multi-hop (“Bagaimana A terhubung ke C melalui B?”)
Analisis temporal (“Bagaimana hubungan entitas ini berkembang?”)

Analisis Perbandingan

Kapan Menggunakan Setiap Varian

Gunakan LongRAG ketika:

Dokumen memiliki koherensi internal yang kuat
Jendela konteks LLM Anda mendukung input besar (32K+)
Jawaban pertanyaan memerlukan pemahaman ketergantungan jangka panjang
Anda bekerja dengan dokumen terstruktur (laporan, kertas, buku)

Gunakan Self-RAG ketika:

Akurasi dan kepercayaan sangat penting
Anda membutuhkan keputusan pencarian yang dapat dijelaskan
False positives dari pencarian yang tidak relevan mahal
Kompleksitas pertanyaan bervariasi (beberapa membutuhkan pencarian, beberapa tidak)

Gunakan GraphRAG ketika:

Domain Anda memiliki hubungan entitas yang kaya
Pertanyaan melibatkan penalaran multi-hop
Hubungan temporal atau hierarkis penting
Anda perlu memahami koneksi antar entitas

Perbandingan Metrik Kinerja

Metrik	RAG Standar	LongRAG	Self-RAG	GraphRAG
Waktu Indeks	1x	0.8x	1.1x	3-5x
Latensi Pencarian	1x	2-3x	1.4x	1.5-2x
Penggunaan Memori	1x	3-4x	1.2x	2-3x
Akurasi (QA)	baseline	+15-25%	+20-30%	+25-40%*
Keterbacaan	Rendah	Sedang	Tinggi	Tinggi

*Perbaikan GraphRAG sangat bergantung pada domain

Pendekatan Hibrida

Sistem produksi terkuat sering menggabungkan beberapa teknik:

LongRAG + GraphRAG: Gunakan struktur grafik untuk mengidentifikasi kluster dokumen yang relevan, lalu ambil dokumen lengkap bukan fragmen

Self-RAG + GraphRAG: Terapkan mekanisme refleksi pada keputusan perjalanan grafik (jalur mana yang diikuti, kapan berhenti memperluas)

Pipeline tiga tahap: Gunakan GraphRAG untuk pencarian awal berbasis entitas → Self-RAG untuk filter relevansi → LongRAG untuk penggabungan konteks

Pertimbangan Implementasi

Model Pembenaman

Berbagai varian RAG memiliki kebutuhan pembenaman yang berbeda:

LongRAG: Membutuhkan pembenaman yang bekerja baik pada tingkat dokumen dan potongan. Pertimbangkan model yang dilatih dengan pembelajaran kontrasif pada urutan panjang.

Self-RAG: Mendapat manfaat dari pembenaman yang menangkap nuansa semantik untuk penilaian relevansi halus.

GraphRAG: Membutuhkan pembenaman yang sadar entitas. Model yang dilatih pada tugas penautan entitas memberikan hasil yang lebih baik.

Pemilihan model pembenaman secara signifikan memengaruhi kinerja. Saat bekerja dengan model lokal, alat seperti Ollama menyediakan cara yang sederhana untuk bereksperimen dengan berbagai model pembenaman sebelum menyetujui implementasi produksi.

Strategi Pemotongan Kembali

Pemotongan ukuran tetap tidak cukup untuk RAG lanjutan:

Pemotongan semantik: Pecah pada batas alami (paragraf, bagian, perubahan topik) Pemotongan rekursif: Buat potongan hierarkis dengan hubungan induk-anak Jendela geser: Gunakan potongan yang tumpang tindih untuk mempertahankan konteks di batas Struktur sadar: Hormati struktur dokumen (header markdown, tag XML, blok kode)

Untuk implementasi berbasis Python, library seperti LangChain dan LlamaIndex menyediakan dukungan bawaan untuk strategi pemotongan ini.

Integrasi Reranking

Reranking secara signifikan meningkatkan kualitas pencarian di semua varian RAG. Setelah pencarian awal, model reranking khusus mere-score hasil berdasarkan fitur interaksi query-dokumen. Ini memberikan peningkatan akurasi yang signifikan (10-20%) dengan dampak latensi minimal jika diintegrasikan secara cermat.

Skala ke Produksi

Pipeline Indeks:

Gunakan pemrosesan terdistribusi (Ray, Dask) untuk kumpulan dokumen besar
Implementasikan indeksing bertahap untuk pembaruan real-time
Simpan pembenaman di basis data vektor yang dioptimalkan (Pinecone, Weaviate, Qdrant)

Optimasi Query:

Cache query yang sering dan hasilnya
Implementasikan routing query (varian RAG berbeda untuk jenis query berbeda)
Gunakan pencarian pendekatan terdekat untuk skala sub-linear

Pemantauan:

Lacak skor relevansi pencarian
Pantau keputusan refleksi dalam Self-RAG
Ukur jalur dan kedalaman perjalanan grafik
Catat skor keyakinan dan umpan balik pengguna

Aplikasi Dunia Nyata

Pencarian Dokumentasi Teknis

Sebuah penyedia cloud besar mengimplementasikan GraphRAG untuk dokumentasinya:

Entitas: Titik akhir API, parameter, kode kesalahan, nama layanan
Hubungan: Ketergantungan, kompatibilitas versi, jalur migrasi
Hasil: Penurunan 35% tiket dukungan, waktu penyelesaian 45% lebih cepat

Penemuan Hukum

Perusahaan teknologi hukum menggabungkan Self-RAG dengan LongRAG:

Self-RAG menyaring dokumen yang tidak relevan secara dini
LongRAG mempertahankan konteks dalam dokumen yang disimpan
Pengacara meninjau 60% lebih sedikit false positives
Preservasi konteks kritis meningkat dari 71% menjadi 94%

Tinjauan Literatur Akademik

Mesin pencari akademik menggunakan pendekatan hibrida:

GraphRAG mengidentifikasi jaringan kutipan dan komunitas penelitian
LongRAG mengambil bagian penuh yang mempertahankan konteks metodologi
Peningkatan 40% dalam penemuan kertas relevan
Waktu tinjauan literatur berkurang dari minggu-minggu menjadi hari-hari

Topik Lanjutan

RAG Multimodal

Mengembangkan varian-varian ini untuk menangani gambar, tabel, dan kode:

Penggalian visual: Hubungkan entitas teks ke gambar dalam dokumen
Pemahaman tabel: Parse data terstruktur ke dalam format grafik
Analisis kode: Bangun grafik dependensi dari basis kode

RAG Adaptif

Pemilihan strategi RAG dinamis berdasarkan karakteristik pertanyaan:

Klasifikasi kompleksitas pertanyaan
Detektor jenis dokumen
Optimisasi biaya-manfaat untuk pemilihan strategi

RAG yang Menghormati Privasi

Mengimplementasikan varian-varian ini dengan pembatasan privasi:

Pencarian terdistribusi di seluruh silo data
Privasi diferensial dalam pembenaman
Pencarian kesamaan terenkripsi

Memulai

Memulai dengan Cepat Menggunakan Python

Bagi yang ingin menerapkan teknik-teknik ini, memulai dengan fondasi Python yang kuat sangat penting. Ekosistem Python yang kaya untuk machine learning membuatnya menjadi pilihan alami untuk pengembangan RAG.

Berikut titik awal sederhana untuk eksperimen:

# Instalasi dependensi
# pip install sentence-transformers faiss-cpu langchain

from sentence_transformers import SentenceTransformer
import faiss
import numpy as np

# Pengaturan dasar untuk eksperimen dengan potongan teks panjang
model = SentenceTransformer('all-MiniLM-L6-v2')

documents = [
    # Dokumen teks panjang Anda di sini
]

# Membuat embedding
embeddings = model.encode(documents)

# Membangun indeks FAISS
dimension = embeddings.shape[1]
index = faiss.IndexFlatL2(dimension)
index.add(embeddings.astype('float32'))

# Query
query = "Pertanyaan Anda di sini"
query_embedding = model.encode([query])
distances, indices = index.search(
    query_embedding.astype('float32'), k=3
)

Pemilihan Kerangka Kerja

LangChain: Terbaik untuk prototyping cepat, integrasi yang luas LlamaIndex: Dioptimalkan untuk pengindeksan dan pencarian dokumen Haystack: Siap untuk produksi, abstraksi pipeline yang kuat Kustom: Ketika Anda membutuhkan kontrol penuh dan optimasi

Kerangka Evaluasi

Lakukan evaluasi yang ketat sebelum penggunaan di produksi:

Metrik pencarian:

Precision@K, Recall@K, MRR (Mean Reciprocal Rank)
NDCG (Normalized Discounted Cumulative Gain)

Metrik generasi:

ROUGE, BLEU untuk kesamaan teks
BERTScore untuk kesamaan semantik
Evaluasi manusia untuk penilaian kualitas

Metrik end-to-end:

Tingkat keberhasilan tugas
Skor kepuasan pengguna
Percentil latensi (p50, p95, p99)

Kesimpulan

Lanskap sistem RAG telah berkembang secara signifikan melebihi pencarian kesamaan vektor dasar. LongRAG, Self-RAG, dan GraphRAG masing-masing mengatasi keterbatasan pendekatan tradisional:

LongRAG menyelesaikan masalah fragmentasi konteks dengan menerima jendela konteks yang diperpanjang dan minimalisasi potongan. Ini adalah pilihan utama ketika koherensi dokumen penting dan Anda memiliki sumber daya komputasi untuk menangani konteks besar.

Self-RAG menambahkan kesadaran diri yang kritis pada sistem pencarian. Dengan merefleksikan keputusan-keputusan sendiri, ia mengurangi positif palsu dan meningkatkan keterpercayaan—penting untuk aplikasi berisiko tinggi di mana akurasi lebih penting daripada kecepatan.

GraphRAG mengungkapkan kekuatan representasi pengetahuan terstruktur. Ketika domain Anda melibatkan hubungan kompleks antar entitas, pencarian berbasis graf dapat mengungkapkan koneksi yang sepenuhnya terlewat oleh kesamaan vektor.

Masa depan RAG kemungkinan besar melibatkan pendekatan hibrida yang menggabungkan kekuatan variasi ini. Sistem produksi mungkin menggunakan GraphRAG untuk mengidentifikasi klaster entitas yang relevan, Self-RAG untuk menyaring dan memvalidasi pencarian, serta LongRAG untuk menggabungkan konteks yang koheren untuk LLM.

Seiring dengan terus berkembangnya LLM dan memperluasnya jendela konteks, kita akan melihat varian RAG yang lebih canggih muncul. Kunci utamanya adalah memahami kebutuhan spesifik kasus penggunaan—struktur dokumen, pola pertanyaan, permintaan akurasi, dan batasan komputasi—and memilih teknik yang tepat atau kombinasi dari teknik tersebut.

Ekosistem alat sedang berkembang pesat, dengan kerangka kerja seperti LangChain, LlamaIndex, dan Haystack menyediakan dukungan yang semakin canggih untuk pola-pola lanjutan ini. Dikombinasikan dengan runtime LLM lokal yang kuat dan model embedding, sekarang lebih mudah untuk bereksperimen dan menerapkan sistem RAG berbasis produksi.

Mulailah dengan dasar-dasar, ukur kinerja secara ketat, dan berkembangkan arsitektur Anda sesuai dengan kebutuhan. Varian RAG lanjutan yang dibahas di sini memberikan peta jalan untuk evolusi tersebut.