LlamaIndex: RAG Pipelines, Indexes & LLM Integration

Quickstart: Build a RAG Pipeline in 10 Lines

Install with pip install llama-index. Load documents, index, and query:

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

# Configure LLM and embedding model globally
Settings.llm = OpenAI(model="gpt-4o-mini", temperature=0.1)
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")
Settings.chunk_size = 512
Settings.chunk_overlap = 50

# Load all documents from a directory (PDFs, .txt, .md, .docx)
documents = SimpleDirectoryReader("./docs").load_data()
print(f"Loaded {len(documents)} documents")

# Build a VectorStoreIndex — chunks docs, embeds, stores vectors
index = VectorStoreIndex.from_documents(
    documents,
    show_progress=True,
)

# Create a query engine
query_engine = index.as_query_engine(
    similarity_top_k=5,          # retrieve top 5 most relevant chunks
    response_mode="compact",     # compact | refine | tree_summarize
)

# Ask questions
response = query_engine.query("What are the main product features?")
print(response)
print(f"Sources: {[n.node.metadata['file_name'] for n in response.source_nodes]}")

Advanced RAG: Reranking, HyDE & Sub-Questions

Improve retrieval quality with advanced patterns beyond basic top-K similarity search:

from llama_index.core import VectorStoreIndex
from llama_index.core.postprocessor import SentenceTransformerRerank
from llama_index.core.query_engine import SubQuestionQueryEngine
from llama_index.core.tools import QueryEngineTool, ToolMetadata
from llama_index.core.retrievers import VectorIndexRetriever

# --- Pattern 1: Reranking (retrieve more, rerank to top-K) ---
retriever = VectorIndexRetriever(index=index, similarity_top_k=20)  # fetch 20

# Rerank the 20 results down to the best 5 using a cross-encoder
reranker = SentenceTransformerRerank(
    model="cross-encoder/ms-marco-MiniLM-L-2-v2",
    top_n=5,
)

from llama_index.core.query_engine import RetrieverQueryEngine
from llama_index.core.response_synthesizers import get_response_synthesizer

query_engine = RetrieverQueryEngine(
    retriever=retriever,
    response_synthesizer=get_response_synthesizer(),
    node_postprocessors=[reranker],
)

# --- Pattern 2: HyDE (Hypothetical Document Embeddings) ---
from llama_index.core.indices.query.query_transform import HyDEQueryTransform
from llama_index.core.query_engine import TransformQueryEngine

base_engine = index.as_query_engine(similarity_top_k=5)
hyde_transform = HyDEQueryTransform(include_original=True)
# HyDE: LLM generates a hypothetical answer, embed that instead of the query
hyde_engine = TransformQueryEngine(base_engine, query_transform=hyde_transform)

# --- Pattern 3: Sub-Question Decomposition ---
# For complex multi-part queries, decompose into sub-questions
tools = [QueryEngineTool(query_engine=index.as_query_engine(), metadata=ToolMetadata(
    name="product_docs", description="Company product documentation"
))]
sub_question_engine = SubQuestionQueryEngine.from_defaults(query_engine_tools=tools)
response = sub_question_engine.query(
    "Compare the pricing and features of our starter vs enterprise plans"
)

Local RAG with Ollama (No API Keys)

Run a fully local RAG pipeline using Ollama and persisted vector store:

import os
from llama_index.core import (
    VectorStoreIndex, SimpleDirectoryReader,
    StorageContext, load_index_from_storage, Settings
)
from llama_index.llms.ollama import Ollama
from llama_index.embeddings.ollama import OllamaEmbedding

# Configure local models (Ollama must be running: ollama pull llama3)
Settings.llm = Ollama(model="llama3", request_timeout=60.0)
Settings.embed_model = OllamaEmbedding(model_name="nomic-embed-text")

PERSIST_DIR = "./storage"

if not os.path.exists(PERSIST_DIR):
    # First run: build and persist the index
    documents = SimpleDirectoryReader("./docs").load_data()
    index = VectorStoreIndex.from_documents(documents)
    index.storage_context.persist(persist_dir=PERSIST_DIR)
    print("Index built and persisted")
else:
    # Subsequent runs: load from disk (no re-indexing)
    storage_context = StorageContext.from_defaults(persist_dir=PERSIST_DIR)
    index = load_index_from_storage(storage_context)
    print("Index loaded from disk")

# Chat engine with memory (multi-turn conversation)
chat_engine = index.as_chat_engine(
    chat_mode="condense_plus_context",
    verbose=True,
)
response = chat_engine.chat("What does our return policy say?")
follow_up = chat_engine.chat("And what about international orders?")  # remembers context

LlamaIndex vs LangChain vs Haystack vs DSPy