Prepare for Secure AI Development

0:00Hello and welcome to the first skill in the secure AI adoption and deployment course.

0:06My name is Jonathan Barrios and I'm excited that you're here. And if you're here, it's probably

0:11because it has something to do with one of the most important problems in AI. It's relatively

0:17easy to get into an AI model and to do something pretty impressive, because we can give a model

0:24a prompt and get a useful answer. And sometimes again, it's impressive, but we can connect it to

0:30documents. We can give it tools. We can build an agent and increasingly we can create an application

0:36that looks remarkably capable in a very short amount of time. But there is an enormous difference

0:42between getting an AI demo to work and building an AI system that an organization should actually

0:48trust in production. But before we get into any of that, a little bit about me. I teach data science,

0:55machine 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,

1:06and now I'm happy to be part of CBT Nuggets. And if you look down here, you can find me at

1:12linkedin.com slash in slash Jonathan dash Barrios dash AI. And also here on my website, where I talk

1:20about the intersection of AI and music. And then finally here on X. And you can find me there at

1:26AI 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

1:39I on X? Well, it turns out that the greatest minds and they are posting the most amazing content

1:46daily, and sometimes even hourly. So if you want to keep in touch with all of that information,

1:52highly recommend to get an X account and just follow those accounts. Don't follow all the other

1:57stuff because there's a lot of noise. And if you want an easy way to stay up to date on X, just

2:03follow me here at x.com slash AI underscore data underscore science. And I do want to front load

2:10that this is also preparing for the course. So that's why this skill is called prepare for secure

2:16AI development and deployment. And the reason being, well, you should all have a programming

2:23background in one way or another, because we're going to assume that you have that knowledge,

2:27and that you can connect to an API, you know what an API is. But aside from that,

2:33AI adoption right now is kind of in a fever pitch. Everyone's racing to adopt this. And

2:39there'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

2:51traditional software development. And that's what this skill is about. It's preparing you for those

2:56development environments that are slightly different than using an IDE. Although you can

3:01use an IDE, we are going to do it a little bit different. We're going to use Jupyter Notebook,

3:07and more specifically, an online cloud version of that called Colab. And if you want to install a

3:13local version, you can do that. And we're going to go through that. But we're also going to show you

3:18how you can use an IDE just as well, using different plugins that allow you to view the

3:23code in a notebook style. And I think that's really the takeaway. So if all of this sounds

3:29kind of like Greek, well, this is a perfect skill for you to start with. We're going to go through

3:34all of that, how to get an API, how to connect it to Google Colab, or your IDE, or your local

3:41Jupyter Notebook instance. So that's a local notebook. But the idea is that we want to work

3:46in a notebook environment. And that's all of the examples that I'm going to be using are in a

3:51notebook environment. So if that's off, it might be a little confusing. However, if you've been

3:56programming 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,

4:06where we get into the different types of software. So this skill is really about preparing for the

4:11course. And we're also going to discuss what we're going to learn in this course, skill by skill.

4:17So we have 1516 skills in this course, and I'll show you each one of those, and kind of give you

4:22an idea of what we're going to cover. So that's what this skill is about. So it's up to you if

4:27you want to skip it or not. But I thought it was really important to add this skill just to make

4:31sure that I'm not leaving anybody behind, I want this to be as accessible as possible. However,

4:38if you already have this experience, totally fine to skip ahead. And earlier, I was saying that,

4:43well, you might have a demo, and it needs a prompt, a model and an answer, right? But a

4:49production system has to answer way more questions. For example, who is the user? What is the user

4:56allowed 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

5:10deterministic soon, if that is a new word for you? How do we know whether the answer is good?

5:16What happens when the model is wrong? And what gets logged and monitored? Also, what happens

5:21when the system fails in production? That's the gap that this course is designed to close.

5:28So really, in this course, we're going to go from an AI model and iteratively go to a production

5:35AI system. And I'm going to write that out. But in this preparation skill, it's really a course

5:42overview, development environment and the learning workflow. So now let's get a course overview. So

5:49what are we going to do here? So we'll first start with an AI model. And this AI model can be

5:55Anthropic, it can be OpenAI, Grok, Google's Gemini, it's more or less going to be course agnostic,

6:02but I am going to be using Anthropics Cloud. So if you want to follow along, I definitely

6:07recommend using Cloud and Anthropic. So use that API. That way, you're going to get a pretty similar

