LangChain Handbook

Getting Started with Chains

Chains are the core of LangChain. They are simply a chain of components, executed in a particular order.

The simplest of these chains is the LLMChain. It works by taking a user's input, passing in to the first element in the chain — a PromptTemplate — to format the input into a particular prompt. The formatted prompt is then passed to the next (and final) element in the chain — a LLM.

Nowadays, chains are mostly built using LangChain Expression Language (LCEL) rather that using objects like the LLMChain. So, when we refer to the LLMChain we are references this past object but nowadays this would be implemented via LCEL syntax - which we'll explore soon.

Let's start by importing all the libraries that we'll be using in this example.

To run this notebook, we will need to use an OpenAI LLM. Here we will setup the LLM we will use throughout the notebook, just input your OpenAI API key below.

Chains and LCEL

Chains in LangChain are now built using the LangChain Expression Language (LCEL), which takes a declarative approach to combining components. Instead of using predefined chain classes, LCEL lets you compose chains using the | operator and other composition primitives.

Types of Chain Composition

1. Sequential Chains (| operator)

   • Chain components one after another
   • Example: prompt | llm | output_parser

2. Parallel Chains (RunnableParallel)

   • Run multiple operations concurrently
   • Example: Running multiple prompts or retrievers in parallel

3. Complex Workflows

   • For more complex scenarios involving branching, cycles, or multiple agents
   • Recommended to use LangGraph instead of LCEL directly

Let's start with a simple example: creating a sequential math chain that can handle calculations...

Let's see what is going on here. The chain processes our input through several sequential steps:

1. The prompt template formats our question
2. The LLM converts it to a mathematical expression
3. The StrOutputParser ensures we get a clean string
4. Finally, our calculate function computes the result

But how did the LLM know to return just the mathematical expression? 🤔

Enter prompts

The question we send isn't the only input the LLM receives 😉. Look at our prompt template:

The system message explicitly instructs the LLM to return only the mathematical expression. Without this context, the LLM would try to calculate the result itself. Let's test this by trying without the system message:

This demonstrates the power of prompting in LCEL: by carefully designing our prompts, we can guide the LLM's behavior precisely.

The beauty of LCEL's sequential composition is how clearly we can see each step in the chain:

Each step flows naturally into the next using the | operator, making it easy to understand and modify the chain's behavior. This is much more flexible than the old approach of using predefined chain classes - we can easily add, remove, or modify steps as needed!

*Note: The calculate function uses numexpr to safely evaluate mathematical expressions without needing a full Python REPL (Read-Eval-Print Loop).

Building Complex Chains with LCEL

Let's build a more complex example that shows how to combine different components using LCEL. We'll create a chain that cleans up messy text and then paraphrases it in a specific style.

First, let's create a function to clean up text by removing extra spaces and newlines. In LCEL, we can use regular functions directly in our chain:

Now, let's create our prompt template for the paraphrasing:

Now we can combine everything into a sequential chain using LCEL's | operator. The beauty of LCEL is how naturally we can compose these components:

Let's look at how this chain works:

1. The dictionary {"text": clean_text, "style": lambda x: x} processes our inputs in parallel using RunnableParallel
2. The | operator connects each component, showing the clear flow of data
3. Each step in the chain serves a specific purpose and is easily modifiable
4. The components work together seamlessly to process and transform the text

This demonstrates how LCEL lets us compose simple components into powerful chains while keeping the code readable and maintainable. Whether you're processing text, generating content, or building complex workflows, LCEL's composition primitives make it easy to build exactly what you need! 🔥

Using RunnableParallel and RunnablePassthrough

Let's explore how to use RunnableParallel for running multiple operations concurrently and RunnablePassthrough for passing data through unchanged:

Batch Processing with LCEL

LCEL chains support efficient batch processing using the .batch() method:

That's it for this example on chains with LCEL.