Fundamentals of Chains

While individual calls to a language model are useful, most practical applications involve a series of operations. A user's query might first need to be refined, then passed to a model, and finally, the model's output might need to be parsed and used as input for another task. Chains provide the structure for linking these operations together into a single, cohesive unit.

At its core, a chain is an end-to-end pipeline that takes an input and produces an output by passing the data through a sequence of components. Think of it as composing functions. If formatting a prompt is one function, $f_{prompt}$, and calling the model is another, $f_{model}$, then a simple chain represents their composition:

$$\text{Output} = f_{model}(f_{prompt}(\text{Input}))$$

This structure makes your application logic explicit and manageable. Instead of writing imperative code to handle each step, you define a declarative sequence that LangChain executes.

The Anatomy of a Basic Chain

The most fundamental chain consists of three parts that you are already familiar with from the previous chapter: a prompt template, a model, and an output parser.

1. PromptTemplate: Takes the initial input variables (e.g., a dictionary) and formats them into a prompt value (either a string or a list of messages) for the model.
2. Model (LLM or ChatModel): Receives the formatted prompt and generates a response (a text string or a message object).
3. OutputParser: Takes the output from the model and transforms it into a more useful format, such as JSON or a Python object.

This sequence represents a single, reusable block of logic. The diagram below illustrates this flow, showing how data is transformed at each step.

A standard chain processes input through a prompt template, a language model, and an output parser to produce structured data.

Why Chains are an Important Structure

Organizing your application logic into chains offers several significant advantages over manually orchestrating each call.

• Standardization: Every chain exposes a unified interface. Whether a chain performs a single LLM call or a complex ten-step process, you interact with it in the same way. This typically involves methods like invoke() for a single input, stream() for streaming outputs, and batch() for processing multiple inputs efficiently. This consistency simplifies building and testing.

• Modularity and Composability: Chains are self-contained and reusable. A chain built to summarize articles can be a single component in a larger chain that first fetches an article, then summarizes it, and finally translates the summary. This modularity is central to building sophisticated applications without creating unmanageable code.

• Observability: When you run a chain, LangChain can trace the entire execution flow. This makes debugging much easier, as you can see the exact inputs and outputs of each step in the sequence. We will explore this in detail when we cover LangSmith.

The standard way to construct chains in LangChain is with the LangChain Expression Language (LCEL), which uses the pipe (|) operator to link components. This syntax makes the data flow intuitive and readable. A simple chain composed of a prompt, model, and parser would look like this:

chain = prompt | model | parser

This single line of code defines a complete, executable pipeline. The input is first "piped" into the prompt, the resulting prompt is piped into the model, and the model's output is piped into the parser. In the following sections, we will use this composition syntax to build our first chains and explore more advanced sequential patterns.