Advanced81 Chapters

GenAI Agent Engineering

A comprehensive learning path from novice to L5 expert in building AI agents using hosted GenAI services (OpenAI, Anthropic, Google Gemini). This path builds skills progressively from Python foundations and agent fundamentals through production-scale multi-agent systems with MCP, A2A protocols, observability, security, and scale challenges.

AgentsLangGraphCrewAIMCPA2AProduction

Learning Path

7 phases • 81 chapters

Phase 10/10 chapters

Foundations

Python essentials and development environment for agent development

0/440 quiz questions

0/61 labs

Tools & Topics

Virtual environments, async programming, type hints, Pydantic, error handling, testing, debugging, logging, project structure

Goals

•Set up professional development environments
•Write async Python code fluently
•Use type hints and Pydantic for robust data handling
•Implement error handling, testing, logging, and debugging

Chapters

1. The Dev Environment

2. The Async Foundation

3. The Type System

4. The Data Validator

5. The Error Handler

6. The Test Writer

7. The Debugger

8. The Logger

9. The HTTP Client

10. The Project Structure

Phase 20/16 chapters

Agent Core & Tools

Core concepts, function calling, agent loops, reasoning patterns, and MCP protocol

0/753 quiz questions

0/115 labs

Tools & Topics

LLM APIs, prompt caching, token economics, function calling, tool definitions, agent loops, structured outputs, prompts, ReAct, planning, chain-of-thought, sandboxing, web navigation, MCP servers, MCP clients, tool routing

Goals

•Call multiple LLM providers (OpenAI, Anthropic, Gemini)
•Implement prompt caching and token cost management
•Build function calling and tool definitions
•Create agent loops with ReAct and planning patterns

Chapters

11. The LLM Client

12. Token Economics

13. Prompt Caching

14. The Function Caller

15. The Tool Definer

16. The Raw Agent Loop

17. The Prompt Engineer (Dynamic)

18. The ReAct Pattern (Manual)

19. The Planner Pattern

20. The Pydantic Tool

21. The Safe Executor (Sandboxing)

22. The Web Navigator

23. The MCP Protocol (Basics)

24. The MCP Server

25. The MCP Client

26. The Tool Router

Phase 30/11 chapters

Memory & LangGraph

Memory systems, context management, and LangGraph fundamentals

0/522 quiz questions

0/77 labs

Tools & Topics

Short-term memory, long-term memory (RAG), agentic RAG patterns, semantic memory, context optimization, state graphs, conditional edges, checkpointing, human-in-the-loop, streaming, subgraphs

Goals

•Implement short-term and long-term memory
•Build RAG and agentic RAG systems
•Create state machines with LangGraph
•Implement checkpointing, streaming, and human-in-the-loop

Chapters

27. Short-Term Memory

28. Long-Term Memory (RAG)

29. Agentic RAG Patterns

30. Semantic Memory

31. Context Optimizer

32. The State Graph

33. The Conditional Edge

34. The Checkpointer (Time Travel)

35. Human-in-the-Loop

36. The Streaming Agent

37. The Subgraph (Composition)

Phase 40/13 chapters

Multi-Agent & Safety

Multi-agent patterns, guardrails, evaluations, security, and serving agents

0/598 quiz questions

0/94 labs

Tools & Topics

Supervisor pattern, hierarchical pattern, reflector pattern, input guardrails, output guardrails, prompt injection defense, evaluations, benchmarking, tracing, observability, tool use debugging, FastAPI, Docker, production databases

Goals

•Implement supervisor, hierarchical, and reflector patterns
•Build input and output guardrails
•Defend against prompt injection attacks
•Evaluate agents with benchmarks

Chapters

38. The Supervisor Pattern

39. The Hierarchical Pattern

40. The Reflector Pattern (Critique)

41. Input Guardrails

42. Output Guardrails

43. Prompt Injection Defense

44. Evaluations (Evals)

45. Agent Benchmarking

46. Tracing & Observability

47. Tool Use Debugging

48. Serving Agents (FastAPI)

49. Podman & Containerization for K8s

50. Production Databases (Postgres/Redis)

Phase 50/8 chapters

Production

Production engineering: deployment, scaling, orchestration, and monitoring

0/355 quiz questions

0/56 labs

Tools & Topics

Scaling patterns, load balancing, multi-tenant architecture, Kubernetes, CI/CD, monitoring, alerting, model routing, fallbacks, long-running agents, system design, cost analysis

Goals

•Scale horizontally with load balancing
•Build multi-tenant agent platforms
•Deploy to Kubernetes with CI/CD
•Monitor with Prometheus/Grafana

Chapters

51. Scaling & Load Balancing

52. Multi-Tenant Agents

53. Kubernetes (K8s) Basics

54. CI/CD for Agents

55. Monitoring & Alerting

56. Model Routing & Fallbacks

57. Long-Running Agents

58. Production Architecture Patterns

Phase 60/8 chapters

Niche Area Topics

Specialized agent domains and niche applications

0/329 quiz questions

0/56 labs

Tools & Topics

Alternative frameworks (CrewAI/AutoGen), A2A protocols, GraphRAG, multi-agent simulation, local models, privacy, vision agents, computer use agents, voice/audio agents

Goals

•Use alternative frameworks (CrewAI, AutoGen)
•Implement A2A protocol for agent communication
•Build GraphRAG for complex knowledge
•Run agents locally for privacy

Chapters

59. Alternative Frameworks (CrewAI/AutoGen)

60. The A2A Protocol

61. Deep Memory (GraphRAG)

62. Advanced Simulation

63. The Privacy Specialist

64. The Vision Agent

65. Computer Use Agents

66. Voice & Audio Agents

Phase 70/1 chapters

Advanced

Cutting-edge agent architectures and research frontiers

0/40 quiz questions

0/7 labs

Tools & Topics

Code agents, Claude Code patterns, Cursor-style assistants, repository-scale reasoning, SWE-bench evaluation

Goals

•Build agents that understand entire codebases
•Implement file editing agents
•Generate and run tests automatically
•Integrate with IDEs and CI systems

Chapters

67. Code Agents