Udemy
Turn what you know into an opportunity and reach millions around the world.
Learn More
Your cart is empty.
Keep shopping
Agentic AI Engineering: Intelligent Agents with MCP & LLMs
New
Rating: 5.0 out of 5(1 rating)
100 students

Agentic AI Engineering: Intelligent Agents with MCP & LLMs

Build and deploy AI agents in Python with LangChain, LangGraph, OpenAI Agents SDK, RAG and Model Context Protocol
Last updated 11/2026
English
English [Auto],

What you'll learn

  • Explain how LLMs and generative AI power agentic AI, and design agents that reason, plan and act in loops
  • Build AI agents in Python with the OpenAI SDK, tool calling, external APIs and robust error handling
  • Orchestrate single and multi-agent workflows with LangChain, LangGraph and the OpenAI Agents SDK
  • Build MCP servers and clients with the Model Context Protocol Python SDK and connect agents to real tools
  • Add retrieval-augmented generation (RAG) with embeddings, vector databases and long-term agent memory
  • Secure, test and deploy production-ready AI agents with guardrails, human approval, monitoring and CI/CD

Course content

1 section • 11 lectures • 2h 46m total length
  • Introduction: How This Course Works4:14

    Start here. This short introduction explains what the course covers and how it works. You'll see the difference between a chatbot and an AI agent, the skills you'll build, the ten-lesson roadmap from AI fundamentals to a production-ready capstone, and what you need before you begin. It ends with a quick warm-up question and simple tips for getting the most from each lesson.

  • How AI, LLMs and Generative AI Work12:04

    Build the foundation every AI agent relies on. You'll learn what artificial intelligence is, how it has evolved, and how generative AI creates new content. Then you'll look inside large language models (LLMs): their architecture, tokens, embeddings and context windows, and how prompt engineering shapes their responses. The lecture finishes by showing how these fundamentals power agentic AI.

  • Agentic AI Concepts: Reasoning, Planning and Agent Loops14:11

    Discover what makes an AI system agentic. You'll learn the anatomy of an intelligent agent and how it makes autonomous decisions through the agent decision cycle. The lecture covers reasoning and planning approaches, reactive versus deliberative agents, memory and context, and the execution loop that keeps an agent working towards its goal, with real-world examples throughout.

  • Build Your First AI Agent in Python13:57

    Move from theory to code. You'll see why Python is the go-to language for AI agents, the core concepts and libraries you need, and a typical agent code structure. You'll make your first LLM API call with the OpenAI Python SDK, write agent functions that carry out tasks, and connect external tools. A mini-project walks you through your first Python agent, with debugging tips for common pitfalls.

  • LangChain vs LangGraph vs OpenAI Agents SDK21:37

    Compare the leading frameworks for building AI agents. You'll learn what agent frameworks do and why they matter, then see how to build workflows with modular chains in LangChain, graph-based orchestration in LangGraph, and native agent orchestration with the OpenAI Agents SDK. A side-by-side comparison, selection scenarios and troubleshooting tips help you choose the right framework for your project.

  • MCP Architecture: Hosts, Clients, Servers and Messages15:53

    Learn the Model Context Protocol (MCP), the open standard for connecting AI agents to tools and data. You'll understand the roles of hosts, clients and servers, the three server primitives (tools, resources and prompts), and how a tool call travels from agent to server and back. You'll also see how clients and servers communicate with JSON-RPC 2.0 messages over stdio or Streamable HTTP, taught to the current official specification.

  • Build and Connect MCP Servers and Clients in Python18:21

    Put MCP into practice with the official Python SDK. You'll build a basic MCP server, code a client that discovers and calls its tools, and follow the end-to-end client-server workflow. Then you'll connect agents to APIs and databases, handle authentication and common security pitfalls, and design reusable MCP tools you can share across projects.

  • Design Multi-Agent Systems and Orchestration14:47

    Learn how teams of AI agents work together. You'll explore multi-agent architectures (centralised, peer-to-peer, hierarchical and hybrid), collaboration methods such as shared memory, blackboards and publish/subscribe, and a step-by-step approach to task delegation. You'll compare orchestration strategies, design human-in-the-loop workflows, and see multi-agent systems at work in real industries.

  • RAG Pipelines, Vector Databases and Agent Memory16:10

    Give your agents up-to-date knowledge and a sense of history. You'll learn how retrieval-augmented generation (RAG) works, how embeddings and vector databases enable semantic search, and how to design a retrieval pipeline from data ingestion to result ranking. A mini-project outlines a simple RAG pipeline, then you'll explore short-term, long-term, episodic and semantic memory, with best practices for each.

  • Secure, Test and Deploy AI Agents16:38

    Make your agents safe and production-ready. You'll learn the main security risks, including prompt injection and data leakage, and how guardrails, access controls and human approval keep agents accountable. Then you'll cover error handling, prompt-injection defences, evaluation and real-time monitoring, and deployment with containers, CI/CD, rollbacks and scaling.

  • Capstone: Build a Production-Ready AI Agent System18:24

    Bring everything together in your capstone project. You'll follow five milestones: design and architecture, LLM integration and orchestration, custom MCP tools and APIs, RAG and memory, and security, evaluation and deployment. Each comes with clear steps, deliverables and tips, plus a production-ready checklist and advice on presenting your work in your portfolio. Complete the capstone assignment straight after this lecture.

  • Capstone Assignment: Design an MCP-Powered AI Agent