6:13experience. 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

6:27we have the prompts, context. And then here we have the response. So this is really about response

6:35handling, I should say. So we're turning the capability into some kind of a useful experience.

6:41So that's the first jump. And then we have knowledge and actions. These are going to be

6:48known 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

7:06really knowledge plus actions. So it means that we're giving access to information and real world

7:12capabilities. So I'm going to add capabilities here. And down here, I'm just going to say useful

7:18user experience. Even though UX can mean a lot of things, I just mean user experience

7:24in the context of building out an AI model and turning it into some kind of a useful

7:29production AI system, right? Giving us a useful experience. And then something important happens,

7:37because when you give it all of these different things like tools, it has an API, of course,

7:42and then REG, well, that's where things can go wrong. So we need to really develop control. And

7:48that's about security, governance, and all kinds of stuff. So a checkmark here for security. And

7:55here 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,

8:09and trustworthy behavior. So the key word I think here is trust for that step. And then finally,

8:16once we clear all of those hurdles, then we have a production AI system. And I do this for a living.

8:24And I got to say, it's a little bit harder than it seems. But that's not a bad thing. Because you

8:29want to take your time through each one of these steps. You'll see that when we learn this, and

8:34then you start to implement this, it's super easy to miss something. And missing one little thing

8:40can 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

8:51when you forget a step in traditional programming, you usually get an error or something doesn't

8:56work, and you kind of understand why. But here, when you get any of these wrong, different things

9:02happen. It's actually counterintuitive. And when the model starts to just invent or hallucinate,

9:09these are all terms that we're going to talk about in this course, you get really unintended

9:15outputs. And that's why evaluation is so important. You need to peer into the system to

9:20understand what's actually happening, because you can't go inside of the model. That's a proprietary

9:25frontier model that you don't have access to their weights. Even though OpenAI says open,

9:32they're not. Those weights are not available to you. And even if they were, it'd be hard to

9:36understand what's happening. So that's not the way to do it. It's really evaluation. And evaluation

9:42gives 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

9:54is where we're going to focus on performance, observability, and also deployment and operations.

10:02And really, this is I'm going to put here value at scale. So a production AI system really delivers

10:10that value at scale. So the model generates, but the application controls. And that's really

10:17important because here, we're going to have real world impact. And so if we go all the way back to

10:23this 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

10:35to just a little bit of code and some amazing things can happen. But that is not a production

10:40AI system. In fact, that's exactly how a lot of these nightmare stories that you hear on the

10:46internet happen. Like a production system deleted an entire database. That's not the fault of the

10:52AI model. That's the fault of the person that built the production AI system. And in this course,

10:58you're going to see exactly how that pans out. And furthermore, I would say this is exactly why

11:03secure AI adoption is really an architecture problem. We're not trying to eliminate probabilistic

11:10AI. We're trying to create value from that flexibility because it's part of what makes

11:16these systems useful in the first place. So our job really is to understand that behavior

11:22intelligently and combine it with deterministic software, security controls, evaluation, and

11:28operational evidence. And by the end of this course, I want you to be able to look at AI

11:33applications and see the system and not just the model. All right. In the next video, we're going

11:39to take a look at the actual skill and go skill by skill. And I think that's going to be very

11:46important 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

11:58start to talk about the arc. And I do have some suggestions for courses that will give you the

12:02foundational knowledge that you need if you feel that you don't have that knowledge. And we'll talk

12:07about that in the next video. See you there.

0:00Now let's look at how the course is building one system and why.

0:04Ideally, for me, I didn't want to write or create a bunch of skills that were just jumping around

0:11from concept to concept. I could, and it would work because you would learn a bunch of different

0:16concepts that are important. However, doing this sequentially, I think, is really much better.

0:24And I like to read a lot of books about education and something called neuroeducation,

0:29where you take neuroscience and combine it with education. And there's a lot of concepts that go

0:34into those books, and I really take them to heart. And I try to design these courses in a way that I

0:40feel is going to be more effective to get it into long-term memory, not just for certifications,

0:46but to be able to build secure AI applications, thinking about architecture. And so that's why

0:52this 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.

1:04So it's kind of a story, but it's really one system. So the first part is understand,

1:11and we'll go over these together, and then extend. And then, like we talked about earlier, control,

1:20and then operate. So when I say understand, this is really where we get into the different types

