LangChain vs LangGraph

LangChain and LangGraph come from the same team and now work as two layers of one stack. LangChain is the higher layer: model integrations, tools, retrieval and a ready-made agent, create_agent, that you customise with middleware. LangGraph is the lower-level runtime underneath: you define the state, nodes and edges yourself to build long-running workflows with checkpoints and human approval. Start with LangChain for standard agents and RAG, and drop down to LangGraph when you need precise control over the flow.

Book a Free Demo

LangChain vs LangGraph β€” Side by Side

FactorLangChainLangGraph
What it isA framework for LLM applications: model interfaces, prompts, tools, retrievers and agents.A low-level orchestration runtime for stateful, multi-step agent workflows built as graphs.
Level of abstractionHigh. Common patterns are ready to use in a few lines.Low. You design each step, the state passed between steps and the routing.
Building agentscreate_agent provides a standard tool-calling loop; middleware adds behaviour such as trimming history, guardrails or approval steps.You build custom architectures: supervisors, routers, loops, parallel branches and sub-graphs.
How they relateSince version 1.0, LangChain agents run on the LangGraph runtime underneath.LangGraph can be used directly, with or without LangChain components.
State and memoryConversation memory and agent state are handled for you, with options to customise.Explicit, typed state that you define; every node reads and updates it.
PersistenceUses LangGraph's checkpointing through the agent.Checkpoints after each step let you resume, go back to an earlier state ("time travel") and recover from failures.
Human in the loopAvailable through middleware for approval steps.Built in: pause a graph, wait for a person's decision or edits, then resume where it stopped.
StreamingStreams tokens and agent steps.Streams tokens, node updates and custom events from inside the graph.
Retrieval and RAGDocument loaders, text splitters, embeddings, vector store integrations and retrievers.Uses LangChain's retrieval components inside graph nodes, or your own retrieval code.
Older APIsAgentExecutor and many legacy chains belong to the pre-1.0 style; new projects use create_agent.The prebuilt create_react_agent is deprecated in favour of LangChain's create_agent.
Learning curveGentle for standard use; a developer can ship a tool-using agent in a day.Steeper: you need to think in graphs, state updates and control flow.
TestingUnit-test tools and prompts, and evaluate agent outputs against LangSmith datasets.Test nodes on their own and the whole graph with fixed inputs; replay checkpoints to reproduce bugs.
ObservabilityLangSmith tracing and evaluation.The same LangSmith tracing, plus LangSmith Studio for visualising and debugging graphs.
Production hostingDeploy as a normal Python service, for example behind FastAPI.Deploy as a service, or on LangSmith Deployment, which provides durable, Postgres-backed persistence.
Good fitChat assistants with tools, RAG apps, structured extraction and single agents.Approval workflows, multi-agent supervisors, long-running tasks and agents that must recover from failures.
Common mistakePushing complex branching logic into prompts instead of code.Building a full graph for a problem that one create_agent call would solve.
GloryTecks course coverageModules on LangChain 1.0 core concepts, tools and tool calling, create_agent with middleware, memory and RAG.Modules on LangGraph state, nodes and edges, persistence and time travel, human-in-the-loop, streaming and multi-agent patterns.
Projects you buildA tool-using research agent and a document Q&A agent.An approval workflow, a supervisor multi-agent writer and a capstone support agent.
Where these facts come fromLangChain 1.0 release post and documentation; GloryTecks LangChain & LangGraph syllabus.LangGraph and LangSmith documentation; GloryTecks LangChain & LangGraph syllabus.

Which should you choose?

You do not have to choose one. Learn LangChain first, because it teaches the building blocks every agent needs, such as models, tools, retrieval and the create_agent loop, and it lets you ship something useful quickly. Then learn LangGraph, because real projects soon need what it provides: explicit state, checkpoints, approval steps, and multi-agent designs you can reason about and debug. A good rule is to start every project with create_agent and middleware, and move to a custom graph only when the flow needs branching, pauses, retries or several cooperating agents. Employers increasingly ask for both, since production agent work combines LangChain's integrations with LangGraph's control and LangSmith's tracing. The 2-month GloryTecks LangChain & LangGraph course follows this order, moving from LangChain 1.0 concepts to LangGraph persistence, human-in-the-loop and multi-agent patterns, with five projects.

