LangChain Chains: LLMChain, SimpleSequentialChain, and SequentialChain

LangChain's chaining mechanism is a fundamental concept for building sophisticated LLM-powered applications. It allows you to break down complex tasks into smaller, manageable steps, each handled by an LLM call. This document explains the core chaining components: LLMChain, SimpleSequentialChain, and SequentialChain.

1. LLMChain

LLMChain is the most fundamental building block in LangChain. It represents a single interaction with an LLM, combining a prompt template with an LLM.

Definition

LLMChain takes a prompt template, populates it with input variables, and then passes the resulting string to an LLM to generate a response.

Key Features

• Single Prompt Template: Uses one prompt template for a single LLM call.
• Dynamic Variable Insertion: Supports inserting dynamic values into the prompt template.
• Ideal for Simple Tasks: Best suited for straightforward, single-step text generation tasks.

Example

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

# Initialize the LLM
llm = OpenAI(temperature=0.7)

# Define the prompt template
prompt = PromptTemplate(
    input_variables=["topic"],
    template="Explain {topic} in simple terms."
)

# Create the LLMChain
chain = LLMChain(llm=llm, prompt=prompt)

# Run the chain
topic = "quantum computing"
output = chain.run(topic)

print(f"Explanation of {topic}:")
print(output)

Use Case

Use LLMChain when your task can be accomplished with a single prompt-response interaction. Examples include:

• Summarization
• Text explanation
• Question answering
• Simple content generation

2. SimpleSequentialChain

SimpleSequentialChain allows you to link multiple LLMChain instances together in a linear fashion, where the output of one chain becomes the input of the next.

Definition

SimpleSequentialChain executes a sequence of LLMChains. The output from the previous chain is automatically passed as the single input to the next chain.

Key Features

• Linear Execution: Chains are executed in a strict, sequential order.
• Single Input/Output Transfer: The entire output of one step is passed as the sole input to the subsequent step.
• No Named Variables: Does not support explicit naming or management of variables between steps. The flow is entirely based on sequential output-to-input.

Example

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain, SimpleSequentialChain

# Assume llm is already initialized from the previous example
# llm = OpenAI(temperature=0.7)

# Chain 1: Generate a company name
chain_one = LLMChain(
    llm=llm,
    prompt=PromptTemplate.from_template("Suggest a name for a company that makes {product}.")
)

# Chain 2: Generate a slogan based on the company name
# The output of chain_one will be passed as {input} to this prompt
chain_two = LLMChain(
    llm=llm,
    prompt=PromptTemplate.from_template("Write a catchy slogan for {input}.")
)

# Create the SimpleSequentialChain
simple_chain = SimpleSequentialChain(chains=[chain_one, chain_two])

# Run the chain with the initial input
product = "eco-friendly water bottles"
output = simple_chain.run(product)

print(f"Company and Slogan for {product}:")
print(output)

Use Case

Use SimpleSequentialChain when you need to build basic pipelines where the output of one LLM call directly feeds into the next, without the need for complex data management or multiple inputs/outputs per step.

3. SequentialChain

SequentialChain is a more advanced and flexible version of SimpleSequentialChain. It allows for multiple named inputs and outputs across the chained steps, enabling more complex workflows.

Definition

SequentialChain allows you to chain multiple chains together, managing named variables. You can specify which outputs from earlier chains are used as inputs for later chains, and also define the final output variables of the entire sequence.

Key Features

• Named Variable Tracking: Explicitly tracks and manages named variables throughout the sequence.
• Flexible Input/Output Mapping: Allows specifying which variables are inputs to the overall chain and which are the final outputs.
• Complex Logic & Branching: Can handle more intricate multi-step processes with explicit data dependencies.
• Multi-Input/Output Workflows: Suitable for scenarios requiring multiple inputs or producing multiple intermediate/final outputs.

Example

from langchain.llms import OpenAI
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain, SequentialChain

# Assume llm is already initialized from the previous example
# llm = OpenAI(temperature=0.7)

# Chain 1: Generate a company name, specifying an output key
chain_one = LLMChain(
    llm=llm,
    prompt=PromptTemplate.from_template("Suggest a company name for a {product}."),
    output_key="company_name"  # Assigns a name to this chain's output
)

# Chain 2: Generate a slogan using the company name
chain_two = LLMChain(
    llm=llm,
    prompt=PromptTemplate.from_template("Create a slogan for {company_name}."),
    output_key="slogan"  # Assigns a name to this chain's output
)

# Create the SequentialChain
sequential_chain = SequentialChain(
    chains=[chain_one, chain_two],
    input_variables=["product"],  # The overall input to the sequence
    output_variables=["company_name", "slogan"],  # The desired final outputs
    verbose=True  # Set to True to see step-by-step execution
)

# Run the chain with a dictionary of inputs
product = "eco-friendly detergent"
output = sequential_chain.run({"product": product})

print(f"\nCompany and Slogan for {product}:")
print(output)

Use Case

Use SequentialChain when:

• You need more control over how variables flow between steps.
• You want to use intermediate outputs from one step as specific inputs to another.
• Your workflow requires multiple inputs or produces multiple distinct outputs.
• You need to build more complex, multi-stage LLM applications.

Comparison Table

Conclusion

LangChain's chaining system provides a scalable and modular approach to building LLM-powered applications:

• LLMChain: For simple, single-prompt interactions.
• SimpleSequentialChain: For basic, linear pipelines where the output of one step directly feeds into the next.
• SequentialChain: For flexible, multi-step logic with explicit control over named variables and complex data flows.

Relevant SEO Keywords

LLMChain, LangChain tutorial, SimpleSequentialChain, SequentialChain, LangChain multi-step chains, LangChain prompt chaining examples, Building pipelines with LangChain chains, Dynamic variable handling in LangChain, LangChain chain types explained, LangChain for multi-input multi-output workflows.

Interview Questions

• What is the primary role of LLMChain in LangChain?
• How does LLMChain handle input variables and prompts?
• When would you choose SimpleSequentialChain over LLMChain?
• What are the limitations of SimpleSequentialChain compared to SequentialChain?
• How does SequentialChain support named variables, and why is this important?
• Can you describe a use case where SequentialChain is more suitable than SimpleSequentialChain?
• How does chaining in LangChain improve workflow modularity and scalability?
• What is the difference in complexity between LLMChain, SimpleSequentialChain, and SequentialChain?
• How do output_keys function in SequentialChain?
• How does verbose=True help when running a SequentialChain?