Build an AI Agent From Scratch With Python

[00:00] Everybody's talking about AI agents.

[00:03] These are programs that can reason, make

[00:06] decisions, and take actions all by

[00:08] themselves given an input from us. And

[00:12] most of us are talking about agents in

[00:14] respect to Kiro or Kiro CLI or Claude

[00:17] code, those agents that can help us to

[00:19] write applications and write code. But

[00:22] in this video, you're going to get

[00:24] hands-on and make your very own agent.

[00:27] But before we do that, what components

[00:30] make up an agent?

[00:36] We start off with the brain or the

[00:38] model, the large language model that

[00:40] gives us the natural language

[00:42] intelligence to be able to process the

[00:45] inputs that the agent gets. But how does

[00:47] the agent do anything? Well, this is

[00:49] with the hands or the tools. These tools

[00:52] give our agent agency to be able to

[00:55] affect change in the outside world. Then

[00:58] we have the system prompt. The system

[01:01] prompt is essentially the personality of

[01:03] our agent. This describes what we want

[01:06] the agent to do and how we want it to go

[01:08] about it. Now, all of those components

[01:10] are brought together in the agentic

[01:13] loop. This is an iterative loop that the

[01:16] agent is in control of. When we put an

[01:18] input into the top of the agent, it then

[01:21] processes through the loop, running

[01:23] tools, thinking, running another tool

[01:25] until it decides it has the output, and

[01:28] then it provides the answer back to us.

[01:30] Now, to build our first agent, we're

[01:33] going to use a framework, and that

[01:35] framework is Strands Agent SDK. This is

[01:39] a completely free and open-source

[01:40] agentic framework. It works with any

[01:43] model provider. It works with any

[01:45] hosting provider. And for us today,

[01:48] we're going to get an agent running on

[01:49] our laptop using a model from the cloud.

[01:53] Let's jump into some code. And here is

[01:55] my coding environment. This is Kiro, and

[01:58] Kiro gives me all of the AI goodness I

[02:00] need to assist me in writing code. But

[02:03] in this case, we're going to write it

[02:05] ourselves from first principles. So, let

[02:08] me go and grab myself up a terminal, and

[02:11] I'm going to kick off a Python project.

[02:14] So, Strands Agent SDK is available in

[02:16] both Python and in TypeScript. Python's

[02:19] more my thing, so that's what I'm going

[02:21] to do. And so, I'm going to start off

[02:22] this project by saying UV init because

[02:26] I'm using UV as a package manager for my

[02:28] project. If you haven't used that

[02:30] before, I'll put a link in the

[02:31] description below of how you can install

[02:33] UV inside of your environment. So, with

[02:36] UV init, you can see on the side here my

[02:38] Python project has started. I now need

[02:40] to include the Strands Agent SDK. So,

[02:43] I'm just going to say UV add, and then

[02:45] I'm going to say Strands {hyphen}

[02:47] Agents. Hit enter, and all of those

[02:50] packages are now being downloaded. And

[02:52] that's all I need to be able to then go

[02:54] ahead and build my first agent. So, if I

[02:57] look on the side here, I've got main.py.

[03:00] This is just the boilerplate main

[03:02] function from the uh initialization of

[03:05] the UV project. So, I can go ahead and

[03:07] select all of that and remove it. Now,

[03:09] let's start writing our Strands Agent.

[03:11] So, all I need to do is import the

[03:13] Strands Agent SDK. So, I'm going to say

[03:15] from Strands

[03:18] import, and then I'm going to import um

[03:21] agent.

[03:23] Pretty much all I need to do. Now, I'm

[03:25] going to go and get myself an agent

[03:27] object. So, I'm going to say agent

[03:29] equals

[03:31] and then I'm going to say

[03:32] agent

[03:34] and that's all I need to do there.

[03:37] And now I can prompt my agent. So, I can

[03:40] just say agent uh tell me a joke.

[03:45] And this is one of the very standard

[03:47] things that we ask an LLM to do because

[03:49] of course the LLM is the intelligence

[03:51] behind our agent. So, essentially all