Learn These Skills in Hyderabad

LangChain vs LangGraph β€” FAQs

Is LangGraph replacing LangChain?+

No. Since the 1.0 releases, the two are designed as layers of one stack. LangChain's create_agent runs on the LangGraph runtime, so you get LangGraph's persistence and streaming without writing a graph yourself. LangGraph remains the place to go when you need custom control flow. The team positions them as complementary, along with LangSmith for tracing and deployment.

Should I learn LangChain or LangGraph first?+

LangChain first. It introduces the concepts you need everywhere, including model calls, tools, structured output, retrieval and the agent loop, at a level where you can build working projects quickly. LangGraph makes much more sense once you have seen where a simple agent breaks down, for example when you need an approval step or a workflow that runs for hours.

Do I need LangChain to use LangGraph?+

No. LangGraph works on its own with any Python code inside its nodes, including direct calls to model APIs. Most teams still use LangChain's model integrations, tools and retrievers inside LangGraph nodes, because they save a lot of boilerplate. The two are designed to fit together, but neither requires the other.

What is create_agent in LangChain 1.0?+

create_agent is LangChain's standard way to build a tool-calling agent: you pass a model, a list of tools and optional middleware, and you get an agent loop that runs on the LangGraph runtime. Middleware hooks let you add behaviour such as summarising long conversations, enforcing guardrails or asking a person to approve a risky tool call, without rewriting the loop.

When is LangGraph worth the extra complexity?+

When your workflow has real structure: steps that must happen in order, branches based on results, pauses for human approval, retries after failures, long-running tasks, or several agents with different roles. In those cases an explicit graph is easier to test and debug than a prompt that tries to manage everything. For a single assistant with a few tools, create_agent is usually enough.

How does LangGraph compare with CrewAI?+

CrewAI is a higher-level framework built around role-based agents working as a crew, which makes multi-agent prototypes quick to write. LangGraph is lower level: more code, but precise control over state, routing, persistence and human input. Many teams prototype quickly with a high-level tool and use LangGraph where control matters. The GloryTecks Multi-Agent Systems course covers CrewAI and AutoGen-style frameworks.

Can LangGraph build multi-agent systems?+

Yes, and that is one of its main uses. Common patterns include a supervisor agent that routes work to specialist agents, hand-offs between agents, and agents running as sub-graphs with their own state. Because each agent is a node or sub-graph, you can trace, test and add approval steps to the whole system. The GloryTecks course builds a supervisor multi-agent writer as one of its projects.

What is LangSmith, and do I need it?+

LangSmith is the LangChain team's platform for tracing, evaluating and deploying LLM applications. Tracing shows every model call, tool call and intermediate step, which is essential for debugging agents. You can build without it, and other tools such as Langfuse exist, but some form of tracing and evaluation is expected in any serious agent project.

Can I use LangChain and LangGraph with any language model?+

Yes. Both work with models from OpenAI, Anthropic, Google and other providers through integration packages, and with open models served locally, for example through Ollama. The GloryTecks course lets you work with OpenAI, Gemini or Claude APIs, and the patterns you learn apply whichever provider your employer uses.

What Python level do I need for the LangChain & LangGraph course?+

You should be comfortable with functions, classes, dictionaries, virtual environments and calling APIs, and ideally have some experience with an LLM API. You do not need machine-learning knowledge. If you are new to Python or to LLMs, start with Python Programming or Generative AI with Python first.

Is LangChain still worth learning?+

Yes. The 1.0 releases simplified the library around a core agent loop and middleware, and removed much of the old complexity that frustrated early users. It remains one of the most widely used frameworks for LLM applications, and its integrations save time. Learn the concepts rather than memorising APIs, since the patterns transfer to other frameworks.

How long is the GloryTecks LangChain & LangGraph course?+

It runs 2 months across 12 modules, from LLM application foundations through tools, create_agent and middleware, memory, RAG, LangGraph state and persistence, human-in-the-loop, multi-agent patterns, evaluation and deployment. You build five projects, ending with a capstone support agent. It runs in live online and classroom batches.

Related Comparisons

See all comparisons