What problem did LangChain face that made the LCEL pipe operator necessary?

LangChain in 2022 had a problem. Every common pattern, prompt to LLM, prompt to LLM to parser, retrieval to prompt to LLM, was a different class. `LLMChain`, `SimpleSequentialChain`, `SequentialChain`, `RetrievalQA`, and so on. Each class had its own constructor signature, its own way to add streaming, its own way to handle async, and behavior drift between them was frequent. LCEL, LangChain Expression Language, is the rewrite that fixes this. Every piece (a prompt template, a chat model, an output parser, a retriever, a tool) implements the same `Runnable` interface. The interface includes `invoke` for single inputs, `batch` for parallel input lists, `stream` for token by token output, and `astream` for the async version. The composition operator is `|` (the pipe), borrowed from shell pipelines. Compose with `chain = prompt | model | parser` and you get a new Runnable that supports all the same operations. The practical impact: one mental model instead of thirty. The same code reads naturally, switches between sync and async without restructuring, and traces through LangSmith uniformly. The old Chain classes are now legacy. New code should use LCEL exclusively.

LCEL is LangChain's declarative composition layer. The concrete syntax is the overloaded `|` operator on the `Runnable` base class: `chain = prompt | model | parser` builds a composed Runnable that pipes the output of each component into the next. The substance, though, is the unified interface. Every Runnable supports invoke, batch, stream, astream, batch_as_completed, and the callback system that drives LangSmith tracing. Composition preserves all of these. The composed chain you got from `|` supports `.batch([...])` and `.stream({...})` automatically, no wrapping required. This means a single piece of code can serve a single-request API, a batch worker, and a streaming chat endpoint without restructuring. LCEL replaced the older Chain class hierarchy (LLMChain, SimpleSequentialChain, SequentialChain, RetrievalQA, and dozens more), which suffered from inconsistent constructors, ad-hoc streaming support, and behavior drift between subclasses. Those classes still exist but are marked legacy; the migration story is to express them as Runnable compositions. The lesson is composition over inheritance. A single small interface implemented by everything beats a deep class hierarchy where each combination needs its own type.