Prepare for Secure AI Development

0:00Hello and welcome to the first skill in the secure AI adoption and deployment course. My name is Jonathan Barrios and I'm excited that you're here. And if you're here, it's probably because it has something to do with one of the most important problems in AI. It's relatively easy to get into an AI model and to do something pretty impressive, because we can give a model a prompt and get a useful answer. And sometimes again, it's impressive, but we can connect it to documents. We can give it tools. We can build an agent and increasingly we can create an application that looks remarkably capable in a very short amount of time. But there is an enormous difference between getting an AI demo to work and building an AI system that an organization should actually trust in production. But before we get into any of that, a little bit about me. I teach data science, machine learning, and AI engineering, and I'm the founder of Barrios AI and co-founder of Kitari.

1:01I've also been a trainer for quite some time at top platforms like Treehouse, Thinkful, and Chegg, and now I'm happy to be part of CBT Nuggets. And if you look down here, you can find me at linkedin.com slash in slash Jonathan dash Barrios dash AI. And also here on my website, where I talk about the intersection of AI and music. And then finally here on X. And you can find me there at AI underscore data underscore science. And here's why I'm on X, it might not be totally apparent.

1:34And first, let me front load that I think that social media is a waste of time. So again, why am I on X? Well, it turns out that the greatest minds and they are posting the most amazing content daily, and sometimes even hourly. So if you want to keep in touch with all of that information, highly recommend to get an X account and just follow those accounts. Don't follow all the other stuff because there's a lot of noise. And if you want an easy way to stay up to date on X, just follow me here at x.com slash AI underscore data underscore science. And I do want to front load that this is also preparing for the course. So that's why this skill is called prepare for secure AI development and deployment. And the reason being, well, you should all have a programming background in one way or another, because we're going to assume that you have that knowledge, and that you can connect to an API, you know what an API is. But aside from that, AI adoption right now is kind of in a fever pitch. Everyone's racing to adopt this. And there's some mistakes that are being made and security vulnerabilities being exposed.

2:44And how do you even adopt or even get into deployment. So there's some differences with traditional software development. And that's what this skill is about. It's preparing you for those development environments that are slightly different than using an IDE. Although you can use an IDE, we are going to do it a little bit different. We're going to use Jupyter Notebook, and more specifically, an online cloud version of that called Colab. And if you want to install a local version, you can do that. And we're going to go through that. But we're also going to show you how you can use an IDE just as well, using different plugins that allow you to view the code in a notebook style. And I think that's really the takeaway. So if all of this sounds kind of like Greek, well, this is a perfect skill for you to start with. We're going to go through all of that, how to get an API, how to connect it to Google Colab, or your IDE, or your local Jupyter Notebook instance. So that's a local notebook. But the idea is that we want to work in a notebook environment. And that's all of the examples that I'm going to be using are in a notebook environment. So if that's off, it might be a little confusing. However, if you've been programming for quite some time, you're familiar with notebooks, and all of this sounds kind of

4:01familiar to you, you're more than happy to skip this skill and go straight to the first one, where we get into the different types of software. So this skill is really about preparing for the course. And we're also going to discuss what we're going to learn in this course, skill by skill. So we have 1516 skills in this course, and I'll show you each one of those, and kind of give you an idea of what we're going to cover. So that's what this skill is about. So it's up to you if you want to skip it or not. But I thought it was really important to add this skill just to make sure that I'm not leaving anybody behind, I want this to be as accessible as possible. However, if you already have this experience, totally fine to skip ahead. And earlier, I was saying that, well, you might have a demo, and it needs a prompt, a model and an answer, right? But a production system has to answer way more questions. For example, who is the user? What is the user allowed to access? What information can the model see? Where does that information even come from?

