The pipe operator (`|`) as a composition syntax is famous in one framework: LangChain's LCEL. Every Runnable in LCEL implements `__or__`, so `prompt | model | parser` creates a new composed Runnable that runs each step in sequence. The pipe reads left to right and matches the data flow, which is why it caught on quickly.
The other three options invent syntax that those frameworks do not actually use.
LlamaIndex composes via Python method chaining. `index.as_query_engine().query('...')`. There is no `__or__` overload on QueryEngines.
Vercel AI SDK uses plain functions and React hooks. `streamText` is a function call, not a Runnable, and there is no pipe semantics. The composition happens through explicit function calls and props.
Haystack v2 uses an explicit socket-wiring API. `pipeline.connect('component_a.output', 'component_b.input')`. The verbosity is intentional; the framework prefers explicit graph construction over operator overloading.
Knowing which framework owns which composition idiom is basic vocabulary; the pipe is LCEL's signature.
**LangChain LCEL is the only one.** It overloads `|` so `prompt | model | parser` composes into a new Runnable. The mechanism is `Runnable.__or__`. Every Runnable implementation returns a `RunnableSequence` when piped, and the resulting object supports the same surface as the originals (`.invoke`, `.batch`, `.stream`, `.astream`).
**Why the others are wrong on the facts.**
- **LlamaIndex** composes via Python method chaining: `index.as_query_engine().query('...')`. QueryEngines do not implement `__or__`. The architectural style is data-centric (Documents, Nodes, Indexes) with explicit method calls, not operator-based composition.
- **Vercel AI SDK** is function and hook shaped. `streamText({...})` is a function call returning a stream; `useChat` is a React hook for the client. There is no Runnable protocol and no pipe operator. Composition happens through TypeScript function calls and React props.
- **Haystack v2** uses an explicit socket-wiring API: `pipeline.add_component('retriever', ...)` then `pipeline.connect('retriever.documents', 'generator.documents')`. The framework prefers verbose explicit graphs over operator magic, partly to support typed input / output sockets.
**The deeper signal.** LCEL's pipe makes the composition visually obvious and gives the framework a single chokepoint to implement batch, stream, and async over the whole chain. It is an opinionated choice with a real ergonomic payoff. And a real limit: you cannot pipe non-Runnables, and complex routing inside the pipe gets awkward (which is partly why LangGraph exists).
Quick reference
TL;DR
LangChain LCEL is the only one that overloads the pipe; LlamaIndex uses method chaining, Vercel AI SDK uses functions, Haystack v2 uses explicit socket wiring.
Imagine four different ways to connect garden hoses.
LangChain LCEL is the one with snap-on connectors. You literally click hose A onto hose B with one motion. The `|` symbol is the snap.
LlamaIndex is more like turning faucets in sequence. You turn one on, water flows through, then turn the next. Method calls in a chain, no clicking.
Vercel AI SDK is just buckets and a person carrying water between them. Explicit function calls, no plumbing metaphor.
Haystack v2 makes you label every pipe end and write down 'connect hose A's output to hose B's input' on a clipboard. Explicit wiring.
Only one of these uses the snap.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example. Click to expand.
Everything you need to truly understand this topic: intuition, mechanics, step by step explanation, code, formulas, and worked example.
Workflow with cycles or loops LCEL is a DAG; pipe composition cannot express cycles. Reach for LangGraph instead.
Composition involving non-LangChain components Only Runnables can be piped; arbitrary callables need wrapping in RunnableLambda first, which dilutes the ergonomic win.
Team uses a non-LangChain ecosystem (LlamaIndex, Vercel, Haystack) The pipe idiom is not portable; adopting LCEL just for the pipe means importing the whole LangChain ecosystem.
Quick scan · 2–4 min
Everything important, quickly.
4 min: the Runnable.__or__ mechanism, why other frameworks did not copy the pipe, where pipe composition wins, and where it runs out.
Side-by-side
Framework
Composition idiom
Why this choice
LangChain LCEL
`a | b | c` pipe over Runnables
Uniform Runnable protocol; batch / stream / async free across the chain
LlamaIndex
Method chaining and factories
Data-centric primitives with distinct types per role
Vercel AI SDK
Function calls + React hooks
Deliberately thin; mirrors provider SDK shape
Haystack v2
Explicit `pipeline.connect(a.out, b.in)`
Typed sockets; static graph analysis
Real-world examples
Real products, models, and research that use this idea.
1LangChain's own quickstart shows `prompt | model | StrOutputParser()` as the canonical Hello World. Pipe composition is the framework's calling card.
2Haystack v2 production pipelines at deepset use explicit `pipeline.connect` calls so socket types are statically checkable.
3Vercel AI SDK adoption in Next.js apps relies on the function and hook style; the SDK never grew a pipe operator and stays deliberately thin.
4LlamaIndex's tutorials emphasize method chaining and named factory methods, reinforcing the data-centric framing the framework prefers.
Interviewer follow-ups
What an interviewer would ask next. Try answering before peeking at the approach.
QWhat does `RunnableSequence` look like under the hood after `prompt | model | parser`?
Sign in or go Pro to see the approach for this follow-up.
QHow does `RunnableParallel` differ from a pipe?
Sign in or go Pro to see the approach for this follow-up.
QWhat would a Haystack-style explicit-connect look like in LangChain LCEL?
Sign in or go Pro to see the approach for this follow-up.
Don't say this
Red flags and common mistakes that signal junior thinking. Click to expand.
Most common mistake
Assuming any composition framework supports the pipe because LCEL made it famous. Then writing `query_engine | synthesizer` in LlamaIndex and getting a TypeError.