Sequential chains in LangChain - Mini Project: Build & Apply

Building a Sequential Chain with LangChain

📖 Scenario: You are creating a simple text processing pipeline using LangChain. This pipeline will take a user's input, process it through two steps sequentially, and produce a final output.

🎯 Goal: Build a sequential chain in LangChain that first converts input text to uppercase, then appends a friendly message.

📋 What You'll Learn

Create two simple functions that process text

Create a SequentialChain using LangChain

Connect the functions in the chain in the correct order

Run the chain with a sample input

💡 Why This Matters

🌍 Real World

Sequential chains help automate multi-step text processing tasks, like formatting user input before sending it to a chatbot or API.

💼 Career

Understanding how to build and run sequential chains is useful for developers working with AI pipelines, chatbots, and automation workflows.

1

Create two text processing functions

Write two Python functions: to_uppercase that takes a string text and returns it in uppercase, and add_greeting that takes a string text and returns it with the string ' Have a nice day!' appended.

LangChain

# Your code here

Hint

Define two functions exactly named to_uppercase and add_greeting with one parameter text.

2

Import LangChain and prepare chain components

Import SequentialChain from langchain.chains. Then create two SimpleChain objects named chain1 and chain2 that wrap the functions to_uppercase and add_greeting respectively.

LangChain

def to_uppercase(text: str) -> str:
    return text.upper()

def add_greeting(text: str) -> str:
    return text + ' Have a nice day!'

# Your code here

Hint

Import SequentialChain and SimpleChain. Wrap each function in a SimpleChain with correct input and output keys.

3

Create the SequentialChain

Create a SequentialChain named seq_chain that runs chain1 followed by chain2. Set input_variables to ["text"] and output_variables to ["final_text"].

LangChain

from langchain.chains import SequentialChain, SimpleChain

def to_uppercase(text: str) -> str:
    return text.upper()

def add_greeting(text: str) -> str:
    return text + ' Have a nice day!'

chain1 = SimpleChain(func=to_uppercase, input_key="text", output_key="upper_text")
chain2 = SimpleChain(func=add_greeting, input_key="upper_text", output_key="final_text")

# Your code here

Hint

Create seq_chain with the two chains in order and specify input and output variables.

4

Run the SequentialChain with sample input

Call seq_chain.run with the argument text="hello world" and assign the result to a variable named result.

LangChain

from langchain.chains import SequentialChain, SimpleChain

def to_uppercase(text: str) -> str:
    return text.upper()

def add_greeting(text: str) -> str:
    return text + ' Have a nice day!'

chain1 = SimpleChain(func=to_uppercase, input_key="text", output_key="upper_text")
chain2 = SimpleChain(func=add_greeting, input_key="upper_text", output_key="final_text")

seq_chain = SequentialChain(
    chains=[chain1, chain2],
    input_variables=["text"],
    output_variables=["final_text"]
)

# Your code here

Hint

Run the chain with text="hello world" and save the output in result.

Practice

1. What is the main purpose of a SequentialChain in Langchain?

easy

A. To create a single chain that never passes outputs

B. To run multiple chains all at the same time independently

C. To run multiple chains one after another, passing outputs as inputs

D. To stop chains from running automatically

Solution

1. Step 1: Understand SequentialChain behavior

   A SequentialChain runs chains in order, passing output from one to the next.

2. Step 2: Compare options to this behavior

   Only To run multiple chains one after another, passing outputs as inputs describes this step-by-step passing of outputs between chains.

3. Final Answer:

   To run multiple chains one after another, passing outputs as inputs -> Option C

4. Quick Check:

   SequentialChain = run chains sequentially with output passing [OK]

Hint: Sequential means one after another with output passing [OK]

Common Mistakes:

• Thinking chains run in parallel
• Believing outputs are not passed
• Confusing SequentialChain with single chain

2. Which of the following is the correct way to create a SequentialChain with two chains named chain1 and chain2?

easy

A. SequentialChain([chain1, chain2])

B. SequentialChain(chains=[chain1, chain2], input_variables=["input"], output_variables=["output"])

C. SequentialChain(chain1, chain2)

