And so it gives me great pleasure to introduce to you the project that I've lined up for you this week.
And boy, is it a meaty one.
Here it is, the capstone project of the course.
I've called it The Price is Right.
It's something which brings together what we've been doing to date.
The idea is we're going to build.
The challenge that's been set for us is to build a platform which can look for deals being published
on the internet, subscribe to RSS feeds so it can it can spot deals that have been published.
When it finds a potential deal, a promising looking deal, it will read it, it will interpret it,
and it will then use a number of LMS, including the proprietary one that we built last week to make
its own estimate of how much that's worth, and if it finds a good opportunity, it will then automatically
send a text message or a push notification to to you or to me telling us that there is a deal that we
should know about and it will run autonomously all the time, just sitting around running in the background,
and every so often you will get a push notification to say there's a new deal that's been posted online,
where the model has decided that this price is a really great price because the item should cost a lot
more.
And I hope you agree, if we can pull that off, if we can build that platform, we've built something
special that is an advanced platform.
It's something which brings together a lot of different bits of functionality, and it's something that
that hopefully I will be proud of, and I hope you'll be proud of it too, when it's built.
There are going to be seven agents.
I already said it, but I say it again.
Seven agents are going to collaborate.
Um, not all of them are built on LMS.
Some of them are more sort of Python processes, but they're sort of seven pieces to the puzzle that
are collaborating.
We will use GPT four or GPT four mini to take information from RSS feeds and parse it and understand
it and turn it into something which is a potential deal.
We will use our frontier busting model that outperforms GPT four.
And Claude will use it to estimate how much things are worth.
But that's not all.
We're going to use other models as well.
We are going to build another Rag pipeline, another rag based model.
Um, but this time we're not going to use langue chain.
We're going to roll our own.
And it's going to be very, very easy.
Um, but it's going to use all 400,000 products that we, we had taken from the Amazon scrape before.
We're going to put all of them in a mega Croma database and use that to add context as part of our Rag
pipeline to a frontier model.
And you can start wondering right now, maybe you already thought of this.
Maybe you're already wondering whether or not that a a frontier model that's armed with similar prices
of similar products, whether that is going to outperform the model that we fine tuned last week.
You'll find out.
We'll see.
But we're going to have both models working together to try and get the best possible price.
And another model as well as as all will be revealed.
So it's going to be it's going to be a huge week.
The most important point, of course, was this capstone project is designed to bring it all together
in a very satisfying way, in a way that's going to feel tangible and real.
But the real point is that this gives you a chance to revise and everything that we've learned and also
just build expertise, build experience, have some real hands on work at making production caliber
models.
And that's that's really the main point of this.
We're doing it in a fun context, something that's going to actually send you push notifications when
there's a when there's a useful product, but it's going to be about learning and solidifying the learning
that we've done over the course of the last seven weeks.
But let me just tell you for a moment, the architecture of our agent platform, we're going to have
a user interface.
Of course, it's going to be built in Gradio.
It's going to be using an agent framework that we'll write, which will just be a simple kind of environment,
which will have memory so that the agents can know what they've recommended in the past, and it will
support things like logging, so we can understand what's going on in our framework.
There will be an agent responsible for planning.
It's going to be coordinating activities across the other agents.
And then we'll have these agents.
We'll have a scanner agent that is going to identify promising deals.
By looking at RSS feeds.
We're going to have something I'm calling the ensemble agent, which is something there is a technical
term ensemble.
When you when you bring together multiple models, this agent is going to be responsible for bringing
together different estimating models that will estimate the price of products.
And we will have a messaging agent that will send us push notifications.
Now this is just the high level architecture because there are more agents than this.
Because of course, that ensemble agent is itself going to collaborate with three other agents.
That will be our three estimating agents.
But I'm not showing them on this diagram because that would be too cluttered.
But I will do, I'm sure, in the future when we get there.
So this is the high level architecture to give you a sense of what we're going to build.
And for today, we're going to focus on just one of these.
And we're not going to look much at this architecture.
We're just going to be talking about taking the model we built last time and putting it up on the internet
using this wonderful service called modal.
Just before we talk about modal, one more thing I wanted to mention that as we're moving now towards
writing more serious code, JupyterLab is a wonderful platform for being iterative and experimental
and quickly turning out different solutions.
But as as we move along the path from R&D into something which is ready to be productionized, there
are some aspects of the coding that will be changing.
For a start, I'm going to start to have type hints in some of the code.
Maybe something that you're super familiar with already.
If not, I'll explain it and it will.
You'll see why.
And it's something which is a good, best practice when building this kind of production caliber code.
Uh, also going to be writing some more comments.
It's something that when you've got a nice Jupyter notebook and you've got like lots of time to put
text and stuff and explain it, maybe you don't need quite the same kind of commenting approach, but
now, at least at the at the method at the function level will put comments in there.
And logging is a good thing to do as well, and we will do that.
Now there's one other thing which is a very good best practice, which is to write unit tests.
Uh, it's very important, of course, to write good unit tests for code that's going into production.
And I'm not going to be doing that because I'm a cowboy.
Uh, and, uh, yeah, I certainly should do that.
But what I will say is that it's a great exercise.
Uh, should you wish to go in and write unit tests behind some of the code that we are productionizing.
That will be wonderful.
I hugely appreciate it.
And if you then wanted of course to do a git push, I will merge it in with delight and will give you,
of course, full attribution and credit for writing the unit tests, which is something that certainly
I should I should be doing.
Um, and it's a very much a good best practice.
Okay.
Uh, the, the brings me to, to introducing modal, which is the platform that we're going to be using
today.
Uh, modal, uh, a platform which allows us to run code remotely on a server, and you only pay for
the time that you use.
It's a very powerful platform.
It's it's become heavily used in the AI world for deploying production models.
Um, but it can also be used just for, for for many different purposes, just for CPU usage to deploy
any function onto the cloud, as we will see.
So without further ado, in the next video, we're going to go to modal and give it a try.
I'll see you there.