LlamaIndex Cheat Sheet

1Install & importspip / packages

pip install llama-index★
The llama-index starter bundle pulls llama-index-core + OpenAI LLM/embedding packages. For a lean install use pip install llama-index-core and add integrations you need.
pip install llama-index-llms-anthropic llama-index-embeddings-huggingface
Everything is a separate namespace package: llama-index-llms-*, -embeddings-*, -vector-stores-*, -readers-*. Install only what you use.
from llama_index.core import ( VectorStoreIndex, SimpleDirectoryReader, Settings, StorageContext)★
Core abstractions live under llama_index.core. Provider classes live under their own module, e.g. from llama_index.llms.openai import OpenAI.
export OPENAI_API_KEY="sk-..."
Default LLM/embeddings are OpenAI unless you override Settings (card 3). Python 3.9+.

2RAG in five linesthe whole idea

docs = SimpleDirectoryReader("data").load_data()★
1— Load every file in a folder into Document objects (PDF, docx, md, txt, and more).
index = VectorStoreIndex.from_documents(docs)★
2— Chunk, embed, and store. Builds an in-memory vector index by default.
qe = index.as_query_engine() resp = qe.query("What is X?")★
3— Retrieve top chunks + synthesize an answer. str(resp) is the text; resp.source_nodes is the evidence.
print(resp) # the grounded answer resp.source_nodes # retrieved chunks + scores
That is retrieval-augmented generation end to end. Everything below is swapping or tuning one of these three steps.

3Settings, LLMs & embeddingsglobal config

from llama_index.core import Settings from llama_index.llms.openai import OpenAI Settings.llm = OpenAI(model="gpt-4o-mini")★
Settings is the global config (it replaced the old ServiceContext). Set it once and every index/engine uses it.
from llama_index.embeddings.openai import OpenAIEmbedding Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")★
Embeddings drive both indexing and retrieval — keep the same model for both. HuggingFace/local via llama-index-embeddings-huggingface.
Settings.chunk_size = 512 · Settings.chunk_overlap = 20
Global chunking defaults (used when no explicit node parser is given).
llm.complete("...") · llm.chat([ChatMessage(...)]) · llm.stream_complete(...)
Any LLM can be called directly. from llama_index.core.llms import ChatMessage. Async twins: acomplete, achat.
qe = index.as_query_engine(llm=OpenAI(model="gpt-4o"))
Override per engine/index too — the llm= / embed_model= kwargs beat the global Settings.

4Loading data & documentsconnect sources

SimpleDirectoryReader("data", recursive=True, required_exts=[".pdf",".md"]).load_data()★
Reads a folder; filters by extension; recurse into subdirs. Handles many file types out of the box.
from llama_index.core import Document Document(text="...", metadata={"source":"faq"})
Build documents by hand. metadata travels with each node and can be used for filtering at query time.
pip install llama-index-readers-web from llama_index.readers.web import SimpleWebPageReader
Hundreds of connectors on LlamaHub (llama-index-readers-*): web, Notion, Slack, S3, SQL, GitHub, Google Drive, and more.
nodes = Settings.node_parser.get_nodes_from_documents(docs)
Documents are split into Nodes (a.k.a. TextNode) before indexing — the retrievable unit. See card 11 for parsers.

5Indexeshow data is organized

VectorStoreIndex.from_documents(docs)★
The workhorse: embed nodes and retrieve by similarity. Best default for RAG.
from llama_index.core import SummaryIndex, PropertyGraphIndex
SummaryIndex walks all nodes (good for summarization); PropertyGraphIndex builds a knowledge graph for graph RAG.
index = VectorStoreIndex(nodes) # from pre-parsed nodes index.insert(Document(text="..."))
Build from nodes directly, and insert/delete_ref_doc to update the index incrementally.
index.as_query_engine() · index.as_retriever() · index.as_chat_engine()★
Any index turns into a query engine (Q&A), a retriever (just nodes), or a chat engine (multi-turn).

6Query enginesask questions

qe = index.as_query_engine(similarity_top_k=5, response_mode="compact")★
similarity_top_k = how many chunks to retrieve; response_mode: compact (default), refine, tree_summarize, simple_summarize.
qe.query("...") · await qe.aquery("...")
Sync & async. The response synthesizer stuffs/refines retrieved context into the LLM prompt.
from llama_index.core.query_engine import RouterQueryEngine, SubQuestionQueryEngine
Advanced: route a query to the right index, or decompose a complex question into sub-questions across sources.
qe = index.as_query_engine(streaming=True) for tok in qe.query("...").response_gen: print(tok, end="")
Token streaming for query engines.

7Retrievers & postprocessorstune recall

r = index.as_retriever(similarity_top_k=10) nodes = r.retrieve("query") # -> NodeWithScore[]★
A retriever returns scored nodes only (no LLM). The building block for custom RAG.
from llama_index.core.postprocessor import SimilarityPostprocessor SimilarityPostprocessor(similarity_cutoff=0.7)
Node postprocessors filter/rerank retrieved nodes before synthesis. Also SentenceTransformerRerank, LLMRerank, MetadataReplacementPostProcessor.
from llama_index.core.vector_stores import MetadataFilters, MetadataFilter index.as_retriever(filters=MetadataFilters(filters=[...]))
Metadata filtering narrows retrieval to matching nodes (source, date, tags).
from llama_index.core.query_engine import RetrieverQueryEngine RetrieverQueryEngine.from_args(retriever, node_postprocessors=[...])
Assemble a custom engine = retriever + postprocessors + response synthesizer.

