LightRAG: Graph RAG yang Ringan, Cepat, dan Murah untuk Dokumen Kalian

# LightRAG: Graph RAG yang Ringan, Cepat, dan Murah untuk Dokumen Kalian Halo temen-temen, kali ini kita bahas satu pendekatan RAG yang menurutku menarik banget karena dia menyelesaikan kelemahan men...

By Ruby Abdullah · · tutorial
lightraggraph-ragragknowledge-graphllm

LightRAG: Graph RAG yang Ringan, Cepat, dan Murah untuk Dokumen Kalian

Halo temen-temen, kali ini kita bahas satu pendekatan RAG yang menurutku menarik banget karena dia menyelesaikan kelemahan mendasar dari RAG biasa, namanya LightRAG. Kalau kalian pernah membangun sistem tanya jawab dokumen dengan vector database dan merasa jawabannya bagus untuk pertanyaan spesifik tapi kacau untuk pertanyaan yang butuh melihat gambaran besar, tutorial ini buat kalian.

Masalahnya begini. RAG konvensional bekerja dengan memotong dokumen jadi chunk, mengubahnya jadi embedding, lalu mencari chunk yang paling mirip dengan pertanyaan. Ini bekerja sangat baik untuk pertanyaan seperti "berapa batas maksimal reimburse?" karena jawabannya ada di satu chunk. Tapi untuk pertanyaan seperti "apa saja tema utama yang muncul di semua laporan kuartal tahun ini?" pendekatan ini gagal, karena jawabannya tersebar di puluhan chunk dan tidak ada satu pun yang secara semantik mirip dengan pertanyaannya.

GraphRAG dari Microsoft menyelesaikan masalah ini dengan membangun graf pengetahuan, tapi biayanya sangat mahal karena butuh banyak panggilan LLM untuk membangun dan meringkas komunitas. LightRAG mengambil ide graf yang sama tapi dengan pendekatan yang jauh lebih hemat. Itulah kenapa dia menarik untuk proyek dunia nyata dengan anggaran nyata.

Introduction

Kenapa RAG Biasa Punya Batas

Aku mau kalian benar-benar paham batasnya, karena banyak orang membuang waktu menyetel chunk size padahal masalahnya struktural.

RAG berbasis vektor mencari kemiripan semantik. Kalau pertanyaan kalian punya jawaban yang tertulis eksplisit di suatu tempat, dia menemukannya. Tapi ada dua jenis pertanyaan yang secara struktural tidak bisa dijawab dengan pendekatan ini.

Pertama, pertanyaan yang butuh menghubungkan informasi antar dokumen. Contohnya, "vendor mana yang muncul di proyek A dan juga proyek C?" Informasi tentang vendor di proyek A ada di satu dokumen dan proyek C di dokumen lain. Pencarian vektor mungkin menemukan salah satunya, tapi tidak punya cara menghubungkannya.

Kedua, pertanyaan agregat atau tematik. "Apa keluhan pelanggan yang paling sering muncul?" Tidak ada satu chunk pun yang berisi jawaban ini. Jawabannya harus disintesis dari keseluruhan korpus.

Bagaimana LightRAG Bekerja

LightRAG menambahkan lapisan graf di atas pencarian vektor.

Saat kalian memasukkan dokumen, LightRAG memakai LLM untuk mengekstrak entitas (orang, organisasi, produk, konsep) dan relasi antar entitas dari setiap chunk. Hasilnya disimpan sebagai graf pengetahuan, di mana simpul adalah entitas dan sisi adalah relasi. Deskripsi entitas dan relasi juga di-embed ke vector store.

Saat kalian bertanya, LightRAG melakukan pencarian di dua level sekaligus. Level rendah mencari entitas spesifik yang disebut di pertanyaan, beserta tetangga langsungnya di graf. Level tinggi mencari kata kunci tematik dan relasi yang relevan secara luas. Konteks dari kedua level itu digabungkan lalu diberikan ke LLM untuk menyusun jawaban.

Efisiensi utamanya dibanding GraphRAG adalah LightRAG tidak membangun ringkasan komunitas hierarkis yang mahal itu. Dia mengandalkan pencarian graf lokal dan global secara langsung. Hasilnya, biaya indexing dan query jauh lebih rendah, dan yang penting, penambahan dokumen baru bersifat inkremental tanpa perlu membangun ulang seluruh indeks.

Instalasi

python -m venv venv

source venv/bin/activate # Linux / Mac

venv\Scripts\activate # Windows

pip install lightrag-hku

pip install openai numpy

Untuk memakai model lokal lewat Ollama:

pip install ollama

Setup Dasar

import os

import asyncio

from lightrag import LightRAG, QueryParam