[03:53] we're doing here is invoking the LLM

[03:56] once. We don't have any tools or

[03:57] anything like that at this stage. We

[03:59] will though in just a moment. So, let me

[04:01] save that, and let me just clear my

[04:04] screen here, and let's go and run that.

[04:06] So, UV run main, and it's almost

[04:09] certainly going to ask me to or tell me

[04:10] the joke about the scientist. You

[04:12] probably heard it before um because

[04:14] that's what LLMs do. So, let's have a

[04:16] look after we've run that. Yes, of

[04:18] course. Why don't scientists trust

[04:20] atoms?

[04:21] Because they make up everything.

[04:25] Okay. So, a really, really simple agent

[04:27] working there, but all it's done is

[04:29] we've taken the input, it's gone into

[04:31] its agentic loop, it's thrown this query

[04:33] essentially over to the large language

[04:35] model, and then it's spat the answer

[04:37] back out. It's no different to just

[04:39] prompting a large language model. In

[04:41] order to make this properly into an

[04:43] agent, well, we've got to start adding

[04:45] these other components. So, let's go

[04:47] ahead and give this a tool. So, I can

[04:49] extend out the things that I'm importing

[04:51] from Strands Agents to also import tool,

[04:54] and tool for us here is actually a tool

[04:57] decorator that we can now decorate a

[04:59] Python function. It becomes a tool that

[05:02] we can then pass to our agent. So, let's

[05:04] just say um def, I'm going to define my

[05:07] own thing. I'm going to say weather. Uh

[05:09] Kiro's trying to be helpful for me under

[05:11] the hood there, which is pretty cool. Um

[05:13] and then I'm going to say city, um which

[05:15] is a string, and the whole thing's going

[05:17] to respond with a string.

[05:20] Um and then I can put in a docstring

[05:21] here. Now, this docstring is more than

[05:23] just helpful to me to remember what this

[05:25] function's for. This docstring is

[05:27] actually something that will get passed

[05:28] to the agent and therefore the large

[05:30] language model so it knows what this

[05:32] tool is for. So, let's just say this is

[05:35] um get the weather for a given city.

[05:41] Um and we're not actually going to

[05:42] implement this code right now, but we

[05:44] are going to just return

[05:46] um

[05:48] it's nice and hot. So, whatever city it

[05:53] asks for, it's always going to say it's

[05:55] nice and hot. This is just a piece of

[05:56] sample code. Now, we can pass that to

[05:59] our agent like this. So, we can say

[06:01] inside of the agent constructor, we can

[06:04] say tools, and we can give it a list of

[06:06] the tools that it's got available to it.

[06:08] In this case, we're going to pass it

[06:10] weather because that's the only tool

[06:11] we've got. And I can hit save. So, let's

[06:13] just review that code just for one

[06:15] moment. So, we're importing Strands

[06:17] Agent SDK, and we're also importing the

[06:20] tool decorator. We're defining a

[06:22] function here as weather that returns a

[06:24] string, so something that's natural

[06:26] language that the agent will be able to

[06:28] make sense out of. And we're decorating

[06:30] that with tool. That means now that this

[06:32] is ready to be loaded as a tool into our

[06:34] agent. We pass that into the agent here

[06:37] with tools equals and the list of tools

[06:39] we have. And now, well, let's ask it

[06:41] something different. What is the

[06:44] weather like in London?

[06:48] Okay, and now let's clear this out so we

[06:51] can run this again

[06:52] and run this agent again. This time,

[06:54] we're actually using the agentic loop

[06:57] because what happens is it goes in and

[06:58] decides, "Okay, I'm going to check the

[07:01] weather in London." It then calls a

[07:03] tool, it calls the weather tool, which

[07:05] is the only tool we have, and then it's

[07:07] come back with, "The weather in London

[07:08] is currently nice and hot." Which of

[07:10] course it's not, or it might be, I don't

[07:12] know. We just made up the answer here,

[07:14] but now you see an agent using a tool.

[07:17] So, there's only one more piece left,

[07:20] and that is the system prompt. And we

[07:22] can do that here um by adding in again

