
Already know some of this? A 2-minute test skips the lessons you know.
Take the placement testA free 30-lesson course built from AaiTech's 4h 36m of YouTube playlist. 3 days at 90 minutes a day, with study notes and a quiz in every lesson. A 2-minute placement test skips what you already know.
Taught by AaiTech on YouTube. Videos play in YouTube's own player, so the creator keeps every view.
Understand LangGraph's core concepts—directed graphs, nodes as decision-makers, edges as data carriers, and state as shared information—to explain why developers choose it for reliable, controllable agentic AI applications.
Implement a complete LangGraph application: install dependencies, configure a Gemini LLM, define a typed state, create an agent node and a weather tool node, wire them with directed edges, compile the graph, and invoke it with sample queries.
Understand what conditional edges are and why they enable dynamic, intent-based routing in LangGraph workflows.
Create a TypedDict state with user message and agent response, then build an agent node that extracts conversion parameters or returns a natural language reply.
Implement a tool node that calls the Frankfurter API to fetch real-time exchange rates and returns structured conversion data.
Connect nodes using `add_node`, `add_edge`, and `add_conditional_edge`; set the entry point; compile and visualize the Mermaid graph.
Understand the problems of stateless agents, the need for memory to maintain context across turns, and the two memory types: stateless (no history) and stateful (maintains context).
Navigate the LangSmith UI to view thread histories, per-step token breakdowns, input/output cost ratios, and observe how growing history inflates input token costs.
Understand what LLM streaming is, why it improves user experience by reducing perceived latency, and how autoregressive decoding generates tokens sequentially.
Compare token selection strategies—greedy decoding, beam search, top-k sampling, top-p (nucleus) sampling, and temperature—to control randomness and output quality in LLM generation.
Provision an Azure OpenAI resource, deploy a GPT-4 model, retrieve endpoint and key, and construct a minimal LangGraph with a single conversation node and checkpointing.
Distinguish between 'updates' (delta-only) and 'values' (cumulative state) streaming modes in LangGraph, and observe how each emits node-level outputs during graph execution.
Use `astream_events` with metadata filters (`langgraph_node`, `langgraph_type`) to capture raw token chunks from the LLM node, then extract and print streaming content in real time.
Learn to define a shopping agent's system prompt, create three Python tools (check price, add to cart, calculate total), bind them to an Azure OpenAI LLM, and construct the LangGraph state graph with nodes and edges.
See how to insert a breakpoint before tool execution using `interrupt_before='tools'` during graph compilation, add a memory checkpointer, and visualize the resulting Mermaid diagram showing the interruption point.
Execute the graph stream until the first interruption, inspect the proposed tool call (check_price for 'apple'), verify correctness, and resume execution by passing `None` to continue the thread.
Retrieve and inspect the graph state to confirm the next node is 'tools', execute the tool call, observe the result, and continue the stream to completion for a multi-tool interaction (adding chocolates to cart).
Build a loop that pauses at each tool call, prompts for human yes/no approval, and automatically resumes the graph upon confirmation, demonstrating a complete human-in-the-loop cycle for adding apples and bread to the cart.
Understand the motivation for editing graph state mid-execution to avoid wasting tokens and waiting for long generations, and see how LangGraph's interrupt-before-agent pattern enables pre-LLM corrections.
Launch LangGraph Studio, enable interrupts, submit a question, use the 'Edit node' UI to change the request (e.g., 10 → 5 apples), fork the state, approve the tool step, and inspect the revised final answer.
Understand the real-world use case of automating automobile warranty claim validation using a multi-agent LangGraph system that compares structured claim data against an unstructured policy PDF.
Set up the Python project using UV package manager, install dependencies, and configure Azure OpenAI credentials (endpoint, key, model deployment) for LLM access.
Create `app.py` with Streamlit to upload claim CSVs, display policy text, invoke `process_claim`, and render results with summary cards, detailed evidence tables, downloadable CSV, and per-row agent tracing for debugging.
Recaps the multi-agent warranty fraud detector built with LangGraph in the previous video and outlines the deployment agenda using Docker and Azure Web App.
Walks through creating a Dockerfile step-by-step: selecting a Python 3.11-slim base image, setting a work directory, copying project files, installing dependencies, exposing port 8501, and defining the Streamlit run command.
Covers Docker Desktop installation, verifying the CLI, building the Docker image with a tag, and inspecting the resulting image layers in Docker Desktop.
Provisions a Resource Group, creates a Linux Web App on a Basic plan, and sets up an Azure Container Registry (ACR) to host the Docker image.
Creates a .dockerignore file to exclude the local .env file, rebuilds and pushes a clean image, then configures Azure Web App Application Settings to inject API keys securely at runtime.
Tests the deployed app end-to-end, confirms it works without baked-in secrets, and deletes the Resource Group to avoid ongoing Azure charges.