Build a Python AI Agent in 10 Minutes

[00:00] Today I'm going to show you how to build

[00:01] an AI agent in Python in less than 10

[00:05] minutes. So let's get started. To begin

[00:07] our project, we need to open up a folder

[00:09] in some type of code editor. In my case,

[00:11] I'm going to be using PyCharm, but you

[00:12] can use anything that you want. I do

[00:14] typically recommend PyCharm for large

[00:16] Python projects because it is well

[00:18] designed for Python and I have a

[00:20] long-term partnership with them. So if

[00:21] you want to try it out for free, you can

[00:23] do that by clicking the link in the

[00:24] description. Now I've made a project

[00:26] here or made a folder called 10minute

[00:28] agent. So open up some kind of folder.

[00:30] We're then going to go to our terminal

[00:31] and we're going to install the

[00:32] dependencies that we need. Now to

[00:34] install these, I recommend using uv and

[00:36] by starting to do uv init and then dot.

[00:39] Do this in the directory where you want

[00:41] to create this project. So we're going

[00:43] to initialize our project. If you don't

[00:45] already have uv installed, I'll leave a

[00:46] video on screen that shows you how it

[00:48] works. From here, we're going to open up

[00:50] main.py, delete everything inside of

[00:52] there, and then start installing our

[00:54] dependencies. So from our terminal,

[00:55] we're going to type uvad. We're going to

[00:57] add lang chain. We're going to add lang

[01:00] graph. We're going to add python-

[01:03] env. And we're going to add langchain-

[01:07] open aai. Now, these are all the

[01:09] dependencies that we need for making an

[01:10] agent. There's multiple ways to do this.

[01:12] We're going to use lang chain and

[01:14] langraph, which is a really modern

[01:15] approach that makes it very easy for us

[01:17] to design agents in Python. So, go ahead

[01:19] and press enter. Add all of those

[01:21] packages and then we're good to start

[01:22] writing some code. So, for this project,

[01:24] I'm going to use GPT4 as my LLM, but you

[01:27] can use any LLM that you want. Since I'm

[01:29] using an LLM from OpenAI, I need to get

[01:31] an OpenAI API key. So, I'm going to make

[01:34] a new file here. I'm going to call this

[01:36] env. And then inside of this file, I'm

[01:39] going to make a variable that says

[01:40] OpenAI_API_key.

[01:42] And I'm going to fill this in with my

[01:44] OpenAI key, which I'll get right now.

[01:46] So, in order to get a key, you will need

[01:47] an account with OpenAI. You can go to

[01:49] this website right here,

[01:50] platform.opai.com/api. openai.com/api

[01:53] keys. You will need a credit card on

[01:55] file, but this will cost you a fraction

[01:56] of a few cents if you're just using it

[01:58] for a demo example. So, here we're going

[02:00] to go here, go ahead and press on create

[02:02] secret key. We're then going to copy the

[02:04] key, which we're not going to share with

[02:05] anybody else, and we're going to paste

[02:06] this inside of our environment variable

[02:08] file. From here, we'll save, close, and

[02:10] then we're ready to start building our

[02:12] agent. Now, speaking of agents, today's

[02:15] sponsor, Notion, just released theirs,

[02:18] which is a complete gamecher. Now,

[02:20] Notion's new AI agent doesn't just help.

[02:22] It finishes the job for you. And as a

[02:25] Notion power user, myself, this has been

[02:27] absolutely amazing. Now, this thing

[02:29] isn't a chatbot. It's an actual AI

[02:31] teammate that lives inside of your

[02:33] Notion workspace and can complete tasks

[02:35] end to end. You give it a goal like

[02:37] summarize last week's meeting notes into

[02:40] a project update, and it figures out the

[02:42] plan, pulls the info, and updates your

[02:44] pages. It even notifies your teammates

[02:46] as well. Now, it's mastered every Notion

[02:49] building block. So, it can edit

[02:50] databases, rewrite documents, audit

[02:52] knowledge bases, or even draft an entire

[02:55] launch plan, all exactly the way that

[02:57] you would. And here's what makes it

[02:59] pretty cool. Your agent actually learns

[03:01] your style. You can tell it where to

[03:03] file things, how to write, even what

[03:05] tone to use. And over time, it builds

[03:07] memories so it starts anticipating what

[03:09] you need next. So, instead of you

[03:11] spending your day buried in admin work,

[03:13] your agent just handles it all for you.

[03:16] Now, if you want to try it out, Notion

[03:17] agents are available right now. Click

