UDEMY.AI.Agent.Engineering.Build.Production.Ready.AI.Agents.2026.BOOKWARE-MiMiR

Section

Appz

Group

MiMiR

Size

47,67 GB

Files

88

Date

2026-10-30

NFO

Mimir, Keeper of the Well of Wisdom
  AI Agent Engineering: Build Production-Ready AI Agents
  https://www.udemy.com/course/ai-agent-engineering/
  Year         : 2026
  Language     : English
  Level        : All Levels
  Category     : Development
  Subcategory  : Software Engineering
  Duration     : 37h 10m
  Lectures     : 292
  Rating       : 4.7/5 (1,319 reviews)
  Students     : 9,989
  INSTRUCTOR(S)
  HEADLINE
    Master AI Agents, RAG, MCP, Memory, Planning, Multi-Agent
    Systems, LangGraph, CrewAI and LangChain in 21 Days
  WHAT YOU'LL LEARN
  * Build AI agents from scratch using Python and understand the
    core architecture behind modern AI agents.
  * Build AI assistants with conversation memory, tool usage,
    document processing, and Retrieval-Augmented Generation
      (RAG).
  * Design autonomous AI agents with planning, reasoning,
    memory,
    and advanced RAG capabilities.
  * Build and integrate AI agents using the Model Context
    Protocol
    (MCP) and connect them to external tools and data sources.
  * Design and orchestrate multi-agent systems where multiple
    specialized AI agents work together to solve complex
      problems.
  * Build production-ready AI agents using LangGraph, CrewAI,
    and
    LangChain.
  * Build a complete AI Research Agent capable of researching
    information, verifying findings, maintaining research notes,
    and generating structured reports.
  * Deploy AI agent applications and build a complete Research
    AI
    Agent Platform as a capstone project.
  REQUIREMENTS
  * No prior experience with AI agents, RAG, MCP, LangGraph,
    CrewAI, or LangChain is required. Everything is explained
      and
    built step by step.
  * Basic familiarity with computers and a willingness to learn
    programming is enough to get started.
  * No advanced Python knowledge is required. The course
    introduces and explains important Python concepts such as
    variables, input, lists, functions, loops, and other
    fundamentals as needed.
  * A computer with a stable internet connection is required for
    following the practical exercises and building the projects.
  * You should be willing to write code, experiment, and learn
    by
    building real AI applications throughout the 21-day journey.
  WHO IS THIS COURSE FOR
  * Beginners who want to learn how to build AI agents and AI-
    powered applications from the ground up.
  * Python learners and developers who want to move beyond basic
    programming and start building practical AI systems.
  * Software developers and engineers who want to understand
    modern AI agent architecture, including RAG, memory,
      planning,
    MCP, and multi-agent systems.
  * AI and machine learning enthusiasts who want hands-on
    experience building autonomous and production-ready AI
      agents.
  * Students and professionals who want to learn popular AI
    agent
    frameworks such as LangGraph, CrewAI, and LangChain through
    practical projects.
  * Anyone who wants to learn by building real-world AI
    projects,
    including a complete AI Research Agent and Research AI Agent
    Platform.
  DESCRIPTION
  Welcome to AI Agent Engineering: Build Production-Ready AI
  Agents ? a 21-day practical journey designed to take you from
  the fundamentals of AI applications to advanced AI agent
  systems. Throughout the course, we will build, experiment, and
  progressively add capabilities such as memory, tools, RAG,
  planning, MCP, multi-agent systems, orchestration, and
  deployment. Also we will learn to use Frameworks LangGraph,
  CrewAI, LangChain to develop AI Agents. And at the end of the
  journey, we will bring many of these concepts together to
    build
  an AI Research Agent and a Research AI Agent Platform. What
    will
  you learn? During this 21-day journey, you will progressively
  learn: Day 1?6: Build the Foundation Build your first AI
    chatbot
  using Python Add conversation memory Learn prompt engineering
  Teach AI assistants to use tools Build applications that can
  work with documents Build your first RAG system Day 7?13:
    Enter
  the World of AI Agents Build your first AI Agent Understand
  Model Context Protocol (MCP) Build autonomous AI agents Learn
  advanced agent planning Explore memory engineering Build
  advanced RAG systems Understand MCP in greater depth Day
    14?15:
  Advanced & Production-Ready Agents Understand multi-agent
  systems Learn agent orchestration Explore how to make AI
    agents
  production-ready Day 16?19: Agent Engineering Frameworks You
  will work with: LangGraph CrewAI LangChain The focus is not
    only
  on using frameworks, but on understanding how they can be used
  to build and structure AI agent applications. Day 18?21: Build
  the Research AI Agent You will build an AI Research Agent,
  explore deployment, and finally bring the concepts from the
  course together in the capstone project: Research AI Agent
  Platform. Learn by Building This is a practical course.
    Instead
  of learning concepts in isolation, we progressively build
  systems and add new capabilities to them. You will see how
  individual concepts such as: LLMs ? Memory ? Tools ? RAG ?
  Agents ? Planning ? MCP ? Multi-Agent Systems can
    progressively
  come together to create more sophisticated AI applications.
    The
  objective is not simply to complete 21 days of videos. The
  objective is to develop the understanding and practical
  experience required to build AI agents yourself. Who is this
  course for? This course is suitable for: Developers Software
  Engineers Students AI Enthusiasts Developers interested in
  Generative AI Anyone who wants to learn how AI agents are
  engineered You don't need to know everything about AI before
  starting. However, you should be comfortable with working on
  computers. How should you approach this course? Don't just
    watch
  the videos. Watch ? Code ? Experiment ? Understand ? Build
    Pause
  the videos and write the code yourself. Experiment with the
  examples. Change things. Try different approaches. Make
    mistakes
  and learn from them. The goal is not simply to reach Day 21.
    The
  goal is to develop the ability to understand and build AI
    agent
  systems. Start Your AI Agent Engineering Journey AI is
    evolving
  rapidly, with new models, frameworks, protocols, and
    techniques
  appearing continuously. This course is designed to give you a
  practical foundation in the concepts and engineering
    approaches
  behind modern AI agents. By the end of this journey, you will
  have explored the major building blocks of AI Agent
    Engineering
  and used them to build increasingly sophisticated systems. So,
  are you ready? Start the 21-day journey and let's build AI
  agents.
  COURSE CONTENT
  Chapter 1: Introduction
    1. Welcome to AI Agent Engineering: Your 21-Day Journey
    2. A Glimpse of A Project From This Course
  Chapter 2: Day 1: Build Your First AI Chatbot using Python
    3. Create Your First AI Application: A Simple AI Assistant
    4. How Does an AI Assistant Answer Questions?
    5. What Is an API?
    6. Setting Up Your Development Environment
    7. Install Ollama
    8. Practical Setup: Install and Test Your AI Development
       Environment
    9. Create Your Project Folder and Virtual Environment
    10. Your First AI Program: Create Configuration
    11. Writing Your First AI Program
    12. Practical Demo: Run Your First AI Program in VS Code
    13. Experiment Time: Explore Your First AI Application
    14. Build Your First AI Assistant
    15. Build Your First AI Assistant ? Updating the Program
    16. Practical Demo: Build and Run Your AI Assistant
    17. Experiment Time: Explore Your AI Assistant and
        Understand Its Limitations
    18. Day 1 Review: What We Built and What We Learned
  Chapter 3: Day 2: Build an AI Assistant That Remembers:
    Conversation Memory
    19. Build an AI Assistant That Remembers
    20. How Conversation Memory Works
    21. Store Conversation History Using Python Lists
    22. Store User and Assistant Messages
    23. Give Memory to Our AI Assistant
    24. Store the AI's Responses
    25. Run the Complete AI Assistant with Memory
    26. Practical Demo ? Build and Test Your AI Assistant with
        Memory
    27. Inspect Your AI Assistant's Memory
    28. Practical Demo ? Inspect and Understand Conversation
        Memory
    29. Practical Demo ? Improve the Conversation Memory Display
    30. Day 2 Review ? Understanding Conversation Memory
  Chapter 4: Day 3: Prompt Engineering: Teach Your AI Assistant
    How to Behave
    31. Teach Your AI Assistant How to Behave
    32. What Is a System Prompt?
    33. How System Prompts Change AI Behavior
    34. Designing AI Behavior with System Prompts
    35. Add a System Prompt to Our AI Assistant
    36. Practical Demo ? Change Your AI Assistant?s Personality
    37. System Prompts and Assistant Configuration
    38. Let the User Choose the Assistant
    39. Configure the Assistant Based on User Choice
    40. Polish and Extend Your AI Assistant
    41. Final Practical Demo ? Build Your Multi-Role AI
        Assistant
    42. Day 3 Review ? Prompt Engineering
  Chapter 5: Day 4: AI Tools: Teach Your AI Assistant to Use
    Tools
    43. Teach Your AI Assistant to Use Tools
    44. What Is an AI Tool?
    45. Building AI Tools with Python
    46. Building Our First Tool: Current Date and Time
    47. Testing and Building More Python Tools
    48. Building Tool #3: Secure Password Generator
    49. Practical Demo: Build and Test Your Python Tools
    50. Our Toolbox Is Growing: Designing Reusable AI Tools
    51. Connecting Tools to Our AI Assistant: Making Decisions
    52. Connect Our First Tool to the AI Assistant
    53. Connect All Our Tools to the AI Assistant
    54. Improving Tool Selection: Handling Different User
        Requests
    55. Practical Demo: Connect and Test Your AI Tools
    56. Refactoring Our Assistant: Building a Tool Manager
    57. Practical Demo: Build and Test the Tool Manager
    58. Integrating the Tool Manager with Our AI Assistant
    59. Practical Demo: Integrate the Tool Manager with Your AI
        Assistant
  Chapter 6: Day 5: Document AI: Teach Your AI Assistant to Read
    Files
    60. Teach Your AI Assistant to Read Files
    61. Reading Your First Text File with Python
    62. Testing and Improving the File Reader Tool
    63. Practical Demo: Build and Test the File Reader Tool
    64. Making Your Assistant Understand Files
    65. Send File Content to the AI Model
    66. Explain Different Documents with the Same AI Assistant
    67. Practical Demo ? Make Your Assistant Understand and
        Explain Files
    68. Ask Questions About a Document
    69. Practical Demo ? Build Your Document Q&A Assistant
    70. Understanding Why We Need RAG
  Chapter 7: Day 6 :  Build Your First RAG System
    71. Why Do We Need RAG?
    72. Building a Knowledge Base with Multiple Documents
    73. Build a Python Document Retriever
    74. Practical Demo ? Build Your First Knowledge Base and
        Retriever
    75. Build a Simple Keyword-Based Retriever
    76. Practical Demo ? Build and Test the Keyword Retriever
    77. Understanding Embeddings and Semantic Search
    78. How Embeddings Represent Meaning
    79. Generate Your First Embeddings with Ollama
    80. Generate and Explore Embeddings
    81. Practical Demo ? Install and Test the Embedding Model
    82. From Embeddings to Semantic Search
    83. Finding the Most Similar Document with Cosine Similarity
    84. Calculate Similarity Between Embeddings
    85. Practical Demo ? Build Your Cosine Similarity Tool
    86. Build a Semantic Document Retriever
    87. Building Your First Complete RAG Application
    88. Completing Your End-to-End RAG Application
    89. Practical Demo ? Build the Complete RAG Pipeline
  Chapter 8: Day 7: Build Your First AI Agent
    90. What Is an AI Agent?
    91. How AI Agents Plan and Choose Tools
    92. Building the Agent?s Brain
    93. Building Our First Planning Agent
    94. Testing and Connecting the Planning Agent
    95. Practical Demo ? Build and Test the Planning Agent
    96. Let the AI Assistant Speak Naturally
    97. Practical Demo ? Connect the Planner to Your AI
        Assistant
  Chapter 9: Day 8 : Model Context Protocol (MCP)
    98. What Is Model Context Protocol (MCP)?
    99. Understanding the MCP Architecture
    100. Building Your First MCP Server
    101. Building Our First MCP Client
    102. Understanding and Testing the MCP Client
    103. Practical Demo ? Build and Test Your MCP Server and
         Client
    104. Building the AI Agent with MCP
    105. Practical Demo ? Build the AI Agent with MCP
    106. Connecting the Planner to the MCP Tools
    107. Practical Demo ? Connect Ollama with the MCP Planner
    108. Completing the MCP-Powered AI Agent
    109. Running and Testing the MCP-Powered AI Agent
    110. Practical Demo ? Complete and Run the MCP-Powered AI
         Agent
  Chapter 10: Day 9 :  Building an Autonomous AI Agent
    111. What Is an Autonomous AI Agent?
    112. Designing the Agent Loop
    113. Building the Agent State
    114. Implementing the Agent State
    115. Testing the Agent State
    116. Practical Demo ? Test the Agent State in VS Code
    117. Building the Agent Loop
    118. Updating the Planner for Autonomous Execution
    119. Building the MCP Executor
    120. Building the Final Agent Runner
    121. Practical Demo ? Build and Test the Autonomous AI Agent
    122. Day 9 Review ? Building an Autonomous AI Agent
  Chapter 11: Day 10 :  Advanced Agent Planning
    123. From Next Action to Task Decomposition
    124. Building the LLM-Based Task Decomposer
    125. Practical Demo ? Build and Test the Task Decomposer
    126. Adding Tasks to the Agent State
    127. Building the State-Aware Planner
    128. Connecting the Planner to MCP Execution
    129. Building the Complete Agent Loop
    130. Building the Answer Generator
    131. Building the Agent Runner
    132. Practical Demo ? Build and Run the Complete Day 10
         Agent
    133. Day 10 Review ? Advanced Agent Planning
  Chapter 12: Day 11 :  Memory Engineering
    134. What Is Memory Engineering?
    135. Building Persistent Memory with SQLite
    136. Practical Demo: Build Persistent Memory with SQLite
    137. Integrating Memory into Our AI Agent
    138. Integrating Memory into the Complete AI Agent
    139. Practical Demo: Test Our AI Agent with Persistent
         Memory
    140. Building a Memory Extractor for Intelligent Long-Term
         Memory
    141. Practical Demo: Build and Test the Memory Extractor
    142. Final Integration: Adding Semantic Memory to Our AI
         Agent
    143. Practical Demo: Test Semantic Memory in Our AI Agent
    144. Day 11 Review: Building AI Agents with Memory
  Chapter 13: Day 12 :  Advanced RAG
    145. Understanding Chunking and Overlap in Advanced RAG
    146. Building a Document Chunking Strategy with Metadata
    147. Generating Embeddings for Document Chunks
    148. Building Semantic Search for Intelligent Retrieval
    149. Building Hybrid Search: Combining Keyword and Semantic
         Retrieval
    150. Understanding Re-Ranking: Finding the Most Relevant
         Results
    151. Building a Vector Store with FAISS and ChromaDB
    152. Building Semantic Search with ChromaDB
    153. Evaluating and Improving RAG Retrieval Quality
    154. Building the Complete Advanced RAG Retrieval Pipeline
    155. Building the Final Answer Generator for Advanced RAG
    156. Building the Final Runner for Our Advanced RAG
         Application
    157. Practical Demo: Run and Test the Complete Advanced RAG
         Application
    158. Day 12 Review: Building Retrieval Intelligence with
         Advanced RAG
  Chapter 14: Day 13  :  MCP in Depth
    159. Building Multiple MCP Servers: Adding a Weather MCP
         Server
    160. Building a Flexible MCP Client for Multiple MCP Servers
    161. Building an MCP Tool Registry for Multiple Servers
    162. Practical Demo: Building and Testing the MCP Tool
         Registry
    163. Upgrading the AI Planner to Handle Tool Arguments
    164. Upgrading the AI Agent to Work with Multiple MCP
         Servers
    165. Upgrading the Autonomous Agent Loop for Multiple MCP
         Servers
    166. Building the Multi-Server AI Agent Runner
    167. Practical Demo: Testing the Multi-Server AI Agent
    168. Understanding MCP Tools and Resources
    169. Understanding MCP Prompts: Reusable Instructions and
         Templates
    170. Understanding Remote MCP and HTTP Transport
    171. Practical Demo: Running a Remote MCP Server with HTTP
         Transport
    172. Understanding Authentication and Authorization in
         Remote MCP
  Chapter 15: Day 14  :  Multi-Agent Systems & Orchestration
    173. Understanding Multi-Agent Systems: Building Manager and
         Worker Agents
    174. Building Specialized AI Workers: Research, Coding, and
         Review Agents
    175. Building the Multi-Agent Manager: Orchestrating
         Specialized Workers
    176. Practical Demo: Running the Complete Multi-Agent System
    177. Making the Multi-Agent Manager Intelligent
    178. Building the Intelligent Multi-Agent Orchestration Loop
    179. Practical Demo: Building and Running the Intelligent
         Multi-Agent Manager
    180. Building Structured Communication Between AI Agents
    181. Upgrading the Coding Agent with Reviewer Feedback
    182. Building Iterative Multi-Agent Orchestration with
         Review and Revision
    183. Practical Demo: Building the Iterative Multi-Agent
         Review and Revision System
    184. Building Safeguards to Prevent Infinite Agent Revision
         Loops
    185. Practical Demo: Preventing Infinite Revision Loops in a
         Multi-Agent System
    186. Sequential vs Parallel Agents: Understanding Fan-Out
         and Fan-In
    187. Practical Demo: Running Sequential and Parallel AI
         Agents with Asyncio
    188. Turning Workers into Autonomous Worker Agents
  Chapter 16: Day 15  :  Making Our AI Agent Production-Ready
    189. Making Our AI Agent Production-Ready: Centralized
         Configuration
    190. Centralizing LLM Access in Our AI Agent
    191. Building Observability with Structured Logging
    192. Building Reliability with LLM Retries, Backoff, and
         Timeouts
    193. Building Agent Security with Secrets, Input Validation,
         and Permissions
    194. Building Safe File Access and Protecting Against Prompt
         Injection
    195. Optimizing AI Agent Performance: Parallel Execution,
         LLM Calls, and Context
    196. Designing the Final Production Architecture for Our AI
         Agent
    197. Practical Demo: Integrating the Production-Ready AI
         Agent Architecture
    198. Day 15 Review: Making Our AI Agent Production-Ready
  Chapter 17: Day 16  :  LangGraph
    199. From Our Existing AI Agent to LangGraph
    200. Building Graph State: Converting Our Existing Agent
         State to LangGraph
    201. Building the Planner Node in LangGraph
    202. Building the LangGraph Runner with MCP Tools
    203. Practical Demo: Building and Running Our First
         LangGraph Agent
    204. Building Conditional Edges in LangGraph for Intelligent
         Routing
    205. Building the Tool Node in LangGraph
    206. Preventing Infinite Agent Loops with Conditional
         Routing in LangGraph
    207. Building the Final Answer Node in LangGraph
    208. Practical Demo: Building and Running the Complete
         LangGraph Agent
    209. Building Human-in-the-Loop Agents with Approval and
         Checkpointing
    210. Integrating Everything Together: Final Langgraph Agent
    211. Practical Demo: Building and Running the Human-in-the-
         Loop LangGraph Agent
  Chapter 18: Day 17  :  CrewAI
    212. From Our Manual Multi-Agent System to CrewAI
    213. Building Our First CrewAI Agents: Researcher, Coder,
         and Reviewer
    214. Building CrewAI Tasks: Connecting Research, Coding, and
         Review
    215. Building Our First CrewAI Crew: Orchestrating Research,
         Coding, and Review
    216. Practical Demo: Build and Run Our First CrewAI Crew
    217. Connecting CrewAI Agents to MCP Tools
    218. Connecting CrewAI to MCP and Using a Real Tool
    219. Practical Demo: Build and Run a CrewAI Agent with MCP
         Tools
    220. Building Hierarchical CrewAI: Adding an LLM-Powered
         Manager
    221. Understanding CrewAI Memory and Choosing the Right
         Agent Framework
    222. Practical Demo: Building and Testing CrewAI
         Hierarchical Execution with Memory
  Chapter 19: Day 18  :  Build Our AI Research Agent
    223. Building the Tools for Our AI Research Agent
    224. Building the Web Search Tool for Our AI Research Agent
    225. Building the Webpage Reader Tool for Our AI Research
         Agent
    226. Practical Demo: Running and Testing Our AI Research
         Agent Tools
    227. Building the AI Research Agent Loop with Ollama Tool
         Calling
    228. Testing Our AI Research Agent
    229. Practical Demo: Running Our  AI Research Agent with
         Tool Calling
    230. Building a Research Planner for Our AI Research Agent
    231. Building Structured Research Notes for Our AI Research
         Agent
    232. Building the Research Notes Reader for Our AI Research
         Agent
    233. Integrating Research Planning and Memory into Our AI
         Research Agent
    234. Testing Our AI Research Agent with Planning and
         Research Notes
    235. Practical Demo: Testing the Research Planner in Our AI
         Research Agent
    236. Building Evidence Verification into Our AI Research
         Agent
    237. Building the Evidence Verifier for Our AI Research
         Agent
    238. Integrating the Evidence Verifier into Our AI Research
         Agent
    239. Building the Final Research Report Generator
    240. Understanding the Complete AI Research Agent Pipeline
    241. Practical Demo: Running the Complete AI Research Agent
  Chapter 20: Day 19: LangChain for Agent Engineers
    242. Introduction to LangChain for Agent Engineers
    243. Practical Demo: Build and Run Your First LangChain
         Application
    244. Building Reusable Prompt Templates with LangChain
    245. Practical Demo: Build and Use a Reusable LangChain
         Prompt Template
    246. Building AI Pipelines with LangChain Expression
         Language (LCEL)
    247. Practical Demo: Building and Testing Our First LCEL
         Chain
    248. Building LangChain Tools and Understanding Tool Calling
    249. Practical Demo: Building and Testing LangChain Tools
    250. Building a Real LangChain Agent with Tools
    251. Practical Demo: Building and Running Our LangChain
         Agent with Tools
    252. Building a LangChain Agent with MCP Tools
    253. Practical Demo: Building and Running a LangChain Agent
         with MCP
    254. Understanding RAG Retrieval with LangChain
    255. Building a Complete RAG Chain with LangChain
    256. Practical Demo: Building and Running a Complete
         LangChain RAG Application
    257. Understanding Agent State and Memory in LangChain
    258. Practical Demo: Building and Testing Agent Memory with
         LangChain
    259. Building the Final LangChain Agent: Integrating MCP and
         RAG
    260. Practical Demo: Building and Running the Final
         LangChain Agent with MCP and RAG
  Chapter 21: Day 20  :  AI Agent Deployment
    261. From AI Agent to Production Service
    262. Building a FastAPI AI Agent Service
    263. Practical Demo: Building and Testing a FastAPI AI Agent
         Service
    264. Building Robust FastAPI APIs with Pydantic and
         Configuration
    265. Building Robust Error Handling for FastAPI AI Agents
    266. Practical Demo: Testing FastAPI Validation and Error
         Handling
    267. Understanding Liveness and Readiness in AI Agent
         Services
    268. Building Application Lifecycle Management in FastAPI
    269. Practical Demo: Testing Application Lifecycle, Health
         Checks, and Readiness
    270. Dockerizing Our AI Agent: Building and Running a
         Containerized Service
    271. Building a Multi-Service AI Agent Environment with
         Docker Compose
    272. Practical Demo: Dockerizing and Running Our AI Agent
         with Docker Compose
    273. Building Reliability with Timeouts and Retries for AI
         Agents
    274. Building Rate Limiting for AI Agent APIs
    275. Building Observability with Structured Logging for AI
         Agents
    276. Practical Demo: Testing Reliability, Rate Limiting, and
         Observability
    277. Building an Automated Evaluation System for AI Agents
    278. Practical Demo: Building and Running Our AI Agent
         Evaluation System
    279. Evaluating AI Agents with LLM-as-a-Judge & Review
  Chapter 22: Day 21  :  Capstone Project: Build the Research AI
    Agent Platform
    280. From Research AI Agent to a Real User-Facing
         Application
    281. Practical Demo: Building and Running the Research AI
         Agent Web Interface
    282. Connecting the Real AI Agent to the Web Application
    283. Connecting the Web Interface to the AI Agent with
         JavaScript
    284. Practical Demo: Connecting the Research AI Agent to the
         Web Application
    285. Building the Beautiful Research AI Dashboard
    286. Practical Demo: Building and Running the Beautiful
         Research AI Dashboard
    287. Building Real-Time Research Progress Streaming for Our
         AI Agent
    288. Modify the Java Script to Show the Research Progress
    289. Practical Demo: Show the Real Research Process in the
         Web Application
    290. Turn the Research Result into a Professional Report
    291. Practical Demo: Complete Research AI Agent Platform
    292. What a Journey .....Congratulations
  DATES
  Published    : 2026-09-05
  Last Updated : 2026-10-05
If you fear the truth, dont come to my well.

Files