Generative AI Training

• VS Code and the Python extensions actually worth installing
• Virtual environments with venv and conda, so one project stops breaking another
• API keys in .env with python-dotenv, and why a key leaked to GitHub gets billed to you
• Installing Ollama and pulling llama3, so you have a free model on your own machine in week one
• git init, commit, push, and a .gitignore written before you have anything to hide
• Hands-on: build the environment, load a cloud key safely, get a completion out of llama3 with the wifi off, and push the repo. We check your git history for secrets.

Beginner~4 hoursYou build: A secret-safe starter repo. Every later module commits into this one.

• Dictionaries, lists and sets, and knowing which one you want
• Classes, methods and inheritance, so your code stops being one long script
• Exceptions and logging, which is how an agent recovers instead of dying
• Async programming with asyncio and aiohttp for high-throughput API calls
• Hands-on: fire concurrent REST calls at an LLM API, log every failure properly, and retry with back-off.

Beginner~6 hoursYou build: An async, fault-tolerant API caller you reuse for the rest of the course.

• Pandas and NumPy for the data that feeds a model
• Regex for pulling structure out of text that has none
• Reading and writing PDF, CSV and TXT files
• Pydantic schemas, so bad data fails loudly at the door instead of quietly three functions later
• Why an exact-match assertion breaks on an LLM, and what to assert instead: type, structure, snapshot
• Hands-on: parse messy text files, validate the result with Pydantic, and write your first pytest suite that passes on output that changes every run.

Beginner~6 hoursYou build: A validated ingestion module with a passing test suite.

• SELECT, JOINs, CTEs and window functions
• Create, read, update and delete, driven from Python
• Vector columns in PostgreSQL with pgvector
• Hands-on: build a SQLite database, run CRUD against it from Python, then query historical rows and assemble them into an LLM context window.

Beginner~5 hoursYou build: A queryable data layer feeding a language model.

• REST and the HTTP methods: GET, POST, PUT, DELETE
• Authentication with Bearer tokens and OAuth
• Writing and reading JSON request and response bodies
• Testing endpoints in Postman before your code ever calls them
• FastAPI, which turns a Python function into a service
• Hands-on: expose your data-fetching function as a live REST endpoint and drive it from Postman.

Intermediate~6 hoursYou build: Your first deployable API service.

• Branching strategies, merging, and what a sensible commit actually looks like
• Pull requests, and taking a code review without taking it personally
• Merge conflicts, including the horrible kind inside a Jupyter notebook
• Hands-on: push the FastAPI project, open a feature branch, hit a conflict we planted for you, resolve it, and merge through a pull request without breaking main.

Intermediate~4 hoursYou build: A repository with real pull-request history on it.

• AI, ML, DL and NLP, and where each word genuinely applies
• The Transformer and attention, worked through step by step: softmax(QKᵀ / √d_k)V
• Tokens, context windows, embeddings and cosine similarity
• Hands-on: compute embedding distances from scratch in NumPy, so semantic search stops feeling like magic before you use a vector database.

Intermediate~6 hoursYou build: A from-scratch semantic similarity notebook.

• The OpenAI, Anthropic and Gemini SDKs side by side
• Few-shot, chain of thought and ReAct prompting, and when each is worth the tokens
• Multimodal work: reading an image and text together and getting structured output back
• Voice: the speech-to-text, LLM, text-to-speech pipeline
• Local inference versus cloud APIs, judged on privacy, latency and cost
• Hands-on: feed Gemini a complex architecture diagram and get back a schema-validated explanation.
• Hands-on: a completely private terminal chatbot with ollama-python. No key, no internet, no data leaving the laptop.
• Hands-on: a real-time voice assistant, microphone to speech-to-text to LLM to speech, with end-to-end latency measured.

Intermediate~9 hoursYou build: A multimodal extractor and a working voice agent.

• Chunking for real: recursive, semantic and fixed-size, and what each one ruins
• Vector databases in depth, with ChromaDB and Pinecone
• Hybrid search: BM25 keyword retrieval combined with vector retrieval
• Reranking with a cross-encoder or a hosted reranker
• HyDE and parent-child retrieval, for the queries plain similarity gets wrong
• Semantic routing: sending a question to the right pipeline based on what it is asking
• Hands-on: build the ingestion pipeline on ChromaDB with OpenAI embeddings, then add hybrid search and a reranker and measure exactly how much retrieval improved.
• Hands-on: the air-gapped build. Ollama for generation, local nomic embeddings, ChromaDB for storage, processing sensitive financial documents with nothing leaving the machine.

Advanced~10 hoursYou build: A cloud RAG service and an offline air-gapped one.

• Why "it looks good to me" collapses the moment a second person uses your app
• Retrieval metrics: hit rate, mean reciprocal rank, nDCG
• Generation metrics in RAGAS and DeepEval: faithfulness, answer relevance, context precision
• LLM-as-a-judge, and the ways it quietly lies to you
• Building a golden test set and keeping it alive as the product changes
• Hands-on: build a golden question-and-answer set for your own Module 8 RAG system, score retrieval and generation, then change the chunking and reranking and show the score move.

Advanced~7 hoursYou build: An evaluation harness you reuse on every project after this one.

• Why MCP exists, and what connecting a model to enterprise data looked like before it
• The client and server architecture
• Loading context, and drawing the security boundary around it
• Hands-on: write your own MCP server in Python that exposes a local file directory and a SQLite database to a desktop LLM client.

AdvancedYou build: A working MCP server on your GitHub.