[07:25] to this. We can say system prompt

[07:28] because at the moment it's basically

[07:30] been super generic. Um and we can say

[07:33] you are a

[07:36] helpful assistant

[07:39] who always responds in the voice of a

[07:44] pirate, which is always super useful.

[07:47] So, let's do that and add a comma at the

[07:49] end of that, and it should all be happy.

[07:51] And then let's go ahead and clear this,

[07:54] and then we're going to run this again.

[07:56] So, we've set the personality of our

[07:59] agent, and now of course it's even

[08:01] thinking in pirate speak. Ah, yes. The

[08:04] seas be calm, and the weather be fine in

[08:06] London. I'm not going to say any more of

[08:09] that. Okay, so now we've got the basics

[08:11] of an agent up and running. Let's start

[08:13] to build up a small project. I like

[08:16] tabletop RPG games, so let's build

[08:19] ourselves a games master that's going to

[08:21] be the beginning of a project you could

[08:23] take a long way.

[08:25] Now, you might have noticed that in the

[08:27] first demonstration that we ran, it

[08:29] worked, but we didn't actually specify

[08:31] the brain. We didn't specify the model

[08:33] that we were going to use. And that's

[08:35] because Strands Agents will actually

[08:37] pick up a model by default for us if we

[08:39] don't. But it's going to be super useful

[08:41] for us to be able to define the model

[08:43] that we actually want to use, and so

[08:44] that's what I'm doing in this code here.

[08:46] So, I'm now saying from Strands Models

[08:49] import Bedrock Model, and then that

[08:51] gives us the opportunity to actually

[08:53] specify the Bedrock model that we want

[08:55] to use. Now, again, Strands Agent SDK

[08:58] doesn't have to use Bedrock models from

[09:00] AWS. It can use models from any

[09:02] provider. Indeed, in a blog post that

[09:04] I've got linked in the description

[09:06] beneath this video, I go through pretty

[09:08] much everything that I'm going through

[09:09] in this video, plus I'll show you how to

[09:12] connect it and with Ollama, a locally

[09:14] running model. But we're using Amazon

[09:17] Bedrock models here. So, let me just go

[09:20] over to the Amazon Bedrock console page

[09:22] in the AWS console because if we go to

[09:25] model catalog over here on the left-hand

[09:27] side, I can see a a list of all of the

[09:30] models which are available for us in the

[09:32] particular region that we're working in

[09:34] from all of the different model

[09:35] providers. And you'll see that there's

[09:37] all of these models from Anthropic here.

[09:39] We can go and see them from places like

[09:41] Meta and Cohere and Deep Seek, um and

[09:44] also models from Amazon ourselves as

[09:46] well. And so, if I go into here, I can

[09:48] find the Nova 2 light model. This is a

[09:51] small, cost-effective model for getting

[09:53] started. It's a great place to start.

[09:56] And in the code that we have here, I've

[09:58] got a model that's actually specified

[10:00] here as Amazon Nova 2 light. So if I go

[10:03] back to the model catalog for a moment,

[10:05] you can see that Nova 2 light there is a

[10:08] model ID right there. Now if I come back

[10:10] to the code, you'll notice I've got us.

[10:13] dot and that's because this is a

[10:15] regional endpoint for this model. So

[10:17] it's going to do the best it can

[10:19] throughout the whole of the US because

[10:20] I'm using US East 1 for this particular

[10:24] example.

[10:25] Um so then I've got the rest of my model

[10:27] defined as we did before, but this time

[10:29] I'm creating a tabletop RPG games

[10:31] master. So I've said you're you're a

[10:33] dramatic and entertaining tabletop RPG

[10:36] games master. Keep the story short and

[10:38] to the point. Um one or two paragraphs

[10:41] at most. We can adjust this. You can

[10:43] adjust this to create a games master

[10:45] which follows your particular style. And

[10:48] so then I can pass in my first prompt

[10:51] essentially, I kick open the tavern door

[10:53] and stride up to the bar. Barkeeper,

[10:56] your finest ale. Okay, let's run this

[10:58] and see what happens.