5:02Also, what actions can the system take? Which rules must remain deterministic, more on deterministic soon, if that is a new word for you? How do we know whether the answer is good? What happens when the model is wrong? And what gets logged and monitored? Also, what happens when the system fails in production? That's the gap that this course is designed to close. So really, in this course, we're going to go from an AI model and iteratively go to a production AI system. And I'm going to write that out. But in this preparation skill, it's really a course overview, development environment and the learning workflow. So now let's get a course overview. So what are we going to do here? So we'll first start with an AI model. And this AI model can be Anthropic, it can be OpenAI, Grok, Google's Gemini, it's more or less going to be course agnostic, but I am going to be using Anthropics Cloud. So if you want to follow along, I definitely recommend using Cloud and Anthropic. So use that API. That way, you're going to get a pretty similar experience. And so when we're starting at the AI model, this is really where we get understanding

6:20and we can get generation and reasoning. And then when we move into an application, this is where we have the prompts, context. And then here we have the response. So this is really about response handling, I should say. So we're turning the capability into some kind of a useful experience. So that's the first jump. And then we have knowledge and actions. These are going to be known as REG. And don't worry if that's a new term. It just means retrieval augmented generation.

6:55But we can also give the AI model tools and we definitely need APIs. And that combination is really knowledge plus actions. So it means that we're giving access to information and real world capabilities. So I'm going to add capabilities here. And down here, I'm just going to say useful user experience. Even though UX can mean a lot of things, I just mean user experience in the context of building out an AI model and turning it into some kind of a useful production AI system, right? Giving us a useful experience. And then something important happens, because when you give it all of these different things like tools, it has an API, of course, and then REG, well, that's where things can go wrong. So we need to really develop control. And that's about security, governance, and all kinds of stuff. So a checkmark here for security. And here we get into evaluation, which is a key part of building reliable and secure AI applications.

8:02So that's also reliability. And like I said, security. So this ensures safe, reliable, and trustworthy behavior. So the key word I think here is trust for that step. And then finally, once we clear all of those hurdles, then we have a production AI system. And I do this for a living. And I got to say, it's a little bit harder than it seems. But that's not a bad thing. Because you want to take your time through each one of these steps. You'll see that when we learn this, and then you start to implement this, it's super easy to miss something. And missing one little thing can actually have really unintended outcomes, even if you have a programming background.

8:46And in the next scale, we're going to get into deterministic and non-deterministic. Because when you forget a step in traditional programming, you usually get an error or something doesn't work, and you kind of understand why. But here, when you get any of these wrong, different things happen. It's actually counterintuitive. And when the model starts to just invent or hallucinate, these are all terms that we're going to talk about in this course, you get really unintended outputs. And that's why evaluation is so important. You need to peer into the system to understand what's actually happening, because you can't go inside of the model. That's a proprietary frontier model that you don't have access to their weights. Even though OpenAI says open, they're not. Those weights are not available to you. And even if they were, it'd be hard to understand what's happening. So that's not the way to do it. It's really evaluation. And evaluation gives you the ability to understand what's happening inside of your production AI system.

9:47So we'll get into that. So let's go ahead and finish the production AI system stage. And this is where we're going to focus on performance, observability, and also deployment and operations. And really, this is I'm going to put here value at scale. So a production AI system really delivers that value at scale. So the model generates, but the application controls. And that's really important because here, we're going to have real world impact. And so if we go all the way back to this one, first part, we see that the AI model is incredibly important, but it's just one component.

10:31And that's what we're doing in this course. A lot of people will just connect an API to just a little bit of code and some amazing things can happen. But that is not a production AI system. In fact, that's exactly how a lot of these nightmare stories that you hear on the internet happen. Like a production system deleted an entire database. That's not the fault of the AI model. That's the fault of the person that built the production AI system. And in this course, you're going to see exactly how that pans out. And furthermore, I would say this is exactly why secure AI adoption is really an architecture problem. We're not trying to eliminate probabilistic AI. We're trying to create value from that flexibility because it's part of what makes these systems useful in the first place. So our job really is to understand that behavior intelligently and combine it with deterministic software, security controls, evaluation, and operational evidence. And by the end of this course, I want you to be able to look at AI applications and see the system and not just the model. All right. In the next video, we're going to take a look at the actual skill and go skill by skill. And I think that's going to be very important because you'll see what the arc is of this entire course. And maybe you think I should

11:53probably take another course because I don't have the foundation. And that will be obvious when we start to talk about the arc. And I do have some suggestions for courses that will give you the foundational knowledge that you need if you feel that you don't have that knowledge. And we'll talk about that in the next video. See you there.

