LangChain is the best-known framework for building applications with language models (LLMs). It appeared as a prototype in 2022, became the de facto standard for tutorials and proofs of concept, took harsh criticism for its complexity, evolved into the current ecosystem with LangGraph, LangSmith, and LangServe, and today is a viable choice for companies that know what they are doing, but it is also a trail that sinks anyone who steps in without judgment.
This guide shows what LangChain really is today, when to use it, when to avoid it, what role LangGraph plays for stateful flows, and how to avoid the mistakes that cost months of rework.
The LangChain ecosystem today
The name "LangChain" has become an umbrella for four distinct things. LangChain (core): a library of abstractions for prompts, chains, retrievers, parsers, and memory. LangGraph: a framework for building stateful applications, with explicit flow control (nodes, edges, cycles) and support for multiple coordinated agents. LangSmith: a SaaS platform for observability, debugging, datasets, and evals for any LLM application (not just LangChain). LangServe: a utility to expose chains as REST APIs.
In 2026, the community's center of gravity has clearly shifted to LangGraph. New applications with real complexity are built on top of it, while LangChain core is used more as a toolbox of utilities.
LangChain's strengths
1. An immense ecosystem: integrations with practically any LLM, vector DB, document loader, search tool. It solves in hours what would take weeks to integrate from scratch. 2. Common patterns ready to go: RAG, agents, summarization, structured output, function calling, multi-modal. 3. An active community: courses, books, repositories, examples covering almost any use case. 4. Integrated observability via LangSmith: execution tracing, visual debugging, datasets for continuous eval. 5. LangGraph: for stateful flows, cycles, human intervention, and multiple agents, it offers a solid mental model.
Criticism and real pain
LangChain collects fair criticism. Excessive abstractions that change frequently, producing fragile, version-dependent code. Implicit "magic" in chains that makes debugging harder. Performance and cost that are not always transparent (nested chains that fire more calls than they seem to). A learning curve for someone who just wanted to do "one call with retrieval" and ends up in seven layers of classes.
These problems have been partly addressed in the latest versions and in the migration to LangGraph, but they remain real. The lesson: treat LangChain as a tool, not a religion.
When to use LangChain (or LangGraph)
It is worth using when: (a) you need to deliver value fast with few engineers and the problem is standard (RAG, classification, summarization, a simple agent); (b) the team will make heavy use of the ecosystem of integrations; (c) you need LangSmith for observability from day one; (d) your application has complex stateful flows (LangGraph shines here); (e) you want to avoid reinventing common abstractions like retriever, parser, prompt template.
When NOT to use LangChain
Avoid it when: (a) your use case is simple and fits in 200 lines of plain TypeScript or Python with the provider's SDK directly; (b) performance and cost need to be absolutely predictable (with LangChain you add layers that make profiling harder); (c) the team has an aversion to heavy frameworks; (d) you need very fine control over the agent's cycle (an in-house harness may be simpler).
Alternatives that grew in 2025-2026
The landscape became plural. Vercel AI SDK: great for web and edge apps, natural integration with Next.js, well-done streaming. Mastra: born in TypeScript with a focus on agents, workflows, and native observability. Claude Agent SDK: for those who use Claude and want an agent cycle standardized by Anthropic. LlamaIndex: strong in RAG and data ingestion, especially over documents. Direct SDK + in-house harness: for teams that want full control and are willing to invest.
Good practices in real LangChain projects
Five rules that save months. 1. Pinned version: treat an upgrade as a migration, not a routine. API breakage happens. 2. LangSmith from day one: without tracing, debugging becomes guesswork. 3. Do not hide expensive calls: each chain should have logging of tokens and aggregate cost. 4. Test your retriever in isolation: 80% of quality problems in RAG come from the retriever, not the LLM. 5. LangGraph for stateful flows: do not simulate state on top of chains, use the right tool.
LangChain and the post-MCP era
With the rise of MCP (Model Context Protocol), part of what LangChain offered as custom integration became an open standard. The sensible direction in 2026 is to use LangGraph (or similar) for orchestration and state, MCP to connect tools and data, and the provider's SDK directly for critical calls where latency and cost matter. This combination separates responsibilities and avoids framework vendor lock-in.
Practical conclusion
LangChain is neither a miracle nor a curse. It is a tool with broad scope, a giant community, known weaknesses, and constant evolution. Those who use it with judgment, understanding what is under the hood and when to switch tools, deliver fast and stay healthy. Those who step in without judgment pay in maintenance and refactoring. At Steply, we use LangChain and LangGraph in specific cases, alongside Mastra, Claude Agent SDK, and an in-house harness, choosing according to the problem. A framework is a means, not an end.