RAG Interview Questions & Answers (2026) — Retrieval-Augmented Generation Interview Prep

[![Stargazers][stars-shield]][stars-url] [![Forks][forks-shield]][forks-url] [![License: MIT][license-shield]][license-url] ![Last Commit][commits-shield] ![Questions][questions-shield] [![Release][release-shield]][release-url] [![PRs Welcome][prs-shield]][prs-url]

1619 RAG (Retrieval-Augmented Generation) interview questions and answers for AI engineers, ML engineers, and GenAI/LLM developers. Covers all 52 RAG architectures, system design scenarios, vector databases, embeddings, chunking, reranking, evaluation, and the production failure modes that come up in real LLM engineering interviews.

⭐ Star this repo if it helps your interview prep — it keeps the project growing.

🚀 Start Here

| Link | Use it for | |---|---| | 🧾 Cheatsheet | All 52 RAG types compared in one table — best for a phone screen the same day | | 🕹️ [Practice Quiz][quiz-url] | Learn and drill: flip through every Q&A as flashcards, filterable by difficulty, section, and a "Scenario only" toggle, plus auto-graded multiple-choice questions, right in the browser | | 🎯 [Self-Assessment][assessment-url] | Test yourself: exam-style set of 10/25/50 multiple-choice questions with an optional timer, a readiness level, per-section breakdown, and saved attempt history | | 🗺️ Learning Path | Structured curriculum if you have more than a few days to prepare | | ▶️ Run Lab 01 in Colab | Build a working RAG pipeline in your browser, no local setup |

Quick Start (run the labs locally)

git clone https://github.com/ather-techie/rag-interview-system.git
cd rag-interview-system/06_labs_py
python3 -m venv .venv && source .venv/bin/activate   # Windows: .venv\Scripts\Activate.ps1
pip install -r requirements.txt
cp .env.example .env   # set AI_PROVIDER / AI_MODEL / AI_API_KEY
jupyter lab 01_naive_rag.ipynb

Prefer zero setup? Every lab notebook has an Open in Colab badge — see Labs & Patterns below.

🕹️ How to Use the Practice Quiz

The [Practice Quiz][quiz-url] is the place to learn and drill. It turns every Q&A into a flashcard and every [MCQ] into an auto-graded question, all in your browser.

1. Choose what to practise

• Difficulty — Basic, Intermediate, Advanced, or All.
• Type — Flashcards, MCQ, or All.
• Options — Scenario only for situational questions, Shuffle for random order.
• Section — focus on a single architecture or failure mode.
• The live count shows how many questions match. Click Start Practice, or Reset filters to start over.

• Think of your answer first, then click Show Answer to check it. Answers are revealed as you go.
• Click Skip to move on, or ✕ to exit.

🎯 How to Use the Self-Assessment

The [Self-Assessment][assessment-url] is an exam-style multiple-choice test that runs entirely in your browser — no install or sign-up.

1. Configure your test

• Questions — choose 10, 25, 50, or All.
• Difficulty — Basic, Intermediate, Advanced, or All.
• Section group — Architectures, Failure modes, or All.
• Timer — Off, 30 s / question, or 60 s / question.
• Click Start assessment.

• Use the numbered bubbles to jump to any question, or Previous / Next to step through.
• Answers are not revealed until you click Submit.
• If the timer is on, the countdown shows at the top right. Use ✕ to exit.

What is RAG?

Retrieval-Augmented Generation (RAG) is an LLM architecture that grounds model responses in external knowledge: documents are chunked, embedded, and stored in a vector database; at query time the most relevant chunks are retrieved via vector search and passed to the LLM as context for generation. RAG reduces hallucination, keeps answers current without retraining, and is the most common production pattern for enterprise LLM applications — which is why it dominates AI engineer and GenAI system design interviews.

Who is this for?

• AI / ML engineers preparing for RAG, LLM, or GenAI interview rounds
• Software engineers moving into LLM application development
• Data scientists facing RAG system design interviews
• Hiring managers and interviewers building question sets for GenAI roles

📚 Table of Contents

• Getting Started
• Core Concepts
• RAG Architecture Map (52 Types)
• Failure Modes & Production Issues
• Labs & Patterns
• Coming Soon
• Study Plans
• How to Use
• Topics Covered
• Contributing
• Star History
• Support
• More from the author

