AI Agent Engineering

By the end, you can

1. Get reliable, structured answers from an LLM with well-built prompts
2. Build LLM apps with LangChain and switch between Groq, OpenAI, Claude and Gemini without rewriting them
3. Understand how models learn, enough to choose between a prompt, RAG and fine-tuning
4. Store and search embeddings in ChromaDB, Qdrant, Pinecone and OpenSearch, and pick the right one for a job
5. Build a RAG system that answers from your own documents, cites them and says when it does not know
6. Build agents that call tools, remember, recover from failure and work with other agents
7. Build and use MCP servers, and wire agents with LangGraph
8. Deploy an AI agent to production, then measure its quality, cost and speed

What you get

• Live classesTaught live on a schedule, with time to ask questions as they come up. Every class is recorded, so a missed session is never lost.
• Reading materialsRunnable, chapter-by-chapter notes with real outputs, in the portal. Read at your own pace and come back to revise any time.
• Topic-wise guided labsA step-by-step hands-on lab for every topic, with hints when you get stuck, so you learn by building and not just by watching.
• Chapter-wise quiz and flash cardsA short quiz after every chapter and spaced flash cards, so what you read actually sticks.
• Weekly assessmentsA short timed test every week on what was taught, scored on the portal, so gaps show up while there is still time to fix them.
• AssignmentsHands-on assignments to build and submit, with feedback, so you finish with real work to show.

Your path, stage by stage

6 stages, in the order you learn them. Each one has a clear goal and ends with something you build and keep. Every topic runs on your own machine first.

1. 1Python for AI
2. 2Talk to models well
3. 3Know how models learn
4. 4Search by meaning
5. 5Answer from your own data
6. 6Build and ship agents

