LCEL & Runnables

💻 Practice Notebook

Master the concepts from this page with hands-on practice: 💻 VS Code | 🚀 Colab | 📥 Download Notebook LangChain Expression Language (LCEL) is a declarative way to build LLM applications, allowing you to compose components using the pipe operator (|).

1. What is LCEL & Why Use It?

Instead of writing imperative code to link prompts, models, and parsers, you connect them together like a Unix pipeline:

# A basic LCEL chain structure
chain = prompt | llm

Why Use LCEL?

Simple: Chain complex components in just a few lines of code.
Readable: Easy to inspect the flow of inputs and outputs.
Composable: Swap prompts, LLMs, retrievers, or parsers effortlessly.
Built-in Support: Handles streaming and parallel operations out of the box.

2. LCEL Code Examples

Example 1: Basic QA Chain

A simple chain that takes a topic, formats a prompt, invokes the model, and extracts the response content.

from langchain_core.prompts import PromptTemplate
from langchain.chat_models import init_chat_model

# Initialize components
llm = init_chat_model("llama-3.3-70b-versatile", model_provider="groq")
prompt = PromptTemplate.from_template("Tell me a short joke about \{topic\}.")

# Compose LCEL Chain: prompt | llm
chain = prompt | llm

# Invoke the chain (returns an AIMessage)
response = chain.invoke({"topic": "programming"})
print(response.content)

Example 2: Subject Line Generator

Generate a professional email subject line using dynamic topic and tone variables.

from langchain_core.prompts import PromptTemplate
from langchain.chat_models import init_chat_model

# Initialize components
llm = init_chat_model("llama-3.3-70b-versatile", model_provider="groq")
prompt = PromptTemplate.from_template("Write a single email subject line for a request about \{request_topic\} in a \{tone\} tone.")

# Compose LCEL Chain
chain = prompt | llm

# Invoke the chain
response = chain.invoke({"request_topic": "server maintenance delay", "tone": "apologetic"})
print(response.content)

3. Exercises for LCEL

Exercise 1: Marketing Pitch Generator

Create a chain that takes a product name and a target audience and generates a catchy marketing slogan. Instructions:

Import PromptTemplate and init_chat_model.
Define a string prompt template containing two variables: {product_name} and {target_audience}.
Initialize the Groq model llama-3.3-70b-versatile.
Compose an LCEL chain linking the prompt template and the chat model.
Invoke the chain passing a dictionary with values for "product_name" (e.g., "EcoWater Bottle") and "target_audience" (e.g., "fitness enthusiasts").
Print the model’s text response using .content.

Solution

from langchain_core.prompts import PromptTemplate
from langchain.chat_models import init_chat_model

llm = init_chat_model("llama-3.3-70b-versatile", model_provider="groq")

prompt = PromptTemplate.from_template(
    "Create a catchy one-sentence marketing slogan for {product_name} targeting {target_audience}."
)

# Compose the chain
pitch_chain = prompt | llm

# Run
result = pitch_chain.invoke({
    "product_name": "EcoWater Bottle",
    "target_audience": "fitness enthusiasts"
})
print(result.content)

Exercise 2: Tech Tag Extractor

Create a chain that takes an article excerpt and lists the top 3 technology keywords mentioned. Instructions:

Import PromptTemplate and init_chat_model.
Define a string prompt template containing a variable {text} that asks the model to list the top 3 technology keywords mentioned in the text.
Initialize the Groq model llama-3.3-70b-versatile.
Compose an LCEL chain linking the prompt template and the chat model.
Invoke the chain passing a dictionary containing a sample text paragraph.
Print the model’s text response using .content.

Solution

from langchain_core.prompts import PromptTemplate
from langchain.chat_models import init_chat_model

llm = init_chat_model("llama-3.3-70b-versatile", model_provider="groq")

prompt = PromptTemplate.from_template(
    "List the top 3 technology keywords mentioned in this text: '{text}'."
)

# Compose the chain
tag_chain = prompt | llm

# Run
result = tag_chain.invoke({
    "text": "Kubernetes is an open-source container orchestration system for automating software deployment and scaling. It was originally designed by Google."
})
print(result.content)

4. Invoking vs. Streaming

4.1 `invoke()`

Waits for the entire model execution to complete and returns the full response at once.

response = chain.invoke({"topic": "Python"})
print(response.content)

4.2 `stream()`

Yields the response progressively, token-by-token. This is crucial for interactive chat interfaces to improve perceived user latency.

for chunk in chain.stream({"topic": "Python generators"}):
    # ChatModel stream yields BaseMessageChunks; print chunk.content
    print(chunk.content, end="", flush=True)

