LangChain Runnables: The DNA of AI Pipelines

What Are LangChain Runnables? #

If you are learning LangChain, one of the most important concepts you will come across is Runnables.

A Runnable is a unit of work that takes an input, processes it, and produces an output.

You can think of Runnables as Lego blocks. Each block performs a particular task, and multiple blocks can be connected together to build an LLM application.

Why Were Runnables Introduced? #

An LLM application usually contains multiple steps. For example:

Runnables provide a common interface that makes it easier to connect these components together.

Using LangChain Expression Language (LCEL), you can write:

chain = prompt | llm | parser

The | operator means that the output of one component is passed to the next component.

Why Use Runnables? #

prompt | llm | parser

Runnable Execution Methods #

Runnables provide a common way to execute LangChain components.

1. invoke() #

Use invoke() when you want to process one input.

result = chain.invoke(input)

Example #

from langchain_core.runnables import RunnableLambda

square = RunnableLambda(lambda x: x ** 2)

result = square.invoke(5)

print(result)

2. RunnableSequence #

RunnableSequence executes multiple Runnables one after another.

The most common way to create a sequence is with the pipe operator:

chain = prompt | llm | parser

This syntax is part of LangChain Expression Language (LCEL).

Example: Prompt → LLM → Parser #

from langchain_ollama import ChatOllama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser

llm = ChatOllama(model="gemma3:1b")

prompt = ChatPromptTemplate.from_template(
    "Explain {topic} in simple words."
)

parser = StrOutputParser()

chain = prompt | llm | parser

result = chain.invoke({
    "topic": "LangChain"
})

print(result)

Important: A Chain Is Also a Runnable #

This is one of the most important concepts to understand.

chain = prompt | llm | parser

The resulting chain is itself a Runnable. Therefore, you can use the same Runnable methods:

chain.invoke(...)
chain.batch(...)
chain.stream(...)

You can even connect this chain to another Runnable:

new_chain = chain | another_runnable

3. RunnableParallel #

RunnableParallel is used when multiple independent tasks need to run using the same input.

Example #

from langchain_ollama import ChatOllama
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.runnables import RunnableParallel

llm = ChatOllama(model="gemma3:1b")

summary_prompt = ChatPromptTemplate.from_template(
    "Give a short explanation of {topic}"
)

question_prompt = ChatPromptTemplate.from_template(
    "Create 3 interview questions about {topic}"
)

summary_chain = summary_prompt | llm
question_chain = question_prompt | llm

parallel_chain = RunnableParallel(
    summary=summary_chain,
    questions=question_chain
)

result = parallel_chain.invoke({
    "topic": "LangChain"
})

print("SUMMARY:")
print(result["summary"].content)

print("QUESTIONS:")
print(result["questions"].content)

RunnableParallel returns the results using the keys you provide.

result["summary"].content
result["questions"].content

4. RunnablePassthrough #

RunnablePassthrough passes the input forward without changing it.

from langchain_core.runnables import RunnablePassthrough

passthrough = RunnablePassthrough()

result = passthrough.invoke("Hello")

print(result)

Example with RunnableParallel #

from langchain_core.runnables import (
    RunnableParallel,
    RunnableLambda,
    RunnablePassthrough
)

chain = RunnableParallel(
    original=RunnablePassthrough(),
    uppercase=RunnableLambda(lambda x: x.upper())
)

result = chain.invoke("hello")

print(result)

{
    "original": "hello",
    "uppercase": "HELLO"
}

5. RunnableLambda #

RunnableLambda allows you to use your own Python functions inside a LangChain workflow.

from langchain_core.runnables import RunnableLambda

word_counter = RunnableLambda(
    lambda x: len(x.split())
)

result = word_counter.invoke(
    "LangChain makes LLM applications easier"
)

print(result)

Why Use RunnableLambda? #

• Data cleaning
• Text preprocessing
• Calculations
• Validation
• Formatting
• Custom business logic

6. RunnableBranch #

RunnableBranch is used when your workflow needs conditional logic.

Think of it as the LangChain equivalent of an if/else decision.

Example #

from langchain_core.runnables import (
    RunnableBranch,
    RunnableLambda
)

long_text = RunnableLambda(
    lambda x: "The text is long."
)

short_text = RunnableLambda(
    lambda x: "The text is short."
)

branch = RunnableBranch(
    (
        lambda x: len(x) > 20,
        long_text
    ),
    short_text
)

result = branch.invoke(
    "This is a very long sentence"
)

print(result)

If the condition len(x) > 20 is true, the first path is executed. Otherwise, the default path runs.

7. batch() #

Use batch() when you want to process multiple inputs using the same Runnable.

from langchain_core.runnables import RunnableLambda

double = RunnableLambda(lambda x: x * 2)

results = double.batch([1, 2, 3, 4])

print(results)

This is useful when processing many independent inputs.

8. Streaming with stream() #

LLM responses can take some time to generate. With stream(), output can be received progressively.

for chunk in chain.stream(input):
    print(chunk, end="")

Streaming is especially useful for:

• Chatbots
• AI assistants
• Interactive applications
• Real-time user interfaces

Runnables in RAG #

Runnables are particularly useful when building RAG (Retrieval-Augmented Generation) applications.

A simplified RAG Runnable pipeline can look like:

from langchain_core.runnables import RunnablePassthrough

rag_chain = (
    {
        "context": retriever,
        "question": RunnablePassthrough()
    }
    | prompt
    | llm
    | parser
)

Here, the retriever generates the context while RunnablePassthrough() keeps the original question.

Runnable Types at a Glance #

Easy Way to Remember Runnables #