Shaya Rajpal, CEO of Guardrails AI, teaches how to add runtime checks to LLM outputs to catch hallucinations, off-topic responses, and data leaks. The course shows how to build validators from scratch and apply them to RAG chatbots for better reliability.
I'm delighted to introduce Safe and Reliable AI via Guardrails, built in partnership with Guardrails AI and taught by Shaya Rajpal, who is CEO Co Founder of Guardrails AI. In this course you learn to implement and use guardrails, which are safety mechanisms and validation tools included in AI applications, particularly those that use large language models or LLMs. Guardrails operate in real time to check the application output to make sure it behaves in a safe and reliable way. They provide a critical layer of control and oversight that enables more responsible AI interactions with your users. One of the biggest challenges in using oms to power applications is that their output is hard to predict in advance. Even small changes in the input prompt can lead to unpredictable changes in output. While there are a number of tools like prompting techniques, model fine tuning, alignment methods at RHF and rag. While techniques like that have significantly improved LLM accuracy, there's still some output variability and unpredictability. And this is where guardrails come in. These additional components of your applications work to check that the responses of an LLM conform to a set of rules and guidelines and can be used to prevent incorrect, irrelevant or sensitive information from being reviewed to users. Implementing guardrails can increase the trustworthiness and reliability of your application, and in this course, Shreya will show you how to build them.
That's right. You'll start by exploring some common failure modes for LLM powered applications, like hallucinations going off topic or revealing personal identifying information from retrieved text. And you'll do this using a lightweight chatbot that's built right into the course notebook. You'll then implement Guardrail's code from scratch to mitigate these failure modes, making use of state of the art validator models from Guardrail's hub. For each one, you'll try the guardrail you implemented in a RAG chatbot so that you can actually see it in action. After completing the course, you'll be able to work with the guardrail code pattern. You've learned to build custom guardrails for your use cases, and this will greatly improve the reliability of your LLM powered applications.
Guardrails are a key tool that you could use to make your applications more safe and reliable. I think they'll become increasingly important in the AI application stack, especially in industries with stricter safety, privacy or registry requirements. So I hope you enroll in this course and help ensure that the LLM applications you build are well behaved. I hope you enjoy the course.
