Debugging failed chains in LangChain - Practice Problems & Coding Challenges

Challenge - 5 Problems

🔧 Debug

intermediate

Identify the error in this LangChain chain execution

Given the following LangChain code snippet, what error will it raise when executed?

LangChain

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

llm = OpenAI(temperature=0)

prompt1 = PromptTemplate.from_template("Repeat: {input}")
chain1 = LLMChain(llm=llm, prompt=prompt1)

prompt2 = PromptTemplate.from_template("Again: {text}")
chain2 = LLMChain(llm=llm, prompt=prompt2)

final_chain = SimpleSequentialChain(chains=[chain1, chain2])

output = final_chain.run("Hello")

A TypeError: __init__() got an unexpected keyword argument 'llm'

B AttributeError: 'SimpleSequentialChain' object has no attribute 'run'

C ValueError: Missing input key for chain execution

D RuntimeError: Chain execution failed due to empty chains list

💡 Hint

Check the constructor parameters for SimpleSequentialChain in LangChain.

SimpleSequentialChain does not accept a 'llm' parameter in its constructor. Passing 'llm=llm' causes a TypeError.

❓ component_behavior

intermediate

What happens when a LangChain chain input key is missing?

Consider a LangChain chain expecting an input key 'question'. What happens if you run the chain with input {'query': 'What is AI?'} instead?

A The chain runs successfully, ignoring the missing 'question' key

B The chain returns None without error

C KeyError is raised indicating 'question' key is missing

D The chain outputs an empty string as the result

💡 Hint

Chains require specific input keys to function properly.

LangChain chains expect specific input keys. Missing required keys causes a KeyError during execution.

❓ state_output

advanced

What is the output of this LangChain chain with a failing LLM call?

Given a LangChain chain that calls an LLM which raises an exception during execution, what will be the chain's output?

LangChain

from langchain.llms.base import LLM

class FailingLLM(LLM):
    def _call(self, prompt, stop=None):
        raise RuntimeError('LLM failure')

    @property
    def _identifying_params(self):
        return {}

    @property
    def _llm_type(self):
        return 'failing'

failing_llm = FailingLLM()

from langchain.chains import LLMChain
from langchain.prompts import PromptTemplate

prompt = PromptTemplate(input_variables=['text'], template='Echo: {text}')
chain = LLMChain(llm=failing_llm, prompt=prompt)

try:
    output = chain.run('test')
except Exception as e:
    output = e.args[0]

A Output is 'LLM failure'

B Output is 'Echo: test'

C Output is None

D Output is an empty dictionary {}

💡 Hint

Consider what happens when the LLM call raises an exception inside the chain.

The LLM call raises a RuntimeError with message 'LLM failure'. The try-except captures it and sets output to the error message string.

📝 Syntax

advanced

Which option correctly initializes a LangChain SequentialChain with two chains?

You want to create a SequentialChain that runs two chains in order. Which code snippet is correct?

A SequentialChain(chains=(chain1, chain2), input_vars=['input'], output_vars=['output'])

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

C SequentialChain(chain1, chain2, input_vars=['input'], output_vars=['output'])

D SequentialChain([chain1, chain2], inputs=['input'], outputs=['output'])

💡 Hint

Check the parameter names and types in SequentialChain constructor.

SequentialChain expects a 'chains' parameter as a list and 'input_variables' and 'output_variables' as lists of strings. Option B matches this.

🧠 Conceptual

expert

Why does a LangChain chain fail silently when using an incorrect input key mapping?

You have a chain expecting input key 'question' but you pass {'query': 'Hello'}. The chain runs but returns an empty string without error. Why?

A The LLM returns empty string for any input not matching 'question'

B LangChain automatically maps unknown keys to expected keys silently

C The chain uses default empty string for missing keys and does not raise errors

D The chain's prompt template uses the wrong variable name, causing empty output

💡 Hint

Consider how prompt templates use input variables and what happens if they don't match inputs.

If the prompt template references a variable name not provided in inputs, it substitutes empty string, causing empty output without error.

Practice

1. What is the primary purpose of using a try-except block when running a LangChain chain?

easy

A. To automatically fix errors in the chain

B. To speed up the chain processing

C. To log the chain output to a file

