Explain what the LCEL pipe operator does and why it became modern LangChain's central abstraction

**LCEL** stands for LangChain Expression Language. The pipe operator `|` is Python operator overloading on the **Runnable** interface: every step (prompt template, model, output parser, retriever, custom function wrapped as `RunnableLambda`) implements the same Runnable contract. The contract has four methods: invoke (single call), batch (many inputs in parallel), stream (yield tokens as they arrive), and astream (async streaming). When you write `prompt | model | parser`, the operator builds a new Runnable that delegates each of those methods through the underlying steps. You get batch and streaming behavior for free, you did not write a single line to enable them. This replaced the old Chain class hierarchy where every chain shape (LLMChain, RetrievalQA, ConversationalRetrievalChain) was its own subclass. Adding a new shape meant subclassing Chain and reimplementing the same boilerplate. LCEL collapsed all of that into one operator and one interface, and gave you batch and streaming as built-in properties of the composite, not as features each subclass had to opt into.

**LCEL's `|` overloads `__or__` on the Runnable interface**, composing two Runnables into a new one. The composite is itself a Runnable, so chains nest, branch (`RunnableParallel`), and conditionally route (`RunnableBranch`) cleanly without new class hierarchies. The real win is the four-method contract every Runnable exposes: invoke, batch, stream, astream. When you compose `prompt | model | parser`, the composite gains all four for free, derived from the underlying steps. The batch method runs the chain in parallel across many inputs, stream yields tokens as the model produces them, astream does the same in async. Without LCEL, every old Chain subclass had to opt into batch and streaming individually, and most did not, which is why pre-LCEL streaming UX was so painful. The Chain class hierarchy was the older abstraction: one class per chain shape. That worked for the small set of canonical chains but did not scale to arbitrary composition. LCEL replaced the hierarchy with one operator and one interface, and made batch and streaming first-class properties of every composite. That single change is what made modern LangChain ergonomic enough for production chat UIs and the foundation of the LangGraph stack on top.