1. 01

   Stage 1 of 6

   Python for AI

   Write Python comfortably, the language every AI tool speaks.

   You buildA small finished Python project on GitHub

   Python Fundamentals12 topics

   12 sessions · from your first print() to a finished small project.

   Basics

   • The print() function
   • Variables, constants and data types
   • A variable is a name, not a box
   • Operators, conditions and input()
   • Functions

   Collections and slicing

   • Indexing and slicing
   • Lists (the delivery man's busy day)
   • Tuples (the magic photo album)
   • Dictionaries (Annachi Kadai)
   • Sets (the rose garden and the botanical garden)

   Going further

   • Generators (the lazy workers of Python)
   • Project (the number guessing game)
2. 02

   Stage 2 of 6

   Talk to models well

   Write prompts that give reliable, structured answers, and call models from code with LangChain and Groq.

   You buildA LangChain app on Groq that returns clean JSON, with a small test set to prove it

   Prompt Engineering14 topics

   14 chapters · get reliable, structured answers from an LLM.

   Writing good prompts

   • The anatomy of a prompt
   • Be specific
   • Give context
   • Assign a role
   • Control the format
   • Show examples (few-shot)
   • Constraints and positive framing

   Structure and reasoning

   • Think step by step
   • Delimiters and structure
   • Iterate and chain prompts
   • Ground the answer
   • System prompts and templates

   Evaluating and practice

   • Evaluate your prompts
   • Capstone (fix five bad prompts)

   LLM Apps with LangChain and Groq10 topics

   Call any model from Python, then build prompts, chains and structured answers with LangChain.

   Calling models

   • How an LLM API works (keys, models, tokens and limits)
   • Groq for very fast answers from open models such as Llama
   • OpenAI, Claude and Gemini through the same code, so you can swap models in one line
   • Streaming the answer as it is written

   Building with LangChain

   • Chat models, messages and prompt templates
   • Structured output with Pydantic models
   • Chains with LCEL (one step after another, and steps in parallel)
   • Document loaders and text splitters for PDFs, web pages and Markdown
   • Retrievers, the bridge from LangChain to a vector database
   • Tracing a chain to see every call, its tokens and its time
3. 03

   Stage 3 of 6

   Know how models learn

   Understand training, validation and features, enough to choose between a prompt, RAG and fine-tuning.

   You buildA churn model trained, validated and explained in plain words

   Machine Learning Essentials23 topics

   23 sessions · how models learn, in plain words, with code.

   Toolkit and maths

   • What Is Machine Learning?
   • The Toolkit (NumPy and pandas)
   • Maths I (Vectors and Matrices)
   • Maths II (Statistics and Probability)
   • Maths III (Derivatives and Gradients)

   Regression and honest validation

   • Linear Regression
   • Gradient Descent
   • Many Features (Scaling, Categories and Curves)
   • Overfitting and Honest Validation
   • Regularization (Ridge and Lasso)

   Classification

   • Logistic Regression
   • Judging a Classifier (Precision, Recall, ROC and AUC)
   • k-Nearest Neighbours
   • Naive Bayes

   Trees, ensembles and SVMs

   • Decision Trees
   • Ensembles (Random Forests and Gradient Boosting)
   • Support Vector Machines

   Unsupervised learning

   • Clustering (Finding Groups Without Labels)
   • PCA (Squeezing Many Features Into a Few)

   Features, neural networks and shipping

   • Features and Pipelines
   • Neural Networks
   • Tuning, Saving and Shipping a Model

   Capstone

   • Capstone (Will This Subscriber Churn?)
4. 04

   Stage 4 of 6

   Search by meaning

   Turn text into vectors and search them with ChromaDB, Qdrant, Pinecone and OpenSearch.

   You buildOne document set searched in all four stores, with the results compared

   Vector Databases and Search12 topics

   ChromaDB, Qdrant, Pinecone and OpenSearch, each run on your laptop and compared on the same data.

   How vector search works

   • Embeddings and similarity (cosine, dot product and distance)
   • Approximate nearest neighbour search and HNSW, in plain words

   ChromaDB

   • A local vector store in a few lines (collections, adding and querying)
   • Metadata filters and keeping the data on disk

   Qdrant

   • Qdrant in Docker (collections, points and payloads)
   • Payload filters, and hybrid search with dense and sparse vectors

   Pinecone

   • Pinecone Local in Docker first, then a managed serverless index
   • Namespaces and metadata, and when a managed service is worth paying for

   OpenSearch

   • OpenSearch in Docker, keyword search with BM25
   • k-NN vector search and hybrid search in the same engine

   Choosing one

   • One handbook loaded into all four, the answers and speed compared
   • Picking a store by cost, scale, filtering and who runs it
5. 05

   Stage 5 of 6

   Answer from your own data

   Build RAG with LangChain that finds the right passages, cites them and says when it does not know.

   You buildAn assistant over a company handbook that cites its sources

   RAG (Retrieval-Augmented Generation)20 topics

   20 sessions · answer from your own documents, from first pipeline to production.

   Foundations

   • Why RAG?
   • Chunking (Cutting Documents Into Pieces)
   • Embeddings (Turning Meaning Into Numbers)
   • Vector Search and Vector Databases
   • Your First RAG Pipeline
   • Prompting for RAG

   Better retrieval

   • Hybrid Search (Meaning Plus Exact Words)
   • Metadata Filtering
   • Re-ranking
   • Query Rewriting (Fix the Question Before Searching)
   • Parent-Child Retrieval (Search Small, Read Big)
   • Context Compression

   Conversation and freshness

   • Conversational RAG
   • Fresh Data and Caching
   • Agentic RAG and Multi-Step Questions

   Quality and safety

   • Evaluating RAG
   • Catching Hallucinations
   • Guardrails and Security

   Serving and capstone

   • Serving RAG (Speed, Streaming and Cost)
   • Capstone (The Finished Pipeline)
6. 06

   Stage 6 of 6

   Build and ship agents

   Build agents with tools, memory and MCP in LangGraph, test them, guard them and serve them.

   You buildAn AI agent in production, with its quality, cost and speed measured

   40 Days of Agentic AI47 topics

   47 sessions · build, test, secure and serve AI agents, with working code each day.

   LLMs, tools and RAG

   • LLMs and Key Terminology
   • Prompt Engineering
   • Tool Calling
   • Retrieval-Augmented Generation (RAG)

   Async, validation and memory

   • Async Python for AI Apps
   • Data Validation with Pydantic
   • Memory for Agents

   Tools, MCP and chains

   • Custom Tools, API & Database Tools, and MCP
   • LCEL (Chains, Parallel Steps and Passthrough)

   Human in the loop and context

   • Human in the Loop (Approve Before the Agent Acts)
   • Conversation Management & the Context Window
   • Personalisation Architectures for AI Agents

   RAG for agents

   • RAG as an Agent Tool
   • Advanced RAG
   • RAG Evaluation

   MCP in depth

   • MCP Fundamentals (Hosts, Clients, Servers, Primitives and Transports)
   • Building Custom MCP Servers and Clients (FastMCP), and Deploying One Remotely

   Agent loops and reliable design

   • Agent Fundamentals (Planning, Reasoning and Reflection)
   • Autonomous Agent Loops (ReAct Built from Scratch)
   • Failure Recovery and Human Feedback in Agents
   • Reliable Agent Design Patterns

   Platforms, memory and multi-agent systems

   • n8n AI Agent Workflows and RAGFlow (Code vs Visual vs Platform)
   • Memory Taxonomy and Mem0; Plan-and-Execute, ReWOO, Reflexion; Self-RAG, CRAG, Adaptive RAG
   • Multi-Agent Systems, Supervisor, Hierarchical, Network and Swarm; the A2A Protocol; AutoGen and CrewAI
   • Computer Use and Browser Agents (Playwright, Sandboxes and Safety)

   Evaluation, guardrails and cost

   • Agent Evaluation and Observability (Golden Sets, Judges and Traces)
   • Guardrails, Safety and Cost (PII, Injection, Budgets and Caching)

   LangGraph

   • LangGraph Fundamentals (State, Nodes and Edges)
   • Building Agents in LangGraph (Summarizer, Map-Reduce and Router)
   • LangGraph Persistence (Checkpoints, Human Approval and Safe Retries)

   Serving LLMs in production

   • Building an LLM Inference Microservice
   • Inside LLM Inference (Prefill, Decode, the KV Cache and PagedAttention)
   • Serving Engines and Batching (vLLM, Continuous Batching, Prefix Caching and Speculative Decoding)
   • Smaller and Faster Models (Quantization, Distillation, LoRA and QLoRA)
   • Decoding Controls (Temperature, Top-p, Repetition and Structured Output)
   • Scaling on Kubernetes (HPA, Cold Starts, Fair Limits and Safe Rollouts)
   • Latency, Cost and Monitoring (TTFT, TPOT, Percentiles and What to Log)

   Production RAG and fine-tuning

   • Ingesting Hard Documents (Scans, Charts and Tables That Span Pages)
   • Keeping RAG Fresh and Safe (Versions, Deletion, Tenants and Multi-Document Questions)
   • Hallucinations and Faithfulness (Causes, Guards and Measurement)
   • Machine Learning Essentials for AI Engineers (Imbalance, F1, Thresholds, Leakage and Drift)
   • Fine-tuning vs RAG, and Embeddings vs Cross-Encoders

   Putting it together and interviews

   • Wiring RAG, Tools and Memory into One Agent
   • Testing, Debugging and Versioning Agent Behaviour
   • Interview Round (Explaining Your Project, Its Architecture and Its Trade-offs)
   • Interview Round (Designing Agent Systems, Explaining Cost and Risk)

   Capstone

   • Capstone (Architect, Build and Deploy a Production Agentic AI System)