🗺️ Getting Started

| # | Topic | Purpose | Questions | |---|-------|---------|-----------| | 00a | Roadmap | RAG maturity model, skill progression, and interview prep pathway | – | | 00b | RAG Taxonomy | Classification framework for all 52 architectures across 4 axes | – | | 00c | Learning Path | Structured curriculum and study plans | – | | 00d | System Design Principles | Production-grade architecture patterns | – |

📖 Core Concepts

| # | Topic | Purpose | Questions | |---|-------|---------|-----------| | 01a | Embeddings | Embedding models, similarity metrics, and fine-tuning | 2 | | 01b | Chunking Strategies | Document splitting and chunk optimization | 2 | | 01c | Vector Databases | Storage, indexing, and hybrid search | 4 | | 01d | Retrieval Strategies | Dense, sparse, hybrid, and advanced retrieval | 3 | | 01e | Reranking | Cross-encoders and precision filtering | – | | 01f | Evaluation Metrics | RAGAS, NDCG, and production monitoring | 2 | | 01g | Prompt Injection Risks | Security and defense strategies | – | | 01h | Fine-Tuning for RAG | When and how to fine-tune embeddings and rerankers | 7 | | 01i | Observability & Evaluation Ops | LLM-as-judge, online metrics, tracing, drift alerts | 7 | | 01j | Multi-Tenancy & Access Control | Tenant isolation, document ACLs, leakage surfaces | 7 | | 01k | Document Ingestion & Parsing | Parsing pipelines, layout extraction, and text normalization | 12 | | 01l | Knowledge Graph Construction | Entity extraction, relation extraction, KG maintenance | 6 | | 01m | Caching Strategies | Semantic cache, KV preloading, invalidation, cost/freshness trade-offs | 5 | | 01n | Cost Optimization | Model tiering, prompt caching, quantization, batching | 4 | | 01o | Agentic Orchestration | Tool-call loops, stopping criteria, ReAct vs. plan-and-execute, full pipeline architecture | 7 | | 01p | Multimodal Embeddings | CLIP, ImageBind, cross-modal alignment, vision-language models | 3 | | 01q | Conversational Memory Architecture | Working/episodic/long-term memory, MemGPT paging, session detection | 3 | | 01r | Microsoft / Azure AI Stack | Pipeline stage to Microsoft service mapping, free-to-run options, Azure AI Search vs Cosmos DB vs PostgreSQL | 6 |

Core Concepts Total: 80 questions across 18 files

🧭 RAG Architecture Map (52 Types)

flowchart TD
    RAG["52 RAG Architectures"] --> F["Foundational"]
    RAG --> AC["Adaptive & Self-Correcting"]
    RAG --> AG["Agentic & Reasoning"]
    RAG --> GR["Graph-Based"]
    RAG --> LC["Long-Context & Memory"]
    RAG --> MS["Multimodal & Structured"]
    RAG --> EF["Efficiency & Query Transform"]
    RAG --> SR["Security, Trust & Real-Time"]
    RAG --> TT["Training-Time / Parametric"]
F --> F1["Naive · Advanced · Modular RAG"]
    F --> F2["DPR · ColRAG/ColBERT"]
AC --> AC1["Adaptive RAG"]
    AC --> AC2["Corrective RAG (CRAG)"]
    AC --> AC3["Self-RAG · Astute RAG"]
    AC --> AC4["Speculative RAG"]
AG --> AG1["Agentic RAG · FLARE"]
    AG --> AG2["Iterative / Multi-hop RAG"]
    AG --> AG3["Search-R1 · Auto-RAG/DeepRAG"]
    AG --> AG4["Deep Research · CoRAG · RQ-RAG"]
GR --> GR1["Graph RAG · LightRAG"]
    GR --> GR2["HippoRAG · KAG"]
    GR --> GR3["GraphReader / GNN-RAG"]
    GR --> GR4["LazyGraphRAG"]
LC --> LC1["Long-Context RAG · RAPTOR"]
    LC --> LC2["Contextual RAG · LongRAG"]
    LC --> LC3["Memory / Conversational RAG"]
    LC --> LC4["MemoRAG · Recursive Summarization"]
MS --> MS1["Structured/SQL · Table-Aware RAG"]
    MS --> MS2["Multimodal RAG · VisRAG"]
