[00:00] (0.16s)
Cursor and other agentic IDs have a big
[00:02] (2.80s)
limitation. Every model they use has a
[00:05] (5.04s)
training cutoff. I'm using Claude 3.7
[00:07] (7.52s)
right now and it stops its learning
[00:09] (9.04s)
beyond a certain point. You might have
[00:10] (10.80s)
noticed this already if you've used it
[00:12] (12.96s)
to build full stack apps. If I tell it
[00:15] (15.20s)
to install Shad CN UI in a project, it
[00:18] (18.08s)
still runs the old install command. That
[00:20] (20.48s)
command has been replaced, but the model
[00:22] (22.64s)
doesn't know the latest version because
[00:24] (24.64s)
it lacks updated context. I tried using
[00:27] (27.12s)
the add docs feature to fix this. I
[00:29] (29.52s)
added documentation for different
[00:31] (31.20s)
frameworks and it helped a bit. But the
[00:33] (33.20s)
agent pulls from both the project and
[00:35] (35.20s)
the documentation at the same time. That
[00:37] (37.44s)
makes the context heavy and the output
[00:39] (39.36s)
code is often poor. Things go more
[00:41] (41.44s)
smoothly when the project is small. For
[00:43] (43.36s)
example, with a lightweight library like
[00:45] (45.76s)
MCP use where everything fits into one
[00:48] (48.56s)
Redmi file. But the moment you move to
[00:50] (50.64s)
something bigger like a Nex.js app with
[00:52] (52.92s)
microservices, the system starts to
[00:54] (54.96s)
struggle. Now there's a much better fix
[00:56] (56.96s)
available. What I'm talking about is the
[00:58] (58.72s)
context 7 MCP server. Context 7 is a
[01:02] (62.00s)
site with a curated list of
[01:03] (63.36s)
documentation. It lets you pull specific
[01:05] (65.52s)
pieces of information with code examples
[01:08] (68.00s)
which when given to cursor agent help it
[01:10] (70.48s)
code accurately. This way it doesn't
[01:12] (72.80s)
mess up when handling unseen code. You
[01:15] (75.28s)
can see that the tools are active here.
[01:17] (77.12s)
Don't worry, I'll show you how to set
[01:18] (78.56s)
everything up. But first, let's test it
[01:20] (80.32s)
out. I'm going to open the agent and ask
[01:22] (82.24s)
it to build an MCP Python agent for
[01:24] (84.48s)
Airbnb using the MCPUs framework. This
[01:27] (87.76s)
framework is used to build AI agents
[01:30] (90.00s)
with MCPS. It's a solid option. I've
[01:32] (92.56s)
already made a video on it, so check
[01:34] (94.16s)
that out if you haven't. Let's give the
[01:35] (95.84s)
agent the
[01:45] (105.48s)
prompt. It has started working. And in
[01:48] (108.24s)
this case, we're using the docs feature
[01:49] (109.92s)
from cursor agent. The documentation
[01:52] (112.08s)
here is small. There's no real chance of
[01:54] (114.32s)
errors. The full documentation for MCPUs
[01:57] (117.36s)
is that one file from the GitHub repo.
[01:59] (119.76s)
It's not a lot, but let's see how much
[02:01] (121.76s)
of a difference it makes. The agent has
[02:03] (123.92s)
opened and I can see it made the correct
[02:06] (126.24s)
imports. Everything matches the source.
[02:08] (128.40s)
Nothing
[02:09] (129.24s)
unexpected. I've accepted the changes.
[02:11] (131.76s)
This is the final file. I ran it and it
[02:14] (134.24s)
works. Now let's try the same prompt
[02:16] (136.24s)
using the context 7 MCP. I'm using the
[02:18] (138.88s)
same prompt. So let's see how it builds
[02:20] (140.64s)
the agent. This
[02:22] (142.52s)
time you can see it's searching the
[02:24] (144.80s)
MCPU's documentation to understand how
[02:27] (147.20s)
to build the agent. When we open it, it
[02:29] (149.68s)
tells us what it's doing. Shows a basic
[02:32] (152.08s)
MCPU's agent implementation and gives a
[02:35] (155.12s)
code example too. In larger projects,
[02:37] (157.52s)
like I mentioned before, this helps
[02:39] (159.12s)
avoid breaking the code base. Let's look
[02:41] (161.28s)
at what it builds.
[03:03] (183.20s)
It's done. Let me just accept the
[03:04] (184.96s)
changes and then I'll look at the code.
[03:06] (186.72s)
This is exactly what I meant. It
[03:08] (188.40s)
included the Playright MCP, created an
[03:10] (190.96s)
advanced Airbnb agent, and then added
[03:13] (193.52s)
more features to it. It extended the
[03:15] (195.52s)
agents capabilities, and that would
[03:17] (197.52s)
never have happened if we used the
[03:19] (199.12s)
simple docs. The simple docs just show
[03:21] (201.36s)
how to implement an MCPU's agent. But
[03:23] (203.92s)
here, because it pulled specific pieces
[03:26] (206.16s)
of information, the agent had more room
[03:28] (208.40s)
to work with. Now I'll test it.
[03:30] (210.32s)
Everything runs fine. The agent works
[03:32] (212.32s)
and everything is set up correctly. I
[03:34] (214.16s)
tested it out and it works. It's
[03:35] (215.76s)
actually pretty amazing. Not overloading
[03:37] (217.76s)
the context really does help the agent
[03:39] (219.76s)
perform better. Another improvement in
[03:41] (221.68s)
cursor is security. You can see that
[03:44] (224.00s)
certain AI features are disabled in myv
[03:47] (227.04s)
file where I've added my API keys. The
[03:49] (229.76s)
file is declared as cursor ignore so
[03:52] (232.00s)
your information won't get leaked. So
[03:54] (234.40s)
for anyone who says you shouldn't build
[03:56] (236.00s)
your backend in cursor or handle things
[03:58] (238.24s)
involving API keys, here's another layer
[04:00] (240.72s)
of security added. This is the GitHub
[04:02] (242.80s)
repo for the context 7 MCP server. And
[04:05] (245.84s)
the installation instructions down here
[04:07] (247.60s)
are now pretty clear. Since all MCP
[04:10] (250.16s)
clients now use a standardized way of
[04:12] (252.32s)
connecting to these MCP servers, they
[04:14] (254.56s)
all use the same methods. There's no
[04:16] (256.48s)
authentication or API key needed. So
[04:18] (258.64s)
it's really straightforward. We have
[04:20] (260.32s)
installation support for cursor windsurf
[04:22] (262.40s)
and now also for VS Code thanks to its
[04:24] (264.72s)
GitHub copilot agent which can now use
[04:27] (267.20s)
MCPS. You just have to copy the command
[04:29] (269.36s)
and paste it. For this video we're going
[04:31] (271.60s)
to be using cursor. Inside cursor go
[04:34] (274.08s)
into your settings and from there
[04:36] (276.24s)
navigate to the MCP section. As you can
[04:38] (278.72s)
see I don't have any MCPS configured
[04:41] (281.28s)
which is why it's giving me this error.
[04:43] (283.20s)
I'm just going to add a new MCP. Paste
[04:45] (285.76s)
the configuration I got and save it. If
[04:48] (288.32s)
we go back, you'll see that the context
[04:50] (290.40s)
7 MCP has now been added. In case the
[04:52] (292.80s)
tools don't appear like this, you can
[04:55] (295.20s)
try refreshing first and it should show
[04:57] (297.36s)
the tools. If that still doesn't work,
[04:59] (299.68s)
just quit cursor and reopen it. That
[05:02] (302.00s)
should fix it. What's actually happening
[05:04] (304.08s)
behind the MCP server? Let's go to their
[05:07] (307.80s)
context7.com. You'll see updated
[05:09] (309.68s)
documentation for different frameworks.
[05:11] (311.60s)
Many of them are already supported. For
[05:13] (313.28s)
example, we have Nex.js here. And I also
[05:15] (315.60s)
noticed MCPUs listed. The documentation
[05:17] (317.92s)
is really up to date and if something
[05:19] (319.52s)
feels missing you can request more.
[05:22] (322.08s)
Right now they have documentation for
[05:24] (324.32s)
around 800 frameworks which is
[05:26] (326.64s)
impressive. If we open one like the
[05:28] (328.88s)
NexJS documentation you'll see
[05:31] (331.04s)
everything laid out clearly. It shows
[05:33] (333.52s)
the total number of tokens. You can
[05:35] (335.52s)
scroll through and find exactly what you
[05:37] (337.36s)
want to learn. For example, search for
[05:39] (339.20s)
pages router and all the related
[05:41] (341.44s)
information shows up.
[05:47] (347.84s)
There's also an option to increase the
[05:49] (349.84s)
token limit to get broader results. You
[05:52] (352.08s)
can copy any of this content and use it
[05:54] (354.16s)
directly with an LLM or inside any code
[05:56] (356.72s)
editor you prefer. There are also a lot
[05:58] (358.72s)
of features being requested. It's a
[06:00] (360.64s)
really active project. And one feature
[06:02] (362.64s)
I'm especially excited about is
[06:04] (364.40s)
documentation versioning. In larger
[06:06] (366.32s)
projects, once you're working with a
[06:08] (368.24s)
specific dependency, you need to refer
[06:10] (370.48s)
to the right version of the
[06:11] (371.76s)
documentation. This is going to help a
[06:13] (373.76s)
lot with that. So, I hope you enjoyed
[06:15] (375.36s)
the video and you're going to start
[06:16] (376.96s)
using the MCP server. It's totally free.
[06:19] (379.76s)
Doesn't really take much to set up and
[06:21] (381.60s)
it provides a whole lot of value. If you
[06:23] (383.92s)
see that anything is missing, please
[06:25] (385.60s)
request a documentation to make it as
[06:27] (387.76s)
much better as possible. And if you like
[06:29] (389.68s)
the video, do subscribe. And if you want
[06:31] (391.92s)
us to keep doing this, click the link in
[06:34] (394.16s)
the description to donate to us. Thanks
[06:36] (396.24s)
for watching. We'll see you in the next