[11:00] Um so again, I've just pasted this into

[11:03] main inside of my project code here. And

[11:06] yeah, look, it does exactly what we

[11:07] thought and it starts off a story. And

[11:10] as you kick open the creaky tavern door,

[11:12] the raucous din of laughter and clinking

[11:14] mugs momentarily hushes. And you can

[11:17] read the rest of that to see what's

[11:18] going to go on. I'm not going to turn

[11:20] this into a let's play session.

[11:23] Let's build and let's continue to build

[11:25] this agent cuz you notice that we don't

[11:26] actually have any tools here. So let's

[11:30] go and add the tool back in. So I'm

[11:32] going to go and add in the tools import

[11:35] one more time. Um and then we're going

[11:38] to find ourselves

[11:40] a tool to add.

[11:41] And so let me paste that in. And here we

[11:44] go. This is actually one of my favorite

[11:45] tools. I love playing around with this.

[11:48] So this is a dice rolling tool or roll

[11:50] dice tool. And it takes as an input the

[11:53] number of sides on the dice. So pretty

[11:55] much anything from a D4 all the way up

[11:57] to a D20

[11:58] and the number of dice you want to roll

[12:00] and then it gives some general

[12:02] instructions here.

[12:03] And it gives instructions to the large

[12:05] language model or in other words, the

[12:06] agent as to what these arguments mean.

[12:09] So the number of sides on each die and

[12:11] then how many dice to roll. And then

[12:13] look, all it's doing is just calculating

[12:16] some random numbers. But it's kind of

[12:17] fun. The one thing I'm going to need to

[12:19] do is import

[12:21] random.

[12:24] So let's just do that up top so that

[12:26] we've got everything ready for the code.

[12:28] And then the next thing I need to do is

[12:30] I need to add this in as a tool. So I'm

[12:32] going to say tools equals and then I'm

[12:34] going to add in my dice

[12:37] roll dice tool like that and save there.

[12:41] Okay, so at this point I can run this

[12:44] again and likely nothing's going to

[12:46] happen because I haven't necessarily

[12:49] done something that requires the dice.

[12:52] But let's just have a quick look.

[12:54] It might decide that it's going to do

[12:56] it. This is part of the

[12:57] non-deterministic nature of agents of

[12:59] course. Yeah, look, it's decided to roll

[13:01] the dice because it's got one.

[13:02] And so what does it say this time?

[13:04] I don't know what I rolled. We can find

[13:06] that out in a second. The barkeep

[13:08] grumbles, eyes narrowing as he slams the

[13:11] tankard down in front of you with a

[13:12] clank. Doesn't sound very happy. I

[13:14] wonder whether I rolled something low.

[13:17] Actually, it's difficult to tell because

[13:18] I can't get back into this agentic

[13:21] conversation. It's finished at this

[13:22] point. Okay, let's fix that. So I'm

[13:26] going to clear that up and I'm going to

[13:28] expand down here. And what I've got here

[13:31] is just a quick chat loop that I can

[13:33] paste in.

[13:34] So if I just grab my

[13:36] code from here. So instead of having

[13:38] this, I can insert above here this. I'm

[13:42] going to borrow this

[13:45] because maybe we can use this in the

[13:47] next call anyway. So let's copy that and

[13:50] delete that. Okay. So now what I've done

[13:52] is I've added in this quick while true

[13:54] loop here. And what it's basically going

[13:56] to do is it's going to allow me to enter

[13:58] some text. When I've entered the text,

[14:00] it will then send that to the agent and

[14:03] then keep going around unless I type in

[14:05] quit or exit. So let's press save on

[14:07] that and now let's run this code again.

[14:11] Now I've got a prompt. And so I could

[14:13] actually just have a general

[14:14] conversation with the agent. So I could

[14:16] just say hello

[14:17] and see what it returns back with.

[14:19] Greetings, intrepid adventurers, etc.

[14:21] etc. Now let's just say that what I want

[14:23] to do is I want to kick open the tavern

[14:25] door, stride up to the bar and say

[14:26] barkeeper, your finest ale. So let's

