Core single-chain construction from prompt to parsed output.
Basic chains are the foundation of reliable LangChain engineering. Before routing, tools, or agents, you need one deterministic path that is easy to test and explain. A basic chain usually has three responsibilities: shape input, run generation, and normalize output.
Canonical structure: prompt | model | parser
AIMessage from the prompt.Why this matters in production: most instability appears when developers skip explicit parsing and pass raw model text downstream. A parser boundary makes output contracts explicit and keeps failures local.
Minimal engineering checklist for a basic chain:
Common beginner error: adding too many instructions in one prompt and assuming the chain is “complete.” A strong basic chain keeps responsibilities narrow and composable.
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.
The basic chain pattern is the first stable unit of LangChain engineering: prompt template -> model -> StrOutputParser. The transcript shows why this is cleaner than invoking each stage manually. You build the workflow once, then call chain.invoke({...}) with the variables the prompt needs. The chain handles the stage transitions for you, and the parser narrows the final output into the shape your application actually wants.
One important practical detail: the input object passed to chain.invoke can be reused by later prompt stages if the chain grows. That means the invocation payload is the shared runtime context for the whole chain, not just the first template. This is why clean variable naming matters. If a later stage needs language, tone, or audience, those keys should be part of the chain's explicit input contract rather than buried in helper code.
Design rule: make the basic chain deterministic and understandable before adding branching or side effects. If a simple prompt-model-parser chain is not stable, a larger orchestration graph will only amplify the instability.
Exhaustive coverage points to ensure complete topic understanding without missing core concepts.
Starter chain walkthrough: 1) Input question enters prompt template. 2) Model generates response draft. 3) Parser normalizes output type. 4) UI renders deterministic structure. 5) Logs capture prompt id and response. A simple deterministic chain should be production-stable before adding routing.
Guided Starter Example
Starter chain walkthrough: 1) Input question enters prompt template. 2) Model generates response draft. 3) Parser normalizes output type. 4) UI renders deterministic structure. 5) Logs capture prompt id and response. A simple deterministic chain should be production-stable before adding routing.
Source-grounded Practical Scenario
Core single-chain construction from prompt to parsed output.
Source-grounded Practical Scenario
A basic chain usually has three responsibilities: shape input, run generation, and normalize output.
Basic chain composition example using prompt + model pipeline.
content/github_code/langchain-course/3_chains/1_chains_basics.py
Simple chain construction and invoke path.
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 - Basic. 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.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.Start flipping cards to track your progress
What is the default LCEL structure for a basic chain?
tap to reveal →Prompt -> Model -> Parser. Each stage has a single responsibility and clear boundary.