Formation Building AI Applications

Module 1: Introduction to Modern AI Applications

• Course orientation and the learn-by-doing approach
• Evolution of AI systems, foundation models, and LLMs
• Reasoning models, and hosted versus local AI
• Why building with AI is now cheap: falling token prices
• Enterprise use cases, capabilities, and limitations
• Hallucinations and reliability concerns
• The Claude model family and how to choose

No lab, orientation and discussion: Course orientation and teaching philosophy, plus the evolution of AI systems and the model landscape behind the week's labs.

Module 2: Prompt and Context Engineering

• Principle 1: clear, specific instructions with delimiters, structured output, condition checks, few-shot
• Principle 2: give the model time to reason, with multi-step work and self-verification
• Iterative prompt refinement
• Summarizing, inferring, transforming, expanding
• The chat format, system prompts, and multi-turn conversations
• Model limitations and hallucination mitigation

Lab 01, effective prompting end to end: Guidelines, iterative refinement, summarizing, inferring, transforming, and expanding, finishing with a working chatbot.

Module 3: Working with the Claude API

• The Messages API: requests, responses, content blocks
• Token usage and cost, and choosing between models
• Structured outputs and JSON generation
• Streaming responses
• Handling responses safely and basic integration patterns

Lab 02, build a Claude-powered assistant: Call the Messages API, handle content blocks and streaming, and return structured JSON output safely.

Module 4: Embeddings and Semantic Search

• Keyword search and its limits
• Embeddings and semantic similarity
• Dense retrieval and approximate nearest neighbour search
• Reranking retrieved results
• Generating grounded answers from retrieved context

Lab 03, semantic search and retrieval: Compare keyword search with embedding-based retrieval, then rerank results and generate grounded answers.

Module 5: Retrieval-Augmented Generation with LangChain

• Document loading from PDF, web, and other sources, and chunking
• Embeddings into a vector store
• Retrieval strategies: similarity and MMR
• Building a question-answering chain over private documents
• Conversational retrieval with memory
• Vector database landscape: Chroma, pgvector, OpenSearch, Pinecone, Weaviate

Lab 04, RAG over your own documents: Load and chunk documents, embed them into a vector store, retrieve with similarity and MMR, and build a question-answering chain with conversation memory.

Module 6: LangChain Fundamentals

• Models, prompts, and output parsers
• Memory types: buffer, summary, token
• Chains: sequential and router chains
• Question answering over a product catalogue dataset
• LLM-based evaluation of outputs

Lab 05, LangChain building blocks: Models, prompts, output parsers, memory, and sequential or router chains applied to a product-catalogue dataset, with LLM-based evaluation.

Module 7: Functions, Tools, and Agents

• Tool use and function calling with Claude
• Turning plain Python functions into model tools
• Structured extraction and tagging with tools
• Tools and routing, and agent executors
• A conversational agent with memory

Lab 06, tools and function calling: Turn plain Python functions into model tools, add structured extraction and routing, and build a conversational agent with memory.

Module 8: Building Agentic AI Systems

• What an agent is: assistants versus agents, and degrees of autonomy
• Planning, reasoning, and reflection loops
• Self-correcting code generation
• Tool-using agents for weather, file writing, and research
• Multi-agent workflows and coordination
• Human-in-the-loop patterns and agent evaluation

Lab 07, build an agentic workflow: Planning, reflection, and self-correcting loops, then a multi-agent workflow with human-in-the-loop checkpoints.

Module 9: AI Agents over Structured Data

• Natural-language querying of CSV data with a pandas agent
• SQL agents over a relational database
• Function calling against a database
• Safety: injection prevention, role-based access, read-only access

Lab 08, natural-language database agent: Query CSV data with a pandas agent and a relational database with a SQL agent, then harden both with read-only access and role-based controls.

Module 10: Serverless LLM Applications on AWS