EF --> EF1["CAG · REFRAG"]
    EF --> EF2["RAG-Fusion · HyDE · Few-Shot Example RAG"]
SR --> SR1["Verifiable/Citation RAG · SURGE"]
    SR --> SR2["Privacy-Preserving · Streaming/Real-Time RAG"]
    SR --> SR3["Agentic Web RAG · WebGPT · Tree of Thought RAG"]
TT --> TT1["REALM · RETRO"]
    TT --> TT2["Atlas · Fusion-in-Decoder · RAFT"]

Full classification (retrieval control, data modality, feedback loop, scope, latency class) for all 52 types: 00_overview/rag_taxonomy.md.

| # | Topic | Questions | |---|-------|-----------| | 02.01 | Naive / Basic RAG | 26 | | 02.02 | Advanced RAG | 26 | | 02.03 | Modular RAG | 26 | | 02.04 | Agentic RAG | 26 | | 02.05 | Graph RAG | 26 | | 02.06 | Corrective RAG (CRAG) | 26 | | 02.07 | Self-RAG | 26 | | 02.08 | Speculative RAG | 26 | | 02.09 | Multi-modal RAG | 26 | | 02.10 | Long-context RAG | 26 | | 02.11 | Adaptive RAG | 26 | | 02.12 | Structured / SQL RAG | 26 | | 02.13 | RAPTOR | 26 | | 02.14 | Contextual RAG | 26 | | 02.15 | LightRAG | 26 | | 02.16 | RAFT | 26 | | 02.17 | Cache-Augmented Generation (CAG) | 26 | | 02.18 | RAG-Fusion | 26 | | 02.19 | Iterative / Multi-hop RAG | 26 | | 02.20 | HippoRAG | 26 | | 02.21 | Memory / Conversational RAG | 26 | | 02.22 | HyDE (Hypothetical Document Embeddings) | 26 | | 02.23 | FLARE (Forward-Looking Active Retrieval) | 26 | | 02.24 | KAG (Knowledge Augmented Generation) | 26 | | 02.25 | GraphReader / GNN-RAG | 26 | | 02.26 | REALM | 26 | | 02.27 | RETRO | 26 | | 02.28 | Atlas | 26 | | 02.29 | Fusion-in-Decoder (FiD) | 26 | | 02.30 | ColRAG / ColBERT | 26 | | 02.31 | Agentic Web RAG | 26 | | 02.32 | Few-Shot Example RAG | 26 | | 02.33 | Verifiable / Citation RAG | 26 | | 02.34 | Privacy-Preserving RAG | 26 | | 02.35 | Streaming / Real-Time RAG | 26 | | 02.36 | Table-Aware RAG | 26 | | 02.37 | Tree of Thought RAG | 26 | | 02.38 | DPR (Dense Passage Retrieval) | 26 | | 02.39 | WebGPT / Tool-Augmented LM | 26 | | 02.40 | SURGE (Schema-Grounded RAG) | 26 | | 02.41 | Recursive Document Summarization RAG | 26 | | 02.42 | Search-R1 / Reasoning RAG | 26 | | 02.43 | Deep Research / Agentic Research RAG | 26 | | 02.44 | MemoRAG | 26 | | 02.45 | LongRAG + Self-Route | 26 | | 02.46 | VisRAG | 26 | | 02.47 | LazyGraphRAG | 26 | | 02.48 | Astute RAG | 26 | | 02.49 | Auto-RAG / DeepRAG | 26 | | 02.50 | CoRAG (Chain-of-Retrieval) | 26 | | 02.51 | RQ-RAG | 26 | | 02.52 | REFRAG | 26 |

RAG Architectures Total: 1352 questions

