Pipe operator for chain composition in LangChain - Mini Project: Build & Apply

Pipe Operator for Chain Composition in LangChain

📖 Scenario: You are building a simple text processing pipeline using LangChain. You want to chain multiple processing steps together using the pipe operator to create a smooth flow of data transformations.

🎯 Goal: Build a LangChain chain that uses the pipe operator | to compose two simple chains: one that converts text to uppercase, and another that adds an exclamation mark at the end.

📋 What You'll Learn

Create a LangChain chain called uppercase_chain that converts input text to uppercase.

Create a LangChain chain called exclaim_chain that adds an exclamation mark at the end of the input text.

Use the pipe operator | to compose uppercase_chain and exclaim_chain into a new chain called full_chain.

Ensure the final chain full_chain can be called with input text to produce the transformed output.

💡 Why This Matters

🌍 Real World

Chaining small processing steps is common in text processing, chatbots, and data pipelines to keep code modular and readable.

💼 Career

Understanding chain composition with pipe operators helps build scalable and maintainable AI applications using LangChain.

1

Create the initial LangChain chains

Create two LangChain chains: uppercase_chain that converts input text to uppercase using a lambda function, and exclaim_chain that adds an exclamation mark at the end using a lambda function.

LangChain

# Create uppercase_chain and exclaim_chain using LangChain chains
# Your code here

Hint

Use RunnableLambda to create simple chains from lambda functions.

2

Add a configuration variable for input text

Create a variable called input_text and set it to the string 'hello world'.

LangChain

from langchain.runnables import RunnableLambda

uppercase_chain = RunnableLambda(lambda text: text.upper())
exclaim_chain = RunnableLambda(lambda text: text + '!')

# Create input_text variable
# Your code here

Hint

Just assign the string 'hello world' to input_text.

3

Compose chains using the pipe operator

Use the pipe operator | to compose uppercase_chain and exclaim_chain into a new chain called full_chain.

LangChain

from langchain.runnables import RunnableLambda

uppercase_chain = RunnableLambda(lambda text: text.upper())
exclaim_chain = RunnableLambda(lambda text: text + '!')

input_text = 'hello world'

# Compose full_chain using pipe operator
# Your code here

Hint

Use full_chain = uppercase_chain | exclaim_chain to chain them.

4

Complete the chain by calling it with input

Call full_chain with input_text and assign the result to a variable called result.

LangChain

from langchain.runnables import RunnableLambda

uppercase_chain = RunnableLambda(lambda text: text.upper())
exclaim_chain = RunnableLambda(lambda text: text + '!')

input_text = 'hello world'

full_chain = uppercase_chain | exclaim_chain

# Call full_chain with input_text and assign to result
# Your code here

Hint

Call the chain like a function: result = full_chain(input_text).

Practice

1. What is the main purpose of the pipe operator in LangChain chain composition?

easy

A. To stop the data flow between chains

B. To create a new chain without connecting existing ones

C. To connect multiple chains so data flows from one to the next

D. To convert chains into plain text

Solution

1. Step 1: Understand the pipe operator role

   The pipe operator is designed to link chains so output from one becomes input to the next.

2. Step 2: Compare options with this role

   Only To connect multiple chains so data flows from one to the next describes connecting chains for smooth data flow, matching the pipe operator's purpose.

3. Final Answer:

   To connect multiple chains so data flows from one to the next -> Option C

4. Quick Check:

   Pipe operator = chain connection [OK]

Hint: Pipe operator links chains for smooth data flow [OK]

Common Mistakes:

• Thinking pipe operator creates chains alone
• Believing it stops data flow
• Confusing it with data conversion

2. Which of the following is the correct syntax to compose two chains chain1 and chain2 using the pipe operator in LangChain?

easy

A. composed_chain = chain1 | chain2

B. composed_chain = chain1 & chain2

C. composed_chain = chain1 + chain2

D. composed_chain = chain1 >> chain2

Solution

1. Step 1: Recall pipe operator syntax

   In LangChain, the pipe operator is represented by the vertical bar | to compose chains.

2. Step 2: Match syntax with options

   composed_chain = chain1 | chain2 uses | correctly between chain1 and chain2. Others use incorrect operators.

3. Final Answer:

   composed_chain = chain1 | chain2 -> Option A

4. Quick Check:

   Pipe operator = | symbol [OK]

Hint: Pipe operator is the vertical bar | between chains [OK]

Common Mistakes:

• Using & or + instead of |
• Using >> which is not pipe in LangChain
• Confusing pipe with bitwise or shift operators

3. Given the following code snippet in LangChain:

chain1 = SomeChain()
chain2 = AnotherChain()
result = chain1 | chain2
output = result.run('input data')

What happens when result.run('input data') is called?

medium

A. Only chain1 processes the input data; chain2 is ignored

B. The input data flows through chain1, then its output flows into chain2, producing final output

C. The input data is processed by chain2 first, then chain1

D. An error occurs because pipe operator cannot be used this way

Solution

1. Step 1: Understand pipe operator chaining behavior

   The pipe operator connects chains so output of the first chain becomes input to the second.

2. Step 2: Trace data flow in the code

   Calling result.run('input data') sends 'input data' to chain1, then its output flows into chain2, producing the final output.

3. Final Answer:

   The input data flows through chain1, then its output flows into chain2, producing final output -> Option B

4. Quick Check:

   Pipe operator = sequential chain flow [OK]

Hint: Pipe operator sends output of first chain to next [OK]

Common Mistakes:

• Thinking chain2 runs before chain1
• Assuming only first chain runs
• Believing pipe operator causes error here

4. Consider this LangChain code snippet:

chain1 = SomeChain()
chain2 = AnotherChain()
composed = chain1 | chain2
composed = chain1 & chain2

What is the issue with the last line?

medium

A. Using & instead of | causes a syntax or runtime error

B. It correctly composes chains with & operator

C. It overwrites the composed chain without error

D. It creates a new chain that runs both chains in parallel

Solution

1. Step 1: Identify correct operator for chain composition

   LangChain uses the pipe operator | to compose chains, not &.

2. Step 2: Analyze effect of using & operator

   Using & is invalid syntax or unsupported, causing an error when running the code.

3. Final Answer:

   Using & instead of | causes a syntax or runtime error -> Option A

4. Quick Check:

   Wrong operator = error [OK]

Hint: Only use | for chaining; & causes errors [OK]

Common Mistakes:

• Assuming & works like |
• Ignoring syntax errors from wrong operator
• Thinking & runs chains in parallel

5. You want to build a LangChain process where data flows through three chains: chainA, chainB, and chainC. You also want to add a filter chain filterChain that only passes data if it meets a condition after chainB. Which pipe operator composition correctly implements this?

hard

A. finalChain = chainA & chainB | filterChain | chainC

B. finalChain = chainA | filterChain | chainB | chainC

C. finalChain = filterChain | chainA | chainB | chainC

D. finalChain = chainA | chainB | filterChain | chainC

Solution

1. Step 1: Understand desired data flow order

   Data should flow: chainA -> chainB -> filterChain -> chainC, so filterChain filters after chainB.

2. Step 2: Match pipe composition to order

   finalChain = chainA | chainB | filterChain | chainC composes chains in correct order using pipe operator. Others reorder or use wrong operator.

3. Final Answer:

   finalChain = chainA | chainB | filterChain | chainC -> Option D

4. Quick Check:

   Correct order with | operator = finalChain = chainA | chainB | filterChain | chainC [OK]

Hint: Chain order matters; pipe operator keeps sequence [OK]

Common Mistakes:

• Placing filterChain before chainB
• Using & operator instead of |
• Mixing chain order incorrectly