This is the flagship program: a structured walk through the full lifecycle of an LLM-powered application. You start with how models actually process text — tokens, context windows, sampling, and model APIs — and move steadily toward systems you would be comfortable putting in front of real users.
Each module pairs short explanations with hands-on Python work. You will build a retrieval pipeline, add tool calling and guardrails, write an evaluation suite that catches regressions, and package the result as a FastAPI service running in Docker with tracing and cost controls in place.
The program closes with a capstone: you design, build, evaluate, and document an AI application of your choosing. The goal is a project you can explain line by line — including its limitations and the trade-offs you made along the way.
fig. — production LLM application
Request path
web client
streams tokens to the UI
api · FastAPI
auth, input limits, rate limits
orchestrator
prompt templates, routing, guardrails
model
hosted or open-weight
retriever
pgvector
tools
allow-listed
Cross-cutting
tracing— OpenTelemetry spans per call
cache— exact-match response cache
evals— regression suite in CI
budgets— token + cost limits per user
redaction— PII scrubbed before logging
Reference architecture used in the capstone. Cross-cutting concerns sit beside the request path, not after it.
02
Prerequisites
Comfortable writing and debugging Python (functions, classes, virtual environments, packages)
Basic familiarity with HTTP APIs and JSON
Working knowledge of Git and the command line
No prior machine learning background required
03
Curriculum
01
Module 01: LLM Foundations
How language models turn text into tokens and back, and how to call them reliably from code.
01.1Tokens, tokenizers, and why token counts drive cost and latency
01.2Context windows: what fits, what gets truncated, and how to budget
01.3Calling a hosted model API: parameters, streaming, retries, and timeouts
01.4Prompt structure: system instructions, examples, and delimiting inputs
01.5Structured outputs with JSON Schema and Pydantic validation
02
Module 02: Retrieval-Augmented Generation
Ground model answers in your own documents with a retrieval pipeline you can inspect and tune.
02.1Document ingestion and cleaning for PDFs, HTML, and Markdown
02.2Chunking strategies and their effect on retrieval quality
02.3Embeddings and vector search with pgvector
02.4Hybrid search and reranking
02.5Returning answers with citations to source passages
03
Module 03: Tools, Agents, and Workflows
Let models call functions and coordinate multi-step work without losing control of the system.
03.1Tool calling: defining schemas and handling tool results
03.2Workflows versus agents: when a fixed pipeline is the better choice
03.3Managing state and conversation memory
03.4Guardrails, input validation, and human-in-the-loop approval steps
04
Module 04: Evaluation and Reliability
Measure whether your application works, and catch it when a change makes things worse.
04.1Building a representative test set from real and synthetic inputs
04.2Deterministic checks, groundedness checks, and rubric-based scoring
04.3LLM-as-judge: useful patterns and known failure modes
04.4Failure analysis: categorizing errors and prioritizing fixes
04.5Regression tests for prompts and pipelines with pytest
05
Module 05: Deployment and Operations
Package the application as a service and give yourself the visibility to run it responsibly.
05.1Serving with FastAPI: request models, streaming responses, and error handling
05.2Containerizing with Docker and managing configuration and secrets
05.3Logging and tracing with OpenTelemetry
05.4Latency and cost controls: caching, model selection, and token limits
05.5Prompt injection and other security risks in LLM applications
06
Module 06: Capstone: Build and Document an AI Application
Design, build, evaluate, and write up an application that brings the previous modules together.
06.1Scoping the problem and writing a short design document
06.2Implementing the core pipeline and its evaluation suite
06.3Deploying the service and reviewing traces from test traffic
06.4Writing the README: architecture, evaluation results, and known limitations
04
Skills and project outcomes
Skills you’ll practice
Calling model APIs with streaming, retries, and timeouts
Producing validated structured outputs with Pydantic
Building retrieval pipelines with embeddings and pgvector
Implementing tool calling with guardrails
Designing test sets and automated evaluations
Serving LLM features through FastAPI
Tracing and monitoring with OpenTelemetry
Controlling latency and cost in production
What you’ll build
A working AI application, deployed as a containerized FastAPI service
An evaluation suite with a versioned test set and regression checks
Tracing and logging that show what the system did for each request
A written project report covering architecture, results, and limitations
Alex focuses on the unglamorous parts of LLM products: input validation, structured outputs and graceful failure. Their sessions are about turning a promising prototype into code a team can maintain.
Priya teaches retrieval-augmented generation from the data up: parsing, chunking, retrieval and the evaluation that tells you whether any of it is working.
Sam covers what happens after the demo works: packaging, deployment, tracing, cost control and the operational habits that keep LLM services predictable.
Sample profile
06
Program FAQs
No. The program focuses on building applications on top of existing models, not training them. Solid Python and a working understanding of APIs are the important prerequisites.