Python and LLM basics
Every agent on this path is Python code that talks to a language model. This stage takes the core of two courses: enough Python to write functions, classes, Pydantic models and async code, and enough about models to know what tokens, temperature and a system prompt do to the answer you get back. It ends with a ticket sorter that sends real tickets to a real model and scores what comes back. Skip what you already know, but do the project either way.
Python for AI
LLM FundamentalsLangChain agents
LangChain is where the agent appears. You start with messages and a chat model, turn Python functions into tools, and hand both to create_agent, which runs the loop: call the model, run the tool it picked, call the model again, until it has an answer. Then you give the agent short-term memory, middleware around every model call, and a pause for a person before a risky tool runs. The stage ends with the desk project, an assistant you build, guard and test across five short lessons.
LangChainLangGraph workflows
create_agent hides the loop. LangGraph shows it. You write the agent as a graph: a state object, nodes that read and update it, and edges that decide what runs next, including branches and loops. Then you build the agent loop yourself, save every step with a checkpointer, pause it with an interrupt, stream its progress, and put a supervisor over several agents. The support agent at the end is the base the capstone grows from.
LangGraphRetrieval and RAG
A support agent that makes up a refund policy is worse than no agent. Retrieval-augmented generation fixes that: split your documents, turn the pieces into vectors, store them, and let the agent search them before it answers. You build it twice, as a retrieval tool for a LangChain agent and as nodes in a LangGraph graph that can refuse when it finds nothing, which is the shape the capstone uses.
LangChainLangGraphMCP tools and long-term memory
Two things turn a support agent into a useful one: tools that live outside its code, and memory that outlasts one conversation. MCP puts tools behind a standard server, so any agent can call them over stdio or HTTP. LangMem pulls facts and events out of conversations and stores them, so the agent can search them next time. Each course has its own project as the checkpoint.
Model Context Protocol
LangMemDeep Agents
Some tasks are too long for a single loop. The agent needs a plan, somewhere to keep notes, and helpers it can hand parts of the work to. Deep Agents builds that on LangGraph: create_deep_agent comes with a todo list, a virtual filesystem and subagents, and you add backends, AGENTS.md memory, skills and human approval.
Deep AgentsGuardrails and safety
From here the path follows the Complete AI Security Course. An agent that answers anything will answer the wrong things: off-topic questions, jailbreaks, requests that leak data. You start with LangChain's guardrails middleware, then move to NeMo Guardrails, where rules live in a config folder: input rails check a message before the model sees it, output rails check the answer before the user does, and dialog rails fix how whole kinds of message are answered.
LangChain
NeMo GuardrailsEvaluation with RAGAS
A guarded agent can still be wrong. RAGAS measures how wrong. You write goldens, questions with answers you trust, run the RAG app over them, and score each answer for faithfulness to what was retrieved, relevance to the question, and correctness. Then you run it as an experiment you can compare later and wire it into CI, so a bad change fails before it ships.
RAGASProduction
The last thing to learn is running the agent for real. A model gateway puts one endpoint in front of every provider. LangGraph's deploy lesson serves the graph locally with a config file, LangSmith records every run so you can read it back, and LangChain's retry and fallback middleware keeps one provider's bad minute from taking the agent down.
LiteLLMLangGraphLangChainCapstone
One support agent that uses everything on this path. It is a LangGraph graph that answers from your policy documents, calls order and refund tools over MCP, remembers each customer with LangMem, runs every message through NeMo input and output rails, and stops for a person before any refund. You score it with RAGAS on a set of goldens and trace every run in LangSmith. When it is done, you have built the job this roadmap is named after.
LangGraphModel Context ProtocolLangMemNeMo GuardrailsRAGASAgentic AI engineer
10 stages, 9 frameworks and 1 projects. Finish them and you will have shipped the kind of systems these teams hire for, with the lessons to back every one.
Browse all frameworksQuestions about this roadmap
What does an agentic AI engineer do?
They build applications where a language model decides the next step: which tool to call, what to look up, what to remember, and when to stop and ask a person. The job covers the agent itself, the retrieval and tools it depends on, the rails that keep it on topic, and the evaluation that shows its answers are right.
Can I start this roadmap as a beginner?
Yes. The first stage is the core of Python for AI and LLM Fundamentals, so you start from variables and lists and learn what a token and a system prompt are before you build an agent. Every later stage assumes only the stages before it.
Do I need an API key or a paid model account?
You need free keys, not paid ones. A free Groq key runs the chat model across the courses, and a free Gemini key from Google AI Studio covers embeddings in the memory and evaluation lessons. No lesson needs an OpenAI key. Claude Code is an optional companion for writing and fixing code as you go; it needs a paid plan, and nothing on this path depends on it.
How is this different from the AI Forward Deployed Engineer roadmap?
This roadmap is about building agents: it goes deep on one stack, LangChain, LangGraph, LangMem, Deep Agents, MCP, NeMo Guardrails and RAGAS, in the order the channel's courses teach it, so each stage builds on the code from the one before. The AI Forward Deployed Engineer roadmap uses the same agent skills inside a wider six-month path that adds software foundations, deployment, enterprise integration and the consulting work of shipping a system for a client.
Why does the LiteLLM stop say coming soon?
The LiteLLM course is being rebuilt in the same video-grounded format as the rest of this path, so its stop is locked until it is ready. You can finish the roadmap without it by marking the stop done by hand, and the course opens in the same place when it is finished.
Where do the videos come from?
From Krish Naik's YouTube channel, mostly the Complete Agentic AI Course In 10 Hours and the Complete AI Security Course In 8 Hours. Each lesson embeds the part of the video that covers the same idea, and the code under it is run against current library versions, so where a library has changed since the recording, the lesson says what changed.