1:26of software. And that's coming up in the next skill. There's software 1.0, 2.0, and 3.0. We'll

1:33get into that. And really, the idea there, so that you have something to hang it on to, is that

1:39AI didn't change software. It's just evolving, and kind of quickly. So there's software 1.0,

1:46which is traditional software. Then there's the second and the third versions. That's where AI

1:50kind of changes that evolution, and we'll discuss that in the next skill. And then we're going to

1:56talk 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,

2:09it might help to have that understanding. But I am building this course in a way that you don't

2:13need that. But if you are the type of learner that enjoys to have foundations that build on each

2:19other, instead of just figuring it out as you go along, both are acceptable. Then I'm going to give

2:24you those suggestions so that you can take those courses as you go through this course, or I should

2:30say before you go through this course. And that's what we're doing in this skill. And I'm going to

2:34show you the actual course in just a second. And then we'll also, in this stage, it's really looking

2:42at model limitations. All right, then here for extends, this is again, when we're talking about

2:48RAG. If you don't know what this is, I am going to explain it. But you might want to take a

2:54foundational course that talks about prompt engineering and what RAG is. And also we'll get

2:59into tools and agents and workflows. But I do want to make clear that I am making this course for both

3:09beginner AI engineers and traditional programmers that don't have a machine learning or AI engineering

3:15background 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

3:26that background, you just take it from the very beginning. But I'll be able to point out as we

3:30go through this course where those of you that have an AI engineering background might want to

3:35consider skipping a skill or two. And I'll make that clear. But I just wanted to note that this

3:40is an accessible course. So just keep that in mind. All right, and then what we're going to do

3:45is move into control. And by control, we mean evaluation, we talked about how important that

3:52one was. So I'm going to put a star next to that one, reliability. And we're going to explore this

4:00by building one system, which also includes guardrails. And most importantly, security.

4:08And then finally, operate. This is where we look at performance, observability,

4:15finally, deployment, and production architecture. So each skill is going to add another layer to

4:24that same system. And that's the idea. We start with a model, then we combine the application

4:31with the model, then we add application plus knowledge plus tools. And then we have that

4:37complete system up here. Alright, so now let's go take a look at the actual course and look at

4:42the different skills. Let me make this a little bit bigger. Actually, I'm going to make it really

4:48small so that you can see these are all the skills in this course. So now let's take a look at the

4:53first few. So this one, I've already explained what this skill is about. We're preparing for

4:57this course in essence. And if you have an AI engineering background, you could probably skip

5:02this one because you already know all the development environment tools that you would need

5:07notebook 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,

5:20learned models, and natural language instructions. And here build a modern AI application,

5:30we're going to essentially trace a request from the user through application code that includes

5:36the model API and then back again. That is probably one of the most insightful parts

5:43of this first section of the course. And then we're going to apply prompts, context,

5:49and model control. And we're really just focusing on prompt context and conversation history

5:56and model controls. And that's because we want to understand exactly what the application sends

6:02to the model. Number four or number five, I should say, explain model knowledge and limitations

6:11is 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

6:22should not automatically be treated as factual evidence. And now we've talked about prompts and

6:28model knowledge. Let me go over here in case you want to take a foundational course. We'll go over

6:33here. And if you go to CBT nuggets, and then you go to the catalog, by clicking on courses down

6:41here, you're going to see a bunch of courses. But what I suggest is going to author and then

6:46checking my name. And once you do that, you'll see different courses that I have. So let's scroll

6:52through here. These are this one right here is a certification. And this is a great introduction to

6:58machine learning and AI engineering to give you those different concepts that you need for

7:03foundational knowledge of AI engineering. And the reason I'm adding machine learning is that

7:08this is the best of both worlds. This is a great foundational course to take. But I wouldn't say

7:15take this after this course, though. And also know that this description here is incorrect,

7:21because the model, they use an AI in it, and it got it wrong, which is actually kind of appropriate

7:27for this course, you have to build a good AI application and do evaluation. So things like

7:32this 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

7:47This is the foundational course that I would recommend. There are a bunch of other mini

7:52courses. So we have, let me go down here, AI agent decoding, these are the different agent decoding

7:58tools. But I would go down here. And you can see that it's programming for data science, AI

8:03productivity 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

8:18with chat GPT, Gemini and Cloud is really the most foundational course. And it's very short,

8:25that would help you with this course. So we've talked about model knowledge, contacts and prompts

