Question 1

What is Retrieval-Augmented Generation (RAG) and how does it dynamically enhance LLM capabilities?

Accepted Answer

Retrieval-Augmented Generation (RAG) is an architectural framework that enhances Large Language Models by dynamically retrieving authoritative knowledge from external databases before generating responses. It separates static model reasoning from dynamic facts, grounding LLM outputs in verified real-world context. Foundational LLMs suffer from static knowledge boundaries (training cut-offs) and lack access to private corporate repositories. RAG solves this by implementing an active in-context search. At query time, a document retriever queries local vector indexes or relational storage to gather semantically relevant facts. These facts are appended directly into the prompt context. The model then synthesizes a highly accurate answer, dramatically minimizing hallucination risks and removing the need for costly continuous fine-tuning.

Question 2

Explain GraphRAG and detail how it enhances context retrieval compared to standard vector-only RAG.

Accepted Answer

GraphRAG integrates structured Knowledge Graphs with semantic search, mapping discrete entities and relationships as interconnected nodes and edges. While traditional RAG retrieves isolated document snippets, GraphRAG traces multi-hop semantic connections, enabling highly contextualized macro-level summaries. Traditional vector RAG treats document chunks as isolated points in high-dimensional space, which fails when queries require synthesized information across multiple distinct concepts. GraphRAG resolves this by using an LLM to parse raw text, extract structured entities (e.g. organizations, technologies, processes), and map relationships as edges. By combining hierarchical graph clustering (such as Leiden communities) with semantic vectors, a system can navigate multi-hop dependencies and produce comprehensive system-wide summaries rather than basic local answers.

Question 3

What are the latest advanced developments in RAG pipelines emerging in the 2024–2025 landscape?

Accepted Answer

Modern RAG advancements focus on complex retrieval strategies including Parent-Document Retrieval, Multi-Vector indexing, Query Expansion, and Self-Correction (Self-RAG). These strategies split representation from retrieval to preserve semantic depth while optimizing search precision. First-generation RAG often retrieved small text chunks that lacked overall context, leading to incoherent generations. Recent advancements separate the retrieval index from the generation context. For instance, Parent-Document Retrieval searches small sub-chunks to maximize vector cosine similarities but passes the larger parent document to the LLM. In addition, Speculative RAG accelerates latency by utilizing a lightweight SLM to draft preliminary responses over retrieved contexts, which are then verified or corrected by a larger model.

Question 4

Implement a function to calculate Cosine Similarity between two dense embedding vectors in plain Python.

Accepted Answer

Cosine similarity measures the cosine of the angle between two multi-dimensional vectors. It is calculated by dividing the dot product of the vectors by the product of their magnitudes (Euclidean norms). In semantic search, texts are converted to dense floating-point vector lists. The cosine similarity score ranges between -1 (perfect opposite) and 1 (identical direction), with values closer to 1 representing close semantic alignment. The following code calculates this metric using only standard Python libraries.

Question 5

Write a plain Python function to split text documents into chunks using a sliding window overlap.

Accepted Answer

Text chunking with sliding overlaps splits long text strings into discrete, fixed-size word arrays while retaining a portion of preceding words to maintain context across chunk boundaries. If you split a document strictly by character count or paragraph limits without overlap, sentences that span the boundaries will be sliced, destroying semantic relationships. Creating a sliding window ensures that the ending context of one chunk is preserved at the start of the next chunk.

Question 6

Implement a simple vector retrieval system from scratch in Python to return the Top-K most similar documents.

Accepted Answer

A vector retriever computes similarity scores between a dynamic query vector and a collection of indexed document vectors, sorting the outcomes in descending order to return the top-K highest-scoring texts. In production, vector databases like Pinecone or Chroma perform similarity lookups. At a basic level, this involves iterating through an index, calculating the cosine similarity for each document vector, sorting by score, and slicing the top results.

Question 7

Create a plain Python implementation demonstrating the core mechanics of Parent-Document Retrieval.

Accepted Answer

