LangGraph Course Repo — Build LLM Agents Hands-On

Learn LangGraph by building Agentic RAG, ReAct and reflection agents, one commit per lesson.

Stars
★ 753
Last updated
21d ago
License
Apache-2.0

At a glance

How it runs
CLI
Works with
Portable with changesOpenAI API
Cost
Free software; you pay for model usage
Setup effort
Medium · a few setup steps
You'll need
PythonPoetryOpenAI API keyTavily API key (optional)LangSmith API key (optional)Shell / CLINetwork accessLocal filesystem
Typical use
Developers learning LangGraph who want to check out project/agentic-rag and cherry-pick commits to see how a RAG graph is assembled step by step.
Not a fit if
  • Developers unwilling to configure API keys, Poetry and multiple branches
  • Teams that want a ready-made production agent instead of learning step by step
Website
udemy.com/course/langchain ↗ set on GitHub
Maintenance
Commits in the last 30 dayslast commit 2026-10-31+0.6 ★/day over 7 days

What does this agent do, and when should you use it?

This repository is the hands-on companion to the Udemy course "LangGraph – Develop LLM-Powered AI Agents". Work is organized as project branches: project/agentic-rag (a RAG pipeline with document grading, web search and adaptive routing), project/ReAct-agent (a reason-and-act loop built in LangGraph), project/reflection and project/reflection-agent (agents that critique and revise their own output), and project/reflexion-agent (an agent that learns from previous runs). Inside each branch, individual commits map one-to-one to lessons, so you can watch a graph grow with git log --oneline. The runnable entry point is main.py, dependencies are managed with Poetry, and configuration lives in a .env file with OPENAI_API_KEY plus optional TAVILY_API_KEY and LANGCHAIN_API_KEY/LANGCHAIN_TRACING_V2. It is teaching material rather than a packaged product: there is no hosted service or deployment manifest, and behaviour depends on the model keys and local setup you provide.

The repo contains several LangGraph sample projects, each driven by main.py, checked out by branch. The Agentic RAG branch walks the full chain in commits: project setup, folder scaffolding, an ingestion pipeline that loads and embeds data, a Graph State that carries memory between nodes, a Retrieve Node that fetches context, a Grade Docs Node that filters for structured relevance, a Web Search Node that calls the Tavily API, and a Generation Node that handles prompting and LLM calls. The graph is then wired with fan-in, fan-out and conditional edges, extended with Self-RAG so the LLM critiques itself, and finished with an Adaptive Router that selects tools dynamically. The ReAct branch implements the classic reasoning-plus-acting loop; the reflection and reflection-agent branches let an agent critique and revise its own output; the reflexion-agent branch feeds lessons from previous runs back into later decisions. Every path reaches external model and search services through keys in .env, with optional LangSmith tracing.

  1. Developers learning LangGraph who want to check out project/agentic-rag and cherry-pick commits to see how a RAG graph is assembled step by step.
  2. Engineers who need to demo a self-correcting retrieval QA flow and want to reuse the Grade Docs Node and Self-RAG ideas in a prototype.
  3. Students or researchers comparing ReAct against reflection/reflexion loops, who can run main.py on each branch and diff the behaviour.
  4. Teams already on the LangChain stack that want a reference for wiring the Tavily web-search tool into multi-step question answering.
  5. Instructors preparing a lesson plan who can map each video to a commit listed in the repository's lesson table.
  6. Developers who want to observe graph execution locally by enabling LANGCHAIN_TRACING_V2 with LANGCHAIN_API_KEY.

Key setup facts

Pulled from the install and usage notes below. The project README has the current values.

Environment variables
OPENAI_API_KEY TAVILY_API_KEY LANGCHAIN_API_KEY
Config files
.env

How do you install or deploy this agent?

The repo expects a Python environment with Poetry. Per the README's Quick Start (note the README spells the repo name langgaph-course; use the real clone URL):

# 1. Clone & enter
$ git clone https://github.com/emarco177/langgaph-course.git
$ cd langgaph-course

# 2. Choose a project branch
$ git checkout project/agentic-rag  # for example

# 3. Install deps (Poetry)
$ poetry install

# 4. Run
$ poetry run python main.py

Then create a .env file in the repository root:

OPENAI_API_KEY=...
TAVILY_API_KEY=...          # optional – for web-search lessons
LANGCHAIN_API_KEY=...       # optional – for LangSmith tracing
LANGCHAIN_TRACING_V2=true   # optional
PYTHONPATH=$(pwd)