[03:19] the link in the description and let

[03:21] notion agent do your work for you.

[03:23] Thanks to Notion. Now, let's get back

[03:25] into it. So, because I'm trying to do

[03:27] this in 10 minutes, I'm not going to

[03:28] write every line of code out

[03:30] individually. I'm going to copy in some

[03:31] different chunks. And if you want all of

[03:33] the code, I'll leave a link to it in the

[03:35] description where you can download it

[03:36] and mess with it from there. So, first

[03:37] things first, we're going to bring in

[03:39] our imports. Now, we're going to need to

[03:41] import a few things from the standard

[03:42] library for doing our typing. We're then

[03:44] going to bring chat openai. We're going

[03:46] to bring in a bunch of different

[03:47] messages that we need. We're going to

[03:49] import the tool and then we're going to

[03:50] import the create react agent which

[03:52] comes from langraph. Now we're also

[03:54] going to do another import where we say

[03:56] from.env

[03:57] import and this is going to be load.env.

[04:00] We're then going to call the load.env

[04:02] function. And what this is going to do

[04:03] is load our environment variables from

[04:05] our environment variable file. We're

[04:07] using a combination of langraph and lang

[04:09] chain here in order to initialize our

[04:12] agent and to get it to be able to call

[04:14] tools. The thing that makes an agent an

[04:16] agent is that it has access to something

[04:19] outside of just a chat interface. So in

[04:21] our case, we're going to provide to this

[04:23] agent a series of tools that allows it

[04:25] to generate kind of mock user data and

[04:28] then save that data into JSON files.

[04:30] Once you understand how to add one tool,

[04:32] you can add as many of them as you want.

[04:34] So let me copy in a few tools that our

[04:36] agent is going to have access to. Then

[04:38] we'll start initializing the agent and

[04:40] start writing everything so we can

[04:41] interact with it. So I've just added

[04:43] three tools which really are just Python

[04:45] functions to my file. Let's go through

[04:47] them one by one so you can understand

[04:49] the kind of composition of a tool. Now a

[04:52] tool can simply be a Python function. So

[04:54] in this case we have a tool called write

[04:56] JSON. We take in some file path which is

[04:58] the file that we want to write to and

[05:00] then some data that we want to write and

[05:02] this returns a string. Now we denote

[05:04] that this is a tool by decorating it

[05:06] with the at@ tool decorator which we

[05:08] imported right here from langchain. Now

[05:10] inside of this tool we can do anything

[05:12] that we want. But we should make sure

[05:14] that we return some kind of AI readable

[05:17] information so that the AI understands

[05:19] what this tool call actually achieved.

[05:21] Now the thing that makes this a tool is

[05:23] this tool decorator. But for any tool,

[05:25] you need to make sure that you denote

[05:27] the types of your parameters. So in this

[05:29] case, we've denoted this is a string and

[05:31] this is a dictionary and then the return

[05:33] type of the function. This is

[05:34] information that will be passed to our

[05:36] LLM or our agent. So it knows which tool

[05:39] to call and how to call that tool. It's

[05:42] also important that you write a dock

[05:43] string. That's something inside of these

[05:45] three uh quotes right here that

[05:47] describes what the function does or what

[05:50] the tool does so the agent understands

[05:52] which tools to call. So in this case we

[05:54] have write a Python dictionary as JSON

[05:56] to a file with pretty formatting. So now

[05:58] the agent knows this is the tool that I

[06:00] can use when I need to do that. Moving

[06:02] on, we have our next tool which can read

[06:03] a JSON file. Same thing we denote the

[06:06] parameters and their types as well as

[06:07] the return type of the function. And

[06:09] then we have a dock string that

[06:10] describes when to use this tool or this

[06:12] function. Okay. And we return good error

[06:14] messages explaining what's going on.

[06:17] Lastly, we have another tool. This can

[06:18] generate sample users. We take in a list

[06:20] of first names, a list of last names, a

[06:22] list of domains, and a minimum and

[06:24] maximum age. And then we generate some

[06:26] sample user data with all of this error

[06:28] and validation checking and pass that

[06:30] back to the LLM. You can have any tools

[06:33] that you want. I'm just giving you three

[06:34] here so you can see a bit of diversity

[06:36] in terms of how they work. Okay, so now

[06:38] that we have our tools, we need to

[06:39] create an LLM and an agent and

[06:41] essentially give these tools to our LLM.

[06:44] So let's start by defining a list of

[06:45] tools, which we can do with this

[06:47] variable right here. Then let's define

