LlamaIndex

By LlamaIndex

Data framework for building RAG pipelines and document agents over your own data

Website ↗ Repository ↗ Docs ↗

v0.14.232026-06-24PythonMIT

#rag #retrieval #indexing #python

51.0k Open source Free tier Paid

Doc version 1.0 · Updated June 28, 2026

Related tools

LangGraph

Multi-Agent Orchestration

Overview

LlamaIndex is a data framework for connecting LLMs to your own data — it ingests, chunks, embeds, and indexes documents, then retrieves the relevant pieces at query time.
It is one of the most common ways to build RAG pipelines and document agents, with connectors for dozens of vector stores and data sources.

flowchart LR
  data[your documents] --> idx[(VectorStoreIndex)]
  q[question] --> idx
  idx --> ans[grounded answer]

The Code samples tab shows a minimal index-and-query flow.

When to use it

Choose LlamaIndex when retrieval is the core of your app — RAG over documents, knowledge bases, or structured sources — and you want ingestion and querying handled by a mature framework. LlamaCloud adds hosted parsing and indexing.

Pricing

Open-source framework, free to use. LlamaCloud is the managed parsing and indexing service.

Plan	Price	Notes
Free	$0	10k credits/mo
Starter	$50/mo	Higher credits, more connectors
Pro	$500/mo	Team features, larger volume
Enterprise	Custom	SSO, SLA, self-hosting

Source ↗ · as of 2026-06-27

Example

Python · index & query

When to use

Reach for the high-level index + query engine when you want retrieval, chunking, and prompting handled for you.

How it flows

from_documents chunks and embeds the docs into an index; the query engine retrieves the relevant chunks and asks the LLM, grounded in them.

Structure

flowchart LR
  docs[your documents] --> idx[(VectorStoreIndex)]
  q[question] --> idx
  idx --> ans[grounded answer]

from llama_index.core import VectorStoreIndex, Document
from llama_index.llms.openai import OpenAI

# Index a few documents, then ask a question grounded in them.
docs = [
    Document(text="Qdrant is a vector database written in Rust."),
    Document(text="LlamaIndex builds RAG pipelines over your own data."),
]
index = VectorStoreIndex.from_documents(docs)
engine = index.as_query_engine(llm=OpenAI(model="gpt-4o-mini"))
print(engine.query("What language is Qdrant written in?"))

Example

LlamaIndex — implementation sample

A real, runnable mini-project. Download it and run with Docker.

View samples/llamaindex_1 on GitHub ↗

June 28, 2026

LlamaIndex — implementation sample

A tiny LlamaIndex sample: it indexes two documents and answers a question grounded in them (OpenAI embeddings + LLM).

Configure

cd samples/llamaindex_1
cp .env.sample .env
# edit .env: set OPENAI_API_KEY (used for embeddings + the LLM)

Run with Docker

cd samples/llamaindex_1
docker build -t aas-llamaindex .
docker run --rm --env-file .env aas-llamaindex "What language is Qdrant written in?"

Run with Docker (in a devcontainer with DooD)

The foreground docker run may print nothing under Docker-outside-of-Docker — run detached and follow the logs:

docker logs -f "$(docker run -d --env-file .env aas-llamaindex "What language is Qdrant written in?")"

Run locally

cd samples/llamaindex_1
pip install -r requirements.txt
python app.py "What language is Qdrant written in?"

Example run

Output varies by model and run — LLMs are non-deterministic. One run with gpt-4o-mini:

Qdrant is written in Rust.

Files

.env.sample

# Copy to `.env` and add your OpenAI API key (used for embeddings + the LLM).
#   cp .env.sample .env
OPENAI_API_KEY=

MODEL=gpt-4o-mini

app.py

"""LlamaIndex: index a few documents and answer a question grounded in them.

Builds an in-memory vector index over two documents (OpenAI embeddings), then
runs a query engine (OpenAI LLM) and prints the grounded answer.

Run:
    docker build -t aas-llamaindex .
    docker run --rm --env-file .env aas-llamaindex "What language is Qdrant written in?"
"""

import os
import sys

from dotenv import load_dotenv
from llama_index.core import Document, VectorStoreIndex
from llama_index.llms.openai import OpenAI

load_dotenv()

MODEL = os.environ.get("MODEL", "gpt-4o-mini")


def main() -> None:
    question = " ".join(sys.argv[1:]) or "What language is Qdrant written in?"
    docs = [
        Document(text="Qdrant is a vector database written in Rust."),
        Document(text="LlamaIndex builds RAG pipelines over your own data."),
    ]
    index = VectorStoreIndex.from_documents(docs)
    engine = index.as_query_engine(llm=OpenAI(model=MODEL))
    print(engine.query(question))


if __name__ == "__main__":
    main()

Dockerfile

FROM python:3.13-slim

ENV PYTHONUNBUFFERED=1

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

ENTRYPOINT ["python", "app.py"]