Naive RAG                          — Chunk → Embed → Store → Retrieve → Generate
Advanced RAG                       — Query rewriting + Hybrid search + Re-ranking
Modular RAG                        — Plug-and-play pipeline components
Agentic RAG                        — LLM decides when/how to retrieve (ReAct, FLARE)
Graph RAG                          — Knowledge graph for entity-aware retrieval
Corrective RAG (CRAG)              — Evaluates retrieval quality, falls back to web search
Self-RAG                           — Model trained to reflect, retrieve, and critique itself
Speculative RAG                    — Small model drafts → Large model selects best
Multi-modal RAG                    — Retrieve across text, images, tables, audio
Long-context RAG                   — Stuff entire docs into large context windows
Adaptive RAG                       — Query classifier routes to no-retrieval / single-hop / multi-hop
Structured / SQL RAG               — Text-to-SQL generation for relational database retrieval
RAPTOR                             — Recursively clusters and summarizes chunks into a multi-level tree
Contextual RAG                     — LLM-generated context prefix prepended to each chunk before embedding
LightRAG                           — Entity-relationship graph + dual-level (local + global) retrieval
RAFT                               — Fine-tunes the LLM generator on oracle + distractor documents
Cache-Augmented Generation (CAG)   — Preloads entire corpus into KV cache — no retrieval step at inference
RAG-Fusion                         — N query reformulations → N parallel retrievals → RRF merge → generation
Iterative / Multi-hop RAG          — Retrieve → reason → retrieve loops (IRCoT, Self-Ask) until a stopping criterion
HippoRAG                           — Personalized PageRank over an LLM-built knowledge graph for single-step multi-hop
Memory / Conversational RAG        — Tiered memory + history-aware query rewriting for multi-turn dialogue
HyDE                               — Embed an LLM-generated hypothetical answer to close the query-document gap
FLARE                              — Retrieve mid-generation when next-sentence tokens fall below a confidence threshold
KAG (Knowledge Augmented Gen.)     — Logical-form reasoning + KG/text mutual indexing for professional domains
GraphReader / GNN-RAG              — Agentic graph-of-notes traversal / GNN-retrieved reasoning subgraphs
REALM (training-time)              — Retriever learned end-to-end during masked-LM pre-training
RETRO (training-time)              — Chunked cross-attention over a trillion-token frozen datastore
Atlas (training-time)              — Jointly-trained Contriever + FiD; few-shot knowledge learning
Fusion-in-Decoder (FiD) (training) — Encode passages separately, fuse them in the decoder
ColRAG / ColBERT                   — Multi-vector late interaction (MaxSim); each token gets its own embedding
Agentic Web RAG                    — Live web search as retrieval backend; real-time freshness + citation extraction
Few-Shot Example RAG               — Retrieves query→answer demonstrations rather than documents; plugged into the prompt
Verifiable / Citation RAG          — Inline citations mapped to specific passages; post-hoc attribution verification
Privacy-Preserving RAG             — On-device embedding, differential privacy, federated retrieval for zero-trust corpora
Streaming / Real-Time RAG          — Continuous index updates from Kafka / CDC; freshness window in seconds
Table-Aware RAG                    — Structured retrieval over semi-structured tables; row/column linearization or SQL hybrid
Tree of Thought RAG                — ToT reasoning branches with conditional per-hypothesis retrieval
DPR (Dense Passage Retrieval)       (foundational) — Bi-encoder trained with question–passage contrastive loss
WebGPT / Tool-Augmented LM          (foundational) — RLHF-trained to issue browser actions (search/click/quote)
SURGE (Schema-Grounded RAG)        — tool_use schema-constrained extraction + per-field NLI grounding validation
Recursive Doc. Summarization RAG   — 4-level summary tree (chunk→section→doc→corpus); routes queries to the right level
Search-R1 / Reasoning RAG          — RL-trained LLM interleaves reasoning and self-issued search calls
Deep Research / Agentic Research   — Parallel plan-search-read-synthesize sub-agents produce a long-form cited report
MemoRAG                            — Compresses the corpus into a global memory that drafts query-time retrieval clues
LongRAG + Self-Route               — Retrieves large (~4K-token) grouped units; Self-Route picks RAG vs. long-context
VisRAG                             — Embeds and reads document pages as images end-to-end via a VLM
LazyGraphRAG                       — Cheap noun-phrase co-occurrence graph at index time, LLM work deferred to query time
Astute RAG                         — Elicits the LLM's own parametric knowledge, reconciles it with retrieved passages
Auto-RAG / DeepRAG                 — Decides retrieve-vs-reason at every step, not once up-front
CoRAG (Chain-of-Retrieval)         — Rejection-sampled retrieval chains; chain length is a test-time compute knob
RQ-RAG                             — Fine-tunes the LLM to chain query-refinement operations via special tokens
REFRAG                             — Compresses chunks into embeddings, RL policy expands only the important ones

⚠️ Failure Modes & Production Issues

