Summary of "Langchain Runnables - Part 2 | Generative AI using LangChain | Video 9 | CampusX"

Overview

This is a continuation tutorial (host: Nitesh) on LangChain Runnables. It explains why LangChain standardized components into a common Runnable interface (with an invoke method) so different components can be connected into flexible pipelines.

Two runnable categories:

Task-specific runnables: core LangChain components converted to runnables (e.g., PromptTemplate, LLMs like ChatOpenAI, Retrievers, OutputParsers like StringOutputParser).
Runnable primitives: building-block runnables that orchestrate how task-specific runnables run (sequentially, in parallel, conditionally, or by wrapping custom logic).

Runnable primitives

The tutorial covers several runnable primitives, their purposes, typical use cases, and common code patterns.

1. RunnableSequence

Purpose: Connect two or more runnables sequentially so the output of R1 becomes the input of R2, and so on.
Typical use cases:
- Simple prompt → LLM → parser (e.g., joke generator).
- Longer chains where one model output feeds another step (e.g., joke → explanation → model → parser).
Code pattern:
- RunnableSequence([prompt, model, parser])
- Or using LCEL pipe syntax: R1 | R2 | R3

2. RunnableParallel

Purpose: Run multiple runnables in parallel on the same input; returns a dictionary mapping branch keys to outputs.
Typical use case: generate different content formats from the same topic concurrently (e.g., a tweet and a LinkedIn post).
Output example: {"tweet": "...", "linkedin": "..."}

3. RunnablePassThrough

Purpose: Return its input unchanged. Useful to preserve original data while other branch(es) process it.
Typical use case: run a parallel branch that prints or stores the raw output while another branch transforms it (e.g., explain a joke while also keeping the raw joke).

4. RunnableLambda

Purpose: Wrap any Python function (including a lambda) as a runnable so it can participate in chains.
Typical use cases:
- Convert a word-count function into a runnable to compute the number of words in a generated joke.
- Preprocessing function for cleaning text (strip HTML, lowercase, remove punctuation, lemmatize) before feeding into an LLM.
Code pattern: RunnableLambda(your_function) or RunnableLambda(lambda x: ...)

5. RunnableBranch

Purpose: Conditional execution (if / elif / else behavior). Each condition is a tuple (predicate, runnable). A default/else runnable is provided last.
Typical use case: generate a long report, then:
- If word_count > threshold (e.g., 500 words), send to a summarization runnable sequence.
- Else, pass-through and print as-is.
Predicate example: lambda x: len(x.split()) > 500

LangChain Expression Language (LCEL)

Introduces a concise declarative operator | (pipe) to build sequential chains: R1 | R2 | R3 replaces RunnableSequence([R1, R2, R3]).
Currently targets sequential composition; expected to expand to declarative constructs for other primitives (parallel, branch) in future releases.

Practical notes demonstrated in the video

Typical imports shown: PromptTemplate, ChatOpenAI, StringOutputParser, RunnableSequence, RunnableParallel, RunnablePassThrough, RunnableLambda, RunnableBranch, load_dotenv.
Parallel branch outputs come as dictionaries keyed by branch names.
Use RunnableLambda for non-LLM deterministic tasks (counts, cleanup, small business logic).
Use RunnablePassThrough to preserve raw inputs alongside derived outputs in parallel workflows.
Branch predicates typically inspect outputs (e.g., parsed text) to route processing.

Code examples walked through (summary)

Joke generator: prompt → ChatOpenAI → StringOutputParser via RunnableSequence.
Joke + explanation: chained sequences to produce both joke and explanation.
Tweet / LinkedIn in parallel: RunnableParallel with two RunnableSequence branches returning a dict.
Pass-through example: demonstrates identity behavior of RunnablePassThrough.
Word-count example: convert a Python function to RunnableLambda and combine with RunnableParallel to show joke + word count.
Conditional summarizer: RunnableBranch with a predicate on word count to choose summarization vs pass-through.

Conclusion

Runnables simplify composing LLM application workflows. The primitives enable common orchestration patterns—sequencing, parallelism, branching—and allow embedding native Python logic. LCEL’s pipe syntax streamlines composing sequences and will likely be extended. Upcoming videos will move toward building RAG applications.

Runnables provide a unified, composable interface for building flexible, maintainable LLM pipelines.

Main speaker / source

Nitesh (YouTube host; CampusX channel / LangChain tutorial series)
Content references: LangChain library (Runnable interface, primitives, PromptTemplate, ChatOpenAI, StringOutputParser, LCEL)