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.

Practice

1. What is the main purpose of using error handling in Langchain chains?

easy

A. To keep the program stable when something goes wrong during chain execution

B. To speed up the chain processing time

C. To automatically fix errors without user input

D. To make the chain run without any input data

Solution

1. Step 1: Understand error handling purpose

   Error handling is used to manage unexpected problems during program execution to avoid crashes.

2. Step 2: Apply to Langchain chains

   In Langchain, error handling around chain.run() helps keep the program stable if the chain fails.

3. Final Answer:

   To keep the program stable when something goes wrong during chain execution -> Option A

4. Quick Check:

   Error handling = stability [OK]

Hint: Error handling prevents crashes during chain execution [OK]

Common Mistakes:

• Thinking error handling speeds up chains
• Believing errors fix themselves automatically
• Assuming chains run without input

2. Which of the following is the correct way to catch errors when running a Langchain chain?

easy

A. try:
chain.run(input)
except Exception as e:
print(e)

B. chain.run(input).catch(error => console.log(error))

C. if chain.run(input) == error:
print('Error')

D. chain.run(input).onError(error => console.log(error))

Solution

1. Step 1: Identify Python error handling syntax

   Python uses try-except blocks to catch errors during execution.

2. Step 2: Match with Langchain usage

   Langchain chains are run with chain.run(), so wrapping it in try-except is correct.

3. Final Answer:

   try: chain.run(input) except Exception as e: print(e) -> Option A

4. Quick Check:

   Python error handling = try-except [OK]

Hint: Use try-except blocks in Python to catch errors [OK]

Common Mistakes:

• Using JavaScript error handling syntax in Python
• Checking error with if statement incorrectly
• Using non-existent chain methods for error handling

3. Given this code snippet, what will be printed if chain.run() raises a ValueError?

try:
    result = chain.run('input data')
    print('Success:', result)
except ValueError as e:
    print('Value error caught:', e)
except Exception as e:
    print('Other error:', e)

medium

A. Success: [result value]

B. No output, program crashes

C. Other error: [error message]

D. Value error caught: [error message]

Solution

1. Step 1: Identify error type raised

   The code says chain.run() raises a ValueError.

2. Step 2: Match error with except blocks

   The first except block catches ValueError, so it will run and print the message.

3. Final Answer:

   Value error caught: [error message] -> Option D

4. Quick Check:

   ValueError caught by matching except block [OK]

Hint: Specific except blocks catch matching errors first [OK]

Common Mistakes:

• Assuming success message prints despite error
• Thinking generic Exception block runs before specific
• Believing program crashes without output

4. What is wrong with this error handling code for a Langchain chain?

try:
    chain.run('data')
except:
    print('Error occurred')
except ValueError:
    print('Value error')

medium

A. The try block is missing an else clause

B. The except blocks are missing the error variable

C. The generic except block comes before the specific except block

D. The chain.run() call is outside the try block

Solution

1. Step 1: Review except block order rules

   In Python, specific exceptions must come before generic except blocks.

2. Step 2: Analyze given code order

   The generic except block is first, so the specific ValueError block is unreachable.

3. Final Answer:

   The generic except block comes before the specific except block -> Option C

4. Quick Check:

   Specific except before generic [OK]

Hint: Place specific except blocks before generic ones [OK]

Common Mistakes:

• Putting generic except before specific
• Ignoring except block order causing unreachable code
• Thinking error variable is always required

5. You want to run a Langchain chain and handle errors differently based on error type. Which code correctly implements this behavior?

try:
    output = chain.run(user_input)
except TimeoutError:
    print('Chain timed out, please retry later.')
except ValueError as ve:
    print(f'Invalid input: {ve}')
except Exception as e:
    print(f'Unexpected error: {e}')

hard

A. This code will not catch TimeoutError because it is not a built-in exception

B. This code correctly handles different errors with specific messages

C. The except blocks should be combined into one to catch all errors

D. The try block should include a finally clause to handle errors

Solution

1. Step 1: Check error handling for multiple error types

   The code uses multiple except blocks to handle different error types separately.

2. Step 2: Verify correctness of error handling

   TimeoutError and ValueError are handled specifically, and a generic Exception block catches others.

3. Final Answer:

   This code correctly handles different errors with specific messages -> Option B

4. Quick Check:

   Multiple except blocks handle errors separately [OK]

Hint: Use multiple except blocks for specific error handling [OK]

Common Mistakes:

• Thinking TimeoutError is not catchable
• Combining all errors in one except loses specificity
• Confusing finally with except for error handling