Belajar ChromaDB - Integrasi dengan Framework LLM

#Pendahuluan

Semua kemampuan ChromaDB yang kalian bangun sejak episode 0 sekarang akan bersatu. Episode 18 membahas integrasi dengan framework LLM — bagian yang mengubah ChromaDB dari database menjadi mesin retrieval yang siap dipakai pipeline RAG.

Kita akan membahas integrasi LangChain sebagai VectorStore dan retriever, adapter LlamaIndex dan framework lain, lalu merangkainya menjadi pola RAG production yang utuh: chunking, embedding, storage, dan query dalam satu alur. Ini adalah episode yang menjawab "jadi, gimana cara pakainya?".

#LangChain: Chroma sebagai VectorStore

#Instalasi dan Membuat VectorStore

Integrasi resmi LangChain hidup di paket langchain-chroma. Install dan sambungkan:

pip install langchain langchain-chroma

VectorStore LangChain

from langchain_chroma import Chroma
 
vectorstore = Chroma(
    collection_name="dokumen",
    persist_directory="./chroma-data",
    embedding_function=embedding_model,
)

Chroma(collection_name="dokumen", persist_directory="./chroma-data", embedding_function=embedding_model) membuat VectorStore yang dibungkus di atas ChromaDB. Semua kompleksitas di episode 3-10 disembunyikan — LangChain mengelola collection dan embedding function untuk kalian.

#Menyimpan Dokumen

Dengan VectorStore, menyimpan dokumen menjadi sepanggil:

Menambah dokumen lewat LangChain

from langchain_text_splitters import RecursiveCharacterTextSplitter
 
splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.split_text(dokumen_panjang)
 
vectorstore.add_texts(
    texts=chunks,
    metadatas=[{"source": "manual"} for _ in chunks],
)

splitter.split_text(dokumen_panjang) memecah dokumen memakai chunking dari episode 10, lalu vectorstore.add_texts(...) menyimpannya. Perhatikan bahwa chunk_size dan chunk_overlap di sini adalah realisasi langsung strategi episode 10.

#Retriever dan RAG Chain Lengkap

#Menjadikan VectorStore Retriever

Mengubah VectorStore menjadi retriever semudah memanggil .as_retriever():

Retriever dari VectorStore

retriever = vectorstore.as_retriever(
    search_type="similarity",
    search_kwargs={"k": 4},
)

vectorstore.as_retriever(search_type="similarity", search_kwargs={"k": 4}) menghasilkan retriever yang mengembalikan 4 dokumen teratas untuk setiap pertanyaan. Parameter k setara n_results dari episode 5.

#Membangun RAG Chain Lengkap

Sekarang rakit semuanya menjadi pipeline jawaban:

RAG chain dengan LangChain

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
 
llm = ChatOpenAI(model="gpt-4o-mini")
 
prompt = ChatPromptTemplate.from_template(
    "Jawab berdasarkan konteks ini:\n{context}\n\nPertanyaan: {question}"
)
 
def jawab(pertanyaan):
    dokumen = retriever.invoke(pertanyaan)
    konteks = "\n\n".join(d.text for d in dokumen)
    pesan = prompt.format_messages(context=konteks, question=pertanyaan)
    return llm.invoke(pesan).content

Fungsi jawab(pertanyaan) menjalankan pola RAG paling inti: retrieve konteks dari ChromaDB, tempel ke prompt, lalu generate jawaban dengan LLM. Inilah alur embed → store → retrieve → generate dari episode 0 dalam bentuk nyata.

#LlamaIndex dan Framework Lain

#ChromaDB sebagai VectorStore LlamaIndex

LlamaIndex juga punya adapter resmi. Alurnya: buat storage context, lalu gunakan VectorStoreIndex:

ChromaDB di LlamaIndex

import chromadb
from llama_index.core import VectorStoreIndex, StorageContext
from llama_index.vector_stores.chroma import ChromaVectorStore
 
chroma_client = chromadb.PersistentClient(path="./chroma-data")
collection = chroma_client.get_collection("dokumen")
 
vector_store = ChromaVectorStore(chroma_collection=collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)
index = VectorStoreIndex.from_documents(documents, storage_context=storage_context)

ChromaVectorStore(chroma_collection=collection) membungkus collection ChromaDB menjadi vector store LlamaIndex. Dari sini, index.as_query_engine() bisa langsung dipakai untuk bertanya.

#Framework Lain di Ekosistem

ChromaDB juga terintegrasi dengan framework lain seperti Haystack dan LlamaStack. Polanya konsisten di mana pun: framework menyediakan adapter, ChromaDB menyediakan storage dan retrieval, dan embedding function tetap dari episode 6. Kuncinya bukan menghafal API tiap framework, melainkan memahami konsep VectorStore — begitu paham, semua adapter terasa familiar.

#Pola RAG Production yang Direkomendasikan

#Arsitektur Utuh

Merangkum episode 0-18 menjadi arsitektur RAG yang siap produksi:

dokumen ──chunk──> embedding ──store──> ChromaDB
                                                │
pertanyaan ──embed──> query ──filter+rerank──> konteks
                                                │
konteks + pertanyaan ──prompt──> LLM ──> jawaban

Pipeline di atas menggabungkan: chunking (episode 10), embedding (episode 6), filter metadata (episode 7), hybrid dan rerank (episode 8), serta LLM sebagai generator. Setiap tahap sudah kalian kuasai di episode masing-masing.

#Checklist Integrasi

Sebelum mendarat ke produksi, pastikan:

• Embedding function konsisten antara ingestion dan query.
• Retriever memakai filter metadata yang relevan (episode 7).
• Pertimbangkan hybrid + rerank untuk akurasi (episode 8).
• Server dan klien terhubung lewat HttpClient (episode 12).
• Auth, TLS, dan network isolation aktif (episode 13-15).

Retriever production dengan filter

retriever = vectorstore.as_retriever(
    search_kwargs={
        "k": 6,
        "filter": {"status": "published"},
    }
)

retriever.as_retriever(search_kwargs={"k": 6, "filter": {"status": "published"}}) menyuntikkan filter metadata langsung ke retrieval — realisasi pra-filter dari episode 17 di level framework.

#Penutup

Episode 18 menyatukan seluruh series menjadi satu tujuan: RAG yang berfungsi. Kalian sudah bisa menjadikan ChromaDB VectorStore dan retriever di LangChain, memakai adapter LlamaIndex, dan merakit pipeline RAG production dari chunking hingga jawaban. ChromaDB bukan lagi sekadar database — ia adalah mesin retrieval dari aplikasi AI kalian.

Inti yang harus dibawa pulang:

• langchain_chroma membungkus ChromaDB sebagai VectorStore dan retriever.
• Chunking di framework mewujudkan strategi episode 10.
• as_retriever() mengubah VectorStore menjadi komponen RAG.
• LlamaIndex memakai ChromaVectorStore sebagai adapter.
• Pola RAG: chunk → embed → store → retrieve → generate.
• Filter dan rerank dari episode 7-8 langsung bisa disuntikkan.

Di episode 19 selanjutnya kita akan membahas advanced query patterns — multi-vector dan multimodal dengan beberapa embedding per dokumen, image dan text embedding, serta feedback loop dengan relevance scoring dan human feedback untuk tuning retrieval yang berkelanjutan. Retrieval kalian mulai cerdas; saatnya membuatnya lebih cerdas.