How do you use this agent?

Once installed, switch to the branch for the project you want and run the entry script:

$ git checkout project/ReAct-agent
$ poetry run python main.py

Use project/agentic-rag for the full RAG pipeline, project/ReAct-agent for the reasoning-and-acting loop, project/reflection and project/reflection-agent for self-critique and revision, and project/reflexion-agent for learning from past runs. To follow the course lesson by lesson, inspect and rewind the history:

$ git log --oneline
$ git checkout <hash>

The web-search lessons additionally require TAVILY_API_KEY; LangSmith tracing requires LANGCHAIN_API_KEY and LANGCHAIN_TRACING_V2=true.

What are this agent's strengths and limitations?

Pros
  • Branch-as-project and commit-as-lesson structure lets each Agentic RAG, ReAct and reflection flow be checked out and replayed independently.
  • The Agentic RAG branch covers a complete node chain: ingestion, retrieval, document grading, web search, generation, self-correction and adaptive routing.
  • Separate reflection and reflexion branches make it easy to contrast in-place revision with learning from previous runs.
  • Poetry manages dependencies and the .env example documents optional Tavily and LangSmith settings, so the environment story is explicit.
Limitations
  • Running anything requires an OpenAI API key, i.e. paid model calls; no local-model alternative is documented.
  • The README repeatedly misspells the repo as langgaph-course (clone command and branch links), so copying the commands verbatim fails.
  • You must create .env and set PYTHONPATH yourself, with install steps split between Quick Start and the config snippet.
  • There are no versioned releases, Docker or hosted deployment instructions, so production hardening is left to the reader.

How does this agent compare with similar options?

Key facts side by side with the most closely related agents.

Agent Source review Form / cost Stars Updated Language Full support on
LangGraph Course Repo — Build LLM Agents Hands-On This agent 33 · Major gaps CLIFree + model costs ★ 753 21d ago — OpenAI API
Agent Systems Handbook 62 · Some gaps Web appFree ★ 315 1mo ago MDX —
Dive into LangGraph 44 · Major gaps Library / SDKFree + model costs ★ 475 1d ago Jupyter Notebook Claude Code
LangChain 62 · Some gaps Library / SDKFree + model costs ★ 150k today Python OpenAI API

How does FollowAgents rate this agent?

FollowAgents source review · FARS-2.1
Major gaps
33/ 100 5-point scale 1.7 / 5
Trust 5/29
Reliability 2/14
Adaptability 9/18
Convention 8/18
Effectiveness 6/13
Verifiability 3/8
Why each dimension lost points
Trust5 / 29 · 0.9/5

The README shows OPENAI_API_KEY, optional TAVILY_API_KEY, and LangSmith tracing configuration, and describes web search, LLM calls, and data embedding, so some data flows are visible (1). It provides no evidence of permission limits, sensitive-data protections, dependency security, confirmation for external actions, or recovery, so those criteria score 0. Git checkout and commit rewind are suggested for experimentation, but product-operation recovery is not described, so rollback scores 1. The README acknowledges LangChain/LangGraph and links documentation, giving partial attribution, but it does not attribute individual implementations or materials (1).

Reliability2 / 14 · 0.7/5

The README says each branch is a project and each commit a lesson, and lists projects and lesson steps. However, its clone path spells the repository as langgaph-course while the object and links use langgraph-course; some branch links are also misspelled. This limits self-consistency to 1. Poetry installation is mentioned, but there is no lockfile, version constraint, or evidence of dependency availability or alternatives (0). No error handling or troubleshooting guidance is included (0).

Adaptability9 / 18 · 2.5/5

The material clearly targets LangGraph learners and lists Agentic RAG, ReAct, reflection, and multi-step graph scenarios (2). Boundaries are only partially stated through project summaries and optional API keys, with no safety or production-use limits (1). Project branches and lesson commits provide a clear selection path (2). Quick Start names a Python entry point, Poetry, and environment variables, but gives no operating-system, version, or deployment guidance (1).

Convention8 / 18 · 2.2/5

The repository map, lesson sequence, and Quick Start provide a clear structure (2). Setup steps are usable but thin and contain an inconsistent repository spelling (1). The README has inconsistent repository and branch-link spellings, so naming stability scores 0. It includes project examples, lesson steps, community links, and an issue channel, but no FAQ (2). Limitations are not documented (0). The included Apache-2.0 license text is complete (3). Commit history and future updates are mentioned, but there is no release or changelog guidance (1). Community and GitHub Issues provide contact routes, but no named maintainer or response commitment (1).