8:31and control and then rag. Those are all things that are going to be reinforced by this course

8:39on 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

8:50runtime. And so rag just means retrieval, augmented generation, we'll get into that

8:55number six, or actually number seven, I should say, integrates software tools so that a model

9:00can request useful actions while execution remains under application control. So that's why we call

9:08this integrate AI models with software tools. Because this is the deterministic stable part.

9:14And this is the non deterministic unstable part, we'll get into the terms and really compare

9:20deterministic and non deterministic in this skill. And here, we're going to build a simple AI agent

9:27with goals, tools, state, a loop and explicit stopping conditions. So you might be asking,

9:33what 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

0:06an agent at all. And also we're going to look at and learn how to choose between workflows and

0:13agents based on the problem you're trying to solve, rather than popularity of the technology.

0:18Because everyone's like, use AI agents for everything. And that's actually a terrible idea.

0:25And this is the skill where I'm going to drill into that. It's actually really important to

0:30talk about because of all the hype. And then here for evaluate AI application quality,

0:36this is where we get into the control system skills. So I would say the next four are going

0:42to be about control. So for this one here, this is where we introduced evaluation. And we do that

0:50so we can test correctness, grounding, usefulness, and behavior instead of deciding quality by

0:57looking 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

1:11a behind the scenes look at things that you might not be aware of. Like for example, cost. Maybe

1:17it's using an extreme amount of tokens and you don't know and then you get a bill and then you're

1:22very surprised. There's a lot of things that evaluation brings to the table. And we'll cover

1:27that in this skill. And this is a good segue, improve AI reliability and guardrails because

1:34well, as you saw before, there was a mistake in the catalog already. And we know that these models

1:40can hallucinate and we need to evaluate them. So in this scale, we're going to focus directly

1:44on guardrails, including validation, retries, fallbacks, autonomy, or I should say bounded

1:52autonomy. And finally, something very important, human review. And then for this one right here,

1:58secure AI applications and data. This is really focusing on security. So authentication,

2:06authorization, sensitive data, also really important prompt injection. Also retrieval

2:13boundaries, 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

2:25cost. So that means that we're measuring performance and cost, including latency,

2:31tokens, model selection, streaming, caching, unnecessary model calls. And then here,

2:38we're going to monitor those AI applications in production because we need to cover deployment.

2:45But before we do, we need application observability with logs, traces, metrics,

2:51evaluation, and alerts. And then we deploy and operate AI application. And this is really

2:58the day-to-day operations, configuration, secrets, versioning, release gates, canaries,

3:06health checks, rollbacks, and what else? Incidents, last but not least. And then finally here,

3:14design a production AI system. This is where we put everything together in a complete production

3:20architecture, which I love doing because I think it really allows you to remember everything that

3:26we'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

3:38because every new capability creates new questions that the next skill is going to help us answer.

3:46And you might be asking, well, how are we going to build this stuff? And we're going to use

3:51Google Colab, which is a cloud version of Jupyter Notebook. So this is a cloud-hosted

4:00notebook. But there is Jupyter Notebook, which used to be called IPython Notebook,

4:06and that's why these file extensions are .ipynb. If you ever see this, it's because it used to

4:14have the name IPython Notebook. And they were like, yeah, that name is terrible. So let's

4:19call 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

4:32differences in the way that it looks and the way it behaves. One's on the cloud, one's on your

4:36machine locally. But they're pretty much very, very, very similar. So we have your laptop here.

4:43Let me block this off. Now we're talking about Google Colab Notebook. So this is your laptop.

4:50It connects to the internet, meaning on a data center on a machine somewhere in Google's data

4:56center. And then you open it in your browser. And it has text cells, Python code cells. And then it

5:04just immediately gives you an output after each cell, if you like. And again, it runs in your

5:09browser. 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,

5:21meaning you can use different powerful GPUs, and some of them for free. And you also have

5:30Gemini built in. And I'm going to show you how all of this works. It's pretty cool.

5:35When you're using Jupyter Notebook, there's no Gemini. But you probably have a model running

5:39locally, or you have access to some kind of a chatbot. So either way, you're going to have

5:44AI to help you as you progress through each development environment. And that's not to say

5:50that you can't use an IDE. You absolutely can. And people do. And there are these different

5:55extensions. For example, if you use Visual Studio Code, you can get an extension so that you can get

6:01a 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