0:00Now let's look at how the course is building one system and why. Ideally, for me, I didn't want to write or create a bunch of skills that were just jumping around from concept to concept. I could, and it would work because you would learn a bunch of different concepts that are important. However, doing this sequentially, I think, is really much better. And I like to read a lot of books about education and something called neuroeducation, where you take neuroscience and combine it with education. And there's a lot of concepts that go into those books, and I really take them to heart. And I try to design these courses in a way that I feel is going to be more effective to get it into long-term memory, not just for certifications, but to be able to build secure AI applications, thinking about architecture. And so that's why this course is building one system. So we're going to build alongside the concepts together.

0:59And I feel that's a much stronger story arc, and stories is how we remember things. So it's kind of a story, but it's really one system. So the first part is understand, and we'll go over these together, and then extend. And then, like we talked about earlier, control, and then operate. So when I say understand, this is really where we get into the different types of software. And that's coming up in the next skill. There's software 1.0, 2.0, and 3.0. We'll get into that. And really, the idea there, so that you have something to hang it on to, is that AI didn't change software. It's just evolving, and kind of quickly. So there's software 1.0, which is traditional software. Then there's the second and the third versions. That's where AI kind of changes that evolution, and we'll discuss that in the next skill. And then we're going to talk about AI applications, prompts, and context. And this is where I would suggest prompt engineering.

2:04If you don't have a background in prompt engineering, you don't know what RAG is, it might help to have that understanding. But I am building this course in a way that you don't need that. But if you are the type of learner that enjoys to have foundations that build on each other, instead of just figuring it out as you go along, both are acceptable. Then I'm going to give you those suggestions so that you can take those courses as you go through this course, or I should say before you go through this course. And that's what we're doing in this skill. And I'm going to show you the actual course in just a second. And then we'll also, in this stage, it's really looking at model limitations. All right, then here for extends, this is again, when we're talking about RAG. If you don't know what this is, I am going to explain it. But you might want to take a foundational course that talks about prompt engineering and what RAG is. And also we'll get into tools and agents and workflows. But I do want to make clear that I am making this course for both beginner AI engineers and traditional programmers that don't have a machine learning or AI engineering background at all. So you might want to skip some videos if you have an AI engineering background

3:21already, some of this stuff is going to sound familiar. And for those of you who don't have that background, you just take it from the very beginning. But I'll be able to point out as we go through this course where those of you that have an AI engineering background might want to consider skipping a skill or two. And I'll make that clear. But I just wanted to note that this is an accessible course. So just keep that in mind. All right, and then what we're going to do is move into control. And by control, we mean evaluation, we talked about how important that one was. So I'm going to put a star next to that one, reliability. And we're going to explore this by building one system, which also includes guardrails. And most importantly, security.

4:08And then finally, operate. This is where we look at performance, observability, finally, deployment, and production architecture. So each skill is going to add another layer to that same system. And that's the idea. We start with a model, then we combine the application with the model, then we add application plus knowledge plus tools. And then we have that complete system up here. Alright, so now let's go take a look at the actual course and look at the different skills. Let me make this a little bit bigger. Actually, I'm going to make it really small so that you can see these are all the skills in this course. So now let's take a look at the first few. So this one, I've already explained what this skill is about. We're preparing for this course in essence. And if you have an AI engineering background, you could probably skip this one because you already know all the development environment tools that you would need notebook environments to be specific. And then here is explain software 1.0 2.0 and 3.0.

5:15And that's just so that we can see what changes when software behavior comes from explicit rules, learned models, and natural language instructions. And here build a modern AI application, we're going to essentially trace a request from the user through application code that includes the model API and then back again. That is probably one of the most insightful parts of this first section of the course. And then we're going to apply prompts, context, and model control. And we're really just focusing on prompt context and conversation history and model controls. And that's because we want to understand exactly what the application sends to the model. Number four or number five, I should say, explain model knowledge and limitations is really about asking the model. What do you know? And also, what do you not know?

