Build Production-Ready Agentic RAG dengan Python

Agentic RAG bukan lagi sekadar proof-of-concept di lab. Startup dan enterprise mulai adopt pattern ini untuk meningkatkan akurasi LLM dengan data internal mereka. Masalahnya, kebanyakan tutorial di internet berhenti di level quickstart tanpa membahas error handling, observability, dan skalabilitas. Padahal, begitu masuk production, justru aspek-aspek itulah yang paling kritis.

Dalam tutorial ini, kita akan membangun pipeline Agentic RAG yang production-ready menggunakan Python. Sumber inspirasi utama berasal dari Production Agentic RAG Course di GitHub yang trending minggu ini. Kita akan ambil konsep intinya dan aplikasikan dalam arsitektur yang bisa kamu deploy ke VPS atau cloud environment.

Langkah 1: Setup Environment dan Install Dependencies

Pastikan kamu sudah punya Python 3.10 atau lebih baru. Buat virtual environment agar dependencies tidak bentrok dengan project lain.

python -m venv venv
source venv/bin/activate  # Linux/Mac
venv\Scripts\activate     # Windows

pip install langchain langchain-community chromadb openai python-dotenv

Buat file .env untuk menyimpan API key dan konfigurasi sensitif. Jangan hardcode API key di source code, itu rookie mistake yang bisa berakibat fatal kalau repo-nya public.

Langkah 2: Arsitektur RAG dengan Vector Store

RAG (Retrieval-Augmented Generation) bekerja dengan menggabungkan retrieval dari knowledge base dengan generasi teks dari LLM. Untuk production, jangan pakai in-memory vector store. Gunakan ChromaDB atau PostgreSQL dengan pgvector agar data persistent dan queryable.

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings()
vectorstore = Chroma(
    persist_directory="./chroma_db",
    embedding_function=embeddings
)

Upload dokumen internal ke vector store dengan chunking strategy yang bijak. Ukuran chunk 500-1000 token dengan overlap 100-200 token biasanya sweet spot untuk dokumentasi teknis. Pertimbangkan juga menggunakan parent-child chunking untuk menjaga konteks hierarchical.

Untuk data yang sensitif, enkripsi vector store atau gunakan on-premise deployment. Jangan asal pakai managed vector DB tanpa mengevaluasi compliance requirement data perusahaanmu.

Langkah 3: Integrasi AI Agent dengan Tool Calling

Ini pembedanya antara RAG biasa dengan Agentic RAG. Agent punya kemampuan untuk memilih tool yang tepat berdasarkan konteks query. Kita definisikan tool retrieval sebagai callable yang bisa dipanggil agent.

from langchain.agents import Tool, AgentExecutor
from langchain.agents.react.agent import create_react_agent

retriever = vectorstore.as_retriever(search_kwargs={"k": 5})

tools = [
    Tool(
        name="knowledge_base",
        func=retriever.get_relevant_documents,
        description="Gunakan tool ini untuk mencari informasi dari dokumen internal."
    )
]

agent = create_react_agent(llm, tools, prompt)
agent_executor = AgentExecutor(agent=agent, tools=tools, verbose=True)

Pastikan deskripsi tool jelas dan spesifik. Agent memutuskan pakai tool mana berdasarkan deskripsi ini. Selain itu, tambahkan max iteration limit untuk menghindari infinite loop kalau agent stuck dalam reasoning cycle.

Langkah 4: Implementasi Fallback dan Error Handling

Di production, LLM bisa hallucinate, API bisa timeout, atau vector store bisa unreachable. Wajib implement fallback chain.

from langchain.chains import LLMChain, SimpleSequentialChain

fallback_chain = LLMChain(llm=llm, prompt=fallback_prompt)

try:
    result = agent_executor.invoke({"input": user_query})
except Exception as e:
    result = fallback_chain.invoke({"input": user_query})
    log_error(e)  # Kirim ke Sentry atau logging service

Tambahkan retry logic dengan exponential backoff untuk API call. Rate limit OpenAI dan provider lain bisa menggagalkan request kamu di peak hours. Gunakan circuit breaker pattern kalau failure rate melebihi threshold tertentu.

Logging tidak cukup dengan print statement. Integrasikan dengan Sentry, Datadog, atau OpenTelemetry untuk distributed tracing. Di sistem Agentic RAG, trace tiap langkah reasoning sangat penting untuk debugging.

Langkah 5: Deployment dan Monitoring

Deploy agent sebagai REST API menggunakan FastAPI atau framework yang kamu prefer. Bungkus dalam container Docker agar environment reproducible.

FROM python:3.11-slim
WORKDIR /app
COPY requirements.txt .
RUN pip install -r requirements.txt
COPY . .
CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Setup observability dengan LangSmith atau alternative open-source seperti Langfuse. Track latency, token usage, dan retrieval accuracy. Data ini esensial untuk optimasi berkelanjutan.

Setelah deploy, lakukan load testing dengan Locust atau k6. Agentic RAG cenderung lebih lambat dari RAG tradisional karena reasoning loop-nya. Optimasi dengan caching dan parallel tool execution sangat direkomendasikan.

Tutorial ini berdasarkan materi dari Production Agentic RAG Course. Repo tersebut menyediakan implementasi lengkap dengan eval framework dan contoh dataset yang bisa langsung kamu adaptasi ke use case sendiri.

Tips Optimasi Query dan Re-ranking

Retrieval quality menentukan seberapa baik jawaban AI-mu. Jangan hanya andalkan cosine similarity. Implement hybrid search yang menggabungkan dense retrieval dengan keyword matching menggunakan BM25 atau TF-IDF.

from langchain.retrievers import EnsembleRetriever

ensemble = EnsembleRetriever(
    retrievers=[dense_retriever, bm25_retriever],
    weights=[0.6, 0.4]
)

Tambahkan re-ranking layer menggunakan cross-encoder model seperti BAAI/bge-reranker-base. Re-ranker ini mengevaluasi relevance antara query dan retrieved documents secara langsung, menghasilkan ranking yang jauh lebih akurat dibanding embedding similarity saja.

Evaluasi retrieval secara berkala dengan metrik seperti MRR (Mean Reciprocal Rank) dan NDCG. Dataset evaluasi tidak harus besar; 50-100 query labeled sudah cukup untuk mengukur improvement dari setiap optimasi.

Untuk production scale, pertimbangkan menggunakan message queue seperti Redis Streams atau RabbitMQ antara retrieval layer dan generation layer. Ini memungkinkan horizontal scaling dan menjaga sistem tetap responsif meski traffic melonjak tiba-tiba.