AI Engineer track · Course 2 of 3

Generative AI Engineering Bootcamp

The technical core of the AI Engineer track. You open up the transformer and implement attention yourself, then use that understanding to design, build and evaluate retrieval augmented generation (RAG) systems on PostgreSQL with indexing, hybrid search and pgvector at scale. The course ends with orchestration frameworks and a first pass at fine-tuning, ready for agents in AIE-3.

Enroll in Generative AI Engineering →See curriculum

Duration: 8 weeks · 56 hours
Format: Live online + self-study
First class: Free, no obligation
Level: Intermediate (after AIE-1)
Schedule: Evenings, US time zones
Lectures: 16 (notes · lab · quiz)
Certificate: Professional Certificate
Tuition: $500 per student, batch of 3 to 5 · payment plans

Course modules

What you'll master.

Module 1

Transformers & the Attention Mechanism

Query, key and value
Scaled dot-product and multi-head attention
Self-attention in Python

Module 2

Advanced Prompting & Structured Generation

Chain-of-thought and prompt chaining
Function and tool calling
JSON schema and Pydantic output

Module 3

Embeddings & Vector Databases

Choosing an embedding model
Chunking strategies
HNSW vs. IVFFlat, pgvector vs. others

Module 4

Advanced PostgreSQL for AI

EXPLAIN ANALYZE and index types
JSONB and full-text plus vector search
Window functions and CTEs

Module 5

RAG Pipelines End to End

Ingestion and chunking
Retrieval, re-ranking and citations
Orchestration and a streaming chat UI

Module 6

Evaluating & Optimizing RAG

Relevance, faithfulness, context precision and recall
Building an evaluation set
Latency and cost

Module 7

Fine-Tuning & Model Adaptation

Fine-tune vs. RAG vs. prompting
LoRA and QLoRA
Fine-tuning a small open model

Lecture by lecture

The complete 16-lecture path.

Every lecture includes a live class, self-study notes, a hands-on coding lab and a 10-question quiz.

01Why Attention: Query, Key & Value

Why attention replaced RNNs and LSTMs (Module 1)
Query, key and value intuition (Module 1)
Scaled dot-product attention, step by step (Module 1)
Recap: tokens and embeddings from AIE-1

LAB Compute attention weights by hand for a short sentence

02Multi-Head Attention & Transformer Designs

Multi-head attention (Module 1)
Positional encoding (Module 1)
Encoder-decoder vs. decoder-only (Module 1)
A minimal self-attention block in Python (Module 1)

LAB Implement self-attention from scratch in NumPy or PyTorch

03Reasoning Prompts & Prompt Chains

Chain-of-thought prompts (Module 2)
Prompt chaining for multi-step tasks (Module 2)
Evaluating and A/B testing prompts (Module 2)
Keeping prompts in version control

LAB A/B test two prompt chains on the same task

04Tool Calling & Structured Generation

Function and tool-calling schemas (Module 2)
JSON schema output (Module 2)
Validating responses with Pydantic (Module 2)
Handling invalid output

LAB Extract validated records from messy text with tool calling

05Embedding Models & Chunking

Comparing embedding models: dimensions and domain fit (Module 3)
Fixed-size, semantic and recursive chunking (Module 3)
Overlap and chunk size trade-offs
Measuring retrieval quality

LAB Benchmark chunking and embedding choices on a real document set

06Vector Indexes & Vector Databases

HNSW vs. IVFFlat (Module 3)
pgvector, Pinecone, Chroma and FAISS trade-offs (Module 3)
Metadata filtering (Module 3)
Hybrid retrieval (Module 3)

LAB Compare an HNSW index with a brute-force scan

07PostgreSQL Performance & Indexing

EXPLAIN and ANALYZE (Module 4)
B-tree, GIN and GiST indexes (Module 4)
Tuning pgvector indexes (Module 4)
Window functions and CTEs (Module 4)

LAB Tune a pgvector HNSW index and measure query time

08Hybrid Search & RAG Data Design

JSONB for flexible AI data (Module 4)
Full-text search plus vector search (Module 4)
Transactions and connection pooling (Module 4)
Schema design for RAG metadata (Module 4)