6:18And we're going to explore why knowledge can be stale or missing and why fluent language should not automatically be treated as factual evidence. And now we've talked about prompts and model knowledge. Let me go over here in case you want to take a foundational course. We'll go over here. And if you go to CBT nuggets, and then you go to the catalog, by clicking on courses down here, you're going to see a bunch of courses. But what I suggest is going to author and then checking my name. And once you do that, you'll see different courses that I have. So let's scroll through here. These are this one right here is a certification. And this is a great introduction to machine learning and AI engineering to give you those different concepts that you need for foundational knowledge of AI engineering. And the reason I'm adding machine learning is that this is the best of both worlds. This is a great foundational course to take. But I wouldn't say take this after this course, though. And also know that this description here is incorrect, because the model, they use an AI in it, and it got it wrong, which is actually kind of appropriate for this course, you have to build a good AI application and do evaluation. So things like this doesn't happen, because they're unpredictable. So they'll probably fix this pretty quickly. But

7:39this is incorrect. Now, if we go down here, we have AI prompt engineering with chat GPT, Gemini This is the foundational course that I would recommend. There are a bunch of other mini courses. So we have, let me go down here, AI agent decoding, these are the different agent decoding tools. But I would go down here. And you can see that it's programming for data science, AI productivity for professionals, these are all good to have, in a sense, because they're short courses.

8:10But I would say this one right here, AI agentic. No, not that one. This one, AI prompt engineering with chat GPT, Gemini and Cloud is really the most foundational course. And it's very short, that would help you with this course. So we've talked about model knowledge, contacts and prompts and control and then rag. Those are all things that are going to be reinforced by this course on prompt engineering. And here for number five, we're going to ground AI with retrieval and rag.

8:45What that means is that we use retrieval and rag to give the model relevant external knowledge at runtime. And so rag just means retrieval, augmented generation, we'll get into that number six, or actually number seven, I should say, integrates software tools so that a model can request useful actions while execution remains under application control. So that's why we call this integrate AI models with software tools. Because this is the deterministic stable part. And this is the non deterministic unstable part, we'll get into the terms and really compare deterministic and non deterministic in this skill. And here, we're going to build a simple AI agent with goals, tools, state, a loop and explicit stopping conditions. So you might be asking, what is an AI agent, we're going to absolutely answer that here and build one out.

0:00And here, where we choose between workflows and agents, we're going to ask whether we need an agent at all. And also we're going to look at and learn how to choose between workflows and agents based on the problem you're trying to solve, rather than popularity of the technology. Because everyone's like, use AI agents for everything. And that's actually a terrible idea. And this is the skill where I'm going to drill into that. It's actually really important to talk about because of all the hype. And then here for evaluate AI application quality, this is where we get into the control system skills. So I would say the next four are going to be about control. So for this one here, this is where we introduced evaluation. And we do that so we can test correctness, grounding, usefulness, and behavior instead of deciding quality by looking at a few good demos. And that's a huge mistake. Look at it. Doesn't it work great?

1:04Maybe that time it did. But how about every other time? So evaluation is also going to give you a behind the scenes look at things that you might not be aware of. Like for example, cost. Maybe it's using an extreme amount of tokens and you don't know and then you get a bill and then you're very surprised. There's a lot of things that evaluation brings to the table. And we'll cover that in this skill. And this is a good segue, improve AI reliability and guardrails because well, as you saw before, there was a mistake in the catalog already. And we know that these models can hallucinate and we need to evaluate them. So in this scale, we're going to focus directly on guardrails, including validation, retries, fallbacks, autonomy, or I should say bounded autonomy. And finally, something very important, human review. And then for this one right here, secure AI applications and data. This is really focusing on security. So authentication, authorization, sensitive data, also really important prompt injection. Also retrieval boundaries, tool permissions, and deterministic security controls. Super important skill.

2:20And now we're getting into the system part of things. We want to optimize AI performance and cost. So that means that we're measuring performance and cost, including latency, tokens, model selection, streaming, caching, unnecessary model calls. And then here, we're going to monitor those AI applications in production because we need to cover deployment. But before we do, we need application observability with logs, traces, metrics, evaluation, and alerts. And then we deploy and operate AI application. And this is really the day-to-day operations, configuration, secrets, versioning, release gates, canaries, health checks, rollbacks, and what else? Incidents, last but not least. And then finally here, design a production AI system. This is where we put everything together in a complete production architecture, which I love doing because I think it really allows you to remember everything that we've covered up to this point. And it asks whether the system is actually ready to operate.