6:12that right now. Go over here. And here it is right in the browser. It says introduction.ipynb.

6:21Remember, it used to be called iPython Notebook. That's the file extension. But it's now Google

6:26Colab here. And if it's locally, I'll show you that in just a second as well. This is basically

6:32what 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.

6:45The classic hello world. Like this. And if I use shift enter, or I hit play, then it connects to

6:55a cloud server over here. And then immediately, you're going to get an output down here. And if

7:01I do this multiple times, it's the same output. And that's called deterministic. We'll get into

7:06that in the next scale. But this is basically how you do that. And if you have a text cell,

7:11it 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

7:24like this. And then you can add links and all kinds of stuff, even LaTeX here, or some math.

7:32So if I enter shift enter, then it renders into this section. So this is really very,

7:39very useful. And you can just put this up here, and it can be heading and some code,

7:43and you can share the notebook. It's pretty wonderful, to be honest. I really like using

7:48Google Colab for teaching. And like I said, you can talk to Gemini right here. So you have Gemini

7:552.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

8:12GPU. Let me say OK. And that's for free. But if you want premium GPUs, you need to upgrade to

8:19Google AI Ultra. And then you have these different other models like a A100 GPU and so on.

8:27And I'm going to just cancel out of that. And I think that's enough to get us started.

8:33All right, so I will see you in the next video where we look at Jupyter,

8:36Conda and Anaconda. This is another very popular way to develop in a notebook environment, but

8:43this time locally.

0:00Welcome back. So now we have Jupyter, Conda, and Anaconda, which are different things,

0:07but they work together. And this is a local version of Colab. So Colab is something that

0:12came after Jupyter Notebook. So what is Jupyter? So Jupyter is more than Jupyter Notebook.

0:19And I'm just going to focus on Jupyter Notebook here. So I'm just going to write Jupyter Notebook.

0:24And again, it runs in your browser, but this time it's local. So that's the difference.

0:27And then it has the same cells, just like Colab that you execute. They can be code cells or they

0:34can be text cells. And it runs with Markdown in the same way. And it gives you that interactive

0:42Python 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.

0:56So that's kind of why it's cool. And then we have Conda, which is part of Anaconda.

1:02So what is Anaconda? What are all these snake names, you know? Well, I guess it's because of

1:08Python. So once Python got into the game, then there's all these snakes. So what is Conda do?

1:14So Conda, you can think of it like this. Let's say you have project A, and project B. So they're

1:23going to have different Python and different packages, right? So you could have different

1:28Python versions. Let's say, for some reason, you need some Python 2 point something. And then here

1:36is Python 3 something, okay? And then you might have some packages that are more for data

1:44visualization. And then this one is more for machine learning and so on, right? So essentially,

1:50it's an environment and package manager, it keeps these separated, right? So it manages

1:58environments. 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,

2:16Jupyter, and a bunch of other common packages for data science, machine learning,

2:22and AI engineering, all that good stuff. So I could say that package or that Anaconda rather,

2:30packages the tools together. So now let's take a look at these websites.

2:36And 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.

2:48Then there's Jupyter Notebook, this is the classic notebook interface.

2:53And then there's JupyterHub, then voila, share your results. And there's a lot more to it. But

3:00really, this is the only one that we would need to use, you try it in your browser locally. And

3:05you can install the notebook, but it's include all of this is included inside of Anaconda. So you

3:12can get started, sign up with an email. So I logged in here, and I'm going to just install this right

3:20here. I think this is probably the easiest way to do it. You can use a command line too, if you'd

3:25like to do that. There's also Miniconda because Anaconda is quite large. So if you explore

3:31Miniconda, you could do that too. And then Conda is going to be included in that as well. So it has

3:37Jupyter Notebook and Conda baked all into the same thing. So right about now, you might be asking,

3:44well, then how do you use all this stuff? Well, let's say that you downloaded this Anaconda

3:50distribution, graphical installer, you just basically follow the prompts. So you're just

3:55going 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

4:12that directory. And so that's the first thing. And then you want to use Conda. So we can say

4:21Conda env list. And you can see that I have challenge or base. So let's go ahead and,

4:30I 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

4:45in Jupyter, and if I have it installed, and I can't remember if I do or not on this one,

4:50it'll open it in a browser. So I'm just going to Oh, actually, you just type in Jupyter

4:55without Conda, my bad, or Jupyter notebook without Conda.

