Error handling in chains in LangChain - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What happens when a chain step raises an exception?

Consider a LangChain chain with multiple steps. If one step raises an exception and no error handling is set, what is the behavior of the chain execution?

LangChain

from langchain.chains import SimpleSequentialChain
from langchain.llms import OpenAI

llm = OpenAI(temperature=0)

chain1 = SimpleSequentialChain(
    chains=[
        # First step: returns 'Hello'
        lambda x: 'Hello',
        # Second step: raises an exception
        lambda x: 1 / 0,
        # Third step: returns 'World'
        lambda x: 'World'
    ],
    verbose=True
)

result = chain1.run('start')

A The chain catches the error internally and returns None.

B The chain ignores the error and continues to the next step, returning 'World'.

C The chain stops immediately and raises a ZeroDivisionError exception.

D The chain retries the failing step until it succeeds.

💡 Hint

Think about what happens when Python code raises an exception without try-except blocks.

Without explicit error handling, any exception raised in a chain step will stop the chain execution and propagate the error up. LangChain does not automatically catch or retry errors.

📝 Syntax

intermediate

Which code correctly adds error handling to a LangChain chain step?

You want to catch exceptions in a LangChain chain step and return a default value instead. Which code snippet correctly implements this?

LangChain

from langchain.chains import SimpleSequentialChain

class SafeStep:
    def __init__(self, func):
        self.func = func
    def __call__(self, x):
        try:
            return self.func(x)
        except Exception:
            return 'default'

chain = SimpleSequentialChain(
    chains=[
        SafeStep(lambda x: x + ' processed'),
        SafeStep(lambda x: 1 / 0),  # will raise
        SafeStep(lambda x: x + ' done')
    ],
    verbose=True
)

result = chain.run('input')

A Add a 'catch_errors=True' parameter to SimpleSequentialChain constructor.

B Wrap each step function in a try-except block inside a callable class, returning a default on error.

C Override the run method of SimpleSequentialChain to ignore exceptions.

D Use a global try-except around chain.run() to catch errors from any step.

💡 Hint

Focus on handling errors inside each step function.

Wrapping each step in a callable class with try-except allows catching errors locally and returning a fallback value. The other options are either not supported or less precise.

❓ state_output

advanced

What is the output of a chain with error handling that returns fallback values?

Given the following chain with error handling wrappers, what is the final output after running with input 'start'?

LangChain

from langchain.chains import SimpleSequentialChain

class SafeStep:
    def __init__(self, func):
        self.func = func
    def __call__(self, x):
        try:
            return self.func(x)
        except Exception:
            return 'error handled'

chain = SimpleSequentialChain(
    chains=[
        SafeStep(lambda x: x + ' step1'),
        SafeStep(lambda x: 1 / 0),  # error triggers fallback
        SafeStep(lambda x: x + ' step3')
    ],
    verbose=False
)

result = chain.run('start')

A "start step1 error handled step3"

B Raises ZeroDivisionError

C "start step1"

D "error handled step3"

💡 Hint

Remember how SimpleSequentialChain passes output from one step to the next.

The first step returns 'start step1'. The second step raises an exception and returns 'error handled'. The third step receives 'error handled' as input and returns 'error handled step3'. SimpleSequentialChain returns the output of the last step.

🔧 Debug

advanced

Why does this LangChain chain silently fail to catch errors?

This code tries to catch errors in a chain step but still crashes. What is the bug?

LangChain

from langchain.chains import SimpleSequentialChain

class SafeStep:
    def __init__(self, func):
        self.func = func
    def __call__(self, x):
        try:
            return self.func(x)
        except Exception:
            pass  # silently ignore error

chain = SimpleSequentialChain(
    chains=[
        SafeStep(lambda x: x + ' ok'),
        SafeStep(lambda x: 1 / 0),  # error
        SafeStep(lambda x: x + ' done')
    ],
    verbose=True
)

result = chain.run('input')

A The SafeStep returns None on error, causing the next step to fail with TypeError.

B The try-except block is missing, so error is not caught.

C The chain does not support callable classes as steps.

D The error is caught but the chain run method ignores the return values.

💡 Hint

What happens if a step returns None but the next step expects a string?

The SafeStep catches the error but returns None implicitly (no return in except). The next step receives None and tries to concatenate, causing TypeError.

🧠 Conceptual

expert

How to implement retry logic for failing chain steps in LangChain?

You want to retry a chain step up to 3 times if it raises an exception before failing. Which approach correctly implements this behavior?

A Wrap the step function in a callable class that retries the function call up to 3 times catching exceptions.

B Set a 'max_retries=3' parameter in SimpleSequentialChain constructor.

C Use a global try-except around chain.run() and call chain.run() again on failure.

D Override the chain's run method to loop 3 times and ignore exceptions.

💡 Hint

LangChain does not have built-in retry parameters for chains.

The correct way is to wrap the step function with retry logic inside a callable class. The other options either do not exist or cause uncontrolled retries or ignore errors.