from lightrag.llm.openai import gpt4ominicomplete, openaiembed

from lightrag.kg.sharedstorage import initializepipelinestatus

os.environ["OPENAIAPIKEY"] = "sk-..."

WORKDIR = "./ragstorage"

os.makedirs(WORKDIR, existok=True)

async def buatrag():

rag = LightRAG(

workingdir=WORKDIR,

embeddingfunc=openaiembed,

llmmodelfunc=gpt4ominicomplete,

)

await rag.initializestorages()

await initializepipelinestatus()

return rag

Perhatikan workingdir. Di situlah semua indeks disimpan: graf pengetahuan, vector store entitas, vector store relasi, dan cache dokumen. Direktori ini adalah aset kalian, backup dengan benar.

Memasukkan Dokumen

import asyncio

async def main():

rag = await buatrag()

# Satu dokumen

with open("kebijakanperusahaan.txt", encoding="utf-8") as f:

await rag.ainsert(f.read())

# Banyak dokumen sekaligus

dokumen = []

for nama in ["laporanq1.txt", "laporanq2.txt", "laporanq3.txt"]:

with open(nama, encoding="utf-8") as f:

dokumen.append(f.read())

await rag.ainsert(dokumen)

print("indexing selesai")

asyncio.run(main())

Proses insert ini adalah bagian yang paling mahal, karena setiap chunk perlu satu panggilan LLM untuk ekstraksi entitas dan relasi. Untuk dokumen yang panjang, ini bisa memakan waktu beberapa menit dan biaya yang perlu kalian perhitungkan.

Tips menghemat biaya di tahap ini: pakai model murah seperti gpt-4o-mini untuk ekstraksi. Kualitas ekstraksi entitas tidak butuh model paling pintar, dan selisih biayanya besar sekali di korpus besar.

Kabar baiknya, LightRAG melakukan deduplikasi. Kalau kalian memasukkan dokumen yang sama dua kali, dia tidak memproses ulang. Dan penambahan dokumen baru bersifat inkremental, tidak perlu membangun ulang semuanya.

Empat Mode Query

Ini bagian paling penting yang harus kalian pahami, karena memilih mode yang tepat menentukan kualitas jawaban.

from lightrag import QueryParam

Mode naive: RAG vektor biasa, tanpa graf

jawaban = await rag.aquery(

"Berapa batas maksimal pengajuan reimburse?",

param=QueryParam(mode="naive"),

)

Mode local: fokus pada entitas spesifik dan tetangganya

jawaban = await rag.aquery(

"Apa peran Budi Santoso dalam proyek Alpha?",

param=QueryParam(mode="local"),

)

Mode global: fokus pada tema dan relasi luas

jawaban = await rag.aquery(

"Apa tema utama yang muncul di seluruh laporan kuartal?",

param=QueryParam(mode="global"),

)

Mode hybrid: gabungan local dan global

jawaban = await rag.aquery(

"Bagaimana hubungan antara keterlambatan vendor dan penurunan margin?",

param=QueryParam(mode="hybrid"),

)

Panduan memilih mode.

Pakai naive untuk pertanyaan faktual sederhana yang jawabannya pasti ada di satu tempat. Ini paling cepat dan paling murah.

Pakai local kalau pertanyaan menyebut entitas spesifik, misalnya nama orang, nama produk, atau nama proyek. Mode ini akan menarik entitas itu beserta relasi langsungnya.

Pakai global untuk pertanyaan tematik, ringkasan, atau pola yang tersebar di banyak dokumen.

Pakai hybrid kalau kalian tidak yakin, atau kalau pertanyaannya menggabungkan entitas spesifik dengan pertanyaan hubungan yang lebih luas. Ini default yang aman meskipun sedikit lebih mahal.

Kalau kalian membangun produk untuk pengguna akhir, aku sarankan pakai hybrid sebagai default dan sediakan opsi naive untuk pertanyaan yang jelas faktual, karena selisih kecepatannya terasa.

Mengatur Parameter Query

param = QueryParam(

mode="hybrid",

topk=60, # jumlah entitas/relasi yang diambil

maxtokenfortextunit=4000, # batas token untuk potongan teks asli

maxtokenforglobalcontext=4000, # batas token untuk konteks relasi

maxtokenforlocalcontext=4000, # batas token untuk konteks entitas

responsetype="Multiple Paragraphs", # format jawaban

)

jawaban = await rag.aquery("Ringkas risiko utama proyek tahun ini", param=param)

responsetype menerima instruksi bebas dalam bahasa alami. Kalian bisa mengisinya dengan "Single Paragraph", "Bullet Points", "Tabel Markdown", atau bahkan instruksi spesifik seperti "Jawaban singkat maksimal tiga kalimat dalam bahasa Indonesia". Ini cara termudah mengontrol format output tanpa menulis prompt sendiri.

