1. Chains Basics

Build chains using LCEL, understand how they work under the hood, and explore LangChain’s Runnable interface

In this section, you will learn the fundamentals of LangChain Expression Language (LCEL), demystify how chains work under the hood using explicit Runnable objects, and explore the global Runnable protocol hierarchy.

Objectives

1. Build a basic chain connecting prompts, models, and string output parsers using the pipe (|) operator.
2. Peek under the hood of LCEL by implementing chains using explicit RunnableLambda and RunnableSequence constructs.
3. Understand the core Runnable Hierarchy and the common methods shared across all LangChain components.

---

1. LCEL Chain Basics

LangChain Expression Language (LCEL) allows you to chain together multiple components. The pipe (|) operator streams inputs through components sequentially:

from dotenv import load_dotenv
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain_openai import ChatOpenAI

# Load environment variables from .env
load_dotenv()

# Create a ChatOpenAI model
model = ChatOpenAI(model="gpt-4o")

# Define prompt templates
prompt_template = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a comedian who tells jokes about {topic}."),
        ("human", "Tell me {joke_count} jokes."),
    ]
)

# Create the combined chain using LangChain Expression Language (LCEL)
chain = prompt_template | model | StrOutputParser()

# Run the chain
result = chain.invoke({"topic": "lawyers", "joke_count": 3})

# Output
print(result)

---

2. Under the Hood: Explicit Sequences

Under the hood, LCEL overloads the pipe operator (|) to implicitly create sequences. We can achieve the exact same behavior by wrapping code steps in RunnableLambda functions and combining them using a RunnableSequence.

from dotenv import load_dotenv
from langchain.prompts import ChatPromptTemplate
from langchain.schema.runnable import RunnableLambda, RunnableSequence
from langchain_openai import ChatOpenAI

# Load environment variables from .env
load_dotenv()

# Create a ChatOpenAI model
model = ChatOpenAI(model="gpt-4")

# Define prompt templates
prompt_template = ChatPromptTemplate.from_messages(
    [
        ("system", "You are a comedian who tells jokes about {topic}."),
        ("human", "Tell me {joke_count} jokes."),
    ]
)

# Create individual runnables (steps in the chain)
# RunnableLambda turns custom python functions into LCEL-ready components
format_prompt = RunnableLambda(lambda x: prompt_template.format_prompt(**x))
invoke_model = RunnableLambda(lambda x: model.invoke(x.to_messages()))
parse_output = RunnableLambda(lambda x: x.content)

# Create the RunnableSequence manually
chain = RunnableSequence(first=format_prompt, middle=[invoke_model], last=parse_output)

# Run the chain
response = chain.invoke({"topic": "lawyers", "joke_count": 3})

# Output
print(response)

---

3. The LangChain Runnable Hierarchy

Almost every component in LangChain—including Prompts, Chat Models, LLMs, Output Parsers, and helper classes—implements the Runnable protocol. This shared base class structure allows components to be seamlessly piped together.

Core Hierarchy Classes

• Runnable: The base protocol class defining the interface contract (invoke, stream, batch).
• RunnableSerializable: Inherits from Runnable. It represents components that can be serialized or saved to disk (e.g. prompt templates, chat models, output parsers).
• RunnableLambda: Wraps a standard Python callable function or lambda so it behaves like a standard LangChain Runnable.
• RunnableSequence: Formed when chaining components using the pipe operator (|). Represents a pipeline where step $N$ feeds into step $N+1$.
• RunnableParallel: Executes multiple branches concurrently on the same input, yielding a dictionary mapped to each branch’s output.
• RunnablePassthrough: Passes the input keys through unchanged or adds new keys dynamically. Commonly used with RunnableParallel to build RAG chains where you want to pass both the original question and retrieved context forward.

Regularly Used Component Runnables

• BasePromptTemplate (e.g. ChatPromptTemplate): Takes a dictionary of arguments and formats it into prompts.
• BaseChatModel / LLM (e.g. ChatOpenAI): Takes prompts/messages and returns message outputs.
• BaseOutputParser (e.g. StrOutputParser, JsonOutputParser): Takes message outputs and parses them into strings or structured formats.

---

Practice & Exercises

To reinforce what you’ve learned in this section, practice with the interactive notebook:

Practice & Exercises

Practice composing simple chains, using different invocation methods (batch, stream), and manually building sequences.

💻 VS Code | 🚀 Colab | 📥 Download