Module 9 Wrap-up: The Safe Assistant
Hands-on: Implement a Bedrock Guardrail and verify your grounding instructions.
Hands-on: Implement a Bedrock Guardrail and verify your grounding instructions.
From Chatbot to RAG. Three hands-on projects to prove your mastery of Generative AI fundamentals.
Defining AI in simple terms and exploring everyday examples of AI in our world.
Understanding how Generative AI sits within the broader fields of Machine Learning and Deep Learning.
Predicting labels vs. creating new data. Understanding the fundamental shift in how AI assists us.
From rule-based systems to GANs and the massive Transformer breakthrough.
Reviewing the AI landscape and testing your ability to distinguish between different AI types.
Understanding the scale, training, and significance of models like GPT-4 and Claude.
From Tokens to Embeddings. Understanding the mechanics of how a computer 'reads' meaning.
Attention Mechanisms and Context. Understanding the 'Secret Sauce' that allows AI to reason across long documents.
Common failure modes. Why AI makes things up and how to detect biased or incorrect outputs.
Choosing your model. Comparing the strengths and tradeoffs of GPT-4, Claude, Gemini, and Llama.
Reviewing the mechanics of LLMs and conducting a comparative model experiment.
The Prompt as an Interface. Understanding why the quality of your input directly determines the utility of the AI.
Zero-shot, Few-shot, and Chain-of-Thought. The three pillars of professional AI interaction.
Defining Persona and Role. How to create an 'Invisible' layer of instructions that controls the AI's personality and safety.
From Text to Table. How to force the AI to return data in specific formats like JSON, Markdown, or CSV.
The Refinement Loop. How to treat prompting as an experiment rather than a one-off command.
Reviewing professional prompting techniques and completing a structured output project.
How AI draws. Understanding Diffusion models and the tools used to create stunning visual content from text.
The Sound of AI. Exploring text-to-speech, music generation, and the emerging frontier of AI-generated video.
AI as a Coding Assistant. How to use LLMs to write, debug, and explain programming languages.
Reviewing non-text GenAI and practicing image generation and code refactoring.
Connecting AI to Reality. How to ground AI responses in your own private data to prevent hallucinations.
The Memory of AI. Understanding how we store and search 'Meaning' using embeddings and specialized databases.
From Chatbot to Coworker. Understanding AI agents that can use tools and make autonomous decisions.
AI on your desktop. Learn why and how to run powerful models locally for total privacy and zero cost.
Reviewing the AI tech stack and building a simple RAG pipeline and local AI setup.
The Weight of Creation. Discussing deepfakes, copyright, and the environmental impact of large-scale AI.
Protecting the Prompt. Understanding prompt injection attacks and data leakage risks in AI systems.
Where we are heading. Discussing Small Language Models (SLMs), autonomous agents, and the new skills required for the AI era.
Finalizing the course with a discussion on ethics and an outlook on the AI co-pilot era.
The Final Challenge. Build a production-ready, agentic RAG system that analyzes companies and returns structured research reports via a REST API.
The starting point. How to set up a clean, isolated Python environment for your LangChain projects.
The core installation. Learning about LangChain's modular package structure and how to install the base library.
Connecting to the brains. How to install specialized packages for OpenAI, Anthropic, and local model providers.
Security First. How to securely manage your API keys using .env files and prevent accidental leaks.
The Hello World of AI. Initializing your first chat model and making a successful invocation.
Hands-on: Verify your complete installation and take the Module 1 challenge.
The Autonomous Mind. Understanding the difference between a static Chain and a dynamic Agent that makes its own decisions.
How the Agent decides. Deep dive into the mechanics of tool selection and processing tool outputs.
Guarding the Budget. How to prevent your agents from getting stuck in infinite loops and burning through your API credits.
Hands-on: Combine tools, memory, and reasoning into a single autonomous Research Agent.
From Stories to Schema. Why production AI must return machine-readable data (JSON) to interact with other software systems.
Parsing the Mess. Learning how to use OutputParsers to extract structured data even from older or less capable models.
Hands-on: Build an Information Extraction agent that converts raw text into a clean Python object.
Listening to the Chain. How to use the Callback system to intercept events like 'LLM Start' or 'Tool End' for logging and UI updates.
Connecting the Hearths. How to pass your custom handlers to models, tools, and executors to start capturing events.
Hands-on: Build a Cost-Monitoring Callback that calculates and prints the price of every AI request.
Finding the Bug. Techniques and tools for identifying where a multi-step chain is failing or hallucinating.