4. Chains Parallel

Branch and execute multiple chains concurrently using RunnableParallel

In this section, we will learn how to run multiple branches of an LCEL chain in parallel using RunnableParallel, then merge their outputs.

Objectives

1. Split execution streams to multiple downstream chains concurrently.
2. Utilize RunnableParallel to define dictionary-structured processing branches.
3. Combine separate analysis branches (such as pros and cons reviews) into a final unified layout.

---

Parallel Chains Plan

Goal

List the main features of a product, then trigger parallel prompt chains to evaluate the pros and cons of those features separately. Finally, merge both review branches into a unified markdown report.

Sample Input

{"product_name": "MacBook Pro"}

Sample Output

A combined text report containing a “Pros:” evaluation and a “Cons:” evaluation.

Plan

1. Retrieve features of the product using a primary prompt-model chain.
2. Prepare a Pros Analysis chain: takes features as input and outputs pros list.
3. Prepare a Cons Analysis chain: takes features as input and outputs cons list.
4. Execute both analysis chains concurrently on the retrieved features dictionary using RunnableParallel.
5. Pipe the parallel outputs into a merge lambda to combine them into a single report.

---

Step-by-Step Implementation

Step 1: Base Feature Retrieval

First, we define a prompt template and chain to retrieve the main features of a product.

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

model = ChatOpenAI(model="gpt-4o")

# Create prompt to list features
prompt_template = ChatPromptTemplate.from_messages([
    ("system", "You are an expert product reviewer."),
    ("human", "List the main features of the product {product_name}."),
])

# Base chain to retrieve product features
base_chain = prompt_template | model | StrOutputParser()

Step 2: Define Branch Chains

Next, we define two downstream helper chains: one to analyze the pros of the features, and one to analyze the cons. We wrap the prompt creation in functions and load them into RunnableLambda.

from langchain.schema.runnable import RunnableLambda

# Pros branch helper
def analyze_pros(features):
    pros_template = ChatPromptTemplate.from_messages([
        ("system", "You are an expert product reviewer."),
        ("human", "Given these features: {features}, list the pros of these features."),
    ])
    return pros_template.format_prompt(features=features)

pros_branch_chain = RunnableLambda(lambda x: analyze_pros(x)) | model | StrOutputParser()

# Cons branch helper
def analyze_cons(features):
    cons_template = ChatPromptTemplate.from_messages([
        ("system", "You are an expert product reviewer."),
        ("human", "Given these features: {features}, list the cons of these features."),
    ])
    return cons_template.format_prompt(features=features)

cons_branch_chain = RunnableLambda(lambda x: analyze_cons(x)) | model | StrOutputParser()

Step 3: Run Sub-branches in Parallel

We use RunnableParallel to feed the output of our base features chain into both the pros and cons branches concurrently.

from langchain.schema.runnable import RunnableParallel

# RunnableParallel maps key values to parallel branch executions
parallel_chain = RunnableParallel(branches={"pros": pros_branch_chain, "cons": cons_branch_chain})

Step 4: Merge Branch Outputs

Finally, we create a function that takes the parallel outputs dictionary and formats them into a final combined report.

def combine_pros_cons(pros, cons):
    return f"Pros:\n{pros}\n\nCons:\n{cons}"

merge_chain = RunnableLambda(lambda x: combine_pros_cons(x["branches"]["pros"], x["branches"]["cons"]))

---

Complete Combined Code

Below is the complete, consolidated Python script uniting all of the steps above:

from dotenv import load_dotenv
from langchain.prompts import ChatPromptTemplate
from langchain.schema.output_parser import StrOutputParser
from langchain.schema.runnable import RunnableParallel, RunnableLambda
from langchain_openai import ChatOpenAI

# Load environment variables from .env
load_dotenv()

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

# Define prompt template
prompt_template = ChatPromptTemplate.from_messages(
    [
        ("system", "You are an expert product reviewer."),
        ("human", "List the main features of the product {product_name}."),
    ]
)


# Define pros analysis step
def analyze_pros(features):
    pros_template = ChatPromptTemplate.from_messages(
        [
            ("system", "You are an expert product reviewer."),
            (
                "human",
                "Given these features: {features}, list the pros of these features.",
            ),
        ]
    )
    return pros_template.format_prompt(features=features)


# Define cons analysis step
def analyze_cons(features):
    cons_template = ChatPromptTemplate.from_messages(
        [
            ("system", "You are an expert product reviewer."),
            (
                "human",
                "Given these features: {features}, list the cons of these features.",
            ),
        ]
    )
    return cons_template.format_prompt(features=features)


# Combine pros and cons into a final review
def combine_pros_cons(pros, cons):
    return f"Pros:\n{pros}\n\nCons:\n{cons}"


# Simplify branches with LCEL
pros_branch_chain = (
    RunnableLambda(lambda x: analyze_pros(x)) | model | StrOutputParser()
)

cons_branch_chain = (
    RunnableLambda(lambda x: analyze_cons(x)) | model | StrOutputParser()
)

# Create the combined chain using LangChain Expression Language (LCEL)
chain = (
    prompt_template
    | model
    | StrOutputParser()
    | RunnableParallel(branches={"pros": pros_branch_chain, "cons": cons_branch_chain})
    | RunnableLambda(lambda x: combine_pros_cons(x["branches"]["pros"], x["branches"]["cons"]))
)

# Run the chain
result = chain.invoke({"product_name": "MacBook Pro"})

# Output
print(result)

RunnablePassthrough Example

RunnablePassthrough allows you to pass inputs through unchanged, or combine them with extra values. It is very useful when you want to forward user inputs to multiple downstream steps (like sending a raw question both to a retriever and directly to the final prompt context).

Below is a simple example showing how to pass a single input value through while dynamically injecting extra arguments:

from langchain_core.runnables import RunnablePassthrough
from langchain.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI
from langchain.schema.output_parser import StrOutputParser

# Initialize model
model = ChatOpenAI(model="gpt-4o")

# Define template requiring 'topic' and 'style'
prompt = ChatPromptTemplate.from_template("Write a short poem about {topic} in the style of {style}.")

# Construct chain
# RunnablePassthrough() passes the input 'topic' through as-is,
# while the lambda dynamically assigns a static value for 'style'.
mapping_chain = {
    "topic": RunnablePassthrough(),
    "style": lambda x: "Shakespearean English"
}

chain = mapping_chain | prompt | model | StrOutputParser()

# Invoke the chain by passing the topic directly as a string
result = chain.invoke("artificial intelligence")
print(result)

[!NOTE] Implicit Dict Coercion to RunnableParallel

You might notice that in LCEL, we sometimes pipe into a raw Python dictionary containing multiple keys and downstream chains, such as:

chain = (
    prompt_template
    | model
    | StrOutputParser()
    | {"pros": pros_branch_chain, "cons": cons_branch_chain}  # Raw dictionary
)

Under the hood, whenever a dictionary is used within an LCEL pipeline, LangChain implicitly coerces it into a RunnableParallel.

During this coercion, any standard Python callables (such as functions or lambdas) are automatically wrapped inside a RunnableLambda.

---

Practice & Exercises

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

Practice & Exercises

Practice setting up parallel processing threads, mapping schemas dynamically, and merging concurrent branch results.

💻 VS Code | 🚀 Colab | 📥 Download