Sequential chains in LangChain - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this SequentialChain?

Consider this LangChain SequentialChain code that processes an input through two steps. What will be the final output printed?

LangChain

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

llm = OpenAI(temperature=0)

chain = SequentialChain(
    chains=[
        LLMChain(llm=llm, prompt=PromptTemplate(template="Translate to French: {text}", input_variables=["text"])),
        LLMChain(llm=llm, prompt=PromptTemplate(template="Translate to English: {text}", input_variables=["text"]))
    ],
    input_variables=["text"],
    output_variables=["final_text"],
    verbose=False
)

result = chain.run({"text": "Hello"})
print(result)

A "Hello"

B An error because output variable names mismatch

C "Hello" (the original input)

D "Bonjour"

💡 Hint

Check how output variables are named and passed between chains in SequentialChain.

The SequentialChain expects the output variable of the first chain to be the input variable of the second chain. Here, the output variable names are not aligned, causing a KeyError or mismatch error.

❓ state_output

intermediate

What is the final output of this SequentialChain with memory?

Given this SequentialChain with a memory buffer, what will be the final output stored in memory after running the chain?

LangChain

from langchain.chains import SequentialChain
from langchain.llms import OpenAI
from langchain.memory import ConversationBufferMemory
from langchain.prompts import PromptTemplate
from langchain.chains import LLMChain

llm = OpenAI(temperature=0)
memory = ConversationBufferMemory(memory_key="chat_history")

chain1 = LLMChain(llm=llm, prompt=PromptTemplate(template="Say hello to {name}", input_variables=["name"]))
chain2 = LLMChain(llm=llm, prompt=PromptTemplate(template="Say goodbye to {name}", input_variables=["name"]))

seq_chain = SequentialChain(
    chains=[chain1, chain2],
    input_variables=["name"],
    memory=memory,
    verbose=False
)

seq_chain.run({"name": "Alice"})
final_memory = memory.load_memory_variables({})
print(final_memory["chat_history"])

A Hello Alice\nGoodbye Alice

B Say hello to Alice\nSay goodbye to Alice

C Hello Alice

D Empty string because memory is not updated

💡 Hint

ConversationBufferMemory only saves if inputs contain 'input' (or input_key) and outputs contain 'output'.

The SequentialChain runs successfully, but after execution, memory.save_context is called with inputs={'name': 'Alice'} (lacks 'input' key) and outputs={'output': final result}. ConversationBufferMemory skips saving due to missing keys, leaving chat_history empty.

📝 Syntax

advanced

Which option correctly creates a SequentialChain with two LLMChains?

Select the code snippet that correctly initializes a SequentialChain with two LLMChains that use different prompts and share input/output variables properly.

A chain = SequentialChain(chains=[LLMChain(llm=llm, prompt=PromptTemplate(template="Q: {q}", input_variables=["q"])), LLMChain(llm=llm, prompt=PromptTemplate(template="Q: {answer}", input_variables=["answer"]))], input_variables=["q"], output_variables=["final_answer"])

B chain = SequentialChain(chains=[LLMChain(llm=llm, prompt=PromptTemplate(template="Q: {q1}", input_variables=["q1"])), LLMChain(llm=llm, prompt=PromptTemplate(template="Q: {q2}", input_variables=["q2"]))], input_variables=["q1"], output_variables=["answer"])

C chain = SequentialChain(chains=[LLMChain(llm=llm, prompt=PromptTemplate(template="Q: {q}", input_variables=["q"])), LLMChain(llm=llm, prompt=PromptTemplate(template="Q: {q2}", input_variables=["q2"]))], input_variables=["q"], output_variables=["final_answer"])

D chain = SequentialChain(chains=[LLMChain(llm=llm, prompt=PromptTemplate(template="Q: {q1}", input_variables=["q1"])), LLMChain(llm=llm, prompt=PromptTemplate(template="Q: {q1}", input_variables=["q1"]))], input_variables=["q1"], output_variables=["final_answer"])

💡 Hint

Check that the output variable of the first chain matches the input variable of the second chain.

Option A correctly chains the output variable 'answer' from the first chain as input to the second chain, allowing sequential processing.

🔧 Debug

advanced

Why does this SequentialChain raise a KeyError?

This SequentialChain code raises a KeyError when run. What is the cause?

LangChain

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

llm = OpenAI(temperature=0)

chain1 = LLMChain(llm=llm, prompt=PromptTemplate(template="Answer: {input_text}", input_variables=["input_text"]))
chain2 = LLMChain(llm=llm, prompt=PromptTemplate(template="Summary: {answer}", input_variables=["answer"]))

seq_chain = SequentialChain(
    chains=[chain1, chain2],
    input_variables=["input_text"],
    output_variables=["summary"],
    verbose=False
)

result = seq_chain.run({"input_text": "Explain AI"})
print(result)

A The second chain expects 'answer' input but the first chain outputs 'text', causing KeyError

B The first chain's prompt template is missing a variable, causing KeyError

C The output_variables list is empty, causing KeyError

D The SequentialChain is missing the 'memory' parameter, causing KeyError

💡 Hint

Check the variable names passed between chains and their outputs.

The first chain outputs a variable named 'text' by default, but the second chain expects 'answer' as input. This mismatch causes a KeyError when the second chain tries to access 'answer'.

🧠 Conceptual

expert

What is the main advantage of using SequentialChain in LangChain?

Select the best explanation for why developers use SequentialChain in LangChain workflows.

A It caches all LLM outputs to avoid repeated API calls.

B It automatically parallelizes multiple LLM calls to improve performance.

C It allows chaining multiple LLM calls where each step's output feeds the next, enabling complex multi-step reasoning.

D It provides a graphical interface to design LLM workflows visually.

💡 Hint

Think about how outputs from one step can be inputs to the next in a chain.

SequentialChain is designed to run multiple chains in order, passing outputs as inputs to the next, which helps build complex workflows with multiple reasoning steps.

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