LangChain vs LlamaIndex: A Production Engineering Comparison for RAG

# =============================================================================
# LANGCHAIN 0.2 LCEL RAG PIPELINE
# =============================================================================
from langchain_openai import ChatOpenAI, OpenAIEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.retrievers.multi_query import MultiQueryRetriever
from langchain_cohere import CohereRerank
from langchain.retrievers import ContextualCompressionRetriever
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
from langchain_core.runnables import RunnablePassthrough
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain_community.document_loaders import DirectoryLoader
import os

def build_langchain_rag(docs_path: str, collection_name: str) -> callable:
    """Build a production LangChain LCEL RAG pipeline with multi-query and reranking."""
    # Load and split documents
    loader = DirectoryLoader(docs_path, glob="**/*.pdf")
    docs = loader.load()

    splitter = RecursiveCharacterTextSplitter(
        chunk_size=512,
        chunk_overlap=64,
        separators=["\n\n", "\n", ". ", " "]
    )
    chunks = splitter.split_documents(docs)

    # Build vector store
    embeddings = OpenAIEmbeddings(model="text-embedding-3-large")
    vectorstore = Chroma.from_documents(
        documents=chunks,
        embedding=embeddings,
        collection_name=collection_name,
        persist_directory=f"./chroma_db/{collection_name}"
    )

    # Multi-query retriever: generates 3 query variants to improve recall
    base_retriever = vectorstore.as_retriever(search_kwargs={"k": 20})
    llm = ChatOpenAI(model="gpt-4o-mini", temperature=0)  # cheaper model for query gen
    multi_query_retriever = MultiQueryRetriever.from_llm(
        retriever=base_retriever,
        llm=llm
    )

    # Cohere reranker: reduces 20 candidates to top 5 by relevance
    compressor = CohereRerank(model="rerank-english-v3.0", top_n=5)
    compression_retriever = ContextualCompressionRetriever(
        base_compressor=compressor,
        base_retriever=multi_query_retriever
    )

    # RAG chain via LCEL
    generation_llm = ChatOpenAI(model="gpt-4o", temperature=0)
    prompt = ChatPromptTemplate.from_template("""
    You are an enterprise knowledge assistant. Answer the question based strictly on the
    provided context. If the answer is not in the context, say "I don't have that information."

    Context:
    {context}

    Question: {question}

    Answer:
    """)

    def format_docs(docs):
        return "\n\n".join(f"[Source: {d.metadata.get('source', 'unknown')}]\n{d.page_content}" for d in docs)

    rag_chain = (
        {"context": compression_retriever | format_docs, "question": RunnablePassthrough()}
        | prompt
        | generation_llm
        | StrOutputParser()
    )
    return rag_chain


# =============================================================================
# LLAMAINDEX 0.10 EQUIVALENT PIPELINE
# =============================================================================
from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.retrievers import VectorIndexRetriever
from llama_index.core.node_parser import SentenceSplitter
from llama_index.core.postprocessor import SentenceTransformerRerank
from llama_index.llms.openai import OpenAI as LlamaOpenAI
from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.core.indices.query.query_transform import HyDEQueryTransform
from llama_index.core.query_engine import TransformQueryEngine

def build_llamaindex_rag(docs_path: str) -> callable:
    """Build an equivalent LlamaIndex 0.10 RAG pipeline with HyDE and reranking."""
    # Configure global settings (0.10 pattern — replaces ServiceContext)
    Settings.llm = LlamaOpenAI(model="gpt-4o", temperature=0)
    Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-large")
    Settings.node_parser = SentenceSplitter(chunk_size=512, chunk_overlap=64)

    # Load documents and build index
    documents = SimpleDirectoryReader(docs_path, required_exts=[".pdf"]).load_data()
    index = VectorStoreIndex.from_documents(documents, show_progress=True)

    # Configure retriever
    retriever = VectorIndexRetriever(
        index=index,
        similarity_top_k=20
    )

    # Sentence transformer reranker (local, no API cost)
    reranker = SentenceTransformerRerank(
        model="cross-encoder/ms-marco-MiniLM-L-2-v2",
        top_n=5
    )

    # Base query engine with reranking
    query_engine = RetrieverQueryEngine(
        retriever=retriever,
        node_postprocessors=[reranker]
    )

    # HyDE: generate a hypothetical document to improve retrieval recall
    # This is a first-class LlamaIndex feature; requires manual LCEL chain in LangChain
    hyde_transform = HyDEQueryTransform(include_original=True)
    hyde_query_engine = TransformQueryEngine(query_engine, query_transform=hyde_transform)

    return hyde_query_engine


if __name__ == "__main__":
    # LangChain usage
    lc_chain = build_langchain_rag("./enterprise_docs", "enterprise_kb")
    lc_answer = lc_chain.invoke("What are our data retention obligations under the MSA?")
    print("LangChain:", lc_answer)

    # LlamaIndex usage
    li_engine = build_llamaindex_rag("./enterprise_docs")
    li_response = li_engine.query("What are our data retention obligations under the MSA?")
    print("LlamaIndex:", li_response)