LangGraph 101 is a two-track tutorial with runnable agents beside the notebooks

Why the framework exists, stated plainly

The context section is the part of this repository that explains the rest, and it is worth reading before the notebooks.

The stated aim at LangChain is to make it easy to build LLM applications, and one type of such application is an agent. In practice though, it is incredibly difficult to build systems that reliably execute on these tasks. And as the team has worked with users to put agents into production, they have learned that more control is often necessary. You might need an agent to always call a specific tool first, or to use different prompts based on its state.

LangGraph is the answer to that. It is a framework for building agent and multi-agent applications, separate from the LangChain package, and its core design philosophy is to help developers add better precision and control into agent workflows, suitable for the complexity of real-world systems.

The third piece is Deep Agents, for complex, multi-step tasks that require planning, filesystem access and delegation. It is an agent harness on top of LangGraph that provides built-in tools, context management and skills out of the box.

So the three names in the title are a stack, not a menu. LangChain is the general application layer, LangGraph is the control and orchestration layer, and Deep Agents is a higher-level harness for the agent that needs to plan and use a filesystem. The repository points at a document on how the frameworks relate to each other.

And there is an honest note about scope. This is a condensed version of LangChain Academy, intended to be run in a session with a LangChain engineer. If you want to go deeper or work through the tutorials alone, LangChain Academy has the pre-recorded videos from the same engineers.

Two tracks, six notebooks

The learning material is split into two tracks, and the split is by how much of LangGraph you already know.

The 101 track, under notebooks/101/, is the fundamentals of building agents with LangChain and LangGraph. It has two notebooks. The first is 101_langchain_langgraph.ipynb, which builds your first agent with models, tools, memory and streaming. The second is 102_middleware.ipynb, which covers middleware, human-in-the-loop patterns and guardrails.

The 201 track, under notebooks/201/, is the production patterns, and it has four notebooks. email_agent.ipynb builds a stateful email triage and response agent. multi_agent.ipynb covers multi-agent systems with supervisors and specialized sub-agents. research_agent.ipynb is a deep research agent with parallel sub-researchers. And deepagents.ipynb builds a research agent from scratch with DeepAgents, covering AGENTS.md, skills, backends, long-term memory, HITL and more.

The selection of topics is what tells you what the framework is for. Middleware, human-in-the-loop and guardrails in the fundamentals track are all about control, which matches the context section's argument. The production track then moves to the shapes that show up when you have several agents: a supervisor, parallel sub-researchers, and a deep agent with its own identity file and on-demand skills.

All the notebooks use the latest LangChain, LangGraph and DeepAgents primitives, and the README names them: create_agent(), create_deep_agent(), middleware and interrupt patterns. The interrupt pattern is the one to notice, because it is how human-in-the-loop is expressed in a graph rather than bolted onto a loop.

The project is a Jupyter Notebook project, MIT licensed, with the last push on 2026-10-20.

Every notebook has a standalone agent next to it

The structure that makes this repository more useful than a notebook dump is the agents/ directory, which holds standalone implementations of the same things the notebooks teach.

These run in LangGraph Studio via langgraph dev, and there is one per example. agents/101/ holds a simple weather agent from the 101 notebook, and the same notebook has an agents/email_agent/ directory with an email triage agent. agents/music_store/ is a multi-agent music store with a supervisor and subagents, agents/researcher/ is the deep research agent with parallel sub-researchers, and agents/deep_agent/ is the DeepAgents research agent with AGENTS.md, skills for a LinkedIn post and a Twitter/X post, long-term memory and HITL.

So the pattern is that a notebook teaches a concept and the directory next to it is the runnable version of that concept, with a langgraph.json at the root acting as the agent registry for langgraph dev. You can interact with the agents through the API or through the LangGraph Studio visual interface.

The deep_agent directory is worth a closer look because it shows what a Deep Agents project looks like on disk. There is an agent.py with the agent definition, an AGENTS.md with the agent identity and instructions, and a skills/ directory with one subdirectory per skill, each holding a SKILL.md, for linkedin-post and twitter-post.

