DecisionRAG (arXiv:2610.35868): Retriever-Free Retrieval via Decision Models — Eliminasi Capability Asymmetry, Hierarchical Tree Navigation, dan Rekor +17.4% Hit@1 Tanpa Indeks Vektor

Dalam lanskap arsitektur sistem kecerdasan buatan modern, Retrieval-Augmented Generation (RAG) telah menjadi fondasi standar untuk memasok fakta dinamis dan membumikan respon model bahasa besar (LLM). Namun, selama bertahun-tahun terdapat jurang kapabilitas asimetris yang mencolok (capability asymmetry): sementara model generator (seperti Qwen3.5-27B, Claude 3.7, dan GPT-5) mengalami lompatan nalar eksponensial, lapisan retriever yang menentukan bukti apa yang boleh dilihat generator masih terkunci pada metode pencocokan leksikal klasik (BM25) atau perbandingan kedekatan kosinus pada ruang embedding statis terkompresi. Apa yang gagal ditemukan oleh retriever pada tahap pertama, tidak akan pernah bisa diselamatkan oleh generator tercanggih sekalipun.

1. Akar Masalah: Dilema Capability Asymmetry pada Pipeline RAG Konvensional

Mayoritas arsitektur pencarian semantik perusahaan mengandalkan paradigma dua tahap (two-stage retrieval pipeline):

1. Tahap Pertama (Candidate Generation): Menggunakan indeks vektor (HNSW, ScaNN, Milvus) atau inverted index BM25 untuk menarik $k$ dokumen awal (misalnya $k=50$ atau $k=100$) dari jutaan kandidat berdasarkan kemiripan representasi dense atau frekuensi kata kunci.
2. Tahap Kedua (Reranking): Menggunakan model reranker cross-encoder (seperti BGE-Reranker atau Qwen3-Reranker-8B) untuk memberi bobot ulang terhadap $k$ kandidat terpilih sebelum disuapkan ke dalam context window generator LLM.

Kelemahan fatal arsitektur ini berakar pada kenyataan bahwa model embedding tahap pertama memampatkan ribuan token informasi ke dalam vektor berdimensi tetap (misalnya 768 atau 1.536 dimensi). Kompresi agresif ini membuang struktur gramatikal halus, korelasi kondisional, dan konteks percakapan multi-turn. Akibatnya, dokumen yang memuat bukti krusial sering kali terlempar di luar $k$ teratas, sehingga reranker tahap kedua maupun generator tidak pernah memiliki kesempatan untuk memeriksanya.

2. Paradigma Decision Models & Kekuatan Penilaian dalam Konteks Bersama (Shared Context)

Inovasi fundamental DecisionRAG adalah pemanfaatan Decision Models (seperti TypeSafe Jev 1.13 atau model keputusan OpenAI). Berbeda dengan LLM generatif biasa yang memprediksi token demi token berikutnya secara autoregresif (yang lambat dan mahal), model keputusan mengevaluasi satu set pertanyaan terhadap suatu konteks data dan langsung menghasilkan distribusi probabilitas pada opsi jawaban yang telah ditentukan dalam satu kali forward pass (tanpa melakukan decode token teks).

DecisionRAG menerapkan dua modus inferensi model keputusan yang beroperasi di atas konteks bersama ($s$):

Mengapa Penilaian dalam Konteks Bersama (Shared Context) Mengungguli Penilaian Terisolasi?

Ketika dokumen dinilai satu per satu secara terpisah, sebuah dokumen yang tampak relevan secara parsial sering kali memperoleh skor probabilitas tinggi karena ketiadaan dokumen pembanding. Namun, ketika seluruh kandidat disajikan dalam shared context yang sama, model keputusan dapat melakukan kalibrasi instan: kandidat parsial langsung memperoleh $P( ext{Yes})$ yang jauh lebih rendah saat kandidat yang sempurna hadir di sebelahnya.

Data empiris pada Natural Questions membuktikan efek kalibrasi ini secara dramatis: skor Hit@1 meningkat dari 47.8% saat kandidat dinilai terpisah menjadi 54.3% saat 50 kandidat dinilai bersama dalam satu request shared context. Ketika 200 kandidat teratas dinilai dengan mode multiple-choice, akurasi Hit@1 melesat hingga 60.6% (+6.8 poin di atas penilaian biner).

3. Arsitektur Navigasi Pohon Hierarki & Skalabilitas Logaritmik Korpus

Alih-alih memindai seluruh dokumen secara flat, DecisionRAG memodelkan korpus sebagai struktur pohon berakar (corpus tree) dengan kedalaman $L$ level, di mana daunnya (leaves) adalah potongan teks (passages) dan simpul internalnya (internal nodes) adalah entitas agregasi bertingkat:

Perhatikan temuan krusial pada Natural Questions: Wikipedia tidak memiliki taksonomi pohon bawaan di atas level halaman artikel. Untuk mengatasi ini, peneliti mengelompokkan 108.626 halaman Wikipedia ke dalam 1.000 klaster topik menggunakan algoritma k-means di atas embedding e5-base-v2 dari judul dan kalimat pembuka, lalu merangkum tiap klaster menjadi satu kalimat ringkas menggunakan Qwen3-8B. Dengan struktur ini, DecisionRAG hanya perlu membaca 16% dari seluruh judul halaman Wikipedia untuk menemukan bukti yang tepat.

Jumlah tahapan sekuensial hanya tumbuh secara logaritmik terhadap volume data total ($mathcal{O}(log N)$), memastikan skalabilitas tinggi untuk korpus skala enterprise berukuran terabita tanpa lonjakan latensi.

4. Tolok Ukur Empiris: MultiDoc2Dial, ConditionalQA, MTRAG, dan Natural Questions

Evaluasi komprehensif dilakukan pada empat benchmark representatif terhadap baseline industri terkuat (BM25, Qwen3-Embedding-8B dense retrieval, BGE reranker, Qwen3-Reranker-8B, dan GPT-5 reranker):

Keputusan Non-Generatif vs Penalaran Generatif Token-by-Token

Banyak praktisi mengasumsikan bahwa meminta LLM generasi (seperti GPT-5) menuliskan nomor dokumen secara teks autoregresif akan menghasilkan penalaran superior. Peneliti menguji hipotesis ini secara langsung: dengan hierarki dan anggaran yang identik, GPT-5 diminta menuliskan daftar kandidat terpilih seperti pada metode LATTICE.

Hasilnya mengejutkan: pada Natural Questions, GPT-5 generatif hanya mencapai Hit@1 sebesar 59.0%, tertinggal 6.0 poin di belakang DecisionRAG (65.0%), sembari membutuhkan waktu 250.8 detik per kueri (4.1 menit!) dan biaya 57.2¢ per kueri. DecisionRAG menyelesaikan tugas yang sama dalam 1.73 detik dengan biaya 2.33¢ (24.5x lebih murah dan 145x lebih cepat).

5. Jebakan Arsitektur (Pitfalls) & Kegagalan Implementasi di Lapangan

Saat merekayasa sistem pencarian hierarkis berbasis model keputusan untuk sistem produksi, tim rekayasa wajib mewaspadai tiga kesalahan fatal:

6. Implementasi Referensi Produksi: DecisionRAG Navigation Engine

Berikut adalah arsitektur TypeScript siap produksi yang mengimplementasikan mesin navigasi hierarkis DecisionRAG, lengkap dengan batching konteks bersama, penilaian biner paralel, dan penyaringan pilihan ganda:

// Production Implementation: DecisionRAG Hierarchical Navigation Engine
// Berdasarkan Arsitektur Riset arXiv:2610.35868 (Cornell University & ASAPP)
// Mengeliminasi indeks vektor statis; menavigasi korpus pohon menggunakan model keputusan (Decision Models)
// dalam Single Forward Pass tanpa decoding autoregresif (zero token generation).

export interface CorpusTreeNode {
  id: string;
  level: number;
  label: string; // Judul dokumen, deskripsi ringkas klaster, atau teks passage
  content?: string; // Teks lengkap untuk level daun (passages)
  parentId?: string;
  children?: CorpusTreeNode[];
}

export interface BinaryJudgmentResult {
  nodeId: string;
  probYes: number; // P(Yes | shared_context, query)
}

export interface ChoiceJudgmentResult {
  nodeId: string;
  probChoice: number; // P(node_i | shared_context, query, A) di mana sum(p) = 1
}

export interface DecisionRAGConfig {
  hierarchyLevels: number; // Jumlah kedalaman pohon korpus L
  retentionBudgets: number[]; // [k_1, k_2, ..., k_{L-1}] jumlah cabang teratas yang dipertahankan
  numReturnedPassages: number; // r: jumlah passage akhir yang diekstraksi
  rerankShortlistSize: number; // m: jumlah kandidat teratas untuk multiple-choice reranking (m <= r)
  batchCandidateLimit: number; // Batas kandidat per forward pass shared context (default 50-200)
}

