Generative AI Engineering Course: RAG & AI AgentsBuild AI Systems ThatThink With Your Data.

Introduce the role of an AI engineer and explain how LLMs behave inside real software. Students set up an LLM API securely and build their first conversational program in Python.

• AI engineering role
• LLM basics
• tokens
• context window
• temperature
• top_p
• model selection
• LLM providers
• API keys
• environment variables
• chat message roles
• conversation history
• latency and cost awareness

Hands-on lab: Build a command-line chatbot in Python that keeps conversation history and reports token usage per reply.

Teach students to write prompts that produce predictable, machine-readable results. Focus on turning free-text LLM output into validated data an application can trust.

• System prompts
• instructions
• few-shot prompting
• step-by-step reasoning
• prompt templates
• JSON output
• structured outputs
• Pydantic validation
• retries on invalid output
• prompt versioning
• hallucination awareness

Hands-on lab: Build a resume and invoice information extractor that returns Pydantic-validated JSON with automatic retry on invalid output.

Wrap LLM calls in a proper backend service. Students learn the engineering patterns that keep AI features fast, reliable and affordable in production.

• FastAPI AI endpoints
• async calls
• streaming responses
• server-sent events
• timeouts
• retries
• rate limits
• error handling
• response caching
• token and cost tracking
• logging
• provider abstraction

Hands-on lab: Build a FastAPI AI service with a streaming chat endpoint, retry logic and per-request cost logging.

Explain how text is converted into vectors that capture meaning. Students build semantic search from scratch before using any vector database.

• Embeddings
• vectors
• dimensions
• embedding models
• cosine similarity
• dot product
• semantic vs keyword search
• NumPy basics
• top-k search
• batching embeddings
• embedding cost

Hands-on lab: Build a semantic FAQ search engine from scratch using an embedding API, NumPy and cosine similarity.

Introduce vector databases and show how applications store, index and query millions of embeddings efficiently. Compare a dedicated vector store with PostgreSQL + pgvector.

• Vector databases
• ChromaDB
• PostgreSQL pgvector
• collections
• metadata
• persistence
• similarity search
• metadata filtering
• ANN indexing basics
• HNSW concept
• add/update/delete vectors
• choosing a vector store

Hands-on lab: Store a document collection in ChromaDB and pgvector, then run filtered similarity queries and compare results.

Teach students how raw business documents become searchable knowledge. Focus on loading, cleaning and chunking choices that decide RAG quality.

• RAG architecture overview
• document loaders
• PDF parsing
• DOCX and HTML parsing
• text cleaning
• fixed-size chunking
• recursive chunking
• semantic chunking
• chunk overlap
• chunk metadata
• ingestion pipelines
• re-indexing

Hands-on lab: Build an ingestion pipeline that converts a folder of PDFs and DOCX files into cleaned, chunked, embedded vectors with metadata.

Connect retrieval and generation into a working question-answering system. Students build RAG in plain Python first, then compare it with LangChain.

• Retrieve-augment-generate flow
• query embedding
• top-k retrieval
• context assembly
• grounding prompts
• source citations
• handling missing answers
• context window limits
• LangChain retrievers
• LangChain chains
• framework vs plain Python

Hands-on lab: Build a "Chat with your PDFs" Q&A system that answers only from the documents and shows source citations.

Show why basic vector search fails on real questions and teach the techniques production RAG systems use to retrieve the right context.

• Retrieval failure modes
• BM25 keyword search
• hybrid search
• reciprocal rank fusion
• cross-encoder reranking
• query rewriting
• multi-query retrieval
• HyDE
• parent-document retrieval
• metadata filtering
• conversational query condensing

Hands-on lab: Upgrade the Day 7 RAG system with hybrid search and reranking, then compare answers before and after on the same questions.

Teach students to measure RAG quality with data instead of guesswork, and to trace every request so failures can be debugged.

• Golden question datasets
• retrieval metrics
• recall@k
• MRR
• faithfulness
• answer relevance
• context precision
• LLM-as-judge
• RAGAS
• hallucination detection
• tracing
• Langfuse / LangSmith
• latency and cost monitoring

Hands-on lab: Build an evaluation suite that scores the RAG system on 20+ questions and produce a before/after quality report.

Turn the RAG pipeline into a usable web product. Students connect document upload, streaming answers and citations across the full stack.

• RAG API design
• document upload endpoint
• background ingestion
• streaming answers
• conversation memory
• chat history storage
• React chat UI
• citation display
• loading and error states
• per-user document collections
• basic access control

Hands-on lab: Build a Knowledge Base Assistant web app: React → FastAPI → vector database → LLM, with document upload and cited answers.

Explain what makes a system an agent and how LLMs call functions. Students write an agent loop from scratch before using any agent framework.

• What is an AI agent
• workflows vs agents
• function calling
• tool schemas
• JSON arguments
• ReAct pattern
• reason-act-observe loop
• tool results
• stopping conditions
• max iterations
• tool error handling

Hands-on lab: Build an agent from scratch in Python with calculator, web search and SQL database query tools.

Teach students to design controllable, multi-step agents as graphs. Focus on routing, state and human approval for actions with real consequences.

• LangGraph introduction
• graphs
• nodes
• edges
• shared state
• conditional routing
• tool nodes
• loops
• checkpoints
• human-in-the-loop approval
• interrupts
• prompt chaining
• routing and parallel patterns

Hands-on lab: Build a support-ticket triage agent that classifies tickets, routes them, drafts replies and waits for human approval before sending.

Combine RAG and agents so the agent decides when and where to retrieve. Introduce agent memory and MCP as the standard way to connect agents to tools and data.

• Retrieval as a tool
• agentic RAG
• self-correcting retrieval
• short-term memory
• long-term memory
• conversation summarisation
• Model Context Protocol
• MCP servers
• MCP clients
• tools
• resources
• connecting external services

Hands-on lab: Build a research assistant agent that chooses between the knowledge base and web search, and exposes a custom tool through an MCP server.

Show when multiple agents help and how to keep AI systems safe and affordable. Students containerize and deploy their AI application.

• Multi-agent patterns
• supervisor agent
• planner-executor
• agent handoffs
• prompt injection
• input guardrails
• output guardrails
• PII handling
• tool permission limits
• cost and token budgets
• Docker
• docker-compose
• environment configuration
• cloud deployment basics

Hands-on lab: Add guardrails and cost limits to the agent application, containerize it with Docker and deploy it to a cloud server.

Complete and demonstrate a production-style AI application combining RAG and agents. Focus on end-to-end integration, evaluation results, architecture explanation and presentation.

• End-to-end integration
• RAG and agent orchestration
• evaluation report
• tracing review
• debugging
• Git/GitHub workflow
• README and architecture diagram
• demo preparation
• project presentation
• AI engineering career paths

Hands-on lab: Complete the AI Knowledge & Operations Assistant with document RAG, tool-using agent, human approval step, React UI, evaluation report and Docker deployment.