D. SequentialChain(chains=chain1 + chain2)

Solution

1. Step 1: Recall SequentialChain constructor

   It requires a list of chains and lists of input and output variable names.

2. Step 2: Check each option's syntax

   Only SequentialChain(chains=[chain1, chain2], input_variables=["input"], output_variables=["output"]) correctly uses named parameters with lists for chains and variables.

3. Final Answer:

   SequentialChain(chains=[chain1, chain2], input_variables=["input"], output_variables=["output"]) -> Option B

4. Quick Check:

   Correct constructor syntax = SequentialChain(chains=[chain1, chain2], input_variables=["input"], output_variables=["output"]) [OK]

Hint: Look for named parameters and list brackets [OK]

Common Mistakes:

• Passing chains without list brackets
• Missing input/output variable lists
• Using plus operator to combine chains

3. Given the following code snippet, what will be the final output printed?

from langchain.chains import SequentialChain

chain1 = SomeChain()  # outputs {'intermediate': 'hello'}
chain2 = SomeChain()  # expects input 'intermediate' and outputs {'final': 'hello world'}

seq_chain = SequentialChain(chains=[chain1, chain2], input_variables=['input'], output_variables=['final'])

result = seq_chain.run({'input': 'start'})
print(result)

medium

A. Error: missing input for chain2

B. 'hello world'

C. 'start'

D. {'final': 'hello world'}

Solution

1. Step 1: Understand chain outputs and inputs

   chain1 outputs {'intermediate': 'hello'}, chain2 uses 'intermediate' input and outputs {'final': 'hello world'}.

2. Step 2: SequentialChain runs chain1 then chain2, passing outputs

   Final result is {'final': 'hello world'}, printed as "{'final': 'hello world'}".

3. Final Answer:

   {'final': 'hello world'} -> Option D

4. Quick Check:

   Output of SequentialChain = {'final': 'hello world'} [OK]

Hint: Final output is dict of output_variables [OK]

Common Mistakes:

• Expecting string instead of dict repr
• Confusing input and output keys
• Assuming error due to input passing

4. What is the error in this code snippet that tries to create a SequentialChain?

seq_chain = SequentialChain(chains=[chain1, chain2], input_variables=['input'])
result = seq_chain.run({'input': 'data'})

medium

A. Missing output_variables parameter causes an error

B. Chains list should be a tuple, not a list

C. Input dictionary keys do not match input_variables

D. run() method requires no arguments

Solution

1. Step 1: Check required parameters for SequentialChain

   Both input_variables and output_variables are required parameters.

2. Step 2: Identify missing parameter

   The code misses output_variables, so it will raise an error.

3. Final Answer:

   Missing output_variables parameter causes an error -> Option A

4. Quick Check:

   output_variables missing = error [OK]

Hint: Always provide input and output variable lists [OK]

Common Mistakes:

• Forgetting output_variables
• Using wrong data type for chains
• Passing arguments incorrectly to run()

5. You want to build a SequentialChain that first extracts keywords from text, then summarizes those keywords. Which approach correctly sets up this workflow?

hard

A. Create two chains: keyword_extractor outputs 'keywords'; summary_chain takes 'keywords' as input; combine with SequentialChain passing these variables

B. Create one chain that does both extraction and summary in one step

C. Run keyword_extractor and summary_chain separately without chaining outputs

D. Use SequentialChain but ignore passing variables between chains

Solution

1. Step 1: Identify the workflow steps

   First extract keywords, then summarize them, so output of first is input of second.

2. Step 2: Use SequentialChain with proper variable passing

   Set keyword_extractor to output 'keywords', summary_chain to input 'keywords', then chain them sequentially.

3. Final Answer:

   Create two chains: keyword_extractor outputs 'keywords'; summary_chain takes 'keywords' as input; combine with SequentialChain passing these variables -> Option A

4. Quick Check:

   SequentialChain passes outputs as inputs [OK]

Hint: Chain outputs must match next chain inputs [OK]

Common Mistakes:

• Trying to do both steps in one chain
• Not passing outputs to next chain
• Ignoring variable names in chaining