Parent-Document Retrieval maps small, highly searchable child chunks to their larger, parent source document IDs. When a search query matches a child chunk, the system retrieves and returns the full parent document instead. RAG often runs into a trade-off: small chunks are easier to search semantically, but their text might lack the necessary context for the LLM to generate an accurate response. Parent-Document Retrieval resolves this. It searches the child chunks to maximize semantic similarity scores, but retrieves the parent document ID from a mapping database to provide the LLM with full context.

Question 8

Implement Query Expansion in plain Python using a custom synonym index to improve retrieval recall.

Accepted Answer

Query Expansion enhances search recall by analyzing a user's initial query and appending synonyms or related domain terms, generating multiple query variations to match a wider range of document contexts. Users often formulate queries using synonyms that don't match the exact words in the document. By expanding the query, the system searches for alternative terms. The code below takes a user query, parses the terms, maps them to synonyms, and returns a unique set of search queries.

Question 9

Write a plain Python function to assemble a Knowledge Graph adjacency mapping for GraphRAG.

Accepted Answer

A Knowledge Graph adjacency list is built by registering unique entity nodes and parsing relationship tuples (edges) to map directed connections from source nodes to target nodes. GraphRAG relies on an underlying knowledge graph. To traverse entity paths and discover multi-hop connections, the system must structure flat entity-relationship tables into traversable adjacency lists. The code below converts raw entity-relationship data into a clean, searchable graph structure.

Question 10

Implement a Hybrid Search ranking function in Python that combines Keyword and Semantic similarity scores using reciprocal rank fusion.

Accepted Answer

Hybrid Search combines lexical (keyword-based sparse searches like BM25) and dense semantic vector searches. It balances these scores using an alpha coefficient to determine the final ranked list. Keyword search excels at finding exact matches (like product IDs or names), while semantic search captures conceptual meaning. Combining both techniques ensures high retrieval accuracy. The function below normalizes and blends these scores using a weight coefficient (alpha) to yield a single ranked list.

Question 11

What are Document Loaders in LangChain and how do they standardize data ingestion pipelines?

Accepted Answer

Document Loaders are standard LangChain interfaces that parse unstructured or semi-structured files from diverse data sources and convert them into unified Document objects consisting of page content and metadata. Corporate data is stored across various formats: PDFs, HTML web pages, cloud buckets, and SQL tables. LangChain's BaseLoader provides a standard interface (the `.load()` and `.lazy_load()` methods) to ingest these sources. By abstracting the parsing logic, it outputs standardized Document instances containing `page_content` (the text string) and `metadata` (a dictionary tracking source paths, page numbers, or timestamps). This ensures a clean, unified ingestion pipeline for downstream chunking and indexing.

Question 12

What are Vector Stores in LangChain and how do they facilitate semantic retrieval in RAG?

Accepted Answer

Vector Stores are specialized databases that store high-dimensional document embeddings. They expose standard retrieval interfaces like `.as_retriever()`, converting user queries into vectors and running nearest-neighbor similarity searches to return relevant contexts. Once documents are split into chunks, they are processed by an embedding model to generate high-dimensional vectors representing their semantic meaning. LangChain's VectorStore classes standardize interactions with databases like FAISS, Chroma, and Pinecone. Under the hood, they calculate cosine or Euclidean distances between the query vector and document embeddings, returning the top-K matching document chunks to ground the LLM's response.

Question 13

Compare the primary Text Splitting mechanisms available in LangChain and their ideal use cases.

Accepted Answer

LangChain text splitters divide long documents into manageable chunks. The primary mechanisms are CharacterTextSplitter (splits by static counts), RecursiveCharacterTextSplitter (recursively splits by semantic separators), TokenTextSplitter (splits by token counts), and MarkdownHeaderTextSplitter (splits by structural headers). Selecting the correct text splitter directly impacts retrieval quality. RecursiveCharacterTextSplitter is the default choice for general text because it iteratively splits by paragraphs, sentences, and words to preserve semantic flow. TokenTextSplitter is crucial for API budget management because it splits text based on token counts to ensure chunks fit within model context windows. MarkdownHeaderTextSplitter parses files by headers, preserving the document's logical hierarchy in the metadata.

Question 14

