Question 1

What is LangChain and what core architectural problems does it solve?

Accepted Answer

LangChain is an open-source development framework designed to simplify the construction of applications powered by Large Language Models (LLMs). It provides standardized abstractions, interfaces, and composable components to connect LLMs with external documents, dynamic datasets, databases, and third-party APIs. Before LangChain, developers had to write custom boilerplate code to handle prompt formatting, model integrations, memory storage, and tool executions. LangChain standardizes these layers. It enables developers to transition from basic single-prompt setups to advanced, context-aware systems like Retrieval-Augmented Generation (RAG) pipelines and autonomous agent teams.

Question 2

Detail the core modules of the LangChain framework.

Accepted Answer

The core modules of LangChain include: Models (unified API abstractions for LLMs and chat endpoints), Prompts (dynamic template generators), Chains (composable execution pipelines), Agents (autonomous decision-making entities), Memory (conversational persistence engines), and Indexes/Retrieval (loaders, splitters, and vector store connectors). These modules serve as the building blocks for LLM architectures. For instance, a basic QA support tool uses Models and Prompts to answer questions, Indexes to fetch relevant company documents via semantic vector search, Memory to retain conversation context, and Chains to bind these operations under a predictable, sequential execution path.

Question 3

What is the purpose of Chains in LangChain and how are they composed?

Accepted Answer

Chains are cohesive execution pipelines in LangChain that combine multiple discrete components—such as prompts, model APIs, and output parsers—into a single executable unit. They are composed declaratively using the pipe operator (|) in LangChain Expression Language (LCEL). Instead of manually nesting API calls and passing outputs from function to function, chains formalize workflows. The pipe operator acts as a UNIX-style pipeline: it streams data from left to right. For example, a prompt template feeds into a chat model, which feeds into a string output parser, creating a typed, predictable text generation pipeline.

Question 4

Explain the ReAct architecture and how Agents operate in LangChain.

Accepted Answer

Agents in LangChain are autonomous reasoning engines that use an LLM to decide which actions to take, execute tools (APIs, databases, browsers), observe the results, and repeat this cycle until a goal is met. They operate on the ReAct (Reasoning and Acting) paradigm. While static chains execute a rigid, predefined sequence of steps, agents can solve open-ended problems dynamically. The agent LLM evaluates the goal, drafts a thought (Reason), selects a tool and generates its arguments (Act), receives the tool's execution result (Observe), and analyzes whether the task is complete or if further actions are required. Modern agents are built on LangGraph for resilient state tracking.

Question 5

What is LangChain Expression Language (LCEL) and what corporate advantages does it offer?

Accepted Answer

LangChain Expression Language (LCEL) is a declarative, domain-specific language designed for composing chains. It offers major corporate advantages including unified sync/async API bindings, automatic streaming support, parallel execution optimization, built-in fallback configurations, and tracing telemetry. LCEL replaces rigid pre-built class workflows (like the older legacy SimpleSequentialChain) with a flexible pipe (|) composition model. Because every LCEL chain implements the Runnable interface, any chain you build automatically supports synchronous execution (invoke), asynchronous processing (ainvoke), streaming tokens (stream), and high-throughput batching (batch) without modifying any underlying code.

Question 6

How does LangChain facilitate Retrieval-Augmented Generation (RAG) workflows?

Accepted Answer

LangChain supports Retrieval-Augmented Generation (RAG) by providing a complete ingestion and retrieval pipeline consisting of Document Loaders (parsing files), Text Splitters (chunking documents), Embedding Models (vectorizing text), Vector Stores (indexing vectors), and Retrievers (semantic similarity search). Standard LLMs have cut-off dates and lack access to private corporate data. RAG resolves this. When a user asks a question, LangChain's retrievers perform a semantic search across a vector store (e.g., FAISS, Chroma, Pinecone) using vector embeddings. The retrieved document chunks are then injected directly into the prompt context, enabling the LLM to generate an accurate, data-backed response.

Question 7

What is LangSmith and how does it support LLM observability and debugging?

Accepted Answer

