For senior developers & software engineers moving into AI
For developers who already ship production backends and now need to ship AI ones. Async LLM architectures, RAG at scale, multi-agent systems and production observability — built live, on your own project, reviewed by a human.
8 weeks
1 live classes/week
Try 2 free classes
What will you learn in the AI Engineering course?
In this AI Engineering course you'll build the production stack behind real AI products — not prompts in a notebook, but async services, retrieval at scale, agent systems and the observability to run them. You'll start with a provider-agnostic base interface in Python 3.12 — asyncio for LLM I/O, Pydantic v2 schemas as contracts, an adapter layer over the OpenAI and Anthropic SDKs — and orchestrate it with LangChain and LCEL.
From there you'll build retrieval end to end, from embeddings and chunking in ChromaDB to Pinecone at scale with hybrid search and reranking; then autonomous agents in LangGraph — stateful, resumable, with human-in-the-loop gates — and multi-agent teams with shared state. You'll close with production: FastAPI, Redis, full tracing, latency and cost controls, CI/CD with evaluation gates, and a capstone that ships a complete AI system with its reliability plan and operational handoff.
Who it’s for
Software engineers with solid Python and backend experience who need to build production AI systems, not demos.
Working AI developers moving from scripts and notebooks to architectures that scale, fail gracefully and can be observed.
Developers who want to ship a production-style AI system end to end and hand it over with a reliability and evaluation plan.
This is an advanced course. You should be comfortable with Python, async programming and building backend services. It is not an introduction to LLMs.
Tools you’ll use

Python 3.12 + asyncio

Pydantic v2
OpenAI & Anthropic SDKs

LangChain (LCEL)

LangSmith

ChromaDB

Pinecone

LangGraph

FastAPI

Redis
When you finish
Design and ship multi-agent systems with hierarchical supervision, handoff protocols and shared state across agent teams.
Implement RAG at scale with Pinecone: namespaces, hybrid search, reranking and metadata governance.
Serve, observe and deploy AI systems in production with FastAPI, Redis, tracing and CI/CD with evaluation gates.
Eight weeks, live
2 weekly live online classes of 2 h. 6 to 8 hours per week.
Module 1
The base interface: connecting to and abstracting LLMs
−
Modern Python 3.12 for production AI backends
Asyncio for LLM I/O workloads
Pydantic v2 schemas as AI contracts
Abstracting OpenAI and Anthropic behind a single adapter
Reliability patterns: retries, timeouts and fallbacks
Pre-delivery 1: the foundation service slice
Live Session: The Base Interface
Module 2
Logical chaining: orchestration with LangChain
+
Module 3
Data persistence and vector DBs
+
Module 4
Document scalability: advanced RAG with Pinecone
+
Module 5
Autonomous reasoning: agents with LangGraph
+
Module 6
Multi-agent systems: collaboration and specialization
+
Module 7
Production and robustness: observability, cost and deployment
+
Module 8
Capstone: production AI system delivery
+
October 27
$595 launch price. Two free classes first.
FAQ
How do the two free classes work?
+
Is the AI teaching the course?
+
How much time does it take per week?
+
Do I need experience to join?
+
What if I can’t make a live class?
+
When do cohorts start, and when does enrollment close?
+