Invocation Input Cheat Sheet

What are you invoking?	Input type	Example
`llm.invoke()`	String	`"What is Python?"`
Prompt with one variable	Dictionary or String	`{"topic": "Python"}` or `"Python"`
Prompt with multiple variables	Dictionary	`{"name": "Siva", "age": 25}`
LCEL chain starting with a prompt	Dictionary	`{"topic": "Generators"}`

5. LangChain Runnables

A Runnable is the fundamental building block in LangChain. Any component that implements invoke(), batch(), or stream() is a Runnable.

5.1 RunnableSequence

Chains multiple runnables sequentially so the output of one component becomes the input of the next. The pipe operator (|) automatically creates a RunnableSequence.

# The pipe creates a RunnableSequence under the hood
chain = prompt | llm

5.2 RunnablePassthrough

Forwards the input value as-is. This is useful for passing unchanged variables down a chain or creating multi-keyed inputs.

from langchain_core.runnables import RunnablePassthrough, RunnableLambda

# Combine Passthrough with Lambda mapping
chain = {
    "original": RunnablePassthrough(),
    "upper": RunnableLambda(lambda x: x.upper())
}

result = chain.invoke("hello")
print(result)

Output:

{'original': 'hello', 'upper': 'HELLO'}

5.3 RunnableParallel

Executes multiple runnables concurrently on the same input, returning their outputs as a unified dictionary.

from langchain_core.prompts import PromptTemplate
from langchain_core.runnables import RunnableParallel

prompt1 = PromptTemplate.from_template("Summarize \{topic\}")
prompt2 = PromptTemplate.from_template("List advantages of \{topic\}")

parallel_chain = RunnableParallel(
    summary=prompt1 | llm,
    advantages=prompt2 | llm
)

result = parallel_chain.invoke({"topic": "Artificial Intelligence"})
print(result)

Output:

{
  "summary": AIMessage(content="AI is the simulation..."),
  "advantages": AIMessage(content="1. Automation...")
}

6. Practice Exercises

Practice 1: Basic LCEL Translation Pipeline

Create a simple LCEL chain combining a prompt template ("Translate the word '{word}' into German.") and a chat model. Invoke it with the word "apple" and print the response content.

Solution

from langchain_core.prompts import PromptTemplate
from langchain.chat_models import init_chat_model

llm = init_chat_model("groq:llama-3.3-70b-versatile", model_provider="groq")
prompt = PromptTemplate.from_template("Translate the word '{word}' into German.")

# Create the LCEL chain
chain = prompt | llm

# Invoke the chain
result = chain.invoke({"word": "apple"})
print(result.content)

Foundations

LangChain Prompts

💻 Practice Notebook

1. What is LCEL & Why Use It?

Why Use LCEL?

2. LCEL Code Examples

Example 1: Basic QA Chain

Example 2: Subject Line Generator

3. Exercises for LCEL

Exercise 1: Marketing Pitch Generator

Exercise 2: Tech Tag Extractor

4. Invoking vs. Streaming

4.1 `invoke()`

4.2 `stream()`

Invocation Input Cheat Sheet

5. LangChain Runnables

5.1 RunnableSequence

5.2 RunnablePassthrough

5.3 RunnableParallel

6. Practice Exercises

Practice 1: Basic LCEL Translation Pipeline

​💻 Practice Notebook

​1. What is LCEL & Why Use It?

​Why Use LCEL?

​2. LCEL Code Examples

​Example 1: Basic QA Chain

​Example 2: Subject Line Generator

​3. Exercises for LCEL

​Exercise 1: Marketing Pitch Generator

​Exercise 2: Tech Tag Extractor

​4. Invoking vs. Streaming

​4.1 invoke()

​4.2 stream()

​Invocation Input Cheat Sheet

​5. LangChain Runnables

​5.1 RunnableSequence

​5.2 RunnablePassthrough

​5.3 RunnableParallel

​6. Practice Exercises

​Practice 1: Basic LCEL Translation Pipeline

💻 Practice Notebook

1. What is LCEL & Why Use It?

Why Use LCEL?

2. LCEL Code Examples

Example 1: Basic QA Chain

Example 2: Subject Line Generator

3. Exercises for LCEL

Exercise 1: Marketing Pitch Generator

Exercise 2: Tech Tag Extractor

4. Invoking vs. Streaming

4.1 `invoke()`

4.2 `stream()`

Invocation Input Cheat Sheet

5. LangChain Runnables

5.1 RunnableSequence

5.2 RunnablePassthrough

5.3 RunnableParallel

6. Practice Exercises

Practice 1: Basic LCEL Translation Pipeline