31 Phases to Learn LangChain & LangGraph

LLM fundamentals

What a large language model actually does under the hood: tokens, context windows, and why “predicting the next token” is the whole game.

LangChain models

How LangChain wraps different LLM providers (OpenAI, Anthropic, local models) behind one consistent interface, so you can swap models without rewriting your app.

Prompt templates

Turning prompts into reusable, parameterized templates instead of hardcoded strings scattered through your code.

Runnables / LCEL

LangChain's composition language for chaining steps together with `|`, so a chain reads like a pipeline instead of a pile of function calls.

Structured output

Forcing the model to return data in a shape your code can actually use (JSON, Pydantic models) instead of parsing free-form text.

Document loaders

Pulling raw content in from PDFs, websites, Notion docs, and databases — the first step of getting your own data into an LLM pipeline.

Text splitting

Breaking large documents into chunks small enough to embed and retrieve, without cutting sentences in half and losing meaning.

Retrievers

The component that takes a query and returns the most relevant chunks from your data — the “search” half of RAG.

Advanced RAG

Techniques beyond naive retrieval: re-ranking, hybrid search, and query rewriting to actually get accurate answers instead of “close enough.”

Tools

Giving an LLM the ability to call real functions — search the web, query a database, hit an API — instead of just generating text.

Tool calling

The actual mechanism: how a model decides which tool to call, with what arguments, and how that call gets executed safely.

Agents

LLMs that don't just answer once, but reason, decide on an action, observe the result, and loop until the task is actually done.

LangGraph State

The shared object that flows through every step of a graph — effectively the “memory” of what's happened so far in a run.

Nodes

Individual units of work in a LangGraph graph: a node reads state, does something, and returns updated state.

Edges

The connections that decide which node runs next, turning a set of nodes into an actual flow instead of a disconnected pile of functions.

Conditional routing

Edges that branch based on state — if the model needs a tool, go here; if it's done, go there.

Loops

Letting a graph return to an earlier node, which is how agents “keep working” instead of running once and stopping.

Persistence

Saving graph state so a run can pause, resume, or recover from a crash without starting over from scratch.

Memory

Giving an agent recall across turns or sessions, from simple chat history to long-term semantic memory.

Human-in-the-loop

Pausing a graph to ask a person for approval or input before continuing — critical for anything with real-world consequences.

Streaming

Sending tokens, state updates, or events back to the user as they happen, instead of making them wait for the whole run to finish.

Async / parallel execution

Running independent steps concurrently instead of one after another, so multi-step agents don't crawl.

Error handling

What happens when a tool fails, a model times out, or output doesn't parse — the difference between a demo and something production-ready.

Agentic RAG

Retrieval that isn't a single fixed step, but something the agent decides to do, redo, or skip based on what it's learned so far.

Multi-agent systems

Multiple specialized agents collaborating, or handing off to each other, instead of one agent trying to do everything.

LangSmith

Tracing and debugging what actually happened inside a chain or agent run, step by step, instead of guessing from the final output.

Evaluation

Measuring whether your agent is actually good, using test sets and metrics, instead of eyeballing a handful of examples.

Security / guardrails

Protecting against prompt injection, unsafe tool calls, and data leaks — the things that turn a cool demo into a liability.

MCP

The Model Context Protocol — a standard way to connect models to tools and data sources, so integrations aren't reinvented for every app.

Production architecture

Deployment, scaling, cost control, and monitoring — what it actually takes to run an agent system reliably in the real world.

Advanced agentic systems

Putting all six themes above together: long-running, self-correcting, multi-agent systems that plan, act, and adapt with minimal supervision.