Parallel execution with RunnableParallel in LangChain - Step-by-Step Execution

Concept Flow - Parallel execution with RunnableParallel

Start RunnableParallel

↓

Receive multiple runnables

↓

Start all runnables at once

↓

Each runnable runs independently

↓

Wait for all runnables to finish

↓

Collect all outputs

↓

Return combined results

↓

End

RunnableParallel runs multiple tasks at the same time, waits for all to finish, then returns all results together.

Execution Sample

LangChain

from langchain.schema.runnables import RunnableParallel, RunnableLambda

r1 = RunnableLambda(lambda x: x + 1)
r2 = RunnableLambda(lambda x: x * 2)
parallel = RunnableParallel(r1=r1, r2=r2)
result = parallel.invoke(3)

This code runs two simple functions in parallel on input 3 and collects their results.

Execution Table

Step	Action	Runnable	Input	Output	Notes
1	Start RunnableParallel with two runnables	r1, r2	3		Prepare to run both functions in parallel
2	Invoke r1	r1	3	4	r1 adds 1 to input
3	Invoke r2	r2	3	6	r2 multiplies input by 2
4	Wait for both runnables to finish	r1, r2			Parallel execution completes
5	Collect outputs	r1, r2		{'r1': 4, 'r2': 6}	Results combined in dict
6	Return combined results	RunnableParallel	3	{'r1': 4, 'r2': 6}	Final output returned
7	Exit				All runnables completed and results returned

💡 All runnables finished, combined results returned as dict

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 5	Final
input_value	3	3	3	3	3
r1_output	None	4	4	4	4
r2_output	None	None	6	6	6
combined_result	None	None	None	{'r1': 4, 'r2': 6}	{'r1': 4, 'r2': 6}

Key Moments - 3 Insights

Why do both runnables receive the same input value?

RunnableParallel sends the same input to each runnable independently, as shown in steps 2 and 3 where both get input 3.

How does RunnableParallel know when all runnables have finished?

It waits for all runnables to complete their invoke calls before moving to step 4, ensuring all outputs are ready.

Why are the outputs combined into a dict?

RunnableParallel collects each runnable's output in order and returns them as a dict, as seen in step 5.

Visual Quiz - 3 Questions

Look at the execution table, what is the output of runnable r1 at step 2?

A 6

B 4

C 3

D None

💡 Hint

Check the 'Output' column in row for step 2 in execution_table

At which step does RunnableParallel collect all outputs?

A Step 3

B Step 4

C Step 5

D Step 6

💡 Hint

Look for the row mentioning 'Collect outputs' in execution_table

If the input changed to 5, what would be the output of r2 at step 3?

A 10

B 5

C 6

D 11

💡 Hint

r2 multiplies input by 2, see step 3 output calculation

Concept Snapshot

RunnableParallel runs multiple tasks at the same time.
Each runnable gets the same input independently.
All runnables run in parallel.
RunnableParallel waits for all to finish.
It returns a dict of all outputs in order.

Full Transcript

RunnableParallel is a tool in langchain that lets you run several tasks at once. You give it several runnables, and it sends the same input to each one. All runnables start running at the same time. RunnableParallel waits until every runnable finishes its work. Then it collects all their outputs into a dict and returns it. For example, if you have two runnables, one adding 1 and one multiplying by 2, and you input 3, r1 outputs 4 and r2 outputs 6. RunnableParallel returns {'r1': 4, 'r2': 6}. This helps you do many things at once and get all results together.

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