Parallel execution with RunnableParallel in LangChain - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What is the output of this RunnableParallel execution?

Consider two simple runnables that return strings. They are run in parallel using RunnableParallel. What will be the combined output?

LangChain

from langchain.schema.runnable import Runnable
from langchain.schema.runnable.parallel import RunnableParallel

class RunnableA(Runnable):
    def invoke(self, input):
        return f"A received {input}"

class RunnableB(Runnable):
    def invoke(self, input):
        return f"B received {input}"

parallel = RunnableParallel(A=RunnableA(), B=RunnableB())
result = parallel.invoke("test")
print(result)

A ['A received test', 'B received test']

B ('A received test', 'B received test')

C {'A': 'A received test', 'B': 'B received test'}

D ['test', 'test']

💡 Hint

RunnableParallel returns a dict of results keyed by the branch names.

RunnableParallel runs each named runnable in parallel and collects their outputs in a dict with branch names as keys. Each runnable returns a string with the input included, so the result is a dict of those strings.

❓ state_output

intermediate

What is the output type of RunnableParallel.invoke()?

When you run RunnableParallel.invoke() with multiple runnables, what type of data structure do you get back?

LangChain

from langchain.schema.runnable.parallel import RunnableParallel

parallel = RunnableParallel(a=runnable1, b=runnable2)
result = parallel.invoke("input")
print(type(result))

A <class 'tuple'>

B <class 'str'>

C <class 'list'>

D <class 'dict'>

💡 Hint

Think about how multiple results are collected from parallel runnables.

RunnableParallel.invoke() returns a dict containing the results from each runnable keyed by branch names.

📝 Syntax

advanced

Which option correctly creates a RunnableParallel with three runnables?

You want to run three runnables in parallel. Which code snippet correctly creates a RunnableParallel instance with them?

A RunnableParallel(r1=r1, r2=r2, r3=r3)

B RunnableParallel(r1, r2, r3)

C RunnableParallel({r1, r2, r3})

D RunnableParallel(runnables=[r1, r2, r3])

💡 Hint

Check the constructor signature for RunnableParallel.

RunnableParallel expects runnables passed as keyword arguments with names, e.g. RunnableParallel(r1=r1, r2=r2, r3=r3). Passing as positional arguments, sets, or unknown kwargs is invalid.

🔧 Debug

advanced

Why does this RunnableParallel code raise a TypeError?

Given the code below, why does it raise a TypeError when invoking?

LangChain

from langchain.schema.runnable import Runnable
from langchain.schema.runnable.parallel import RunnableParallel

class RunnableX(Runnable):
    def invoke(self, input):
        return input * 2

parallel = RunnableParallel(x=RunnableX(), bad="not a runnable")
result = parallel.invoke(5)

A Because one branch is not a Runnable instance

B Because input 5 is not a string

C Because RunnableX.invoke returns an int, not a string

D Because RunnableParallel requires exactly one runnable

💡 Hint

Check the types of elements passed to RunnableParallel.

RunnableParallel expects all branches to be Runnable instances. Passing a string causes a TypeError when trying to call invoke on it.

🧠 Conceptual

expert

How does RunnableParallel handle exceptions from individual runnables?

If one runnable in a RunnableParallel raises an exception during invoke, what happens to the overall RunnableParallel invocation?

A RunnableParallel retries the failing runnable until it succeeds

B The exception is propagated immediately and the entire RunnableParallel invocation fails

C The exception is caught and replaced with None in the results list

D RunnableParallel skips the failing runnable and returns results from others

💡 Hint

Think about error handling in parallel execution.

RunnableParallel does not catch exceptions internally. If any runnable raises an exception, it propagates and causes the entire invocation to fail.