[06:49] our model. So the model that we're going

[06:51] to use or the LLM is going to be GPT4

[06:54] mini. You can use any LLM that you want

[06:56] here, but this is the one that I'll use

[06:57] for this video. Then we're going to

[06:59] define what I call our system message or

[07:02] our system prompt. Now that's not just

[07:04] what I call it, that's what it's called.

[07:06] But essentially, this tells the system

[07:08] what it's supposed to be doing so that

[07:10] it has some more context in terms of how

[07:12] it should behave. You can read through

[07:13] this if you want, but essentially I'm

[07:15] telling it that this is a data generator

[07:17] agent that's able to generate sample

[07:19] data for an application and then save

[07:21] that in a JSON file. Now, once we have a

[07:24] list of tools, an LLM or a model, and

[07:26] some system message, we can create our

[07:29] agent. And that's because an agent is

[07:30] made up of those three components. It

[07:32] can also be made up of more, but in this

[07:34] case, that's what we'll use. So, we can

[07:35] say agent is equal to create react

[07:37] agent. We pass the LLM, we pass the list

[07:40] of tools, and then we pass the system

[07:42] message. Now, in order to use our agent,

[07:44] we need some kind of driver code. So,

[07:46] we're going to bring in a function that

[07:48] looks like this, where in order to run

[07:50] the agent, we take in some user input,

[07:52] we can take in a history, which is all

[07:54] of the previous messages. So, we can

[07:55] store that and have some previous

[07:57] context, and then we return an AI

[08:00] message. What we're able to do is invoke

[08:02] the agent. So, we say agent.invoke.

[08:04] We can pass all of the previous messages

[08:06] plus the new message. And then what we

[08:09] can say is that we have some limit in

[08:10] terms of how many tool calls this can do

[08:12] which is 50. And then we can return

[08:14] whatever the last response is from this

[08:17] agent. If there's an error then we can

[08:19] return something like this. Now what

[08:21] this is going to do is automatically

[08:23] respond to the most recent message for

[08:25] us. So we'll get the most recent

[08:27] response and it will do any tool calls

[08:29] as it needs to in this step. So when we

[08:32] agent on.invoke invoke and we have

[08:33] access to various tools. If the agent

[08:35] needs to call a tool, it will go ahead

[08:36] and just call it, use the tool and then

[08:39] return to us whatever the response is

[08:41] that it thinks that we want. That's how

[08:43] we run the agent. Now, let's bring in a

[08:45] little bit more driver code just to make

[08:46] this application look a bit prettier and

[08:48] we can test it out. So, what I'm doing

[08:50] is I'm just putting some formatting. I'm

[08:52] saying, okay, let's create a list of all

[08:54] of the messages we've sent so far. Let's

[08:56] ask the user for some user input. If

[08:57] they want to quit, we can quit.

[08:59] Otherwise, we can just run the agent and

[09:01] then we can print out whatever the

[09:03] response was, update the history and

[09:05] keep going. Now, in order to run our

[09:07] agent, what we can do is open up our

[09:09] terminal. So, let's go here, type uv

[09:11] run, and then the name of our file,

[09:13] which is main. py. This will take a

[09:15] second, and then what we're able to do

[09:17] is start asking the agent questions. So,

[09:18] we can say something like generate five

[09:21] random users. And let's see what the

[09:23] result is that we get. Okay. Okay. And

[09:25] if we just bring this up a little bit

[09:26] larger, you can see that we have five

[09:28] random users generated. Now, let's take

[09:30] one of the examples here. So, maybe make

[09:32] users like this. Okay. So, make users

[09:35] age 25 to 35 with company.com emails and

[09:38] save three of them to users.json.

[09:43] And let's see what we get. Okay. And if

[09:45] we have a look here, we can see a

[09:46] users.json file was just created. We

[09:49] have three users inside of here. And

[09:51] then lastly to test this we can say what

[09:54] is the oldest user in users.json

[09:59] and let's see if it's able to read that

[10:00] and give us the result. Okay we found

[10:02] the oldest user which is Bob Johnson

[10:04] here at age 25. So that is the AI agent

[10:08] in Python in approximately 10 minutes.

[10:11] You can add any tools that you want. You

[10:13] can change the LLM. You can change the

[10:14] system prompt and quite quickly you can

[10:16] make something very interesting. Again,

[10:18] if you want the code, it will be

[10:19] available from the link in the

[10:20] description. And I look forward to

[10:21] seeing you in another video.

[10:24] [Music]