Omar Hosney

LangChain Expression Language (LCEL) Cheat Sheet

Benefits of LCEL

Optimized parallel execution: Use RunnableParallel for faster chains.
Async support: Easily handle concurrent requests.
Streaming: Incremental outputs minimize delays.
LangSmith tracing: Automatic logging for observability.
Deployable: Use LangServe for production-ready chains.

Should I Use LCEL?

Simple Chains: Use LCEL for prompt + LLM setups.
Complex Logic: Prefer LangGraph for branching or cycles.
LLM Call: Call the chat model directly if single-step.

Composition Primitives

RunnableSequence: Chain runnables sequentially.
RunnableParallel: Run tasks concurrently.
Type coercion: Automates dictionary and function conversions.

Useful Patterns

Pipe Operator: Combine runnables with |.
Function Conversion: Turn any function into RunnableLambda.
Default Arguments: Use bind for defaults.
Retries: Add with_retry for error handling.

Code Examples

Invoke: runnable.invoke(input).
Batch: runnable.batch([inputs]).
Stream: Use runnable.stream() for incremental output.
Fallbacks: Add with_fallbacks() for backups.

Legacy Chains

Migration: Replace with LCEL for transparency.
Customization: LCEL supports flexible prompts and models.
Consistency: Standard behavior for all chains.

Sample Code: Sequential Composition


from langchain_core.runnables import RunnableLambda, RunnableSequence

# Define individual runnables
runnable1 = RunnableLambda(lambda x: x * 2)
runnable2 = RunnableLambda(lambda x: x + 3)

# Create a sequence
chain = RunnableSequence([runnable1, runnable2])

# Invoke the chain
result = chain.invoke(5)  # Output: 13

Sample Code: Parallel Composition


from langchain_core.runnables import RunnableLambda, RunnableParallel

# Define individual runnables
runnable1 = RunnableLambda(lambda x: x ** 2)
runnable2 = RunnableLambda(lambda x: x + 10)

# Create a parallel runnable
chain = RunnableParallel(first=runnable1, second=runnable2)

# Invoke the chain
result = chain.invoke(4)  # Output: {'first': 16, 'second': 14}