LangSmith is a developer platform designed for monitoring, evaluating, and debugging LLM applications. It integrates seamlessly with LangChain to provide detailed execution traces that record all prompt formats, API token costs, model latencies, and tool execution states. When building complex agentic systems, diagnosing why an execution failed is extremely difficult. LangSmith acts as a complete debugging suite. By enabling a few environment variables, every call in your LangChain pipeline is automatically recorded in a web UI. Developers can inspect the exact prompt sent to the LLM, view the raw tool parameters, check model response times, and construct test datasets to run automated evaluations.

Question 8

Implement a basic LangChain LCEL pipeline combining a PromptTemplate and a ChatModel in Python.

Accepted Answer

A basic LangChain LCEL pipeline is built by composing a prompt template, a model instance, and an output parser using the pipe operator. The following code demonstrates a functional translation chain using the Gemini API. In this setup, PromptTemplate.from_template declares a dynamic prompt. We pass it through a chat model and a StrOutputParser (which extracts the raw text from the chat message object). When calling invoke, LCEL handles variables mapping and executes the chain sequentially.

Question 9

Write a python code block implementing a LangChain mathematical agent equipped with custom calculation tools.

Accepted Answer

A mathematical agent can be built by defining a safe calculation tool and integrating it with a ChatModel under an autonomous execution loop. LLMs struggle with precise math calculations. To solve this, we create a tool that performs safe mathematical operations. We bind this tool to the LLM, enabling the agent to dynamically route math questions to our tool rather than attempting to compute the result generatively.

Question 10

How do you generate and calculate similarities between embeddings in LangChain?

Accepted Answer

Embeddings are generated in LangChain using embedding model classes (like GoogleGenerativeAIEmbeddings or HuggingFaceEmbeddings). We can compare these dense semantic vectors using mathematical operations like dot products or cosine similarity. Embedding models map text snippets into high-dimensional vector spaces. Semantic distance represents how close two vectors point in that space. In the code below, we generate embeddings for documents and a target search query, and calculate their similarity using a basic dot product.

Question 11

Create a custom tool for a LangChain Agent that queries external REST APIs.

Accepted Answer

A custom tool for querying external APIs is declared using the @tool decorator, utilizing Python's requests library to fetch data and returning a formatted string response for the agent's context. Custom API tools expand agent capabilities to live web data. The docstring of our tool explains the REST inputs to the agent's LLM, ensuring that the model accurately extracts variables (like city names or time zones) and formats the HTTP call correctly.

Question 12

How do you configure persistent session memory in a LangChain Agent using LangGraph?

Accepted Answer

Persistent session memory in modern LangChain is configured by passing an InMemorySaver checkpointer to the agent's runner runtime, using a unique thread_id to separate conversation sessions. Legacy memory classes like ConversationBufferMemory are deprecated in modern LangChain. Today, persistent memory is handled via checkpointing. By passing a checkpointer to our agent, the state of the conversation is saved programmatically at the end of each turn, allowing the model to recall past topics when given the same thread_id.

Question 13

Build a sequential LCEL chain that processes text through multiple steps in Python.

Accepted Answer

A sequential LCEL chain is built by linking multiple runnables together using the pipe operator, allowing the output of an upstream chain (e.g. summarization) to flow directly into a downstream chain (e.g. translation). Under LCEL, sequential pipelines are highly modular. We define two separate chains with distinct prompts and output parsers. We then compose them into a sequential chain where the output of the first chain feeds into the second.

Question 14

Write a python code block generating a dynamic prompt template using multiple variables.

Accepted Answer

Dynamic prompts are declared using the PromptTemplate class by specifying string placeholders that are filled programmatically at runtime using the .format() or .invoke() methods. Hardcoding prompts limits system flexibility. Using dynamic variables allows applications to inject custom roles, tasks, and historical context values directly into the model's instructions at runtime.

Question 15

Compare the primary chaining structures in LangChain: Sequential, Parallel, and Routing.

Accepted Answer

Sequential chains execute tasks in a fixed, linear order. Parallel chains process multiple inputs or tasks simultaneously to optimize execution times. Routing chains dynamically select a specific downstream execution path based on intent classification. Selecting the correct chaining architecture dictates system performance and API costs. Sequential flows are best for step-by-step logic like summarization followed by translation. Parallel flows are essential for speed, such as querying multiple vector indexes at once. Routing flows optimize resources by directing simple tasks to fast SLMs and reserving expensive models for complex logical reasoning.