Kalau kalian butuh melihat konteks yang diambil tanpa memanggil LLM untuk jawaban akhir, misalnya untuk debugging:

param = QueryParam(mode="hybrid", onlyneedcontext=True)

konteks = await rag.aquery("Siapa saja vendor logistik kita?", param=param)

print(konteks)

Ini sangat berguna waktu jawaban terasa salah. Sering kali masalahnya bukan di LLM, tapi di konteks yang diambil.

Memakai Model Lokal dengan Ollama

Untuk data sensitif yang tidak boleh keluar dari server kalian, semuanya bisa berjalan lokal.

import os

from lightrag import LightRAG

from lightrag.llm.ollama import ollamamodelcomplete, ollamaembed

from lightrag.utils import EmbeddingFunc

async def buatraglokal():

rag = LightRAG(

workingdir="./raglokal",

llmmodelfunc=ollamamodelcomplete,

llmmodelname="qwen2.5:14b",

llmmodelkwargs={

"host": "http://localhost:11434",

"options": {"numctx": 32768},

},

embeddingfunc=EmbeddingFunc(

embeddingdim=1024,

maxtokensize=8192,

func=lambda texts: ollamaembed(

texts, embedmodel="bge-m3", host="http://localhost:11434"

),

),

)

await rag.initializestorages()

return rag

Dua catatan penting untuk setup lokal. Pertama, numctx harus cukup besar, minimal 32768, karena ekstraksi entitas mengirim prompt yang panjang. Kalau context window terlalu kecil, ekstraksi akan terpotong dan graf kalian jadi berantakan. Ini penyebab nomor satu hasil buruk di setup lokal.

Kedua, pilih model yang cukup pintar untuk ekstraksi terstruktur. Model 7B ke bawah sering gagal mengikuti format ekstraksi. Aku sarankan minimal 14B, dan qwen2.5 atau llama3.1 bekerja cukup baik. Untuk embedding, bge-m3 bagus dan mendukung banyak bahasa termasuk bahasa Indonesia.

Melihat dan Memakai Grafnya

Salah satu keunggulan pendekatan graf adalah kalian bisa melihat apa yang sebenarnya dipahami sistem.

import networkx as nx

G = nx.readgraphml("./ragstorage/graphchunkentityrelation.graphml")

print(f"jumlah entitas: {G.numberofnodes()}")

print(f"jumlah relasi: {G.numberofedges()}")

Entitas paling terhubung, biasanya konsep paling sentral

derajat = sorted(G.degree, key=lambda x: x[1], reverse=True)

for node, d in derajat[:15]:

print(f"{d:4d} {node}")

Lihat tetangga dari satu entitas

target = "PROYEK ALPHA"

if target in G:

for tetangga in G.neighbors(target):

data = G.getedgedata(target, tetangga)

print(f"{target} -> {tetangga}: {data.get('description', '')[:80]}")

Aku selalu menjalankan ini setelah indexing pertama. Kalau entitas paling terhubung ternyata hal-hal yang tidak relevan, itu tanda ekstraksi kalian bermasalah dan perlu perbaikan prompt atau pembersihan dokumen.

Menambahkan Domain Khusus

Kalau dokumen kalian punya jenis entitas spesifik, kalian bisa memberi tahu LightRAG.

rag = LightRAG(

workingdir=WORKDIR,

embeddingfunc=openaiembed,

llmmodelfunc=gpt4ominicomplete,

addonparams={

"entitytypes": [

"orang", "organisasi", "produk", "proyek",

"vendor", "regulasi", "risiko", "lokasi",

],

"language": "Indonesian",

},

)

Menyebutkan language itu penting untuk dokumen non-Inggris. Tanpa ini, ekstraksi entitas dan deskripsinya sering keluar dalam bahasa Inggris meskipun dokumennya berbahasa Indonesia, yang membuat pencarian jadi kurang akurat.

Membungkus Jadi API

from fastapi import FastAPI

from pydantic import BaseModel

from contextlib import asynccontextmanager

from lightrag import LightRAG, QueryParam

from lightrag.llm.openai import gpt4ominicomplete, openaiembed

from lightrag.kg.sharedstorage import initializepipelinestatus

ragglobal = {}

@asynccontextmanager

async def lifespan(app: FastAPI):

rag = LightRAG(

workingdir="./ragstorage",

embeddingfunc=openaiembed,

llmmodelfunc=gpt4ominicomplete,

)

await rag.initializestorages()

await initializepipelinestatus()

ragglobal["rag"] = rag

yield

app = FastAPI(lifespan=lifespan)

