The pipe | operator is a common method for chaining LangChain components. Building production-ready applications, however, requires a thorough understanding of the LangChain Expression Language (LCEL) that powers this composition. LCEL isn't just syntactic sugar; it's a declarative way to define computation graphs, providing a standardized interface for components and enabling features like streaming, asynchronous operations, and parallel execution out of the box. Examining the main concepts behind LCEL will help you use its full potential for complex architectures.
At the foundation of LCEL is the Runnable protocol. Any component designed to be part of an LCEL chain, whether it's a prompt template, an LLM, an output parser, or a custom function, adheres to this standard interface. This uniformity is what allows different components to be connected. The Runnable protocol defines several methods, the most significant being:
invoke(input): Executes the component synchronously with the given input.ainvoke(input): Executes the component asynchronously. Essential for I/O-bound operations like LLM calls in production web servers.stream(input): Executes the component synchronously and streams back chunks of the output as they become available. This is particularly useful for providing incremental responses from LLMs to users.astream(input): Executes the component asynchronously, streaming back output chunks. Combines the benefits of async execution and streaming.batch(inputs): Executes the component synchronously on a list of inputs, potentially with optimizations.abatch(inputs): Executes the component asynchronously on a list of inputs.By standardizing on these methods, LCEL ensures that any Runnable can be invoked, streamed, or batched in a consistent manner, regardless of its internal implementation. When you implement custom components (as discussed later in this chapter), adhering to the Runnable protocol makes them first-class citizens within the LangChain ecosystem.
When you use the pipe operator (|) to connect two Runnable components, like prompt | model, LCEL internally constructs a RunnableSequence.
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
# Assume OPENAI_API_KEY is set
prompt = ChatPromptTemplate.from_template("Tell me a joke about {topic}")
model = ChatOpenAI()
# This creates a RunnableSequence instance
chain = prompt | model
A RunnableSequence is itself a Runnable. When you invoke the sequence, it executes its constituent components sequentially:
{"topic": "bears"}) is passed to the invoke method of the first element (prompt).PromptValue) is passed to the invoke method of the second element (model).AIMessage) becomes the final output of the sequence.This sequential execution applies similarly to stream, astream, batch, and abatch. For streaming, LCEL handles passing chunks through the sequence. If a component doesn't natively support streaming (like a simple prompt template), LCEL smartly passes its complete output downstream once available, allowing subsequent streaming-capable components (like an LLM) to operate as expected.
LCEL also supports parallel execution of Runnables. This is typically achieved using a dictionary syntax, which creates a RunnableParallel instance.
from langchain_core.runnables import RunnableParallel
# Example setup (replace with actual runnables)
runnable1 = ChatPromptTemplate.from_template("Runnable 1: {input}") | model
runnable2 = ChatPromptTemplate.from_template("Runnable 2: {input}") | model
# Define parallel execution using RunnableParallel
parallel_chain = RunnableParallel(
output1=runnable1,
output2=runnable2,
)
# Note: In a chain, you can also use a dictionary literal, which LCEL
# automatically converts to a RunnableParallel:
# chain = {"output1": runnable1, "output2": runnable2} | some_next_step
# Invoking this runs runnable1 and runnable2 potentially in parallel
# The input is passed to *both* runnables
output = parallel_chain.invoke({"input": "parallel processing"})
# Output will be a dictionary:
# {'output1': AIMessage(...), 'output2': AIMessage(...)}
When a RunnableParallel (or a dictionary literal used in a chain) is invoked, it passes the same input to each of its contained Runnables. It then attempts to execute these Runnables concurrently, especially when using asynchronous methods like ainvoke or abatch. The final output is a dictionary where keys correspond to the keys provided in the definition, and values are the outputs of the respective Runnables.
Comparison of data flow in sequential (
RunnableSequence) and parallel (RunnableParallel) execution patterns within LCEL.
Understanding this distinction is significant for designing efficient chains. Use RunnableSequence (|) when the output of one step is the input to the next. Use RunnableParallel ({}) when multiple steps can operate on the same input independently and potentially concurrently.
LCEL provides a .with_config() method on any Runnable to pass down configuration options like callbacks, recursion limits, or run names. This configuration is generally propagated through the sequence or parallel execution graph.
# Example of passing configuration
result = chain.with_config(
{"run_name": "JokeGenerationRun"}
).invoke({"topic": "robots"})
Streaming support is a core feature. When you call .stream() or .astream() on an LCEL chain, the framework orchestrates the streaming process end-to-end. If an LLM component streams tokens, LCEL ensures these tokens are yielded as they arrive. For sequences, intermediate non-streaming steps complete their execution, and their output is passed to the next step, which might then initiate streaming. Output parsers designed for streaming can process token chunks incrementally. This built-in streaming capability is important for interactive applications where users expect immediate feedback.
Grasping LCEL internals is not merely academic. It directly impacts your ability to:
Runnable interface and how RunnableSequence and RunnableParallel execute helps trace data flow and pinpoint errors or unexpected behavior, especially when using tools like LangSmith (covered in Chapter 5).RunnableParallel) or leveraging asynchronous methods (ainvoke, astream, abatch) allows you to build more responsive and scalable applications (explored further in Chapter 6).Runnable protocol ensures your custom logic integrates into LCEL chains, inheriting features like streaming and configuration management.LCEL provides the architectural backbone for complex LangChain applications. By understanding its core principles, the Runnable protocol, sequential composition via RunnableSequence, parallel execution via RunnableParallel, configuration propagation, and inherent support for streaming and asynchronous operations, you are better equipped to design, build, and debug advanced, production-grade LLM systems.
Cleaner syntax. Built-in debugging. Production-ready from day one.
Built for the AI systems behind ApX Machine Learning
Was this section helpful?
Runnable protocol, outlining its methods (invoke, ainvoke, stream, astream, batch, abatch) and how they form the standard interface for LCEL components.asyncio module, which provides the foundation for concurrent and asynchronous operations leveraged by LCEL's ainvoke, astream, and abatch methods.© 2026 ApX Machine LearningAI Ethics & Transparency•