Requirements

  • Basic Python: variables, functions, loops and installing packages with pip
  • A Windows, macOS or Linux computer that can run a recent version of Python 3
  • An API key from an LLM provider such as OpenAI if you want to run the examples (small usage charges may apply)
  • Some familiarity with JSON and web APIs is helpful, but not essential
  • No previous experience with AI, LLMs or agent frameworks: Lesson 1 starts from the basics

Description

"This course contains the use of artificial intelligence."

Build AI agents that reason, use tools, look things up and run safely in production.

Most AI agent tutorials stop at a chatbot that calls one function. Real projects need more than that. They need an agent that plans across several steps, talks to other systems through the Model Context Protocol (MCP), pulls the right facts from your own documents, remembers what users told it, and stays safe when someone tries to trick it.

This course takes you through all of it, in a sensible order. You start with how large language models (LLMs) and generative AI really work, then move on to agentic AI: agents that reason, plan and act in a loop. From there you build agents in Python, compare the main frameworks, connect MCP servers and clients, and finish with a capstone project you can add to your portfolio.

What's inside

  • AI and LLM fundamentals: tokens, context windows, embeddings and prompt engineering, explained without the hype.

  • Agentic AI concepts: reasoning, planning, agent loops and memory, and how they fit together.

  • AI agents in Python: calling LLM APIs with the OpenAI Python SDK, writing agent functions, using external tools and fixing common bugs.

  • LangChain, LangGraph and the OpenAI Agents SDK: what each framework is for, how to build a workflow in each, and how to choose between them.

  • Model Context Protocol (MCP): hosts, clients and servers, tools, resources and prompts, JSON-RPC messages and transports, taught to the current official specification.

  • MCP servers and clients: building both with the official Python SDK, and connecting agents to APIs and databases.

  • Multi-agent systems: architectures, task delegation, orchestration strategies and human-in-the-loop workflows.

  • RAG and agent memory: embeddings, vector databases, semantic search, retrieval pipelines, and short- and long-term memory.

  • Security, evaluation and deployment: guardrails, prompt-injection defences, access control, testing, monitoring, Docker, CI/CD and scaling.

  • Capstone project: plan and build a production-ready AI assistant that brings everything together.

How the course works

Each lesson is an animated video of 12 to 22 minutes, with clear diagrams, code walkthroughs, flashcard recaps and short knowledge checks that pause so you can think before the answer appears. Every video has accurate English captions, and section quizzes plus a final quiz help the ideas stick.

The MCP and OpenAI material has been checked against the current official documentation, so you won't be learning patterns that stopped working last year.

By the end, you'll understand how modern AI agents are designed, and you'll have a clear plan for building, securing and shipping your own. Start with Lesson 1 and build your first agent this week.

What you'll learn

  • Explain how LLMs and generative AI power agentic AI, and design agents that reason, plan and act in loops

  • Build AI agents in Python with the OpenAI SDK, tool calling, external APIs and robust error handling

  • Orchestrate single and multi-agent workflows with LangChain, LangGraph and the OpenAI Agents SDK

  • Build MCP servers and clients with the Model Context Protocol Python SDK and connect agents to real tools

  • Add retrieval-augmented generation (RAG) with embeddings, vector databases and long-term agent memory

  • Secure, test and deploy production-ready AI agents with guardrails, human approval, monitoring and CI/CD

Requirements

  • Basic Python: variables, functions, loops and installing packages with pip

  • A Windows, macOS or Linux computer that can run a recent version of Python 3

  • An API key from an LLM provider such as OpenAI if you want to run the examples (small usage charges may apply)

  • Some familiarity with JSON and web APIs is helpful, but not essential

  • No previous experience with AI, LLMs or agent frameworks: Lesson 1 starts from the basics

Who this course is for

  • Python developers who want to move from simple chatbots to AI agents that plan, use tools and act

  • Software engineers adding LLM features, RAG or MCP integrations to real products

  • Data scientists and machine learning engineers moving into generative AI and agentic AI engineering

  • Technical leads and architects who need to choose between LangChain, LangGraph and the OpenAI Agents SDK

  • Computer science students and career changers building a portfolio project for AI engineering roles

  • Not for complete beginners to programming: you'll need basic Python to follow the code

Where this course can take you

The skills in this course map directly onto roles that companies are hiring for right now:

  • AI Engineer or Agentic AI Engineer: design and build agents that plan, use tools and act, from first prototype to production.

  • LLM Engineer: integrate large language models into real products, with prompt design, RAG pipelines and evaluation.

  • AI Integration Developer: connect AI agents to company APIs, databases and internal tools through MCP servers and clients.

  • Machine Learning Engineer moving into generative AI: add agent orchestration, vector databases and memory to the skills you already have.

  • AI Solutions Architect: choose the right frameworks, design multi-agent systems and plan secure, scalable deployments.

  • Backend or Full-Stack Developer with AI skills: add intelligent features, automation and AI-powered search to the products you already build.

Who this course is for:

  • Python developers who want to move from simple chatbots to AI agents that plan, use tools and act
  • Software engineers adding LLM features, RAG or MCP integrations to real products
  • Data scientists and machine learning engineers moving into generative AI and agentic AI engineering
  • Technical leads and architects who need to choose between LangChain, LangGraph and the OpenAI Agents SDK
  • Computer science students and career changers building a portfolio project for AI engineering roles
  • Not for complete beginners to programming: you'll need basic Python to follow the code