LCEL Demo 4

As LCEL (LangChain Expression Language) pipelines grow, you frequently need to pass values through unchanged or inject/transform inputs at specific points. RunnablePassthrough is the LCEL primitive for this: it can act as a transparent pipe that forwards data unchanged or as an injector that adds/overrides keys in the runtime input. This document provides concise, corrected examples that illustrate the common patterns for using RunnablePassthrough, plus guidance and best practices.

Overview

Purpose: Pass through input unchanged, or inject/modify runtime keys.
Typical uses: preserve existing call signatures, insert context/configuration, or compute values before downstream runnables.
Works well inside LCEL chains built with prompts, LLMs, and parsers.

Basic prompt -> LLM -> output parser chain

Example showing a simple chain: Prompt → LLM → Output Parser.

from langchain_openai import ChatOpenAI
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

prompt = ChatPromptTemplate.from_template("""
You are a helpful assistant on {topic}.
Answer the following question: {question}
""")

llm = ChatOpenAI()
output_parser = StrOutputParser()

# Build the chain: prompt -> llm -> output_parser
chain = prompt | llm | output_parser

result = chain.invoke({"topic": "movies", "question": "Tell me about The Godfather movie"})
print(result)

Expected truncated example output:

"The Godfather" is a classic American crime film released in 1972, directed by Francis Ford Coppola. The movie is based on the novel of the same name by Mario Puzo. It stars Marlon Brando as Vito Corleone and Al Pacino as Michael Corleone...

RunnablePassthrough as a no-op passthrough

Inserting a plain RunnablePassthrough() anywhere in the pipeline with no .assign(...) simply forwards the data unchanged. This is useful as a placeholder or to preserve structure when conditionally inserting logic.

from langchain_core.runnables import RunnablePassthrough

# Passthrough at the start (no change to behavior)
chain = RunnablePassthrough() | prompt | llm | output_parser
result = chain.invoke({"topic": "movies", "question": "Tell me about The Godfather movie"})
print(result)

# Passthrough at the end (no change to behavior)
chain = prompt | llm | output_parser | RunnablePassthrough()
result = chain.invoke({"topic": "movies", "question": "Tell me about The Godfather movie"})
print(result)

Both examples produce the same output as the basic chain above because the passthrough forwards the input unchanged.

RunnablePassthrough as an injector (`.assign(...)`)

RunnablePassthrough can add or override keys in the input dictionary at the point where it is placed in the chain. Use .assign(...) to compute or pin values. The assign mappers receive the runtime input (commonly named x), so you can compute values based on the current state or return constants. Example: build a chain that accepts only question and injects topic = "movies" before the prompt is evaluated.

from langchain_core.runnables import RunnablePassthrough

# Chain accepts only "question". Inject "topic" = "movies" prior to prompt.
new_chain = (
    RunnablePassthrough()  # forward initial request
    | RunnablePassthrough().assign(topic=lambda x: "movies")  # inject topic
    | prompt
    | llm
    | output_parser
)

# Now callers provide only the question
result = new_chain.invoke({"question": "Tell me about Inception"})
print(result)

You can test the effect on the runtime dictionary:

test_chain = RunnablePassthrough() | RunnablePassthrough().assign(topic=lambda x: "movies")
print(test_chain.invoke({"question": "Tell me about Inception"}))
# Expected output: {'question': 'Tell me about Inception', 'topic': 'movies'}

Use cases and quick reference

Use Case	Behavior	Example
No-op passthrough	Forwards input unchanged	`RunnablePassthrough()`
Inject constant key	Adds a pinned value at runtime	`RunnablePassthrough().assign(topic=lambda x: "movies")`
Compute value from input	Generate value using the current runtime payload	`RunnablePassthrough().assign(user_id=lambda x: x.get("session", {}).get("id"))`
Preserve external API	Hide internal keys from callers by injecting defaults internally	Use `.assign(...)` inside the chain, callers only supply public keys

Why this is useful

RunnablePassthrough is a small but powerful primitive. Use it to:

keep pipeline elements as hollow pipes when no transformation is required,
inject or compute additional inputs at runtime with .assign(...),
pin or hide configuration/context values so external callers don’t need to supply them.

Notes and best practices

.assign(...) mappers are evaluated at runtime and merged into the dictionary forwarded to downstream components.
The lambda parameter name (often x) is arbitrary; it represents the current runtime input at that stage. If the injected value is constant, you can ignore it (e.g., lambda x: "movies").
Instantiate parsers and runnables explicitly (e.g., StrOutputParser()), and prefer clear variable names for readability.
Use RunnablePassthrough to preserve external call signatures while adding internal context or configuration.
When computing values based on prior steps, ensure the required keys exist to avoid runtime errors — validate or provide fallbacks inside your lambda.

Example patterns

Insert configuration or user context only when needed.
Replace complex conditional logic in the chain with targeted, testable mappers using .assign(...).
Combine multiple .assign(...) calls to coalesce values from different sources (e.g., session, defaults, and request).

Next steps

You can convert arbitrary Python functions into runnable components (for example, using a RunnableLambda) to encapsulate custom logic as first-class LCEL runnables. This lets custom logic participate directly in chains and simplifies testing and reuse.

Introduction

Overview of LangChain

Key Components of LangChain

Interacting with LLMs

Tips, Tricks, and Resources

Introduction to LCEL

Adding Memory to LLM Apps

Performing Retrieval

Implementing Chains

Using Tools

Building Agents

Conclusion

Building Blocks of LLM Apps

Overview

Basic prompt -> LLM -> output parser chain

RunnablePassthrough as a no-op passthrough

RunnablePassthrough as an injector (`.assign(...)`)

Use cases and quick reference

Why this is useful

Notes and best practices

Example patterns

Next steps

Links and references

Watch Video

​Overview

​Basic prompt -> LLM -> output parser chain

​RunnablePassthrough as a no-op passthrough

​RunnablePassthrough as an injector (.assign(...))

​Use cases and quick reference

​Why this is useful

​Notes and best practices

​Example patterns

​Next steps

​Links and references

Watch Video

Overview

Basic prompt -> LLM -> output parser chain

RunnablePassthrough as a no-op passthrough

RunnablePassthrough as an injector (`.assign(...)`)

Use cases and quick reference

Why this is useful

Notes and best practices

Example patterns

Next steps

Links and references