• Amazon Bedrock and Claude on Bedrock
• Generating text with foundation models through boto3
• A pipeline that transcribes audio and summarizes it with Claude
• CloudWatch logging and observability
• Deploying the pipeline as an AWS Lambda function
• Event-driven architecture triggered by an upload

Lab 09, serverless AI on AWS Lambda: Transcribe audio, summarize it with Claude on Bedrock, deploy the pipeline as a Lambda function, and enable CloudWatch logging.

Module 11: Agents and Guardrails on Bedrock

• Creating a Bedrock agent
• Connecting the agent to a system with action groups and Lambda
• Adding calculation and code capabilities
• Bedrock Guardrails: topic and content policies
• Attaching a knowledge base for grounded answers

Lab 10, Bedrock agent with guardrails and a knowledge base: Create the agent, connect it through action groups and Lambda, add calculation and code capabilities, then attach guardrails and a knowledge base.

Module 12: Multimodal and Advanced Models (Optional)

• Multimodal reasoning: image and document understanding
• Long-context summarization, multi-document work, and codebase question answering
• Prompt optimization and synthetic data generation
• Optional lab 11: multimodal and long context

Optional lab 11, multimodal and long context: Image and document understanding, long-context summarization, and prompt optimization, run provider-native with a substitute where the client environment requires it.

Module 13: The AI Application Threat Model

• How AI apps differ from normal apps: semantic versus syntactic attacks
• The OWASP GenAI and LLM Top 10 at a builder's altitude
• Where the risk lives: prompt, retrieval, tools, output, identity
• Mapping the earlier systems to their attack surface

No lab, interactive threat modeling: Students threat-model their own applications against the surface mapped in the earlier modules, using the OWASP LLM Top 10 as the checklist.

Module 14: Prompt Injection Defense

• Direct and indirect prompt injection
• Hidden instructions in documents, HTML, and Markdown
• Jailbreaks, role confusion, and context override attacks
• Layered defenses: instruction and data separation, input inspection, the operator channel, allow and deny policies

Lab 12, attack and defend a chatbot: Attack your own chatbot, bypass a naive filter, then build layered detection with instruction and data separation and allow or deny policies.

Module 15: Securing RAG Pipelines

• The RAG attack surface: ingestion, embeddings, retrieval, generation
• Poisoned documents and indirect injection through retrieved content
• Data exfiltration and cross-document contamination
• Defenses: ingestion sanitization, provenance scoring, metadata isolation, retrieval policies, output validation

Lab 13, poison and secure a RAG pipeline: Upload a poisoned PDF and take over the assistant, then add ingestion sanitization, provenance scoring, and retrieval scoping to stop it.

Module 16: Safe Tools and Agent Execution

• Excessive agency and tool abuse
• Unsafe tool execution, and SQL or command injection through agents
• Least-privilege tool design and scoped credentials
• Approval gates, human-in-the-loop, and sandboxing
• Secrets management: credentials out of prompts, tools, and memory

Lab 14, secure a tool-using agent: Harden the database agent and the tool-using agent with least privilege, approval gates, sandboxing, and scoped credentials.

Module 17: Guardrails, Validation, and Responsible AI

• Output validation and structured-output enforcement
• Guardrails: topic, content, and safety policies
• Handling refusals and unsafe generations
• Governance, auditability, logging, and human oversight
• Cost and abuse controls, including denial of wallet

Lab 15, guardrails and output validation: Add topic, content, and safety policies, enforce structured output, handle refusals, and add rate limits and cost budgets.

Module 18: Capstone: Harden Your AI Application

• Input inspection and prompt injection detection
• A sanitized, provenance-aware retrieval pipeline
• Least-privilege, approval-gated tools
• Output guardrails and validation
• Logging and abuse monitoring

Lab 16, harden your application: Apply input inspection, a provenance-aware retrieval pipeline, least-privilege tools, output guardrails, and abuse monitoring to the systems built across the week.