I keep seeing tutorials where someone loads a single PDF and builds a chatbot with LlamaIndex. That's massive overkill. You're adding an abstraction layer for no tangible benefit if your scope is truly one document.
For a single-doc Q&A, you need three things:
1. Chunk the text.
2. Generate embeddings for those chunks.
3. Store them in a vector store for similarity search.
LlamaIndex wraps this, but you can do it directly with LangChain or even raw API calls with less code and fewer moving parts. The complexity it manages—like building graphs of indices—is irrelevant for one file.
Here's a minimal LangChain implementation for a single PDF:
```python
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import OpenAIEmbeddings
from langchain.vectorstores import Chroma
# 1. Load & Chunk
loader = PyPDFLoader("your_doc.pdf")
documents = loader.load()
text_splitter = RecursiveCharacterTextSplitter(chunk_size=1000, chunk_overlap=200)
chunks = text_splitter.split_documents(documents)
# 2. Embed & Store
embeddings = OpenAIEmbeddings()
vectorstore = Chroma.from_documents(documents=chunks, embedding=embeddings, persist_directory="./chroma_db")
# 3. Query
retriever = vectorstore.as_retriever()
relevant_chunks = retriever.get_relevant_documents("Your question here")
# Feed chunks to your LLM of choice
```
Where LlamaIndex earns its keep is when you have multiple, heterogeneous data sources and need to compose a unified query across them (e.g., a SQL database, a PDF, and a SaaS API). Its `QueryEngine` abstractions and built-in connectors are useful there.
But for "chat with this PDF"? You're paying a complexity tax for features you aren't using. Benchmark it yourself: build the same simple app with and without LlamaIndex. Compare lines of code, latency for simple queries, and cognitive overhead for debugging. I'd bet the native version wins on all three.
Show me the query.
LangChain as the "minimal" alternative is funny. You're trading one abstraction for another.
Your three steps are correct, but you can skip the framework entirely. OpenAI's API, a cheap vector DB, and a few lines of Python. The tutorials exist to sell courses, not to solve problems efficiently.
—EB
You're right about the core process. The benefit of a framework like LlamaIndex, even for a single document, becomes more apparent when you need to manage metadata filtering or complex retrieval strategies later on.
Your LangChain example is clear, but it doesn't handle query-time operations. If you add a simple retrieval chain with a prompt template and the LLM call, the code length quickly matches what you'd write in LlamaIndex. The abstraction starts paying off when you need to implement hybrid search or adjust top-k parameters without rewriting your pipeline.
For a truly minimal approach, I'd skip both frameworks. Use `pypdf` for chunking, the OpenAI SDK directly for embeddings, and `chromadb`'s bare client. It's about 40 lines for the entire ingestion and query loop, which is instructive to understand the actual mechanics.