Question 16

How do you build a semantic document search pipeline using FAISS and LangChain in Python?

Accepted Answer

A semantic search pipeline is built by vectorizing document segments using an embedding model, indexing them in a FAISS vector store, converting the index into a retriever, and passing the results to a generation chain. To perform RAG, we first index text in a FAISS vector database. We then declare a chain that uses our FAISS index as a retriever: when a query is received, the retriever fetches the most semantically relevant text chunks, injects them as context into a prompt template, and generates an accurate, grounded response.

Question 17

Write a python code block demonstrating how to parse structured comma-separated list outputs from an LLM.

Accepted Answer

Structured outputs are parsed in LangChain by appending an output parser class (such as CommaSeparatedListOutputParser) at the end of the LCEL chain, converting the raw LLM text into a typed Python list. By default, LLMs return freeform text. To integrate with application logic, we must extract structured formats. Placing an output parser in the LCEL chain enforces validation and programmatically converts strings into parsed python objects.

Question 18

Implement error handling and fallback routing in a LangChain LCEL chain.

Accepted Answer

Error handling and fallback routing are implemented in LangChain using the .with_fallbacks() method. This configures an execution chain to automatically catch exceptions (like rate-limits or API failures) and divert the query to a backup chain. Relying on a single API can lead to downtime. Fallback routing ensures system resilience: if the primary model throws a rate-limit error, LangChain catches the exception and routes the task to a secondary model seamlessly.

Question 19

Build a LangChain Agent equipped with multi-source tool routing.

Accepted Answer

An agent with multi-source tool routing binds multiple specialized tools (like search tools and database tools) under a ReAct executor, allowing the agent to dynamically route tasks to the best-suited resource. By defining multiple tools, the agent acts as a dispatcher: it analyzes the task description, matches the intent to the most appropriate tool schema, executes the tool, and consolidates the results into a single answer.

Question 20

Explain the purpose of custom Callback Handlers in LangChain and how to implement one.

Accepted Answer

Custom Callback Handlers in LangChain are event-driven monitoring tools that inherit from BaseCallbackHandler. They hook into intermediate execution states, allowing developers to execute custom logging, auditing, or alert operations when LLMs or chains start and finish. Chains are often 'black boxes'. Callback handlers expose their internal operations: they trigger callback hooks like on_llm_start or on_chain_end as tasks execute. This allows developers to log exact queries, record API latency metrics, or audit system performance in real-time.

Question 21

What is LangGraph and what core architectural problems does it solve?

Accepted Answer

LangGraph is a low-level orchestration framework designed for building stateful, multi-actor applications with Large Language Models (LLMs). It solves the limitations of standard Directed Acyclic Graphs (DAGs) by supporting cyclic execution paths, durable state persistence, real-time token streaming, and human-in-the-loop validation hooks. Traditional orchestration libraries process tasks linearly (DAGs), meaning you cannot easily run loops where an agent writes code, compiles it, sees an error, and loops back to self-correct. LangGraph solves this by modeling workflows as a stateful graph (with nodes, edges, and state). It handles state updates, keeps checkpoints after every step, and allows developer systems to pause and resume agent execution seamlessly.

Question 22

Contrast StateGraph (Graph API) and the Functional API in LangGraph.

Accepted Answer

StateGraph (Graph API) is a declarative approach where developers explicitly declare a shared state schema, register nodes (functions), and define static or conditional edges. The Functional API is an imperative approach that enables persistence and checkpointing directly inside standard, procedural Python control flows (using normal loops and conditional statements). StateGraph is best suited for complex, multi-agent systems because it enforces a clean, visual graph architecture where state transitions are managed explicitly through reducers. The Functional API is ideal for adding fault-tolerance and streaming capabilities to existing procedural Python codebases with minimal restructuring.

Question 23

How does checkpointing work in LangGraph and what capabilities does it enable?

Accepted Answer

