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.