| # | Topic | Questions | |---|-------|-----------| | 03.01 | Hallucination Despite Context | 10 | | 03.02 | Retrieval Failure | 14 | | 03.03 | Embedding Mismatch | 10 | | 03.04 | Stale Index Problem | 10 | | 03.05 | Context Window Overflow | 10 | | 03.06 | Reranker Failure | 10 | | 03.07 | Conversational Context Drift | 10 | | 03.08 | Cascading Retrieval Failure | 4 | | 03.09 | Semantic Cache Leakage | 5 |

Failure Modes Total: 83 questions

🪟 Microsoft Stack

RAG on Azure and the Microsoft AI platform, as interview questions. These appear in the Practice Quiz and Self-Assessment as the Microsoft Stack section. For a pipeline-stage-to-service map and free ways to practise without an Azure subscription, see Microsoft / Azure AI Stack.

| # | Topic | Questions | |---|-------|-----------| | 11.01 | Azure AI Search for RAG | 26 | | 11.02 | Azure OpenAI and Foundry for RAG | 26 | | 11.03 | Microsoft Agent Framework and Semantic Kernel | 26 | | 11.04 | RAG Reference Architecture on Azure | 26 |

Microsoft Stack Total: 104 questions

Grand Total: 1619 questions

Difficulty distribution across the interview bank, failure modes, and Microsoft stack: 408 Basic, 595 Intermediate, 536 Advanced

Scenario-based questions (tagged [Scenario]): 218

Multiple-choice questions (tagged [MCQ]): 228

All cited papers with arXiv/DOI links: REFERENCES.md

🔬 Labs & Patterns

Hands-on Jupyter notebooks and composition pattern guides:

| # | Section | Contents | |---|---------|----------| | 04 | Patterns | Router + fallback, fan-out/fan-in, migration path, anti-patterns | | 06 | Labs | 5 Jupyter notebooks: Naive RAG → Hybrid RAG → Reranker → RAGAS Evaluation → Agentic RAG. Each has an badge — no local setup needed | | 08 | Evaluation | Golden dataset construction guide + RAGAS CI harness | | 09 | Tools | Eval & observability tool comparison (Ragas, TruLens, DeepEval, LlamaIndex eval, LangChain eval); vector DB & framework comparisons still planned |

🪟 Microsoft Technology in This Repo

Microsoft Research and the Azure AI platform shape much of modern RAG. Where they show up here:

| Topic | Where | What you get | |---|---|---| | Microsoft Stack question section (104 questions, in the quiz and assessment) | 11 — Microsoft Stack | Azure AI Search, Azure OpenAI and Foundry, Agent Framework and Semantic Kernel, Azure reference architecture | | Pipeline stage to Microsoft service map | Microsoft / Azure AI Stack | What to use at each stage, free ways to practise, Azure AI Search vs Cosmos DB vs PostgreSQL | | "Microsoft Stack" row on every architecture | RAG Architecture Map | Each architecture file's Tools & Frameworks table lists the Azure service and Microsoft open-source option | | Microsoft GraphRAG | 05 — Graph RAG | Leiden community detection, global vs local queries | | LightRAG vs GraphRAG | 15 — LightRAG | Build-cost and quality trade-offs | | LazyGraphRAG | 47 — LazyGraphRAG | Defers LLM summarization to query time | | CoRAG (Microsoft Research) | 50 — CoRAG | Chain-of-retrieval training | | LLMLingua prompt compression | 10 — Long-Context RAG | Compressing context to cut cost | | Microsoft Presidio | 34 — Privacy-Preserving RAG | PII detection and anonymization | | DiskANN, Azure Cosmos DB, PostgreSQL pg_diskann | Vector Databases | Billion-scale ANN on SSD | | Azure AI Document Intelligence | Document Ingestion | Managed OCR and layout extraction | | Microsoft Agent Framework, Semantic Kernel, AutoGen | Agentic Orchestration | Framework selection | | Azure AI groundedness | Evaluation Metrics | Groundedness vs faithfulness | | Azure OpenAI in the labs | Labs setup | Set AI_PROVIDER=azure |

🔄 Coming Soon

| # | Section | Status | |---|---------|--------| | 05 | Graphs | Planned | | 07 | Simulator | Planned | | 10 | Decision System | Planned |

🗓️ Study Plans

1 Day (phone screen tomorrow)

