Generative AI and agentic AI
Generative AI and agentic AI is the work of building software on large language models: programs that write and reason in text, answer questions from your own documents, call tools, and repeat a task until it is done.
Last updated: 08 Oct, 2026 · LangChain 1.4 · LangGraph 1.2
This course builds that software in Python, one working piece at a time. Each lesson makes one thing, runs it against a real model, shows what came back and explains every line a beginner needs. The code runs on free keys, and the whole course needs two of them.
What you will build
- A language-model app in a few lines of Python: a prompt in, a reply out, then messages, streaming, structured output and memory. It starts in Your first LLM app.
- A question-answering system over your own documents (RAG): load, split, embed, retrieve and answer with sources, then measure the answers. It starts with Retrieval-augmented generation (RAG).
- An agent that picks its own tools, remembers the conversation, asks a person before a risky step and works with other agents. It starts with AI agents.
- A loop that checks its own work: a writer agent, a reviewer agent, a verifier and a stop condition. It starts with Loop engineering.
- A harness around a model: routing, guardrails and a trace for a customer-support assistant. It starts with Harness engineering.
- A smaller, cheaper model: quantization, LoRA and QLoRA, with the arithmetic run in NumPy so you can see the numbers. It starts with Quantization.
- The habits of a production app: evaluation, gateways, cost and latency. They start with Evaluating LLM apps.
The learning path
Read the parts in order. Each part uses what the earlier ones built: RAG calls the models from the second part, agents use both, and the loop and harness parts are built from agents. The fine-tuning part needs only the first two parts.
Lessons by part
Who this course is for
- Python developers who want to build with language models and have not called one from code yet.
- Data scientists and ML engineers who know models and want to build applications and agents around them.
- Students who use ChatGPT and want to know how such a tool is made.
The lessons start from a blank file and explain tokens, embeddings, tools and agents as they come up. Nothing before the quantization lessons needs mathematics beyond arithmetic.
What to know first
- Basic Python: variables, functions, lists, dictionaries and imports. If those are new, Python for AI teaches them on one AI program.
- Running a script or a notebook and typing a command in a terminal. Installing Python for generative AI shows every step.
- Nothing about machine learning or LangChain. The first lessons explain what a language model is, and every idea the first model calls use is explained where they are made.
- Two free API keys, a Groq key and a Google key, set up in Installing Python for generative AI. No credit card is needed.
How a lesson reads
- One bold sentence defines the topic, and the line under it gives the date and the library versions the lesson was run on.
- Small pieces of code come first, each one explained, then one complete program that runs. The output under it is what a real run printed.
- Examples marked live call a hosted model. Replies differ in wording from run to run, so the text under a live example describes the run shown, not a promise about yours.
- Clips from the videos sit above the section they cover. Where a video shows an older call or a model that no longer exists, the page says what the video does and what the page uses instead.
- A comparison, a Watch out box and a Try it close each lesson: two or three small changes to make to the code you ran.
The videos and repositories behind the lessons
The lessons follow these videos and the repositories that come with them. The loop and harness demos come from the repositories linked in that video's description.
| Material | What it feeds | Kind |
|---|---|---|
| Complete Agentic AI Course In 10 Hours | LangChain, LangGraph, RAG, vectorless RAG, deep agents, guardrails, evaluation and gateways: the main source for the second, third, fourth and eighth parts | Video |
| Complete RAG Crash Course With Langchain In 2 Hours | The RAG part: loading, chunking, embeddings, vector stores and the pipeline | Video |
| Mastering LLM Chatbots And RAG Evaluation Crash Course | Evaluating RAG and LLM apps | Video |
| Agentic AI With Langgraph And MCP Crash Course-Part 1 | ReAct agents, human in the loop and MCP | Video |
| Loop Engineering And Harness Engineering Crash Course | The loop engineering and harness engineering parts, with their demos | Video |
| Generative AI Fine Tuning LLM Models Crash Course | Quantization, 1-bit models, LoRA, QLoRA and fine-tuning | Video |
| Generative AI Vs Agentic AI Vs AI Agents, AI vs ML vs DL vs Generative Ai, What is Agentic AI? Important For GEN AI In 2025 | The first part: what generative AI, agents and agentic AI are | Videos |
| krishnaik06/Langchain-V1-Crash-Course | The LangChain notebooks: models, tools, messages, structured output, middleware | Repository |
| krishnaik06/Agentic-LanggraphCrash-course | The LangGraph and MCP notebooks | Repository |
| krishnaik06/RAG-Tutorials | The RAG notebooks, agentic RAG, RAG evaluation and PageIndex vectorless RAG | Repository |
| krishnaik06/Deep-agents-With-Langchain | A deep agents demo project | Repository |
| krishnaik06/Finetuning-LLM | The fine-tuning notebooks | Repository |
Where to go deeper
Each lesson teaches the part of a framework it needs, then points to a full course for the rest.
- LLM Fundamentals: tokens, next-token prediction, temperature, context windows, cost and speed on a real model.
- Natural Language Processing: text preprocessing, embeddings, RNNs and the transformer, step by step.
- LangChain and LangGraph: the two frameworks the lessons use, covered in full.
- Model Context Protocol, Deep Agents, RAGAS, DeepEval, LiteLLM and Guardrails AI: one course each for the tools named in the later parts.
Related
Every expert started right here.