Effectiveness6 / 13 · 2.3/5

The README describes learning outcomes and how to start, but provides no sample output or demonstrated result (1). The staged projects, graph workflows, and commit-based lessons offer clear learning value for a LangGraph course (2). Setup requires Poetry and an OpenAI key, with optional external services for search and tracing; costs and resource requirements are not estimated (1).

Verifiability3 / 8 · 1.9/5

Feature and course claims can be traced to the README's project list, lesson table, and startup steps, but claims such as “production-grade” are unsupported (1). README and license provide complementary documentation, but no source-code or test material is included to corroborate the course features (1). Required and optional environment variables are distinguished, but factual evidence and promotional claims are not systematically separated (1).

Risks and how to mitigate them
  • Not found in source: least-privilege scopingGrant only what the task needs: a dedicated account or read-only token, scoped to specific directories and repos.
  • Not found in source: confirmation before actingTurn on (or add) a confirmation step before it acts, and try it in a sandbox or test environment before real data.
  • Not found in source: dependency securityPin versions and run a dependency audit (npm audit, pip-audit) before installing; prefer running it in a container.
  • Not found in source: disclosed external effectsEstablish which external systems it writes to, sends to or changes, and verify with test accounts or repos before production.
  • Check the repository and branch-link spellings before following the setup instructions; the README contains inconsistent names and links.
  • The setup calls for an OpenAI key, and some lessons may use Tavily and LangSmith. The supplied material does not explain costs, data retention, or failure recovery.
Evidence confidence: Low Reviewed Nov 08, 2026 Reviewed revision d35e10e8286d
Review evidence README.mdLICENSE
See the full review method →
Maintain this project? Add the FARS badge to your README

The badge shows the current review score and verdict and links back to this page. It refreshes about once an hour after a re-review.

FARS

[![FARS review](https://followagents.com/badge/langgraph-course.svg)](https://followagents.com/en/agents/langgraph-course)
<a href="https://followagents.com/en/agents/langgraph-course"><img src="https://followagents.com/badge/langgraph-course.svg" alt="FARS review"></a>

FAQ

Does using this repository cost money?
The code is free, but you supply OPENAI_API_KEY and pay per model call. TAVILY_API_KEY and LANGCHAIN_API_KEY are optional and used for web search and LangSmith tracing respectively.
Which branch should I start with?
The README quickstart uses project/agentic-rag as its example. For the smallest conceptual step, start with project/reflection, then move through ReAct, reflection-agent, reflexion-agent and finally agentic-rag.
The clone URL looks wrong — what should I use?
The README writes langgaph-course, but the repository is langgraph-course. Clone https://github.com/emarco177/langgraph-course.git and adjust the cd target accordingly.
Can I run it without web search?
Yes. Only the lessons involving the Web Search Node need TAVILY_API_KEY; the rest run with just OPENAI_API_KEY configured. Network access to the model endpoint is still required.
Is this ready for production deployment?
It is course companion material organized by branches and commits, with no releases, containers or deployment orchestration. Treat it as a reference to adapt, not a deployable service.
Is LangGraph Course Repo — Build LLM Agents Hands-On open source?
Yes. The source code is on GitHub (emarco177/langgraph-course) under the Apache-2.0 licence.
Is LangGraph Course Repo — Build LLM Agents Hands-On safe to use?
FollowAgents' FARS review (Nov 08, 2026) scored LangGraph Course Repo — Build LLM Agents Hands-On 5/29 on trust and safety. The review did not find these safety controls in the source: least-privilege scoping, confirmation before acting, dependency security, disclosed external effects. Before giving it real accounts or data: Grant only what the task needs: a dedicated account or read-only token, scoped to specific directories and repos.
Is LangGraph Course Repo — Build LLM Agents Hands-On still maintained?
Yes. The latest commit on GitHub is from 2026-10-31, within the last 30 days.
Who makes LangGraph Course Repo — Build LLM Agents Hands-On?
LangGraph Course Repo — Build LLM Agents Hands-On is published on GitHub by the account emarco177. FollowAgents has not verified which person or company is behind that account.
What is LangGraph Course Repo — Build LLM Agents Hands-On's official website?
The project's GitHub repository lists https://www.udemy.com/course/langchain/ as its website. That link is set by the repository owner; the source code itself is on GitHub (emarco177/langgraph-course).
Was this page helpful?
View on GitHub ↗ Install ↓

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related concepts