[00:00] (0.16s)
So, in one of my previous videos, I said
[00:02] (2.48s)
that front end is dead. And to explain
[00:04] (4.48s)
what I meant, I'm going to talk to you
[00:06] (6.16s)
about APIs. Every app you build is
[00:08] (8.40s)
controlled by its internal APIs. And
[00:10] (10.56s)
when it needs to fetch data from
[00:12] (12.16s)
external sources, it uses external APIs.
[00:15] (15.04s)
These internal APIs can actually be
[00:16] (16.96s)
hosted on MCP servers, which is a
[00:19] (19.04s)
protocol that allows AI agents powered
[00:21] (21.28s)
by large language models to control
[00:23] (23.28s)
those APIs. And if they are able to
[00:25] (25.20s)
control the APIs, they can effectively
[00:27] (27.36s)
control the entire application. This
[00:29] (29.28s)
means you no longer need a traditional
[00:31] (31.12s)
front end to manage everything because
[00:32] (32.88s)
AI models can now operate the whole app
[00:35] (35.12s)
on your behalf. You can use the fast API
[00:37] (37.52s)
MCP library to set this up. These MCPS
[00:40] (40.40s)
can now be integrated directly into AI
[00:42] (42.72s)
agents which you can configure inside
[00:44] (44.64s)
your applications. I demonstrated a
[00:46] (46.80s)
library called MCPUs where you simply
[00:49] (49.44s)
plug in the MCP and the library
[00:51] (51.52s)
automatically gives you an agent. In
[00:53] (53.68s)
this way, you are essentially
[00:55] (55.12s)
programming large language models to
[00:57] (57.12s)
control your application using these
[00:58] (58.88s)
MCPs. Now, when it comes to external
[01:01] (61.28s)
APIs, if you are developing applications
[01:03] (63.52s)
that rely heavily on outside data, you
[01:05] (65.92s)
are still going to need them. For
[01:07] (67.20s)
example, if your app wants to use
[01:09] (69.12s)
location or navigation data from Google
[01:11] (71.44s)
Maps, then it will need access to those
[01:13] (73.60s)
external APIs. We are now moving toward
[01:16] (76.00s)
AIdriven applications. So, the question
[01:18] (78.24s)
becomes, how would your AI agent access
[01:20] (80.64s)
that data? Today I want to show you a
[01:22] (82.72s)
really simple way to make that happen.
[01:24] (84.48s)
I'll be introducing you to Postman's new
[01:26] (86.48s)
MCP generator. Postman, as you might
[01:28] (88.88s)
know, is a platform used for testing
[01:30] (90.96s)
APIs, but now they have introduced a
[01:33] (93.20s)
powerful tool that lets you generate an
[01:35] (95.20s)
MCP server for any API you want. What's
[01:38] (98.00s)
even better is that the server is hosted
[01:40] (100.08s)
locally, not on some remote platform. So
[01:42] (102.48s)
any application you build can include
[01:44] (104.16s)
the MCP server right within it. Let's
[01:46] (106.40s)
search for Google Maps. Just like I
[01:48] (108.16s)
mentioned earlier, you'll see there are
[01:49] (109.68s)
multiple API documentation sets
[01:51] (111.76s)
available for it. If we open up the core
[01:53] (113.76s)
APIs, we can see a wide variety of data
[01:56] (116.40s)
ready for use. For example, the air
[01:58] (118.40s)
quality API contains a huge amount of
[02:00] (120.96s)
information that you can access and use
[02:03] (123.04s)
freely. The roads API is another great
[02:05] (125.28s)
example. You can pull whatever data you
[02:07] (127.28s)
need and implement it in your
[02:08] (128.80s)
application without much complexity.
[02:10] (130.72s)
Postman has provided a very
[02:12] (132.24s)
straightforward method for setting this
[02:13] (133.68s)
up. In this video, I'm going to show you
[02:15] (135.44s)
how to generate an MCP server for any
[02:18] (138.00s)
API you choose. The API documentation
[02:20] (140.48s)
available is vast and detailed. You'll
[02:22] (142.64s)
find documentation for platforms like
[02:24] (144.64s)
Figma, X, and OpenAI, as well as
[02:27] (147.20s)
financial APIs like those for Mastercard
[02:29] (149.60s)
and Stripe. It's an incredibly
[02:31] (151.12s)
wide-ranging collection. And the best
[02:32] (152.88s)
part is you can generate MCP servers for
[02:35] (155.20s)
any of them. Even if you do not want to
[02:36] (156.96s)
integrate them into your own
[02:38] (158.32s)
applications, you can still use them
[02:40] (160.16s)
inside Claw Desktop where they can be
[02:42] (162.08s)
operated however you see fit. So let me
[02:44] (164.88s)
guide you through the entire process of
[02:46] (166.80s)
what you actually need to do. First, for
[02:49] (169.20s)
any API you want to convert into an MCP
[02:51] (171.84s)
server, you simply begin by searching
[02:53] (173.92s)
for it. If you have learned programming
[02:55] (175.76s)
the traditional way, you will probably
[02:57] (177.76s)
remember that one of the very first
[02:59] (179.60s)
projects many of us completed while
[03:01] (181.60s)
learning to work with APIs was a simple
[03:04] (184.16s)
weather map application. In my own case,
[03:06] (186.56s)
I used the open weather map API as part
[03:09] (189.28s)
of my learning process. Right here, you
[03:11] (191.36s)
can see several different types of APIs
[03:13] (193.36s)
available for use. This section is
[03:15] (195.28s)
focused on documentation, but the
[03:17] (197.12s)
important thing is that all of these
[03:18] (198.72s)
APIs are going to be converted into
[03:20] (200.48s)
tools for your MCP server. If we go
[03:22] (202.80s)
ahead and select all of them, each of
[03:24] (204.72s)
the three requests will be turned into
[03:26] (206.56s)
individual tools that belong to a single
[03:28] (208.96s)
MCP server. In our case, that would be
[03:31] (211.52s)
the open weather MCP server, which will
[03:33] (213.84s)
now include these three tools. You can
[03:35] (215.84s)
see that it shows three requests have
[03:37] (217.76s)
been selected. The next step is to add
[03:39] (219.76s)
them. And once that is done, you will
[03:41] (221.68s)
see that the requests have been added.
[03:43] (223.60s)
Now, we just need to click on the
[03:45] (225.04s)
generate button. After about 10 to 30
[03:47] (227.44s)
seconds, the MCP server will be fully
[03:49] (229.92s)
generated. Once it is ready, you will
[03:51] (231.92s)
notice that the MCP server has been
[03:53] (233.92s)
created, but it is not hosted on any
[03:56] (236.08s)
remote server. This MCP server is
[03:58] (238.16s)
designed to run locally on your own
[04:00] (240.00s)
machine. To make that possible, they
[04:01] (241.84s)
provide a zip file that contains the
[04:03] (243.76s)
complete codebase for the MCP server
[04:06] (246.08s)
which you can run locally. All you need
[04:07] (247.92s)
to do at this point is download the zip
[04:09] (249.84s)
file. You can see that the zip file has
[04:12] (252.08s)
been downloaded. Now, you are going to
[04:13] (253.68s)
extract the zip file and place it into
[04:15] (255.76s)
any folder you prefer. I am going to
[04:17] (257.60s)
move it into this folder. Since I
[04:19] (259.36s)
already had the file there, I will just
[04:21] (261.12s)
replace it. Now the folder has been
[04:22] (262.88s)
successfully moved and I am going to
[04:24] (264.72s)
open my terminal. As you can see, I am
[04:26] (266.96s)
already inside my developer folder. I
[04:29] (269.12s)
will navigate into the folder I just
[04:30] (270.80s)
copied which is named Postman MCP
[04:33] (273.28s)
server. Inside this MCP server folder, I
[04:36] (276.24s)
will run the command npm install which
[04:38] (278.48s)
will install all the necessary
[04:40] (280.00s)
dependencies. If this part is
[04:41] (281.76s)
unfamiliar, there is actually a full
[04:43] (283.84s)
guide that explains everything I am
[04:45] (285.84s)
doing right now. As you can see, npm
[04:48] (288.08s)
install has been executed and once it
[04:50] (290.32s)
completes, we are ready to run the
[04:52] (292.08s)
server locally. All the dependencies
[04:54] (294.08s)
have now been installed. The next
[04:55] (295.84s)
command we need to run is node mcp
[04:59] (299.16s)
server.js. This is a javascript file
[05:01] (301.68s)
that will start our mcp server. Once
[05:04] (304.08s)
that command has been run, the mcp
[05:06] (306.32s)
server will be up and running. We can
[05:08] (308.24s)
stop it at this point and also open it
[05:10] (310.08s)
to see how it works. As you can see, it
[05:12] (312.32s)
has opened successfully. Another
[05:14] (314.16s)
important thing to keep in mind is that
[05:16] (316.00s)
every MCP server you create will include
[05:18] (318.56s)
environment variables or API keys that
[05:21] (321.12s)
need to be set. Postman handles this by
[05:23] (323.44s)
automatically inserting them into yourv
[05:26] (326.24s)
file. All you need to do is retrieve the
[05:28] (328.32s)
appropriate keys, paste them into the
[05:30] (330.40s)
file, and your MCP server will be ready
[05:32] (332.72s)
to use. You no longer have to pass the
[05:34] (334.80s)
API key manually through the MCP server
[05:37] (337.84s)
command which is a helpful feature. This
[05:39] (339.76s)
is the MCP server file and this is the
[05:42] (342.08s)
MCP that has been generated for us. You
[05:44] (344.48s)
can go ahead and modify it however you
[05:46] (346.32s)
want which is a really useful option.
[05:48] (348.16s)
Now Postman has also mentioned that we
[05:50] (350.16s)
can test the MCP server using Postman
[05:52] (352.88s)
itself. This functionality is not
[05:54] (354.80s)
limited to just the MCP servers
[05:56] (356.72s)
generated by Postman. You can test any
[05:58] (358.80s)
MCP server using Postman which is
[06:01] (361.04s)
incredibly convenient. But what if you
[06:02] (362.80s)
want to run your MCP server in cursor? I
[06:05] (365.20s)
am going to show you how to do that. If
[06:07] (367.12s)
you're enjoying the video, I'd really
[06:08] (368.88s)
appreciate it if you could subscribe to
[06:10] (370.64s)
the channel. We're aiming to hit 25,000
[06:13] (373.12s)
subscribers by the end of this month,
[06:14] (374.72s)
and your support really helps. We share
[06:16] (376.72s)
videos like this three times a week, so
[06:18] (378.72s)
there's always something new and useful
[06:20] (380.40s)
for you to check out. Before I continue,
[06:22] (382.40s)
I need to get the API key. So, I am here
[06:24] (384.64s)
in the Open Weather dashboard, and I
[06:26] (386.56s)
have my API key available right here.
[06:28] (388.56s)
Now I am going to head back into cursor
[06:30] (390.72s)
open the env file and paste my API key
[06:33] (393.60s)
there. Now here in cursor in the MCP
[06:36] (396.48s)
servers section this is what you are
[06:38] (398.32s)
going to do. First we are going to add a
[06:40] (400.56s)
global MCP server. Since we do not have
[06:43] (403.12s)
a template to paste at the moment I am
[06:45] (405.36s)
going to ask it to generate a simple MCP
[06:48] (408.00s)
template that will be used with node
[06:49] (409.92s)
going forward. The template has now been
[06:52] (412.00s)
generated. We do not need the
[06:53] (413.52s)
environment file that came with it. So
[06:55] (415.52s)
let's go ahead and remove that. You can
[06:57] (417.28s)
see that the command is currently set to
[06:59] (419.20s)
run with node. Next, we need to replace
[07:01] (421.36s)
the path with the actual location of our
[07:03] (423.52s)
MCP server. To do that, go back to your
[07:06] (426.00s)
terminal. You will see the path where
[07:07] (427.60s)
your MCP server is located. To get the
[07:10] (430.08s)
full path, simply type the command and
[07:12] (432.32s)
press enter. The output will give you
[07:14] (434.32s)
the complete directory path. Inside
[07:16] (436.40s)
cursor, you are going to paste that full
[07:18] (438.48s)
path followed by the file name MCP
[07:21] (441.40s)
server.js. For example, this is my full
[07:23] (443.84s)
path and I am just adding MCPS server.js
[07:27] (447.04s)
to the end of it. The command stays as
[07:28] (448.80s)
node and now you can rename the server
[07:30] (450.56s)
to anything you like. For example, let's
[07:32] (452.32s)
name it weather MCP agent. At this
[07:34] (454.48s)
point, we have the weather MCP agent
[07:36] (456.48s)
created. Press command and S to save the
[07:38] (458.80s)
JSON file. If you go back into your
[07:40] (460.88s)
settings, you will see that the MCP
[07:42] (462.80s)
server is now listed and all the tools
[07:44] (464.80s)
are available. These tools include get
[07:46] (466.80s)
weather history, get current weather,
[07:49] (469.12s)
and get forecasted weather. There are no
[07:51] (471.36s)
issues showing up which means the API
[07:53] (473.44s)
key has been placed correctly and
[07:55] (475.28s)
everything is being accessed without any
[07:57] (477.28s)
problems. The MCP server is now running
[07:59] (479.60s)
and you can follow this same approach
[08:01] (481.28s)
for any other platform whether you are
[08:03] (483.20s)
working with Windinssurf cloud or
[08:04] (484.72s)
desktop. It will work with all of them.
[08:06] (486.72s)
If you want to build agents around it,
[08:08] (488.48s)
you can use the MCPUs library. This is a
[08:11] (491.20s)
very powerful library that allows you to
[08:13] (493.28s)
use MCP servers as agents directly in
[08:16] (496.08s)
your code. For instance, if your
[08:17] (497.92s)
application is based around weather
[08:19] (499.60s)
information, you could add this MCP
[08:21] (501.76s)
server agent into it and create a
[08:23] (503.76s)
feature where a user gives a voice
[08:25] (505.76s)
command with the name of a place and the
[08:27] (507.76s)
app automatically returns the weather
[08:29] (509.60s)
data. There is so much you can do with
[08:31] (511.28s)
this. If you browse through the
[08:32] (512.88s)
available options, you will notice there
[08:34] (514.88s)
are a huge number of documented APIs.
[08:37] (517.44s)
For example, you can use the Discord API
[08:39] (519.68s)
if you are building a social media
[08:41] (521.36s)
automation tool that reposts content
[08:43] (523.76s)
across different platforms. Everything
[08:45] (525.68s)
is already here and you do not have to
[08:47] (527.60s)
build it manually. A language model can
[08:49] (529.68s)
handle everything for you through the
[08:51] (531.28s)
MCP server. If you run a search, you
[08:53] (533.44s)
will even find an official Instagram API
[08:55] (535.84s)
workspace. You can also find one for
[08:57] (537.76s)
Facebook and for X as
[09:00] (540.76s)
well. This is a really powerful tool and
[09:03] (543.44s)
the number of things you can build with
[09:04] (544.88s)
it is truly impressive. Okay, so you can
[09:07] (547.36s)
clearly see that I asked it about the
[09:09] (549.12s)
weather in the UK, specifically in
[09:10] (550.96s)
Birmingham. It called the tool, passed
[09:12] (552.96s)
in the location along with the units in
[09:15] (555.04s)
which we wanted the temperature and
[09:16] (556.80s)
successfully retrieved the current
[09:18] (558.48s)
weather. It used the current weather
[09:20] (560.08s)
tool and it responded that the
[09:21] (561.84s)
temperature is 18° C. If we go and
[09:24] (564.88s)
check, we can confirm that it is
[09:26] (566.48s)
accurately fetching the data from the
[09:28] (568.32s)
open weather API. That brings us to the
[09:30] (570.96s)
end of this video. If you'd like to
[09:32] (572.48s)
support the channel and help us keep
[09:34] (574.16s)
making tutorials like this, you can do
[09:36] (576.16s)
so by using the super thanks button
[09:38] (578.00s)
below. As always, thank you for watching
[09:39] (579.92s)
and I'll see you in the next one.