| Step | Do this | |---|---| | 1 | Skim cheatsheets/CHEATSHEET.md — all 52 types compared | | 2 | Read Q1–Q5 of Naive RAG, Advanced RAG, Agentic RAG | | 3 | Read 00_overview/roadmap.md for the big picture |

1 Week (first-round interview)

| Day | Focus | |---|---| | 1–2 | 01_concepts/ — embeddings, chunking, vector DBs, retrieval, reranking | | 3–4 | 02_interview_bank/ — all 52 architectures, all questions | | 5 | 03_failure_modes/ — the 9 production failure patterns | | 6 | Run Labs 01–03 — naive → hybrid → reranker, hands-on | | 7 | 00_overview/system_design_principles.md + a mock system design round |

4 Weeks (deep prep / career switch)

| Week | Focus | |---|---| | 1 | Core concepts (01_concepts/) + Labs 01–02 | | 2 | Full interview bank (02_interview_bank/) — all 52 architectures | | 3 | Failure modes + 08_evaluation/ + Labs 03–04 | | 4 | Agentic RAG deep dive (01_concepts/agentic_orchestration.md) + Lab 05 + mock interviews using the [Practice Quiz][quiz-url] and the [Self-Assessment][assessment-url] to gauge readiness |

💡 How to Use

Content types:

1. Getting Started (00_overview/) — Roadmap, taxonomy, learning path, and system design principles for orientation

1. Core Concepts (01_concepts/) — Reference material, mostly not Q&A

1. Interview Questions (02_interview_bank/) — 26 questions per architecture (22 free-form plus 4 multiple-choice)

1. Failure Modes (03_failure_modes/) — 4–14 questions per failure pattern

1. Labs (06_labs_py/) — 5 runnable notebooks turning the Q&A into working pipelines

🏷️ Topics Covered

Embeddings · Chunking strategies · Vector databases (FAISS, Pinecone, Weaviate, pgvector) · Hybrid search (BM25 + dense) · Reranking & cross-encoders · RAG evaluation (RAGAS, NDCG) · Agentic RAG · Graph RAG · Self-RAG & Corrective RAG · Multi-modal RAG · Text-to-SQL · Prompt injection & RAG security · Hallucination mitigation · LLM observability · Multi-tenancy & access control · Knowledge graph construction · Semantic caching · Cost optimization · Privacy-preserving retrieval · Streaming / real-time indexing · Citation & attribution · ColBERT multi-vector retrieval · Reasoning RAG & RL-trained search (Search-R1) · Deep Research agents · Vision-native RAG (VisRAG)

Contributing

This repo grows best with real-world signal. If you were asked a RAG question in an interview, open an issue or a PR — real questions are prioritized over synthetically generated ones.

See CONTRIBUTING.md for the format, and CODE_OF_CONDUCT.md for community guidelines.

⭐ Star History

• Open an issue on GitHub
• Join the Discord community
• Contact: [email protected]

🔗 More from the author

• ai-agents-design-patterns — design patterns for building production AI agents
• ai-system-design-interview — system design interview prep for AI/ML platforms

License

MIT

See Contributing to add your interview experience to the repo.

[stars-shield]: https://img.shields.io/github/stars/ather-techie/rag-interview-system?style=flat-square [stars-url]: https://github.com/ather-techie/rag-interview-system/stargazers [forks-shield]: https://img.shields.io/github/forks/ather-techie/rag-interview-system?style=flat-square [forks-url]: https://github.com/ather-techie/rag-interview-system/network/members [license-shield]: https://img.shields.io/github/license/ather-techie/rag-interview-system [license-url]: LICENSE [commits-shield]: https://img.shields.io/github/last-commit/ather-techie/rag-interview-system [questions-shield]: https://img.shields.io/badge/questions-1619-blue [release-shield]: https://img.shields.io/github/v/release/ather-techie/rag-interview-system [release-url]: https://github.com/ather-techie/rag-interview-system/releases [prs-shield]: https://img.shields.io/badge/PRs-welcome-brightgreen [prs-url]: CONTRIBUTING.md [pages-url]: https://ather-techie.github.io/rag-interview-system/ [quiz-url]: https://ather-techie.github.io/rag-interview-system/quiz.html [assessment-url]: https://ather-techie.github.io/rag-interview-system/assessment.html