Detail the end-to-end architecture and flow of a standard RAG system constructed using LangChain.

Accepted Answer

A standard LangChain RAG pipeline consists of two primary phases: the Indexing Phase (loads, splits, embeds, and indexes documents) and the Query Phase (embeds the query, retrieves similar chunks, formats the prompt, and generates the response).  RAG pipelines require robust, structured stages to deliver accurate answers. In the Indexing Phase, Document Loaders fetch raw files, Text Splitters divide the text into overlapping chunks, Embedding Models vectorize the chunks, and Vector Stores index them. In the Query Phase, the user's query is converted to an embedding, the Retriever fetches the top-K similar chunks, the system injects them into a Prompt Template, and the LLM synthesizes the final grounded answer. Composed using LangChain Expression Language (LCEL), this creates a highly maintainable, streaming-friendly architecture.

Question 15

Implement a LangChain script to load and parse files using TextLoader and PyPDFLoader.

Accepted Answer

LangChain parses diverse files using specialized loaders. TextLoader reads plain text files, while PyPDFLoader extracts pages and metadata from PDF documents, outputting standardized Document instances. Before processing text, we must ingest it. PyPDFLoader parses PDF documents page-by-page, recording page numbers and file source paths in the metadata. This metadata can be used by the LLM to generate citations. The code below demonstrates loading both plain text and PDF files.

Question 16

Write a Python script to build a local vector index using FAISS and Google Embeddings with LangChain.

Accepted Answer

A local vector store is initialized using FAISS and Google Generative AI embeddings by passing a list of texts to `FAISS.from_texts()`, and then converting the index into a standard retriever. FAISS is a high-speed library for dense vector similarity search. In the script below, we vectorize documents using Google Generative AI embeddings, index them in a local FAISS store, and convert the store into a retriever that performs a similarity lookup to fetch the top-2 matching chunks.

Question 17

Implement text chunking in LangChain using RecursiveCharacterTextSplitter with custom overlap configurations.

Accepted Answer

Hierarchical text splitting is implemented using RecursiveCharacterTextSplitter by defining `chunk_size` and `chunk_overlap` parameters. It recursively checks separators like newlines and spaces to keep paragraphs and sentences intact. RecursiveCharacterTextSplitter is the default splitter in LangChain because it prioritizes structural context. It attempts to split text using a sequence of separators (`['

', '
', ' ', '']`), preserving paragraph and sentence boundaries before resorting to word-level splits.

Question 18

Build a complete LangChain indexing pipeline that loads a text document, chunks the content, vectorizes it, and indexes it in a FAISS store.

Accepted Answer

A complete LangChain indexing pipeline integrates TextLoader, RecursiveCharacterTextSplitter, GoogleGenerativeAIEmbeddings, and FAISS to ingest, process, and index documents for semantic search. To perform RAG, we must first build the document index. This script demonstrates the entire ingestion flow: loading raw files from disk, dividing them into overlapping chunks, vectorizing the text using Google embeddings, and storing them in a local FAISS index.

Question 19

Implement a Retrieval Chain in LangChain using a FAISS VectorStore retriever and a ChatPromptTemplate.

Accepted Answer

A retrieval chain is built by converting a vector store to a retriever and composing a chain using LCEL. The chain fetches context from the vector store, formats the prompt template, and passes the input to the chat model. A retrieval chain connects external knowledge to an LLM. In the script below, the retriever fetches relevant document chunks, which are passed under the `context` key to the prompt template. This grounds the LLM's response, ensuring it answers based on the retrieved facts.

Question 20

Build a complete RAG pipeline using LangChain, Google Gemini, and a FAISS vector store that outputs clean, parsed text.

Accepted Answer

A complete RAG pipeline combines document ingestion, splitting, vectorizing, indexing, retrieval, and generation into a single LCEL chain, utilizing StrOutputParser to return a clean string response. This script demonstrates a complete RAG system. It loads documents, splits them, indexes them in FAISS, retrieves relevant contexts, and uses Google Gemini to generate a factual answer. The pipeline uses StrOutputParser to return a clean text response, ready for user display.

RAG & GraphRAG Interview Prep Portal