LlamaIndex: indexes, query engines & retrievers

If LangChain and LangGraph are about orchestrating agents, LlamaIndex is about feeding them — it’s the data framework that turns your messy documents into something an LLM can query. It’s one of the three frameworks the major agent courses teach, and in 2026 it has grown well beyond “a RAG library” into the leading platform for document agents. This lesson is the on-ramp.

The LlamaIndex vocabulary

LlamaIndex’s whole design is that every step of RAG is a named, swappable component. Learn the five nouns and you can read any LlamaIndex codebase:

• Documents — raw content loaded from a source (PDF, web page, database) by a loader / reader.
• Nodes — the chunks a node parser splits Documents into, each with text + metadata. (LlamaIndex calls chunks “Nodes.”)
• Index — a structure built over the Nodes for fast lookup. The default, VectorStoreIndex, embeds each Node and stores the vectors.
• Retriever — given a query, fetches the most relevant Nodes from the Index.
• Response Synthesizer — composes the final answer from the retrieved Nodes (and a Query Engine wraps retriever + synthesizer into one .query() call).

The five nouns split across two phases — an expensive offline build that hands its index to a cheap online query:

The five lines that do it

The reason LlamaIndex is beginner-friendly: the defaults wire all of that together for you.

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader

documents = SimpleDirectoryReader("./docs").load_data()   # loader → Documents
index = VectorStoreIndex.from_documents(documents)        # parse → embed → index
query_engine = index.as_query_engine()                    # retriever + synthesizer
response = query_engine.query("What's our refund window?") # retrieve → synthesize
print(response)            # grounded answer
print(response.source_nodes)  # the Nodes it used — citations for free

Five lines, and you have grounded RAG. But because each piece is a component, you can swap any of them — a smarter node parser, a hybrid retriever, a re-ranking synthesizer — without rewriting the rest.

# A miniature LlamaIndex, to feel the component pipeline (no install needed).
class Node:
    def __init__(self, text, meta): self.text, self.meta = text, meta

# 1) Loader -> Documents  2) Node parser -> Nodes
doc = "Enterprise plans: full refund within 30 days. Starter: non-refundable."
nodes = [Node(s.strip(), {"id": i}) for i, s in enumerate(doc.split(".")) if s.strip()]

# 3) Index = Nodes + a (mock) keyword retriever
def retrieve(query, nodes, k=1):
    q = set(query.lower().split())
    scored = [(len(q & set(n.text.lower().split())), n) for n in nodes]
    scored.sort(key=lambda x: -x[0])
    return [n for _, n in scored[:k]]

# 4) Query engine = retrieve + synthesize
def query(q):
    hits = retrieve(q, nodes)
    ctx = " ".join(n.text for n in hits)
    return f"[answer grounded in]: {ctx}", [n.meta for n in hits]

ans, sources = query("enterprise refund")
print(ans)
print("source nodes:", sources)

[answer grounded in]: Enterprise plans: full refund within 30 days
source nodes: [{'id': 0}]

Trace the five components: one Document becomes two Nodes (split on .), the keyword “index” scores each Node against the query, the retriever returns the best one, and the query engine synthesizes an answer plus the source Node’s metadata — citations for free. Swap any piece (a smarter parser, a vector retriever, a re-ranking synthesizer) and the rest is unchanged.

In one breath

• LlamaIndex is the data framework — it turns messy documents into a queryable index through five named, swappable components.
• Learn the five nouns: Documents (loaded), Nodes (chunks), Index (embedded structure), Retriever (fetches Nodes), Response Synthesizer (composes the answer) — and a Query Engine wraps retriever + synthesizer behind .query().
• It splits an offline build (load → parse → embed → index, expensive, once) from online querying (retrieve → synthesize, cheap, per question).
• Five default lines get you grounded RAG with source_nodes for free, yet every stage is swappable without rewriting the rest.
• It’s not LangChain-or-LlamaIndex — many stacks use LlamaIndex for retrieval, LangGraph for the agent loop.

Quick check

Next

Modern LlamaIndex builds everything — including agents — on event-driven Workflows. And for the messy-PDF problem that breaks naive loaders, see LlamaParse.