5:04And 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.

5:15Hello, world. And I run it and immediately it runs because it doesn't have to connect

5:21to a cloud somewhere. So that's the main difference. If I go back over here,

5:26and I use Command or Ctrl C, we can shut this down. So it's a server basically running in

5:34your 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.

5:46But a lot of these already installed for you. But the main separation here is that

5:52you are managing the packages, they're installed when you have Anaconda installed,

5:58but you need to install them into the environment so that you can keep them separate. So you can

6:05choose what version of Python that you want to use, you can choose the packages that go in there

6:09and you can keep them separated. And then that's pretty much the flow. And then when you're done,

6:15you 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.

6:31For example, if I say code period, we can open Visual Studio Code. And you can see that I already

6:38have this extension installed. If I click on this, you can see code cells, same thing. So I'm going

6:47to say hello world again. Well, hello world, exclamation mark, run that. And it's going to ask

6:56for Python environments, there's a little bit of a setup here. And I'm going to use the same one

7:02that we were using before 3.115, which is for that challenge environment. And these are the

7:09different 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,

7:21we get hello world. And I can also trash these right here. And you can also add markdown

7:26h1. And you can see that there. All right. And now you can see that we can do this in an IDE.

7:33And instead of Gemini, you can use Claude. And you could ask Claude something right here as well.

7:38And 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,

7:52you're doing research, or you're building something and prototyping,

7:55you might want to use a notebook, especially Colab, because it's very convenient. If you

8:00like working locally, that's something that you've been doing, then you probably are going

8:04to use Jupyter Notebook. But if you're working in a much larger production environment,

8:09you're probably going to use an IDE. It actually has all the development tools that you need as

8:15a software developer. And AI engineers use those in development environments for many reasons,

8:20mostly 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

8:36programming as well. So there's some benefits there. You can kind of do that inside of Jupyter

8:42Notebook or Colab with Gemini, you can, but the IDE has a lot more advantages for many, many reasons.

8:52Alright, 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.

9:07Because the provider can change, but the application pattern is going to remain the same.

9:12And that's why I was saying earlier, you can use different models, but they are going to have

9:17different personalities and different behaviors. So you would have to do some testing every time

9:22you change. But generally, you can just plug another API in there. So let's say that we have

9:30your Python application right here. And you build features, you can send requests. And this is also

9:38where you handle responses. And this is actually where you integrate into your product. And you're

9:48going to use HTTPS, normally, API calls, and it goes back and forth to the model API here. And

10:00again, this could be different models, right? It could be, let's say, Anthropic, which has Cloud,

10:09it 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.

10:30Hugging Face is a great place to look at models too. So I'm going to add them and they have a lot

10:36of models. But you could also use some other provider. And the main idea here is that the chat

10:43app is not the same thing as the API. So chat apps are built on top of the API, and your application

10:52directly calls that API. So here, we're going to have this back and forth, it's going to be requests

10:59and responses. And here in the model API, this is the standard interface. And this is where you send

11:06the prompts. And you also receive completions, that's what they're called. And they're simple

11:11to switch providers, like I was saying before, but the most important part is that you're going

11:15to need an API key. And we're going to put that into Colab. That's what we're going to do in this

11:20course. So you have that API key and don't hard code the keys, you want to, you don't want to

11:27expose 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

11:38pretty straightforward in Colab, I'll show you how that works. And then that means that your

11:42application that we write inside of Google Colab can use that API because it has secure access to

11:49that API key, meaning that the application reads the key from the config. And it's if you're doing

11:55this locally, you're going to use environment variables, right, dot env. And you need to have

12:02some 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.

0:05Now, here we are in the challenge section. And the idea here is to test your knowledge.

0:11We're really trying to find knowledge gaps. So if you identify a gap in any of your understanding

0:18of any of the videos above, just review the appropriate video before moving forward.

0:23And the idea there is that we're really trying to create small iterative learning curves going up,

0:28right? If you skip a concept or you move on to the next skill and you have knowledge gaps,

0:35it just increases the size of that learning curve and it makes it more difficult to learn and it's

0:40not as fun. So this is a really powerful course and it's one of the most valuable skills that

0:46you can learn today. And I'm really excited for us to do this because it's going to be,

0:50number one, a lot of fun because we're going to build stuff along the way. And number two,

0:56we're going to help our organizations make sure that we deploy AI systems

1:01with 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.