LangChain and LangGraph

Explain like I'm five

Imagine you are building a robot helper.

• LangChain is the LEGO kit with instructions: pre-made pieces for talking to AI models, reading documents, calling tools, and chaining steps. You snap blocks together without designing every gear yourself.
• LangGraph is the circuit board underneath: it decides which step runs next, remembers what already happened, can loop back, pause for a human, and resume after a crash.

You can use the LEGO kit without thinking about the circuit board — until your robot needs a custom brain with loops, memory, and “wait for approval” buttons. Then you wire the circuit board yourself.

What is LangChain?

LangChain is an open-source framework (Python and JavaScript) for building applications on top of large language models.

It gives you reusable building blocks so you do not re-implement the same glue code for every project:

Mental model: LangChain is the developer-experience layer — integrations, abstractions, and a fast path to “working demo.”

What it is not: a model host, a vector database, or a deployment platform by itself (though the LangChain ecosystem also includes LangSmith for tracing/evals and LangGraph Platform for deployment).

What is LangGraph?

LangGraph is a library for building stateful, graph-shaped workflows where each step is a node, transitions are edges, and shared data lives in state.

Unlike a simple linear chain (A → B → C), a graph can:

• Loop — agent calls a tool, reads result, thinks again
• Branch — if retrieval confidence is low, ask a clarifying question
• Pause — human-in-the-loop approval before a destructive action
• Persist — checkpoint state so a long job survives restarts
• Stream — emit partial results as each node completes

Core concepts:

Mental model: LangGraph is the orchestration runtime — explicit control flow for agents that act over time, not just respond once.

Inspired by graph systems like Pregel/NetworkX; implemented by the same team behind LangChain (official overview).

How they fit together (2025–2026)

flowchart TB
  subgraph apps [Your application]
    RAG[RAG pipeline]
    AGENT[Agent with tools]
    MULTI[Multi-agent workflow]
  end

  subgraph lc [LangChain — framework layer]
    INT[Model / tool / retriever integrations]
    CA[create_agent + middleware]
    LCEL[LCEL chains]
  end

  subgraph lg [LangGraph — runtime layer]
    SG[StateGraph]
    CP[Checkpointing]
    HITL[Human-in-the-loop interrupts]
  end

  RAG --> INT
  RAG --> LCEL
  AGENT --> CA
  CA --> SG
  MULTI --> SG
  SG --> CP
  SG --> HITL

Key fact (v1.0, Oct 2025): LangChain agents now use LangGraph as the execution engine. create_agent replaced the older AgentExecutor. You do not choose one instead of the other for most agent work — LangChain sits on LangGraph.

When the boundary becomes visible: you need to inspect mid-run state, custom routing, durable multi-day workflows, or multi-agent handoffs — then you drop to LangGraph directly and design the StateGraph yourself.

Sources: LangChain product concepts, LangGraph overview.

LangChain vs LangGraph — decision table

How this maps to your vault

Practical takeaway: your RAG notes already use LangChain as plumbing (splitters, loaders, retrievers). Agentic AI is where LangGraph matters most — when the system must remember, branch, and keep acting across steps.

Minimal code shapes (conceptual)

LangChain — linear RAG chain

# Conceptual — not a full runnable script
from langchain_text_splitters import RecursiveCharacterTextSplitter
from langchain_core.prompts import ChatPromptTemplate

splitter = RecursiveCharacterTextSplitter(chunk_size=500, chunk_overlap=50)
chunks = splitter.split_text(raw_text)

prompt = ChatPromptTemplate.from_template(
    "Answer using only this context:\n{context}\n\nQuestion: {question}"
)
# chain = retriever | prompt | model   (LCEL composition)

LangGraph — explicit state machine

# Conceptual — graph with a loop
from typing import TypedDict
from langgraph.graph import StateGraph, END

class AgentState(TypedDict):
    messages: list
    step_count: int

def call_model(state: AgentState) -> AgentState:
    ...

def should_continue(state: AgentState) -> str:
    return "tools" if needs_tool(state) else END

graph = StateGraph(AgentState)
graph.add_node("model", call_model)
graph.add_node("tools", run_tools)
graph.add_conditional_edges("model", should_continue)
# compile with checkpointer for durable state

Common misconceptions

Ecosystem map

flowchart LR
  LC[LangChain
framework]
  LG[LangGraph
runtime]
  LS[LangSmith
tracing / evals]
  LGP[LangGraph Platform
deployment]

  LC --> LG
  LC --> LS
  LG --> LS
  LG --> LGP

When to read next

Navigation

← 2_AI Index · Agentic AI · MCP