LlamaIndex: Data Framework for LLM Applications & RAG

Core Pipeline: Load, Index, and Query

The fundamental LlamaIndex workflow — load documents, build a VectorStoreIndex, and query with natural language.

pip install llama-index llama-index-embeddings-openai llama-index-llms-openai

from llama_index.core import (
    SimpleDirectoryReader,
    VectorStoreIndex,
    Settings,
    StorageContext,
    load_index_from_storage
)
from llama_index.llms.openai import OpenAI
from llama_index.embeddings.openai import OpenAIEmbedding

# Global settings — applied to all indexes and query engines
Settings.llm = OpenAI(model="gpt-4o-mini", temperature=0)
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")
Settings.chunk_size = 1024
Settings.chunk_overlap = 128

# Load documents from a directory (supports PDF, DOCX, MD, TXT, HTML, CSV...)
documents = SimpleDirectoryReader("./data").load_data()
print(f"Loaded {len(documents)} documents")

# Build a VectorStoreIndex (embeddings auto-generated for each chunk)
index = VectorStoreIndex.from_documents(documents, show_progress=True)

# Persist to disk
index.storage_context.persist(persist_dir="./index_storage")

# Later: reload from disk (no re-embedding needed)
storage_context = StorageContext.from_defaults(persist_dir="./index_storage")
loaded_index = load_index_from_storage(storage_context)

# Create a query engine and ask questions
query_engine = loaded_index.as_query_engine(similarity_top_k=4)
response = query_engine.query("What is the main architecture of the system?")
print(response)
# Access source nodes used for the answer
for node in response.source_nodes:
    print(f"  score={node.score:.3f} | {node.text[:100]}...")

Custom Node Parsing & Metadata Enrichment

Control how Documents are split into Nodes and enrich Nodes with metadata for better retrieval.

from llama_index.core.node_parser import (
    SentenceSplitter,
    SemanticSplitterNodeParser,
    HierarchicalNodeParser
)
from llama_index.core.extractors import (
    TitleExtractor,
    QuestionsAnsweredExtractor,
    SummaryExtractor
)
from llama_index.core.ingestion import IngestionPipeline

# Build an ingestion pipeline with custom transformations
pipeline = IngestionPipeline(
    transformations=[
        # Hierarchical splitter: creates parent (512) + child (128) chunks
        HierarchicalNodeParser.from_defaults(chunk_sizes=[512, 128]),

        # Auto-extract metadata using LLM
        TitleExtractor(nodes=3),               # extract document titles
        QuestionsAnsweredExtractor(questions=3), # what questions does this answer?
    ]
)

nodes = pipeline.run(documents=documents)
print(f"Created {len(nodes)} nodes from {len(documents)} documents")
for node in nodes[:2]:
    print(f"  chars={len(node.text)} | metadata={list(node.metadata.keys())}")

# Auto-merging retriever (retrieves child chunks, merges to parent context)
from llama_index.core.retrievers import AutoMergingRetriever
from llama_index.core.storage.docstore import SimpleDocumentStore

docstore = SimpleDocumentStore()
docstore.add_documents(nodes)
index = VectorStoreIndex(nodes)

base_retriever = index.as_retriever(similarity_top_k=12)
auto_merging_retriever = AutoMergingRetriever(
    base_retriever, storage_context=index.storage_context, verbose=True
)

Query Routing & Multi-Document Synthesis

Route queries to different indexes automatically, or break complex questions into sub-questions.

from llama_index.core.tools import QueryEngineTool
from llama_index.core.query_engine import SubQuestionQueryEngine, RouterQueryEngine
from llama_index.core.selectors import LLMSingleSelector

# Create specialized indexes for different document sets
qdrant_index = VectorStoreIndex.from_documents(qdrant_docs)
milvus_index  = VectorStoreIndex.from_documents(milvus_docs)

# Wrap as tools with descriptions for routing
tools = [
    QueryEngineTool.from_defaults(
        query_engine=qdrant_index.as_query_engine(),
        name="qdrant_guide",
        description="Information about Qdrant vector database, payload filtering, and sparse vectors"
    ),
    QueryEngineTool.from_defaults(
        query_engine=milvus_index.as_query_engine(),
        name="milvus_guide",
        description="Information about Milvus distributed database, DiskANN, and billion-scale search"
    ),
]

# RouterQueryEngine — LLM picks which tool to use
router_engine = RouterQueryEngine(
    selector=LLMSingleSelector.from_defaults(),
    query_engine_tools=tools,
    verbose=True
)
response = router_engine.query("How does Qdrant's payload filtering compare to SQL WHERE clauses?")
print(response)

# SubQuestionQueryEngine — breaks complex queries into sub-questions
sub_engine = SubQuestionQueryEngine.from_defaults(query_engine_tools=tools, verbose=True)
response = sub_engine.query(
    "Compare the index types supported by Qdrant and Milvus, and which is better for 1B vectors?"
)

LlamaIndex vs LangChain vs Haystack