LangChain stopped being "the framework that does everything" and became a thin composition layer over a specialized ecosystem. Here's what actually changed and why it's still the default choice in production.
In 2023 and 2024, LangChain drew justified criticism: too many abstractions, chains (`LLMChain`, `SimpleSequentialChain`) that hid what was actually happening to the prompt, and an API surface that shifted from version to version. The team's response wasn't to abandon the project but to split it: `langchain-core` holds the interfaces (`Runnable`, `BaseChatModel`, `BaseRetriever`), `langchain` holds the high-level orchestration logic, and each integration lives in its own package (`langchain-openai`, `langchain-anthropic`, `langchain-postgres`, etc.).
This separation is why updating a provider's SDK today no longer breaks your retrieval chain, and why you can install only what you actually use in production instead of a package with hundreds of transitive dependencies.
The most important change was the consolidation of the LangChain Expression Language (LCEL). Instead of `Chain` subclasses, every object participating in a flow implements the `Runnable` interface, with consistent methods: `invoke`, `batch`, `stream`, `ainvoke`. This lets you compose declaratively with the `|` operator.
This uniformity is what later made it possible to build LangGraph on top: a state graph where every node can literally be a LangChain `Runnable`, no adapters needed.
It's worth being explicit about what's now considered legacy: `LLMChain`, `ConversationChain`, and the classic `AgentExecutor` with `initialize_agent()` still work but no longer receive active improvements. Current documentation pushes toward building agents with `langgraph.prebuilt.create_react_agent` or custom graphs, and building simple chains with direct LCEL. If your 2023 codebase still uses `from langchain.chains import LLMChain`, it's time to migrate — not because it's going to stop working tomorrow, but because debugging, token streaming, and tool support are noticeably worse in that older layer.
With each provider's native SDKs (OpenAI, Anthropic, Google) getting more complete, the reasonable question is whether LangChain still adds value. In our experience with clients in Guatemala and the region, the answer is yes, for three concrete reasons:
First, real model-provider abstraction: switching from `ChatOpenAI` to `ChatAnthropic` or to a local model via `ChatOllama` is a one-line change if your chain is built with `Runnable`. Second, the retrieval integration catalog (vector stores, hybrid retrievers, document loaders) is still the broadest on the market. Third, combining it with LangSmith for traceability and LangGraph for flow control covers the entire lifecycle without leaving the same conceptual ecosystem.
For a trivial use case — a single call to a model with a fixed prompt, no retrieval, no tools — adding LangChain is over-engineering. Anthropic's or OpenAI's native SDK is more direct and has fewer layers to debug. LangChain starts paying dividends when there's real composition: multiple steps, multiple data sources, a need to swap models, or a requirement for structured observability.
If your team started a project in 2023 with the old API, plan an incremental migration to LCEL and, for flows with conditional logic or cycles, to LangGraph. There's no need to rewrite everything at once: `Runnable` and LangGraph graphs can coexist with legacy chains while you migrate module by module. For new projects, the recommendation is to start directly with `langchain-core` + LCEL for the simple parts, and LangGraph for anything with state, loops, or human intervention.
Carlos Montiel is an enterprise AI solutions architect. He implements LLMs, Agents, RAG, and orchestrators for companies across Guatemala and Latin America. Reach out for a consultation.
Contact Carlos Montiel