That skills layout is the interesting idea. A skill is a markdown file in a directory, so an agent picks up a capability by having it on disk, and you can add one by adding a folder. The AGENTS.md file plays the same role for the agent as a system prompt would in a hand-written loop, but it is a file you can edit and version.

There is also a utils/ directory with models.py for centralised model configuration and utils.py for shared utilities, plus a .env for API keys, and an mcp/ directory in the repository.

Setting it up takes a clone, a copy and a sync

The pre-work section is a short sequence, and it uses uv.

First the clone:

git clone https://github.com/langchain-ai/langgraph-101.git

Then the environment file, and the copy is what makes the difference since the .env holds your keys:

$ cd langgraph-101
# Copy the .env.example file to .env
cp .env.example .env

Then the package install, with the note that you need a recent version of pip and python:

# Install uv if you haven't already
pip install uv

# Install the package, allowing for pre-release 
uv sync

# Activate the virtual environment
source .venv/bin/activate

The .env.example file itself is a good map of what the tutorials expect. It has the OpenAI key commented options including a base URL override, optional LangSmith tracing with an endpoint that defaults to the cloud API and a project name of langgraph-101, commented sections for Azure OpenAI with its key, endpoint and API version, Anthropic with its key, AWS with access key, secret key, region and model ARN, and Google Vertex AI with a path to a credentials file.

The .env is not committed, and the repository root has a .gitignore that covers it.

There is a note about corporate restrictions. If you run into issues with setting up the Python environment or acquiring the necessary API keys due to any restrictions, such as corporate policy, the instruction is to contact a LangChain representative and they will find a work-around. That is an unusual thing for a tutorial repository to say, and it tells you the workshop is designed to be run inside a company.

One models.py decides which provider every notebook uses

The model configuration is centralised deliberately, and the reason is stated in the README. This repository uses a centralized utils module to avoid code duplication, and all model configurations and shared utilities are defined there.

There are two files. utils/models.py handles LLM model initialisation for OpenAI, Anthropic, Azure, Bedrock and Vertex AI, and utils/utils.py holds the shared utility functions, which are named in the README as show_graph and get_engine_for_chinook_db.

The default is OpenAI with the o3-mini model, and to switch providers you edit utils/models.py. The dependency list backs that up. The project pulls in langchain-openai, langchain-anthropic, langchain-aws for Bedrock, langchain-google-vertexai and azure-identity, so all five providers are installed and the choice is a matter of editing one file rather than reinstalling anything.

There is a convenience detail that saves a lot of friction in a notebook-based tutorial. Notebooks automatically add the project root to Python's path, so they can import from utils regardless of which subdirectory they are in. Without that, every notebook would need a sys.path hack, and one of the first cells in every notebook would be noise.

The get_engine_for_chinook_db utility is a small hint about the kind of example this is. Chinook is the standard sample database with an artists, albums, tracks and customers schema, and using it as the data source for the tools and memory exercises means the agent has something realistic to query without a setup step.

The Python requirement is 3.11 or newer, and the dependency versions are all pinned with a lower bound, including langgraph at 1.0.1 or newer, langchain at 1.3.10 or newer and deepagents at 0.5.3 or newer.

Editorial conclusion

Adopt langgraph-101 if you are new to LangGraph and want the fundamentals taught in a sequence rather than pieced together from documentation, and you have an afternoon for a workshop session. Skip it if you are already building multi-agent systems in production, since the 201 track is patterns rather than a production guide, and if you need model-specific depth, since the notebooks stay provider-neutral. Verify first that you have Python 3.11 or newer and a working key for the provider you intend to use, that the .env file is copied from the example, and that the default model choice is one you can run, since the default is OpenAI with o3-mini.

Frequently asked questions

Official sources

1. Issues
2. langchain-ai/langgraph-101 on GitHub
3. License: MIT
4. README