How to Build Agentic AI Apps With LangGraph and MCP

TL;DR

LangGraph lets developers build controllable AI agents using graph primitives like states, nodes, and edges. This Part 1 crash course covers the fundamentals: building a basic chatbot, integrating single and multiple tools, adding memory and human-in-the-loop feedback, streaming techniques, and implementing an MCP server from scratch, using the UV package manager for fast environment setup.

Transcript

hello guys so welcome to this amazing crash course on building agentic AI application with the help of Langraph this entire crash course has been divided into three important parts and each and every part will be somewhere around 2 to three hours of videos right and here you can basically see what in which way we are going to cover all the topics a... Read More

Key Insights

• The crash course is divided into three parts, each roughly two to three hours long. Part 1 covers fundamentals (~2h50m), Part 2 covers advanced concepts (~2h), and Part 3 focuses on end-to-end projects and deployment.
• Part 1 teaches core building blocks: how to build a chatbot, integrate one or multiple tools, add memory, add human-in-the-loop feedback, use streaming techniques, and build MCP completely from scratch using the graph API.
• LangGraph is built for reliability and controllability, letting developers steer agent actions with moderation checks and human-in-the-loop approvals while persisting context for long-running workflows to keep agents on course.
• The UV package manager is used instead of conda for environment setup. Written in Rust, it is described as 10 to 100 times faster than pip and replaces tools like pip, poetry, pyenv, and twine in one.
• Part 2 covers advanced LangGraph concepts including multi-agent workflows where agents communicate with other agents to solve complex tasks, multi-state management, the functional API, and debugging in LangGraph Studio.
• Part 3 focuses on building end-to-end projects, covering the LLMOps pipeline, deployment techniques, and evaluation metrics using open-source tools like MLflow, AWS for tracking, Grafana for reports, and Hugging Face Spaces for deployment.
• The graph API is presented as the most efficient way to learn LangGraph. A functional API also exists and is covered later, but the instructor recommends starting with the graph API to understand core components.
• Project setup uses uv init to initialize the workspace (creating gitignore, python-version, main.py, and pyproject.toml), uv venv to create the virtual environment on Python 3.13.2, and uv add ipykernel to enable running code in Jupyter notebooks.

Questions & Answers

Q: What is the LangGraph agentic AI crash course structure?

The crash course is divided into three important parts, each roughly two to three hours of video. Part 1 covers fundamental techniques for building agentic AI applications and runs approximately two hours fifty minutes. Part 2 covers advanced LangGraph concepts and is around two hours. Part 3 focuses on building complete end-to-end projects, including deployment. This structure moves learners progressively from fundamentals toward production-grade applications.

Q: What topics are covered in Part 1 of the course?

Part 1 covers various fundamental techniques important for building agentic AI applications. These include how to build a chatbot, how to integrate a single tool and multiple tools into a chatbot, how to add memory, how to add human-in-the-loop feedback while executing the graph state, different streaming techniques, and how to build MCP completely from scratch. It also covers core concepts like states, graphs, nodes, edges, and using the graph API.

Q: Why does the course use the UV package manager?

The course uses UV because it is a really fast, extremely fast Python package and project manager completely written in Rust, which makes it very fast. It is highlighted as 10 to 100 times faster than pip and acts as a single tool to replace pip, pip-tools, pipx, poetry, pyenv, twine, and virtualenv. It also installs and manages different Python versions within the same project, so creating environments and installing packages happens very quickly.

Q: How do you set up a LangGraph project environment with UV?

First run uv init in the project workspace, which creates files including gitignore, a python-version file, main.py, and pyproject.toml, defaulting to Python 3.13. Next, create a requirements file listing libraries like langgraph, langchain, and langsmith. Run uv venv to create a virtual environment (created with version 3.13.2), activate it, then install dependencies. For Jupyter, also run uv add ipykernel since it is required to run anything in the notebook.

Q: What is covered in Part 2 of the LangGraph course?

Part 2 covers advanced LangGraph concepts, focusing on various kinds of workflows and agents. A key topic is developing applications where agents communicate with other agents to solve a complex workflow. It also covers handling multi-state management even in multi-agent setups, using the functional API directly instead of only graph APIs, and how to debug and monitor applications in LangGraph Studio. These fundamentals are a step toward developing production-grade applications, and Part 2 runs around two hours.

Q: What will Part 3 of the course teach?

Part 3 focuses on building completely end-to-end projects. It covers the LLMOps pipeline and deployment techniques. The instructor also explores evaluation techniques and metrics specifically for LLMs and how to use them with LangGraph. It uses open-source tools like MLflow, AWS to track metrics, and Grafana to display reports. Deployment is demonstrated using Hugging Face Spaces. This is described as a tentative plan to complete the LangGraph crash course.

Q: Why does the instructor recommend using the graph API to learn LangGraph?

The instructor states that the most efficient way of learning LangGraph is specifically using the graph API. While there is another API called the functional API that is also covered later in the course, the instructor recommends starting with the graph API. Before building the basic chatbot, the video emphasizes understanding some important components of LangGraph, and the graph API functionality is used as the primary approach for developing the initial chatbot application.

Q: What makes LangGraph suitable for building AI agents?

According to the description, LangGraph is built for developers who want powerful, adaptable AI agents. It offers reliability and controllability, letting developers steer agent actions with moderation checks and human-in-the-loop approvals while persisting context for long-running workflows. It is low-level and extensible, using descriptive primitives free from rigid abstractions and supporting scalable multi-agent systems. It also provides first-class streaming support with token-by-token streaming and streaming of intermediate steps for visibility into agent reasoning.

Q: How do you build a basic chatbot in LangGraph according to the video?

The video builds a basic chatbot using LangGraph's graph API inside a Jupyter notebook. After setting up the UV environment and installing langgraph, langchain, and langsmith, the instructor creates a basic_chatbot.ipynb file, selects a kernel, and adds ipykernel via uv add. Before writing the chatbot code, the instructor stresses understanding LangGraph's important components first. The graph API is chosen as the most efficient learning approach for developing the basic chatbot application step by step.

Summary & Key Takeaways

• This Part 1 crash course teaches building agentic AI applications with LangGraph. The full course spans three parts of two to three hours each. Part 1 covers fundamentals including chatbots, tool integration, memory, human-in-the-loop feedback, streaming, and MCP, plus core concepts like states, graphs, nodes, and edges.

• Part 2 addresses advanced LangGraph concepts, focusing on workflows and agents that communicate with other agents to solve complex tasks. It also covers multi-state management, the functional API as an alternative to graph APIs, and debugging and monitoring applications in LangGraph Studio toward production-grade builds.

• Part 3 targets end-to-end projects, the LLMOps pipeline, and deployment techniques. It explores evaluation metrics for LLMs using open-source tools like MLflow, AWS for metric tracking, and Grafana for displaying reports, with deployment handled through Hugging Face Spaces.

• For setup, the course uses the UV package manager, a fast Rust-based Python tool that is 10 to 100 times faster than pip. Steps include uv init to initialize the workspace, adding libraries like langgraph, langchain, and langsmith to requirements, and uv venv to create a virtual environment.

• The hands-on portion begins by building a basic chatbot using LangGraph's graph API in a Jupyter notebook. The instructor selects a kernel, adds ipykernel via uv, and prepares to explain the important components of LangGraph before writing the chatbot code, emphasizing step-by-step practice.