export class DecisionRAGNavigator {
  constructor(
    private readonly config: DecisionRAGConfig,
    private readonly decisionModelClient: {
      evaluateParallelBinary: (context: string, questions: Array<{ id: string; query: string; candidateText: string }>) => Promise;
      evaluateMultipleChoice: (context: string, query: string, candidates: Array<{ id: string; text: string }>) => Promise;
    }
  ) {}

  /**
   * Menavigasi pohon korpus dari klaster root hingga passage daun menggunakan Decision Model
   */
  public async retrieve(query: string, rootNodes: CorpusTreeNode[]): Promise {
    let currentCandidates: CorpusTreeNode[] = [...rootNodes];

    // Tahap 1 hingga L-1: Navigasi Hierarki Bertingkat (Klaster -> Dokumen -> Bagian)
    for (let level = 0; level < this.config.hierarchyLevels - 1; level++) {
      const budget = this.config.retentionBudgets[level] || 10;
      
      // Evaluasi probabilitas relevansi biner dalam shared context
      const scoredCandidates = await this.scoreCandidatesInBatches(query, currentCandidates);
      
      // Ambil top-k kandidat terbaik berdasarkan P(Yes)
      scoredCandidates.sort((a, b) => b.probYes - a.probYes);
      const topSelected = scoredCandidates.slice(0, budget);

      // Ekspansi cabang anak untuk level berikutnya
      const nextLevelNodes: CorpusTreeNode[] = [];
      for (const selected of topSelected) {
        const originalNode = currentCandidates.find(n => n.id === selected.nodeId);
        if (originalNode && originalNode.children) {
          nextLevelNodes.push(...originalNode.children);
        }
      }

      if (nextLevelNodes.length === 0) {
        break;
      }
      currentCandidates = nextLevelNodes;
    }

    // Tahap L: Penilaian Relevansi Lembar Daun (Leaf Passages Scoring)
    const finalPassageScores = await this.scoreCandidatesInBatches(query, currentCandidates);
    finalPassageScores.sort((a, b) => b.probYes - a.probYes);
    
    // Ambil top-r passages
    const topPassageIds = finalPassageScores.slice(0, this.config.numReturnedPassages);
    let finalRankedNodes = topPassageIds.map(scored => currentCandidates.find(n => n.id === scored.nodeId)!);

    // Tahap Opsional: Multiple-Choice Re-ranking untuk Kandidat Shortlist (m <= r)
    if (this.config.rerankShortlistSize > 1 && finalRankedNodes.length > 1) {
      const shortlist = finalRankedNodes.slice(0, this.config.rerankShortlistSize);
      const choiceCandidates = shortlist.map(n => ({ id: n.id, text: n.content || n.label }));

      const sharedContext = this.buildSharedContext(query, shortlist);
      const choiceScores = await this.decisionModelClient.evaluateMultipleChoice(
        sharedContext,
        query,
        choiceCandidates
      );

      choiceScores.sort((a, b) => b.probChoice - a.probChoice);
      const rerankedTop = choiceScores.map(cs => shortlist.find(n => n.id === cs.nodeId)!);
      
      // Gabungkan top yang telah di-rerank dengan sisa kandidat
      finalRankedNodes = [...rerankedTop, ...finalRankedNodes.slice(this.config.rerankShortlistSize)];
    }

    return finalRankedNodes;
  }

  private async scoreCandidatesInBatches(query: string, nodes: CorpusTreeNode[]): Promise {
    const results: BinaryJudgmentResult[] = [];
    const batchSize = this.config.batchCandidateLimit;

    for (let i = 0; i < nodes.length; i += batchSize) {
      const batch = nodes.slice(i, i + batchSize);
      const sharedContext = this.buildSharedContext(query, batch);
      
      const questions = batch.map(node => ({
        id: node.id,
        query: query,
        candidateText: node.content || node.label,
      }));

      const batchResults = await this.decisionModelClient.evaluateParallelBinary(sharedContext, questions);
      results.push(...batchResults);
    }

    return results;
  }

  private buildSharedContext(query: string, nodes: CorpusTreeNode[]): string {
    // Membentuk context bersama yang dibaca model satu kali
    const formattedCandidates = nodes
      .map((n, idx) => `[${idx + 1}] ID: ${n.id} | Info: ${n.label}`)
      .join('\n');
    return `QUERY: ${query}\n\nCANDIDATE POOL (SHARED EVALUATION FRAME):\n${formattedCandidates}`;
  }
}

7. Panduan Rekayasa Lapangan & Kesimpulan Arsitektural

Bagi arsitek sistem AI yang mengelola sistem RAG berskala petabita, terobosan DecisionRAG menawarkan peta jalan migrasi yang jelas: