Parallel execution with RunnableParallel in LangChain - Mini Project: Build & Apply

Parallel execution with RunnableParallel

📖 Scenario: You are building a simple program that runs two tasks at the same time to save time. Each task is a small function that returns a message. You will use RunnableParallel from LangChain to run these tasks together.

🎯 Goal: Create two simple functions that return messages, then use RunnableParallel to run them at the same time and get both results.

📋 What You'll Learn

Create two functions called task1 and task2 that return strings

Create a RunnableParallel instance with task1 and task2

Run the parallel tasks and store the results in a variable called results

Print the results to see both outputs

💡 Why This Matters

🌍 Real World

Running multiple tasks at the same time can save time in programs that do independent work, like fetching data from different sources or processing files.

💼 Career

Understanding parallel execution is important for building efficient applications and services that handle multiple operations simultaneously.

1

Create two simple functions

Create two functions called task1 and task2. task1 should return the string 'Hello from task 1'. task2 should return the string 'Hello from task 2'.

LangChain

# Define task1 and task2 functions
# Your code here

Hint

Use def to create functions and return to send back the message.

2

Import RunnableParallel and create instance

Import RunnableParallel from langchain.runnables. Then create a variable called parallel_runner and set it to RunnableParallel({"task1": task1, "task2": task2}).

LangChain

def task1(_):
    return 'Hello from task 1'

def task2(_):
    return 'Hello from task 2'

# Import RunnableParallel and create parallel_runner
# Your code here

Hint

Use the import statement exactly as shown. Pass a dictionary {"task1": task1, "task2": task2} to RunnableParallel.

3

Run the parallel tasks

Use the invoke method of parallel_runner to run both tasks at the same time. Store the result in a variable called results.

LangChain

from langchain.runnables import RunnableParallel

def task1(_):
    return 'Hello from task 1'

def task2(_):
    return 'Hello from task 2'

parallel_runner = RunnableParallel({"task1": task1, "task2": task2})

# Run the parallel tasks and save results
# Your code here

Hint

Call parallel_runner.invoke({}) and assign it to results.

4

Print the results

Add a line to print the results variable to see the output of both tasks.

LangChain

from langchain.runnables import RunnableParallel

def task1(_):
    return 'Hello from task 1'

def task2(_):
    return 'Hello from task 2'

parallel_runner = RunnableParallel({"task1": task1, "task2": task2})

results = parallel_runner.invoke({})

# Print the results
# Your code here

Hint

Use print(results) to show the output.

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