3:31And this is all very intentional. Every skill in this order has a goal and a purpose because every new capability creates new questions that the next skill is going to help us answer. And you might be asking, well, how are we going to build this stuff? And we're going to use Google Colab, which is a cloud version of Jupyter Notebook. So this is a cloud-hosted notebook. But there is Jupyter Notebook, which used to be called IPython Notebook, and that's why these file extensions are .ipynb. If you ever see this, it's because it used to have the name IPython Notebook. And they were like, yeah, that name is terrible. So let's call it Jupyter Notebook. And that's what it's called now. And this is a local version.

4:25And this one here is a cloud version. And that's the only difference. I mean, there are some differences in the way that it looks and the way it behaves. One's on the cloud, one's on your machine locally. But they're pretty much very, very, very similar. So we have your laptop here. Let me block this off. Now we're talking about Google Colab Notebook. So this is your laptop. It connects to the internet, meaning on a data center on a machine somewhere in Google's data center. And then you open it in your browser. And it has text cells, Python code cells. And then it just immediately gives you an output after each cell, if you like. And again, it runs in your browser. There's no local Python setup required. And it's great for learning and experimentation.

5:15A lot of researchers use Colab. And also Colab lets us use the AI system instead of initial setup, meaning you can use different powerful GPUs, and some of them for free. And you also have Gemini built in. And I'm going to show you how all of this works. It's pretty cool. When you're using Jupyter Notebook, there's no Gemini. But you probably have a model running locally, or you have access to some kind of a chatbot. So either way, you're going to have AI to help you as you progress through each development environment. And that's not to say that you can't use an IDE. You absolutely can. And people do. And there are these different extensions. For example, if you use Visual Studio Code, you can get an extension so that you can get a notebook experience. And that's what you want to do so that you can get these different cells.

6:07And I'm going to show you exactly what these different cells do in Colab. In fact, let's do that right now. Go over here. And here it is right in the browser. It says introduction.ipynb. Remember, it used to be called iPython Notebook. That's the file extension. But it's now Google Colab here. And if it's locally, I'll show you that in just a second as well. This is basically what you do. So you have a coding cell. But if you hover over here, you can create a text cell.

6:38But let's just do something simple. Let's do the print. The classic hello world. Like this. And if I use shift enter, or I hit play, then it connects to a cloud server over here. And then immediately, you're going to get an output down here. And if I do this multiple times, it's the same output. And that's called deterministic. We'll get into that in the next scale. But this is basically how you do that. And if you have a text cell, it allows you to use markdown. So it says new section, and you can see a preview over here.

7:16And then you can do something like lorem ipsum. I'm just going to actually write it dot, dot, dot like this. And then you can add links and all kinds of stuff, even LaTeX here, or some math. So if I enter shift enter, then it renders into this section. So this is really very, very useful. And you can just put this up here, and it can be heading and some code, and you can share the notebook. It's pretty wonderful, to be honest. I really like using Google Colab for teaching. And like I said, you can talk to Gemini right here. So you have Gemini 2.5 and Gemini 3. But if you want to pay for it, you can go to 3.1 Pro. That's just an option.

8:03And if you go to runtime and change runtime type, you have a CPU here, but you can also get a T4 GPU. Let me say OK. And that's for free. But if you want premium GPUs, you need to upgrade to Google AI Ultra. And then you have these different other models like a A100 GPU and so on. And I'm going to just cancel out of that. And I think that's enough to get us started. All right, so I will see you in the next video where we look at Jupyter, Conda and Anaconda. This is another very popular way to develop in a notebook environment, but this time locally.

