RAG & Retrieval Systems Interview Prep
Test & Track Your Readiness

What RAG actually is, why it was invented, how context-stuffing beats fine-tuning for most knowledge tasks, and the anatomy of a working retrieval pipeline. The correct mental model before building anything.

How you split documents determines everything downstream. Fixed-size, sentence, semantic, recursive, and proposition-level chunking — when each wins, how overlap works, what happens when you get it wrong.

pgvector, Pinecone, Weaviate, Qdrant, Chroma — what differentiates them architecturally, how HNSW and IVF indexes work, when to use managed vs embedded, the latency vs recall trade-off.

Bi-encoders vs cross-encoders, how FAISS works under the hood, exact vs approximate nearest neighbor, the retrieval recall problem, how embedding model choice cascades into retrieval quality.

Why BM25 still beats embeddings for exact-match queries, how TF-IDF scoring works, SPLADE and learned sparse vectors, when to keep a keyword index alongside your vector index.

Dense + sparse retrieval combined via Reciprocal Rank Fusion or score normalisation. When hybrid beats either alone, how to weight the two sides, practical implementation patterns.

Why first-stage retrieval is approximate and reranking fixes it, how cross-encoders see both query and document together, Cohere Rerank, Flashrank, the latency budget math, when to skip reranking.

How you format retrieved context in the prompt matters as much as retrieval quality. Citation patterns, grounding instructions, handling empty retrieval, preventing the LLM from ignoring the context it was given.

HyDE (Hypothetical Document Embeddings), query decomposition, multi-hop retrieval, query expansion, step-back prompting — when simple top-k retrieval fails and these patterns rescue it.

Iterative retrieval inside an agent loop, tool-calling into vector and structured databases, deciding when to retrieve vs when the model already knows, orchestration patterns for complex multi-step research.

What RAGAS measures and how, faithfulness vs relevance vs groundedness, building a golden retrieval dataset, LLM-as-judge pitfalls specific to RAG, online vs offline evaluation.

The 10 ways RAG systems fail in production: hallucination despite context, retrieval returning wrong chunks, context poisoning, semantic drift, and adversarial injection — with concrete diagnostics for each.

Designing a production RAG system: indexing pipeline architecture, async re-indexing on document updates, multi-tenancy isolation, latency budget across the retrieval stack, data freshness guarantees.

Retrieval over PDFs with tables and figures, image search, ColPali and late interaction models, table-aware chunking, extracting structure from documents before indexing.

Running RAG in production: tracing a query end-to-end, A/B testing retrieval, cost structure of embedding + retrieval + generation, cache layers, monitoring what matters.

Choosing the right embedding model, reading MTEB correctly, asymmetric prefixes, Matryoshka truncation, int8 and binary quantization, multilingual and domain adaptation, and how to safely version-migrate embeddings without downtime.

The layer between the user's raw input and retrieval: intent classification, filter extraction, cleaning and expansion, multi-turn rewriting, routing to the right retrieval stack, and unsafe-query gating.

When vector similarity is not enough: entity/relation extraction, Leiden communities, hierarchical summaries, local vs global queries, and when GraphRAG beats vector RAG.

When the answer lives in a database, not documents: schema-aware retrieval, few-shot SQL generation, static validation, safe execution, table QA on DataFrames, and hybrid docs+data agents.

Escaping the one-chunk-size trap: parent-document retrieval, sentence-window, RAPTOR summary trees, LongRAG long-unit retrieval, and query-time context compression (LLMLingua, RECOMP).

The full RAG attack surface: cross-tenant leaks, indirect prompt injection via retrieved documents, PII redaction, cache poisoning, denial-of-wallet, system-prompt exfiltration, and adversarial evaluation.

Retrieval for source code: AST-aware chunking with tree-sitter, code-tuned embeddings, symbol/file/repo index tiers, call-graph expansion, diff and blame-aware ranking, and repo-scale incremental indexing.

The write path of RAG: event-driven ingest, idempotent chunk IDs, delta detection, batched embedding, blue-green model migrations, dead-letter queues, reconciliation, backfills, and multi-source pipelines.

Systematic pass on both axes: where cost/latency actually go in a RAG pipeline, which levers move the needle (routing, prompt caching, quantization, tiered retrieval, cache hierarchies, small-model+retrieval), and which are premature optimization. Includes the cost anti-patterns that catch every team.

Teaching the model to use retrieved context better. RAFT (distractor-aware training), RA-DIT (dual retriever+generator tuning), cross-encoder distillation to bi-encoder, small-model distillation from frontier traces. When fine-tuning beats prompt engineering — and when the six cheaper alternatives fix the same problem.