[14:28] just press enter on that and see. Now

[14:31] let me just expand that up.

[14:33] This time it decided not to roll the

[14:36] dice, but it's given us a bunch of

[14:38] things that we could do. Um so pay for

[14:40] the ale. I haven't read the entire

[14:42] story. I just don't really feel like I

[14:44] have time to do that. What if I say roll

[14:46] a D20? Just throwing the games master a

[14:50] curveball here I suppose.

[14:52] Oh, it's decided it's going to do a

[14:53] charisma check. So it's rolled the dice,

[14:55] done a charisma check and got 17. I'm

[14:58] doing well with my charisma today. So

[15:00] you can see here how we are getting

[15:03] started. And if I had the time and if I

[15:05] wanted to, I could actually clear this

[15:07] out, start again and actually start a

[15:10] agentic run campaign all by myself with

[15:13] my agent. Now you can actually do this

[15:16] and you could actually start to play

[15:17] this for quite some time. At some point,

[15:20] the context window's going to fill up

[15:22] and the whole thing's going to come

[15:23] crashing down. And we can take a look at

[15:25] that in a subsequent follow-up video.

[15:26] But for now, it's going to keep that

[15:28] conversation history, in other words,

[15:30] the game history going and you can

[15:32] follow on with responses about things

[15:34] that have happened about the game that

[15:36] you're playing. Now before we wrap this

[15:38] up, let's go quite a few steps forward.

[15:41] I've got a more established games master

[15:43] code that I can paste into here and then

[15:45] we can step through what we've got.

[15:47] Okay, here it is. And in this case, I'm

[15:50] hopefully going to make it a little bit

[15:51] nicer to look at and a little bit better

[15:53] to play. Let's step through the code

[15:55] that I've got here and of course, all of

[15:58] the code which I've had for the entire

[16:00] video up until this point is going to be

[16:02] linked in the description below. So

[16:04] first of all, I define some colors

[16:06] because I want to make something look a

[16:07] little bit nicer in the command line

[16:09] when we're playing this. Going to try

[16:10] and separate out some of the tool calls

[16:12] from what I'm typing and things like

[16:15] that. We've got a tool call hook here.

[16:18] We'll get back to what this is in just a

[16:20] second, but we've got more tools to look

[16:22] at. So we've got a tool which is the

[16:24] look up rule tool. And this is going to

[16:27] look up rules from the rule book. And I

[16:29] have actually copied in a rule book

[16:31] here. It's just a simple piece of text.

[16:33] So this is a simple set of text

[16:35] instructions that we can ask the agent

[16:37] to dip into so it can come and have a

[16:39] look at what are the combat rules? What

[16:41] are the skills checks rules? Now look,

[16:43] this is super simple and honestly, I

[16:45] could put all of the things that are in

[16:47] this rule book actually in the context

[16:50] or in the system prompt for the agent.

[16:53] But I'm just demonstrating here how we

[16:54] can use a tool to go and query and get

[16:57] data from another source. In this case,

[16:59] it's a text file. But this is the basics

[17:02] of retrieval augmented generation. We

[17:04] can get much more complex with this and

[17:06] we could search an entire enterprise or

[17:08] corporate document repository. But for

[17:10] now, we're just searching this

[17:12] text-based rule book. That's the tool

[17:15] there that we've got. We've got roll

[17:16] dice here again, but we've also got some

[17:18] other things. We've got player state. So

[17:20] this is able to keep hold of what our

[17:23] current player state is. Like what are

[17:25] our current hit points? What's our

[17:26] current strength? The agent can actually

[17:29] update this as we go along because it's

[17:30] got a couple of tools. It's got get

[17:32] player state which will just return that

[17:34] player state and update player state. So

[17:37] the agent can keep track of our health

[17:40] as we play this game. And we could be

[17:41] able to query that as well. And here's

[17:43] our agent. We're still using Nova 2. Um

[17:46] here's our system prompt. It's a little

[17:48] bit more comprehensive now. Just talks a

[17:51] little bit more about what's going on.

[17:52] It explains that there's a rule book

[17:54] there and the different sections of the