class Tanya(BaseModel):

pertanyaan: str

mode: str = "hybrid"

@app.post("/tanya")

async def tanya(req: Tanya):

rag = ragglobal["rag"]

jawaban = await rag.aquery(

req.pertanyaan,

param=QueryParam(mode=req.mode, responsetype="Multiple Paragraphs"),

)

return {"jawaban": jawaban, "mode": req.mode}

class Dokumen(BaseModel):

teks: str

@app.post("/dokumen")

async def tambahdokumen(req: Dokumen):

rag = ragglobal["rag"]

await rag.ainsert(req.teks)

return {"status": "berhasil"}

Perhatikan pemakaian lifespan. Inisialisasi storage dilakukan sekali saat startup, bukan per request, karena memuat graf dan vector store memakan waktu.

Tips dan Best Practice

Bersihkan dokumen sebelum insert. Header, footer, nomor halaman, dan teks navigasi yang berulang akan menghasilkan entitas sampah yang mengotori graf kalian.

Pakai model murah untuk ekstraksi dan model pintar untuk menjawab. Kalian bisa mengatur ini dengan membuat dua konfigurasi berbeda, dan penghematannya signifikan.

Selalu periksa grafnya setelah indexing pertama. Lima menit melihat entitas teratas menghemat berjam-jam menebak-nebak kenapa jawabannya jelek.

Untuk dokumen berbahasa Indonesia, selalu set language di addon_params, dan sebutkan jenis entitas yang relevan dengan domain kalian.

Jangan pakai mode global untuk pertanyaan faktual sederhana. Kalian membayar lebih mahal untuk jawaban yang justru lebih kabur.

Backup direktori kerja kalian. Membangun ulang indeks untuk korpus besar itu mahal dalam waktu dan uang.

Evaluasi dengan set pertanyaan yang mencakup kedua tipe: faktual spesifik dan tematik luas. Kalau kalian hanya menguji dengan pertanyaan faktual, kalian tidak akan pernah tahu apakah lapisan grafnya benar-benar memberi nilai tambah.

Kesimpulan

LightRAG adalah titik tengah yang bagus antara RAG vektor sederhana yang murah tapi terbatas, dan GraphRAG yang kuat tapi mahal. Ringkasannya:

RAG vektor gagal secara struktural pada pertanyaan yang butuh menghubungkan informasi antar dokumen atau membutuhkan sintesis tematik.

LightRAG membangun graf entitas dan relasi saat indexing, lalu memakai pencarian dua level saat query.

Empat mode query melayani kebutuhan berbeda: naive untuk fakta sederhana, local untuk entitas spesifik, global untuk tema, dan hybrid sebagai default yang aman.

Penambahan dokumen bersifat inkremental, yang membuatnya jauh lebih praktis untuk sistem yang terus bertambah datanya dibanding pendekatan yang harus membangun ulang indeks.

Semuanya bisa berjalan lokal dengan Ollama, asal context window cukup besar dan modelnya cukup pintar untuk ekstraksi terstruktur.

Graf yang dihasilkan bisa kalian inspeksi langsung, dan itu alat debugging yang sangat berharga.

Coba ambil sepuluh dokumen internal di kantor kalian, index dengan LightRAG, lalu ajukan dua jenis pertanyaan: satu yang jawabannya jelas ada di satu dokumen, dan satu yang butuh melihat pola di semua dokumen. Bandingkan hasilnya dengan RAG vektor biasa yang kalian punya. Selisih di pertanyaan tipe kedua itulah nilai sebenarnya dari pendekatan graf. Selamat mencoba.

Artikel Terkait

Tutorial Lengkap Unstructured: Preprocessing Dokumen untuk RAG dan Aplikasi LLM

Tutorial Lengkap Unstructured: Preprocessing Dokumen untuk RAG dan Aplikasi LLM Dalam membangun aplikasi Retrieval-Augme...

DSPy: Berhenti Ngoprek Prompt Manual, Biarkan Compiler yang Optimasi

DSPy: Berhenti Ngoprek Prompt Manual, Biarkan Compiler yang Optimasi Halo temen-temen, kali ini aku mau ngenalin satu li...

RAGFlow: Bikin RAG Engine yang Ngerti Dokumen Beneran, Lengkap dengan Sitasi

RAGFlow: Bikin RAG Engine yang Ngerti Dokumen Beneran, Lengkap dengan Sitasi Halo temen-temen, balik lagi sama aku. Kala...

Cognee: Bangun Memory dan Knowledge Graph untuk AI Agent-mu

Cognee: Bangun Memory dan Knowledge Graph untuk AI Agent-mu Halo temen-temen, di tutorial kali ini aku mau ngajak kalian...