D. To catch errors and handle them gracefully during chain execution

Solution

1. Step 1: Understand error handling in LangChain

   Using try-except blocks allows the program to catch errors that occur during chain execution instead of crashing.

2. Step 2: Purpose of graceful handling

   This helps to manage errors by logging them or providing fallback behavior, improving user experience.

3. Final Answer:

   To catch errors and handle them gracefully during chain execution -> Option D

4. Quick Check:

   Error handling = catch and manage errors [OK]

Hint: Use try-except to catch chain errors and avoid crashes [OK]

Common Mistakes:

• Thinking try-except speeds up execution
• Assuming try-except fixes errors automatically
• Confusing logging with error handling

2. Which of the following is the correct way to enable verbose logging in a LangChain chain for debugging?

easy

A. chain.enable_logs()

B. chain.verbose = True

C. chain.logging = 'verbose'

D. chain.debug = True

Solution

1. Step 1: Check LangChain verbose property

   LangChain chains have a verbose attribute that can be set to True to enable detailed logging.

2. Step 2: Confirm correct syntax

   Setting chain.verbose = True is the standard way to turn on verbose mode for debugging.

3. Final Answer:

   chain.verbose = True -> Option B

4. Quick Check:

   Verbose mode = chain.verbose = True [OK]

Hint: Set chain.verbose = True to get detailed logs [OK]

Common Mistakes:

• Using chain.debug instead of chain.verbose
• Trying to call a non-existent enable_logs() method
• Assigning string values instead of boolean

3. Given this code snippet, what will be the output if the chain fails at the second step?

try {
  const result = await chain.call({ input: 'Hello' });
  console.log('Success:', result);
} catch (error) {
  console.log('Error:', error.message);
}

medium

A. Error: [error message]

B. Success: [result object]

C. No output, code crashes

D. Success: undefined

Solution

1. Step 1: Understand try-catch behavior on failure

   If the chain fails at any step, the await chain.call() throws an error caught by the catch block.

2. Step 2: Output from catch block

   The catch block logs the error message with prefix 'Error:', so the output will be the error message string.

3. Final Answer:

   Error: [error message] -> Option A

4. Quick Check:

   Chain failure triggers catch block output [OK]

Hint: Errors trigger catch block, printing error message [OK]

Common Mistakes:

• Assuming success message prints on failure
• Expecting no output when error occurs
• Confusing error object with result object

4. You have a LangChain chain that silently fails without any error message. Which debugging step is most effective to find the problem?

medium

A. Enable verbose mode and check intermediate outputs

B. Remove all try-except blocks to see raw errors

C. Restart the computer and rerun the chain

D. Ignore the failure and continue

Solution

1. Step 1: Enable verbose mode for detailed logs

   Verbose mode shows step-by-step outputs and internal states, helping identify where the chain fails silently.

2. Step 2: Check intermediate outputs and error messages

   Reviewing these outputs reveals hidden errors or unexpected data causing failure.

3. Final Answer:

   Enable verbose mode and check intermediate outputs -> Option A

4. Quick Check:

   Verbose + outputs = find silent failures [OK]

Hint: Turn on verbose and watch outputs to spot silent errors [OK]

Common Mistakes:

• Removing try-except can hide errors in async code
• Restarting computer rarely fixes code logic errors
• Ignoring failure prevents problem solving

5. You have a chain with multiple steps, but it fails only when input is empty. How can you modify the chain to handle empty inputs without failing?

hard

A. Remove all error handling to see the raw failure

B. Set chain.verbose = False to hide errors

C. Add a pre-processing step to check for empty input and provide a default value

D. Ignore empty inputs and run chain as usual

Solution

1. Step 1: Identify input validation need

   Empty inputs cause failure, so adding a check before running the chain prevents errors.

2. Step 2: Implement pre-processing with default value

   By providing a default or skipping processing for empty input, the chain runs safely without crashing.

3. Final Answer:

   Add a pre-processing step to check for empty input and provide a default value -> Option C

4. Quick Check:

   Pre-check input prevents empty input failures [OK]

Hint: Check inputs first; supply defaults to avoid chain errors [OK]

Common Mistakes:

• Disabling verbose hides useful debug info
• Ignoring empty inputs causes silent failures
• Removing error handling loses control over failures