8Function & ReAct agentstool-using LLMs

from llama_index.core.agent.workflow import FunctionAgent agent = FunctionAgent(tools=[multiply], llm=Settings.llm, system_prompt="You are a helpful assistant.")★current
The modern agent (function/tool-calling), built on Workflows. ReActAgent is the reasoning-trace variant for models without native tool calls.
resp = await agent.run("What is 12 * 7?") print(resp)★
.run() is async and returns the final response. Agents run the reason→call-tool→observe loop until done.
def multiply(a: int, b: int) -> int: """Multiply two numbers.""" return a * b
A plain typed function with a docstring becomes a tool automatically. Or wrap explicitly with FunctionTool.from_defaults(fn).
qe_tool = QueryEngineTool.from_defaults(query_engine=qe, name="docs", description="Company handbook")
Wrap a query engine as a tool so an agent can decide when to do RAG. from llama_index.core.tools import QueryEngineTool, FunctionTool.

9Workflows (event-driven)orchestration

from llama_index.core.workflow import ( Workflow, step, StartEvent, StopEvent, Event, Context)current
Workflows are the async, event-driven orchestration layer (they replaced the legacy Query Pipeline). Agents are built on them.
class Flow(Workflow): @step async def run(self, ev: StartEvent) -> StopEvent: return StopEvent(result="done")★
Each @step consumes an event type and emits the next. The graph is inferred from the type hints — no manual edges.
result = await Flow(timeout=60).run(topic="...")
Run the workflow; steps execute as their input events fire. Steps can run concurrently.
from llama_index.core.agent.workflow import AgentWorkflow AgentWorkflow(agents=[research, write], root_agent="research")
Multi-agent: several agents that hand off to each other, coordinated by a root agent.
ctx = Context(agent) await agent.run("...", ctx=ctx) # carries memory across runs
Context holds per-run state/memory and enables streaming events and human-in-the-loop steps.

10Persistence & vector storesdon't re-embed

index.storage_context.persist(persist_dir="storage")★
Save the default (in-memory) index to disk so you don't re-embed on every run.
from llama_index.core import load_index_from_storage sc = StorageContext.from_defaults(persist_dir="storage") index = load_index_from_storage(sc)★
Reload a persisted index. StorageContext bundles the doc store, index store, and vector store.
pip install llama-index-vector-stores-chroma from llama_index.vector_stores.chroma import ChromaVectorStore
Swap the in-memory store for a real DB: Chroma, Qdrant, Pinecone, Weaviate, pgvector, Milvus, and more.
sc = StorageContext.from_defaults(vector_store=vstore) VectorStoreIndex.from_documents(docs, storage_context=sc)
Wire a backing vector store into the index via StorageContext. To reconnect: VectorStoreIndex.from_vector_store(vstore).

11Ingestion & chunkingnodes pipeline

from llama_index.core.node_parser import SentenceSplitter SentenceSplitter(chunk_size=512, chunk_overlap=50)★
The default splitter. Others: SentenceWindowNodeParser, SemanticSplitterNodeParser, MarkdownNodeParser, TokenTextSplitter.
from llama_index.core.ingestion import IngestionPipeline pipe = IngestionPipeline(transformations=[ SentenceSplitter(), Settings.embed_model])★
Compose splitters, extractors, and the embed model into one reusable pipeline. pipe.run(documents=docs).
IngestionPipeline(..., docstore=SimpleDocumentStore())
Attach a docstore for dedup / incremental ingestion — unchanged docs are skipped on re-run.
from llama_index.core.extractors import TitleExtractor, QuestionsAnsweredExtractor
Metadata extractors enrich nodes (titles, keywords, hypothetical questions) to boost retrieval quality.

12Chat enginesmulti-turn

ce = index.as_chat_engine(chat_mode="condense_plus_context") ce.chat("and what about Y?")★
Chat engines keep history + retrieve. condense_plus_context rewrites the follow-up into a standalone query, then does RAG.
chat_mode: "context" · "condense_question" · "best" · "react"
Modes trade off simplicity vs. reasoning. context injects retrieved chunks each turn; react gives the engine tools.
from llama_index.core.memory import ChatMemoryBuffer ce = index.as_chat_engine(memory=ChatMemoryBuffer.from_defaults(token_limit=3000))
Control the conversation memory buffer. ce.stream_chat(...) streams; ce.reset() clears history.

13Ecosystem & integrationsthe wider stack

# LlamaHub — 300+ readers, tools, vector stores, LLMs★
Browse integrations at llamahub.ai; each is a pip install llama-index-* package with a stable import path.
pip install llama-cloud-services from llama_cloud_services import LlamaParse
LlamaParse (part of LlamaCloud) parses complex PDFs/tables/figures into clean markdown for better RAG.
# legacy: llama_index.* (no .core) -> llama-index-legacymigration
Pre-0.10 flat imports like from llama_index import ... are gone. Use llama_index.core; the frozen old API is the llama-index-legacy package.
# ServiceContext removed -> use Settings (card 3)migration
ServiceContext was deprecated then removed. Global config now flows through Settings.

LlamaIndex cheat sheet

Outline

Getting started

Models & data

Indexing & retrieval

Agents & workflows

Storage, chat & ecosystem

Getting Started

Models & Data

Indexing & Retrieval

Agents & Workflows

Storage, Chat & Ecosystem

Worth memorizing