[17:55] rule book that it can get. Um and then

[17:57] we've got all of those

[17:59] tools all in that tool list there.

[18:02] Including then, we've also got hooks. So

[18:05] hooks is a powerful thing inside of

[18:07] Strands Agents SDK. So at various points

[18:10] in the life cycle of that agentic loop

[18:13] that we looked at, different hooks will

[18:15] fire and you can go and hook into that

[18:18] with your code to go and do a certain

[18:20] thing. And so we have tool indicator as

[18:23] a hook that we're going to register

[18:25] here. So if I just scroll back up to the

[18:27] top where that hook was defined, um we

[18:31] can see here that it actually extends

[18:32] hook provider which is something that we

[18:35] have called in from the Strands Agents

[18:37] SDK. We're actually calling in all the

[18:40] necessary things that we need to

[18:41] register this hook. And so this hook

[18:44] here is going to get called before and

[18:47] it's basically just going to print out

[18:49] the name of the tool which is being used

[18:51] just to break up something in the user

[18:53] interface. This is very simple example

[18:56] of how to use hooks. They're super

[18:57] powerful. If you want to dig into the

[19:00] documentation, of course, a link is in

[19:02] the description below.

[19:03] So let's scroll down again back to our

[19:06] main agent. And then we have a game loop

[19:08] here. Just a little bit more flare if

[19:11] you like inside of the chat agent

[19:13] itself. Otherwise, everything is the

[19:15] same. So let's jump in here. Let's

[19:18] expand this out just a bit more so I've

[19:20] got some more room to play. And let's

[19:22] play for the last time our quest. So

[19:25] I've got

[19:26] an interesting start out here. It says

[19:28] the sun dips low casting long shadows

[19:31] across the cobbled road as you approach

[19:33] approach the humble village of Everbrook

[19:37] Hollow.

[19:38] And on it goes with the weaving of the

[19:40] story. Let's have a look.

[19:42] You push open the creaky door of the

[19:45] rusty tankard, the warm amber light

[19:48] spilling out into the cooling evening

[19:50] air. And then it's got all these other

[19:52] stuff learned down there. Let's have a

[19:54] look. And it says, "What would you like

[19:56] to do? Speak with Innkeeper, approach

[19:58] the lone figure." Do you know what? I

[20:00] think it's always a good idea for roll

[20:02] to roll for investigation. So, let's

[20:04] roll for investigation.

[20:07] Also, I want to have a go with the tool.

[20:09] So, it's looking up some rules. It's

[20:12] decided. And then it's rolling the dice.

[20:15] Um and then well, it doesn't actually

[20:16] say what number we got back for Oh, no,

[20:18] it does. It We rolled a three. Oh,

[20:20] that's not good. So, we probably didn't

[20:22] manage to discover very much. But you

[20:24] can see how this works. It's looking up

[20:26] rules. It's uh rolling the dice. And

[20:29] it's also remembering um the status of

[20:32] us as a player. This is a much more

[20:34] sophisticated agent. But it's just

[20:37] scratching the surface of what we could

[20:39] do. You can see how we can build in

[20:41] pretty much any tool, anything you can

[20:43] do programmatically, you could build in

[20:45] a tool for your agent. And then beyond,

[20:48] if you want to add memory, if you want

[20:51] to add connections to other types of

[20:53] document stores, if you want to add

[20:55] connections to MCP servers, or if you

[20:57] want to publish this out to the internet

[21:00] and have a cloud-hosted

[21:02] agent, you can do all of those things

[21:04] with Amazon Bedrock Agent Core. That's

[21:06] the next step beyond building an agent

[21:09] with Strand's Agent SDK. And for Amazon

[21:11] Bedrock Agent Core, there'll be a link

[21:13] in the description below. Thank you so

[21:15] much for taking the time to go through

[21:18] on this quest and this journey with me

[21:20] for building agents. I hope you have a

[21:23] lot of fun building agents, maybe as

[21:25] much [music] fun as I'm having telling

[21:27] you about them. Thank you so much for

[21:28] watching, and I will see you in another

[21:30] video really soon.