0:00Welcome back. So now we have Jupyter, Conda, and Anaconda, which are different things, but they work together. And this is a local version of Colab. So Colab is something that came after Jupyter Notebook. So what is Jupyter? So Jupyter is more than Jupyter Notebook. And I'm just going to focus on Jupyter Notebook here. So I'm just going to write Jupyter Notebook. And again, it runs in your browser, but this time it's local. So that's the difference. And then it has the same cells, just like Colab that you execute. They can be code cells or they can be text cells. And it runs with Markdown in the same way. And it gives you that interactive Python output. So you can think of Jupyter Notebook as the workspace, right? Or like an IDE.

0:50But instead of calling it an IDE, we call it a notebook because it kind of looks like a notebook. So that's kind of why it's cool. And then we have Conda, which is part of Anaconda. So what is Anaconda? What are all these snake names, you know? Well, I guess it's because of Python. So once Python got into the game, then there's all these snakes. So what is Conda do? So Conda, you can think of it like this. Let's say you have project A, and project B. So they're going to have different Python and different packages, right? So you could have different Python versions. Let's say, for some reason, you need some Python 2 point something. And then here is Python 3 something, okay? And then you might have some packages that are more for data visualization. And then this one is more for machine learning and so on, right? So essentially, it's an environment and package manager, it keeps these separated, right? So it manages environments. So I'm going to say environment manager, right? So then what is Anaconda? Well,

2:07this is called a Python distribution. And by that, I mean that it includes Python, Conda, Jupyter, and a bunch of other common packages for data science, machine learning, and AI engineering, all that good stuff. So I could say that package or that Anaconda rather, packages the tools together. So now let's take a look at these websites. And we'll start off with Jupyter. And like I said, there's more than one thing here.

2:42If I scroll down here, you have JupyterLab, they call it a notebook interface. Then there's Jupyter Notebook, this is the classic notebook interface. And then there's JupyterHub, then voila, share your results. And there's a lot more to it. But really, this is the only one that we would need to use, you try it in your browser locally. And you can install the notebook, but it's include all of this is included inside of Anaconda. So you can get started, sign up with an email. So I logged in here, and I'm going to just install this right here. I think this is probably the easiest way to do it. You can use a command line too, if you'd like to do that. There's also Miniconda because Anaconda is quite large. So if you explore Miniconda, you could do that too. And then Conda is going to be included in that as well. So it has Jupyter Notebook and Conda baked all into the same thing. So right about now, you might be asking, well, then how do you use all this stuff? Well, let's say that you downloaded this Anaconda distribution, graphical installer, you just basically follow the prompts. So you're just going to go ahead and install this. And then I'm going to create a new project over here.

4:04This is called this Jupyter. And then you can open up the terminal here, drag this in. Now we're in that directory. And so that's the first thing. And then you want to use Conda. So we can say Conda env list. And you can see that I have challenge or base. So let's go ahead and, I don't know, let's create a new one. Actually, let's go ahead and activate one of these.

4:36Conda activate. And now you can see that I'm inside of this Conda environment. And if I type in Jupyter, and if I have it installed, and I can't remember if I do or not on this one, it'll open it in a browser. So I'm just going to Oh, actually, you just type in Jupyter without Conda, my bad, or Jupyter notebook without Conda. And just like that, it opens up right here. So I'm going to click on new and notebook.

5:10And I'm going to select this. And then we have the same thing I can do print. Hello, world. And I run it and immediately it runs because it doesn't have to connect to a cloud somewhere. So that's the main difference. If I go back over here, and I use Command or Ctrl C, we can shut this down. So it's a server basically running in your browser locally. But you need to use Conda install, and then you can name a package here.

5:41So like TensorFlow, or whatever you need, maybe you need pandas, then you would install it here. But a lot of these already installed for you. But the main separation here is that you are managing the packages, they're installed when you have Anaconda installed, but you need to install them into the environment so that you can keep them separate. So you can choose what version of Python that you want to use, you can choose the packages that go in there and you can keep them separated. And then that's pretty much the flow. And then when you're done, you go back here, you say Conda deactivate. And then you're back to a clear terminal.

