LangChain vs LangGraph: picking the right tool for the right job

DanielMarch 28, 2025March 28, 2025

LangChain and LangGraph often cause confusion. And I can understand why!

Not only do they share a similar name, but they are also developed by the same team and serve a common purpose: working with and integrating LLMs (Large Language Models).

Even more interestingly, up until a certain point, one can replace the other.

Think of them like a saw and an axe. Both are used for cutting, but depending on the specifics of the job, one tool might be more effective than the other. In some cases, you might even use both together to get the best results.

I think the diagram below explains quite well the difference the flow types we can define LangChain vs LangGraph:

As the name suggests, LangChain is built around chains. By chains we mean sequential workflows where each step follows a predefined order. It’s ideal for A → B → C type of flows, where each step follows the previous one.

This is the code that defines a very simple chain:

const chain = pointA.pipe(pointB).pipe(pointC)

On the other hand, LangGraph supports dynamic, branching flows. It allows decision making at each step, enabling paths like A → B or C, depending on conditions. This makes it well suited for AI agents use cases, where the LLM needs to determine the next action dynamically.

For example the LangGraph code for the above structure will look like so:

const graph = new StateGraph()
 .addNode("A", functionA)
 .addNode("B", functionB)
 .addNode("C", functionC)
 .addConditionalEdges("A", makeDecision, ["B", "C])

Consider the following prompt:

Translate this text into English and summarize it: 
<< long text in Spanish here >>

This is a classic example of a sequential chain A->B->C, where:

• A is translating the text
• B summarizes translated text
• C is outputting the result

In a chain, the output of a step is used as the input of the next step.

Now, let’s look at a scenario where an AI Agent assistant helps a user choose a weekend activity:

You are an AI assistant helping a user choose a weekend activity.  
Step 1: Ask if they prefer indoors or outdoors.  
- If indoors, do a web search and suggest a movie or a book 
- If outdoors, check the weather and 
  - If the weather is good, use Google Maps to suggest a hiking track  
  - If it rains, use skyscanner.com to search for a flight. 
Step 2: Output the final recommendation.

In this case, the flow branches based on user input and external conditions. The AI agent may call different tools dynamically, such as a web search, weather API, Google Maps, or Skyscanner. This is precisely the type of workflow that LangGraph excels at.

As a side note, LangChain does offer some branching capabilities using something like RunnableMap. But LangGraph is much more ergonomic when handling these types of situations.

These tools are not mutually exclusive. They can also work together. For example, within a LangGraph structure, one node could contain a sequence of steps implemented using LangChain.

But the overall idea is to remember that:

• LangChain will be the tool you will reach out to add LLM integration with simpler direct flows
• while LangGraph is a perfect tool to define AI Agent flows, where sometimes the LLM is the one who decides which node of the graph will get invoked next.

In my opinion, it's best to start with understanding the fundamentals of LangChain and then move to LangGraph. While you don’t need to fully master LangChain before using making agents with LangGraph, having a solid grasp of its foundations will certainly help.