Parallel execution with RunnableParallel in LangChain - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to create a RunnableParallel instance with two runnables.

LangChain

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

runnable1 = Runnable()
runnable2 = Runnable()
parallel = RunnableParallel([1])

Drag options to blanks, or click blank then click option'

Arunnable1, runnable2

Brunnable1=runnable1, runnable2=runnable2

C(runnable1, runnable2)

D{runnable1, runnable2}

Attempts:

3 left

💡 Hint

Common Mistakes

Using square brackets for list syntax.

Passing runnables separated by commas without keyword names.

The RunnableParallel constructor expects keyword arguments mapping names to runnables, so we pass runnable1=runnable1, runnable2=runnable2.

2fill in blank

medium

Complete the code to run the RunnableParallel instance with input 'data'.

LangChain

result = parallel.[1]('data')

Drag options to blanks, or click blank then click option'

Aexecute

Brun

Cinvoke

Dinvoke_async

Attempts:

3 left

💡 Hint

Common Mistakes

Using 'run' or 'execute' which are not methods of RunnableParallel.

Using 'invoke_async' which is for asynchronous calls.

The RunnableParallel class uses the invoke method to execute all runnables in parallel and collect their results.

3fill in blank

hard

Fix the error in the code to run RunnableParallel asynchronously.

LangChain

import asyncio

async def main():
    result = await parallel.[1]('input')
    print(result)

asyncio.run(main())

Drag options to blanks, or click blank then click option'

Aainvoke

Brun

Cexecute_async

Dasync_run

Attempts:

3 left

💡 Hint

Common Mistakes

Using synchronous methods with await causing errors.

Using method names that do not exist in RunnableParallel.

To run RunnableParallel asynchronously, use the ainvoke method with await.

4fill in blank

hard

Fill both blanks to create a RunnableParallel that runs two different runnables and run it synchronously.

LangChain

r1 = Runnable()
r2 = Runnable()
parallel = RunnableParallel([1]=r1, [2]=r2)
output = parallel.[3]('test input')

Drag options to blanks, or click blank then click option'

Ar1

Br2

Cinvoke

Dexecute

Attempts:

3 left

💡 Hint

Common Mistakes

Passing runnables without kwarg syntax or with wrong syntax.

Using 'execute' which is not a RunnableParallel method.

We pass the two runnable instances r1 and r2 as keyword arguments to RunnableParallel, then call invoke to execute synchronously.

5fill in blank

hard

Fill all three blanks to create a RunnableParallel, run it asynchronously, and print the result.

LangChain

import asyncio

r1 = Runnable()
r2 = Runnable()
parallel = RunnableParallel([1]=r1, [2]=r2)

async def main():
    result = await parallel.[3]('async input')
    print(result)

asyncio.run(main())

Drag options to blanks, or click blank then click option'

Ar1

Br2

Cainvoke

Drun

Attempts:

3 left

💡 Hint

Common Mistakes

Using synchronous invoke method with await causing errors.

Passing runnables without kwarg syntax.

We create RunnableParallel with r1 and r2 as kwargs, then use ainvoke awaited inside an async function to run asynchronously.

Practice

1. What is the main purpose of using RunnableParallel in langchain?

easy

A. To run multiple tasks at the same time to save time

B. To run tasks one after another in a fixed order

C. To stop tasks from running automatically

D. To run only one task repeatedly

Solution

1. Step 1: Understand RunnableParallel's role

   RunnableParallel is designed to run tasks together, not sequentially.

2. Step 2: Identify the benefit

   Running tasks in parallel saves time by doing them simultaneously.

3. Final Answer:

   To run multiple tasks at the same time to save time -> Option A

4. Quick Check:

   Parallel execution = run tasks together [OK]

Hint: RunnableParallel means tasks run together, not one by one [OK]

Common Mistakes:

• Thinking RunnableParallel runs tasks one after another
• Confusing parallel with repeated single task
• Assuming it stops tasks automatically

2. Which of the following is the correct way to create a RunnableParallel with two tasks named task1 and task2?

easy

A. RunnableParallel{task1, task2}

B. RunnableParallel(task1, task2)

C. RunnableParallel({"task1": task1, "task2": task2})

D. RunnableParallel(task1 + task2)

Solution

1. Step 1: Recall RunnableParallel syntax

   RunnableParallel expects a dictionary {"name": task} as its argument.