LAB Build a hybrid search query: full-text, vector and metadata filters

09Document Ingestion & Embedding Pipelines

Ingesting PDF, HTML and text (Module 5)
Preprocessing and cleaning (Module 5)
Chunking and embedding pipelines (Module 5)
Re-ingesting changed documents

LAB Build an ingestion pipeline into PostgreSQL

10Retrieval, Augmentation & Citations

Retrieval for a question (Module 5)
Prompt augmentation (Module 5)
Formatting citations (Module 5)
Answering "I don't know"

LAB Answer questions with cited sources from your pipeline

11Re-ranking, Orchestration & Chat UI

Re-ranking with cross-encoders (Module 5)
LangChain and LlamaIndex style chains (Module 5)
A Streamlit or Gradio chat interface (Module 5)
Streaming responses (Module 5)

LAB Build a RAG chatbot with re-ranking and citations

12Evaluating & Optimizing RAG

Relevance, faithfulness, context precision and recall (Module 6)
Building an evaluation dataset (Module 6)
Grounding and citations against hallucination (Module 6)
Caching and batching for latency and cost (Module 6)

LAB Evaluate your chatbot and fix its weakest metric

13When to Fine-Tune

Fine-tuning vs. RAG vs. prompt engineering (Module 7)
Full fine-tuning vs. parameter-efficient fine-tuning (Module 7)
LoRA and QLoRA (Module 7)
Compute and cost

LAB Decide fine-tune, RAG or prompting for four scenarios

14Fine-Tuning a Small Open Model

Preparing an instruction-tuning dataset (Module 7)
Training with Hugging Face PEFT (Module 7)
Evaluating the result (Module 7)
Comparing against the base model

LAB Fine-tune a small open LLM with LoRA on a custom dataset

15Capstone: RAG Knowledge Assistant

Architecture and data model (Capstone)
Hybrid search and re-ranking (Capstone)
Building the evaluation set (Capstone)
Instructor check-in

LAB Build the RAG knowledge assistant

16Capstone: Evaluation Report & Demo

Relevance and faithfulness results (Capstone)
Latency and cost results (Capstone)
Writing the evaluation report (Capstone)
Final demo

LAB Present the assistant and its evaluation report

AI Engineer track

Three courses, one path.

Each course builds on the one before it, so you can take them back to back as one program.

Course 1AI Engineering FoundationsBeginner · 4 weeks · 40 hours
Course 2Generative AI EngineeringIntermediate (after AIE-1) · 8 weeks · 56 hours
Course 3Agentic AI EngineeringAdvanced (after AIE-2) · 12 weeks · 60 hours

Before you start

Who it is for

Developers who finished AI Engineering Foundations (or have the same skills) and want to build production LLM and RAG apps

Prerequisites

AI Engineering Foundations (AIE-1): Python, SQL with PostgreSQL and basic LLM API use.

Tools you will use

PythonPyTorchPostgreSQLpgvector (HNSW, IVFFlat)LangChain or LlamaIndexHugging Face Transformers and PEFTAn LLM APIStreamlit or Gradio

Capstone project

What you will ship

A production-style RAG knowledge assistant over a real document collection, on PostgreSQL and pgvector with hybrid search and re-ranking, plus a written evaluation report (relevance, faithfulness, latency).

Assessment

Graded labs (40%), capstone RAG demo and evaluation report (60%)

Certificate

Professional Certificate: Generative AI Engineering, issued by Netwisers when you pass.

Outcomes

By the end you will

Implement self-attention, multi-head attention and positional encoding from first principles
Tune PostgreSQL and pgvector indexes for hybrid search
Build a complete RAG pipeline from ingestion to cited answers
Measure a RAG system for relevance, faithfulness, latency and cost
Adapt a small open model to a task with LoRA

Career paths

Roles this prepares you for

Generative AI EngineerLLM Application DeveloperAI Engineer (mid-level)

Includes resume review, LinkedIn optimization and mock interviews focused on the US job market.

Next cohort

Ready to start Generative AI Engineering?

Book a free consultation. We will confirm the next start date in your time zone and walk you through tuition and payment plans.