Checkpointing in LangGraph automatically serializes and saves the state of the graph at every step (superstep) inside a specific thread identifier. This enables fault-tolerant execution, conversation memory preservation, 'time-travel' debugging, and human-in-the-loop interruption protocols. Checkpointers are stateful saver classes (e.g. MemorySaver in RAM, or PostgresSaver in DB). After a node completes, LangGraph writes a snapshot of the active state to the checkpointer. If the server crashes, the workflow can resume from the exact superstep. It also allows developers to inspect past states, 'time-travel' by rewinding state to a past step, and pause execution for human verification.

Question 24

Differentiate between short-term and long-term memory architectures in LangGraph.

Accepted Answer

Short-term memory in LangGraph is thread-scoped, persisting conversation context and variables dynamically within a single session using checkpointers. Long-term memory is persistent across threads and users, managed via the Store interface using key-value namespaces to store profile preferences and historical facts. Agents require different memory speeds. Short-term memory lives inside the graph's active state (representing what was said in the current chat session). Long-term memory represents a persistent database (e.g. remembering that a user prefers 'Dark Mode' or has a 'Premium' plan). When a graph starts, it queries the Store to fetch long-term user profile insights, injecting them into the active session state.

Question 25

How do you declare a basic StateGraph with nodes, edges, and state execution in Python?

Accepted Answer

A basic StateGraph is declared by defining a shared state structure (typically a TypedDict), creating node functions that receive and return state dictionaries, registering nodes using add_node, mapping edges using add_edge, compiling the builder, and invoking the compiled graph. Nodes represent computational steps (functions), and edges define the routing direction. The START edge directs the initial input to the first node, and the final edge directs the output to END. The compile step turns these declarations into an executable Runnable.

Question 26

Write a python code block implementing conditional edges and routing in LangGraph.

Accepted Answer

Conditional edges dynamically route graph execution based on state values at runtime. They are added using the .add_conditional_edges() method by passing a routing function that returns a destination string matching registered node names. Static edges always go to the same node. Conditional edges evaluate states dynamically. In the code below, the router function inspects the variable count and routes the execution flow back to the processing loop if a condition is met, or exits the graph when complete.

Question 27

How do you add in-memory checkpointing to a LangGraph workflow to enable thread persistence?

Accepted Answer

Durable thread persistence is enabled by initializing an InMemorySaver checkpointer and passing it to the .compile() method. Workflows are then invoked with a custom config containing a unique thread_id. By compiling our StateGraph with a checkpointer, the execution state is saved automatically. The thread configuration acts as a session key: invoking the graph with the same thread ID loads the persisted state, allowing the workflow to resume from where it left off.

Question 28

How do you implement real-time token streaming in a LangGraph execution workflow?

Accepted Answer

Real-time token streaming is implemented by calling the .stream() method on compiled graphs instead of .invoke(), utilizing streaming modes like 'messages' to capture token chunks as they are generated by model nodes. Waiting for an LLM to complete its entire response degrades the user experience. By calling .stream(), LangGraph yields execution updates asynchronously. We can iterate over this stream to capture and display token chunks in real-time.

Question 29

Explain how to construct a multi-agent system in LangGraph using Subgraphs.

Accepted Answer

A multi-agent system is constructed in LangGraph by creating separate compiled graphs for individual specialized agents, and nesting them as standard node functions inside a primary parent StateGraph. Creating one massive graph for multiple agents leads to bloated, unmaintainable state schemas. Subgraphs resolve this: we isolate agent workflows (e.g. a specialized coder agent graph and a specialized QA tester agent graph) into independent graphs, and register them as nodes in the main coordinator graph.

Question 30

Implement error handling, recovery, and retry loops in a LangGraph workflow.

Accepted Answer

Error handling and recovery are implemented in LangGraph by placing try-except blocks inside node functions to catch exceptions, recording error states in variables, and routing to retry loops using conditional edges. If a node function throws an unhandled exception, graph execution immediately crashes. To make our graph resilient, we catch exceptions inside our nodes, write the error message to the state dictionary, and use conditional routing edges to automatically retry the operation or route to a fallback node.

LangChain Interview Prep Portal