Composing prompts, models, and parsers into end-to-end LCEL pipelines.
Chains are LangChain's most powerful component — the ability to compose multiple steps into a sequential pipeline. The instructor calls them his personal favourite because they're where the framework earns its name.
LCEL (LangChain Expression Language) uses the pipe operator (|) to compose any Runnable component into a chain:
chain = prompt | model | output_parser\nresult = chain.invoke({'topic': 'Python decorators'})Each component receives the output of the previous one as input. The final output is the result of the last component in the chain.
Output Parsers are commonly the last step — they transform the raw AIMessage into a more useful format:
StrOutputParser — extracts just the text stringJsonOutputParser — parses the response as JSONPydanticOutputParser — validates and types the responseChains are lazy — they don't execute until .invoke(), .stream(), or .batch() is called. This enables building complex workflows declaratively before triggering execution.
Source-backed reinforcement: these points add detail beyond short-duration UI hints and emphasize production tradeoffs.
First-time learner note: Build deterministic baseline chains first (prompt -> model -> parser), then add retrieval, memory, or tools only when the baseline is stable.
Production note: Keep contracts explicit at each boundary: input variables, output schema, retries, and logs. This is what keeps orchestration reliable at scale.
A chain is a workflow boundary, not just a pretty pipe operator. The core idea is that one runnable finishes a task and passes its output to the next runnable so the whole path behaves like a unified system. Some tasks are prompt-formatting steps, some are model invocations, some are parsing steps, and some can even be ordinary code transforms or API calls. LCEL gives you one composition language for all of them.
Useful mental model: chains are typed dataflow graphs. Each stage receives a particular shape, transforms it, and hands off a new shape. If the stage boundaries are clear, you can reason about the chain in the same way you would reason about a backend pipeline or ETL workflow. If the stage boundaries are fuzzy, teams end up blaming the model for failures that were really caused by malformed prompts, missing variables, or bad post-processing.
Production note: the value of chains increases with observability. Once you can see stage-by-stage inputs, outputs, latency, and exceptions, the chain stops feeling like magic and starts behaving like an inspectable service pipeline.
Exhaustive coverage points to ensure complete topic understanding without missing core concepts.
LCEL chain run: 1) Define prompt | model | parser. 2) Invoke with one input payload. 3) Prompt formats instruction. 4) Model returns AIMessage. 5) Parser returns app-ready output. 6) Add retries/parallel branches only after baseline is stable. This is the core LangChain execution model.
Guided Starter Example
LCEL chain run: 1) Define prompt | model | parser. 2) Invoke with one input payload. 3) Prompt formats instruction. 4) Model returns AIMessage. 5) Parser returns app-ready output. 6) Add retries/parallel branches only after baseline is stable. This is the core LangChain execution model.
Source-grounded Practical Scenario
Composing prompts, models, and parsers into end-to-end LCEL pipelines.
Source-grounded Practical Scenario
Chains are LangChain's most powerful component — the ability to compose multiple steps into a sequential pipeline.
Auto-mapped source-mentioned code references from local GitHub mirror.
content/github_code/langchain-course/1_chat_models/1_chat_models_starter.py
Auto-matched from source/code cues for Chains — Overview.
Open highlighted code →content/github_code/langchain-course/1_chat_models/2_chat_models_conversation.py
Auto-matched from source/code cues for Chains — Overview.
Open highlighted code →Questions an interviewer is likely to ask about this topic. Think through your answer before reading the senior angle.
Test yourself before moving on. Flip each card to check your understanding — great for quick revision before an interview.
Drag to reorder the architecture flow for Chains — Overview. This is designed as an interview rehearsal for explaining end-to-end execution.
LCEL uses the pipe operator (|) to chain components. Each component's output becomes the next component's input. Toggle components on/off, then hit Run to simulate execution.
Formats variables into a structured prompt. e.g. "You are {role}. Answer: {question}"
ChatPromptTemplate.from_messages([
("system", "You are {role}."),
("human", "{question}")
])Sends the prompt to the LLM and returns an AIMessage with the response.
ChatOpenAI(model="gpt-4o-mini")Extracts the plain text string from the AIMessage. Without it you get the full object.
StrOutputParser()stream()), parallel execution of multiple chains, and built-in observability with LangSmith — all without changing your chain code.Use this lab to compare how LangChain orchestration patterns affect critical-path latency, merge complexity, and failure handling.
Keep stages narrow. If a stage only reformats data, make that explicit so debugging is cheap.
Start flipping cards to track your progress
What is a LangChain Chain?
tap to reveal →A sequence of composable steps (prompt, model, parser, retriever, tools) connected with LCEL's pipe operator (|). Each step's output is the next step's input. Execute with .invoke(), .stream(), or .batch().