2. Step 2: Match options to syntax

   Only RunnableParallel({"task1": task1, "task2": task2}) passes a dict {"task1": task1, "task2": task2}, others use wrong syntax.

3. Final Answer:

   RunnableParallel({"task1": task1, "task2": task2}) -> Option C

4. Quick Check:

   Dict of tasks = {"task1": task1, "task2": task2} [OK]

Hint: Use curly braces {} to pass {"name": task} dictionary [OK]

Common Mistakes:

• Passing tasks as separate positional arguments
• Using invalid set syntax {}
• Trying to add tasks with + operator

3. Given the code:

parallel = RunnableParallel({"taskA": taskA, "taskB": taskB})
results = parallel.invoke()
print(results)

If taskA returns 'Hello' and taskB returns 'World', what will be printed?

medium

A. {'taskB': 'World', 'taskA': 'Hello'}

B. ['HelloWorld']

C. 'Hello World'

D. {'taskA': 'Hello', 'taskB': 'World'}

Solution

1. Step 1: Understand RunnableParallel output order

   RunnableParallel returns a dict with results in the order keys are defined.

2. Step 2: Match task results to output dict

   taskA under 'taskA' returns 'Hello' first, taskB under 'taskB' returns 'World' second, so {'taskA': 'Hello', 'taskB': 'World'}.

3. Final Answer:

   {'taskA': 'Hello', 'taskB': 'World'} -> Option D

4. Quick Check:

   Order of results matches dict definition order [OK]

Hint: Results dict order matches task definition order [OK]

Common Mistakes:

• Reversing the order of task results
• Thinking results are combined into one string
• Expecting a list instead of dict output

4. What is wrong with this code snippet?

parallel = RunnableParallel(task1, task2)
results = parallel.invoke()

medium

A. RunnableParallel requires tasks inside a dictionary, not separate arguments

B. invoke() method does not exist on RunnableParallel

C. You must call run() instead of invoke()

D. RunnableParallel cannot run more than one task

Solution

1. Step 1: Check RunnableParallel constructor usage

   RunnableParallel expects a dictionary of tasks, not separate positional arguments.

2. Step 2: Identify the error in code

   Passing task1, task2 as separate positional arguments causes a TypeError.

3. Final Answer:

   RunnableParallel requires tasks inside a dictionary, not separate arguments -> Option A

4. Quick Check:

   Tasks must be in a dictionary [OK]

Hint: Always use a dictionary or named kwargs for RunnableParallel tasks [OK]

Common Mistakes:

• Passing tasks as separate positional arguments
• Using wrong method name instead of invoke()
• Thinking RunnableParallel runs only one task

5. You want to run three independent tasks taskX, taskY, and taskZ in parallel and combine their results into a single string separated by commas. Which code correctly does this?

hard

A. parallel = RunnableParallel(taskX, taskY, taskZ)
results = parallel.invoke()
combined = ','.join(results)
print(combined)

B. parallel = RunnableParallel({"taskX": taskX, "taskY": taskY, "taskZ": taskZ})
results = parallel.invoke()
combined = ','.join(results.values())
print(combined)

C. results = [taskX(), taskY(), taskZ()]
combined = ','.join(results)
print(combined)

D. parallel = RunnableParallel([taskX, taskY, taskZ])
combined = parallel.invoke().join(',')
print(combined)

Solution

1. Step 1: Create RunnableParallel with dictionary of tasks

   parallel = RunnableParallel({"taskX": taskX, "taskY": taskY, "taskZ": taskZ}) results = parallel.invoke() combined = ','.join(results.values()) print(combined) correctly passes tasks as a dictionary to RunnableParallel.

2. Step 2: Invoke and join results properly

   This calls invoke() to get dict results, then joins the values with commas correctly.

3. Step 3: Check other options for errors

   parallel = RunnableParallel(taskX, taskY, taskZ) results = parallel.invoke() combined = ','.join(results) print(combined) passes tasks incorrectly as positional; C runs tasks sequentially; D uses invalid list and misuses join.

4. Final Answer:

   Using RunnableParallel({"taskX": taskX, "taskY": taskY, "taskZ": taskZ}) and ','.join(results.values()) -> Option B

5. Quick Check:

   Dict tasks + invoke + join values = correct [OK]

Hint: Pass tasks as dict, invoke, then ','.join(results.values()) [OK]

Common Mistakes:

• Passing tasks without dictionary syntax
• Calling join() on the wrong object
• Running tasks sequentially instead of parallel