6:23But you can also use Visual Studio Code or PyCharm. And that allows you to use an extension. For example, if I say code period, we can open Visual Studio Code. And you can see that I already have this extension installed. If I click on this, you can see code cells, same thing. So I'm going to say hello world again. Well, hello world, exclamation mark, run that. And it's going to ask for Python environments, there's a little bit of a setup here. And I'm going to use the same one that we were using before 3.115, which is for that challenge environment. And these are the different environments that you can sort of create in the terminal and then go over here.

7:14And rightfully so there's no end quotations. So I'm going to run it now. And zero seconds, we get hello world. And I can also trash these right here. And you can also add markdown h1. And you can see that there. All right. And now you can see that we can do this in an IDE. And instead of Gemini, you can use Claude. And you could ask Claude something right here as well. And you might be asking, well, why would I want to use an IDE over Colab or Jupyter Notebook?

7:47Just think of it like this. If you're working in the course with me, or you're doing research, you're doing research, or you're building something and prototyping, you might want to use a notebook, especially Colab, because it's very convenient. If you like working locally, that's something that you've been doing, then you probably are going to use Jupyter Notebook. But if you're working in a much larger production environment, you're probably going to use an IDE. It actually has all the development tools that you need as a software developer. And AI engineers use those in development environments for many reasons, mostly because you're about to deploy a production AI system. So there's some advantages there.

8:26Linting, for example. But you can also use Cursor, or Claude Code to help you with agentic programming as well. So there's some benefits there. You can kind of do that inside of Jupyter Notebook or Colab with Gemini, you can, but the IDE has a lot more advantages for many, many reasons. Alright, so now that we have the development environments out of the way, what's next?

8:57Well, that's going to be your application talks to models through APIs. That's the next logical step. Because the provider can change, but the application pattern is going to remain the same. And that's why I was saying earlier, you can use different models, but they are going to have different personalities and different behaviors. So you would have to do some testing every time you change. But generally, you can just plug another API in there. So let's say that we have your Python application right here. And you build features, you can send requests. And this is also where you handle responses. And this is actually where you integrate into your product. And you're going to use HTTPS, normally, API calls, and it goes back and forth to the model API here. And again, this could be different models, right? It could be, let's say, Anthropic, which has Cloud, it could be OpenAI that has a bunch of different models. Now that we've just launched a bunch of

10:17them called Terra, Astra, and others, you can use Google has Gemini, you can use XAI has Grok. Hugging Face is a great place to look at models too. So I'm going to add them and they have a lot of models. But you could also use some other provider. And the main idea here is that the chat app is not the same thing as the API. So chat apps are built on top of the API, and your application directly calls that API. So here, we're going to have this back and forth, it's going to be requests and responses. And here in the model API, this is the standard interface. And this is where you send the prompts. And you also receive completions, that's what they're called. And they're simple to switch providers, like I was saying before, but the most important part is that you're going to need an API key. And we're going to put that into Colab. That's what we're going to do in this course. So you have that API key and don't hard code the keys, you want to, you don't want to expose those, we'll talk about that. And inside of Colab, you can put it into secrets, that's a

11:32secret store. And this stores the keys securely and lets your application read them. So it's pretty straightforward in Colab, I'll show you how that works. And then that means that your application that we write inside of Google Colab can use that API because it has secure access to that API key, meaning that the application reads the key from the config. And it's if you're doing this locally, you're going to use environment variables, right, dot env. And you need to have some sort of code that is able to read that securely.

0:00And that's pretty much the skill. So that's a wrap. And the way that works is like this. Now, here we are in the challenge section. And the idea here is to test your knowledge. We're really trying to find knowledge gaps. So if you identify a gap in any of your understanding of any of the videos above, just review the appropriate video before moving forward. And the idea there is that we're really trying to create small iterative learning curves going up, right? If you skip a concept or you move on to the next skill and you have knowledge gaps, it just increases the size of that learning curve and it makes it more difficult to learn and it's not as fun. So this is a really powerful course and it's one of the most valuable skills that you can learn today. And I'm really excited for us to do this because it's going to be, number one, a lot of fun because we're going to build stuff along the way. And number two, we're going to help our organizations make sure that we deploy AI systems with sound architecture and safety and security built in.

1:06All right. Until next time, I hope this has been informative and I'd like to thank you for viewing.