roadmap
- 01
- 02
- 03
- 04
- 05
- 06
- 07
- 08
Prepare for LangChain interview questions on building LLM apps and agents. Covers prompts and LCEL, retrieval and RAG, tool-calling agents, LangGraph orchestration, and LangSmith tracing.
93 of 93 questions in your plan: 0 known, 0 in progress, 0 due, 0 skipped, 93 new. 0 cut, outside your plan.
The framework is tested through the applications built on it: in AI engineer and LLM application loops it turns up inside a practical coding task (wire a retriever into a chain, give a model a tool and handle the call it asks for) or as the vocabulary of a design round about a RAG or agent system.
The questions go below the API surface. What does the | operator actually build, and why can the result stream and batch as well as invoke? When a chat model is bound to tools, what turns a Python function into the schema the model sees, and who runs the call and hands the result back? In a graph, what happens when two nodes write the same state key, and why does a node paused with interrupt run again from its first line when the thread resumes? How do you show a prompt change made answers better rather than merely different?
Early-career candidates are measured on assembling the pieces and explaining the data passing between them. Senior candidates are pushed on failure: an agent circling until it hits the recursion limit, a side effect repeated on resume because its node was not idempotent, a retriever quietly returning nothing useful, and the evaluation set and traces that would have caught each before a user did.
Each module is one part of the ecosystem, in the order an application needs them: written, then orchestrated, then measured. LangChain opens with prompt templates, the step most chains begin with, and then LCEL, the protocol nearly every later component implements; once that contract is clear, a chat model is one more runnable, with structured output and tool binding on top. Memory and retrieval then bring in context from outside the prompt, one from the conversation, the other from your documents. Tools and agents close the module because an agent is everything before it in a loop: the model picks a tool, the tool runs, its result returns to the messages.
That loop is where LangGraph takes over. The state graph makes it explicit as nodes, edges and a typed state whose reducers decide how updates merge, and conditional routing is how the graph chooses between calling another tool and finishing. Checkpointing precedes human-in-the-loop because a run can pause for approval only if its state was saved somewhere to resume from. Multi-agent patterns wait until one graph is familiar, and streaming and observability hand over to the last module.
LangSmith answers the question the first two modules leave open: is the output any good? Traces come first, since experiments and evaluators both work on recorded runs. Datasets and experiments fix a set of inputs to compare versions against, evaluators score the results, from exact checks to an LLM judge with biases of its own, and online evaluation carries that scoring onto production traffic, with human annotation feeding new examples back into the dataset.
A few days before the loop, cut the plan down to what is asked most: set level to the band you are applying at, leave only must know in importance, and keep the default by frequency study order. Type out each chain and tool-calling answer in a Python file as you read it: the practical round asks for code, not a description. Senior candidates should save their last hours for checkpointing, interrupts and evaluators, where a design conversation about a production agent ends up. With weeks to spare, choose by topics as the study order and build alongside the plan: one graph with a tool, a checkpointer and an approval step before its side effect, traced into LangSmith and scored against a small dataset whenever the prompt changes. If you learned the framework through its older chain and agent classes, start at LCEL anyway: current documentation builds with runnables and graphs, and interviewers listen for that vocabulary. The plan stays inside the LangChain ecosystem. Python itself, how a vector index finds nearest neighbors, and serving open models on your own GPUs are outside it; the [AI Engineer roadmap](/roadmaps/ai-engineer) places this framework among those layers and the rest of that loop.
A few days before the loop, cut the plan down to what is asked most: set level to the band you are applying at, leave only must know in importance, and keep the default by frequency study order. Type out each chain and tool-calling answer in a Python file as you read it: the practical round asks for code, not a description. Senior candidates should save their last hours for checkpointing, interrupts and evaluators, where a design conversation about a production agent ends up.
With weeks to spare, choose by topics as the study order and build alongside the plan: one graph with a tool, a checkpointer and an approval step before its side effect, traced into LangSmith and scored against a small dataset whenever the prompt changes. If you learned the framework through its older chain and agent classes, start at LCEL anyway: current documentation builds with runnables and graphs, and interviewers listen for that vocabulary.
The plan stays inside the LangChain ecosystem. Python itself, how a vector index finds nearest neighbors, and serving open models on your own GPUs are outside it; the AI Engineer roadmap places this framework among those layers and the rest of that loop.