تدريب Shadowing: MCP vs API Explained: Do You Really Need MCP? - تعلم التحدث بالإنجليزية عبر الفيديو

اختر وضع التدريب

كل وضع يفتح غرفة تدريب بملء الشاشة.

251 جمل
إذا كانت الجمل قصيرة أو طويلة جدًا، انقر على Edit لتعديلها.
1
You have probably seen people fighting about MCP versus API.
2
One side says MCP changes everything.
3
The other side says, we already have APIs, why do we need a new thing?
4
In this video, we will settle this properly.
5
What MCP actually is, where it sits in your application, and how does it compare with APIs.
6
And in the second half of this video, we will answer the confusions people usually have about MCP, starting with the biggest one.
7
Why do we even need MCP when API docs already exist?
8
Let's start with what we already know.
9
An API is how two programs talk to each other.
10
And let's make it concrete right away.
11
Say you have written program A that needs to read messages from Slack, and Slack is our program B here.
12
Slack exposes an endpoint, which is just a URL, something like api .slack .com .messages.
13
Your program sends a request to this URL, and Slack sends back a response with the data.
14
This is basically how API call works.
15
It's very clean and predictable, and for normal software, this is perfect.
16
Now, here is the important reality for API calls.
17
You, the developer, build each of these API integrations.
18
You also usually write the rules for when each API should be called.
19
When a deploy finishes, call
20
Slack's send message endpoint.
21
When someone asks for yesterday's messages, call the history endpoint.
22
If this happens, call Slack.
23
If that happens, call Jira.
24
In most production cases, your app won't talk to just Slack.
25
Your app might talk to 10 services.
26
Slack for alerts, Gmail for email, Jira for tickets, Notion for documents, your own database for user records, and five more like them.
27
For each one of those 10 services, you write the same kind of logic for every app you want to talk to.
28
The authentication, the API calls, the error handling, the retries if API call fails.
29
Now, let's upgrade program A.
30
Imagine you add an LLM to the application, so that the application can think and reason about the situation.
31
Instead of you deciding every case in advance, the model can look at a situation and decide what to do.
32
This sounds great, to be honest.
33
And here is the secret that makes everything else in this video easier.
34
The model does not directly make the API call.
35
The model tells your application what action it wants, and your application, normal software outside the model, performs that action.
36
So what actually happens is this.
37
Your application will feed the information to the model.
38
Here are the things that this application can do for you, like send a Slack message, create a Jira ticket, query the database.
39
The model reads the situation and writes back a message.
40
Please call the Slack endpoint, channel on call, text the payment service is down.
41
And then your application logic, normal code written by you, actually makes that API call.
42
The model says what to do, and the app executes the actual API calls.
43
Basically, situation hasn't changed at all.
44
You still wrote all 10 API integrations by hand.
45
Adding the model did not remove any of the API calls.
46
The model now decides which call to make, but you still built every single API call.
47
Now imagine your org builds a second app, a chat support app for customers, also powered by an LLM.
48
The support model reads a customer's chat and decides things like, this one needs a Jira ticket, that one needs an email reply.
49
This support app needs to access the same 10 services all over again.
50
So your team writes the Gmail integration again, the Jira integration again, all 10 of them, for app number 2.
51
So for the first app, you wrote 10 API integrations.
52
And for the second app, you again wrote 10 API integrations.
53
Two apps times 10 services.
54
That is 20 piles of integration code your team is writing and maintaining.
55
And when your org builds a third app next year, it becomes 30 API integrations.
56
So here's the question that led to MCP.
57
What if nobody has to hard code these API calls into every app?
58
This is how it will work.
59
Each of your apps gets one standard piece called an MCP client, and each service, Slack, Gmail,
60
Jira, Notion, your database, gets a small program sitting next to it called an MCP server.
61
The MCP client and the MCP server speak one common language, so any client can talk to any server.
62
Now count with me.
63
Two apps means two MCP clients.
64
Ten services means ten MCP servers.
65
Two plus ten.
66
In our simple example, that is roughly 12 pieces to build, instead of 20 separate integrations.
67
And the third app next year?
68
It simply reuses the same 10 servers, you just add one more client.
69
And honestly, in practice it can be even better, because for popular products, the MCP server usually already exists.
70
Slack, for example, builds and hosts its own official MCP server.
71
But for your own database, or your internal tools, your team may still have to build that that server yourself.
72
even the client.
73
Most teams get it from an AI framework instead of writing it from scratch.
74
Let's zoom in to one of these MCP servers.
75
One server can offer many actions, so this server will announce that I can offer sending a message, reading a channel's history, and searching old messages.
76
And now pay attention to this detail because this is the part people get wrong.
77
The MCP client inside your app connects to each of the ten servers and asks what actions are available.
78
This is called discovery.
79
The app then shows that list of actions to the model and the model chooses which action fits the task.
80
You no longer have to hard code every decision.
81
The model can choose from the actions that your application allows it to use.
82
You hand the model a labeled toolbox and let the model pick.
83
Let me walk you through one complete round trip so there is no magic left anywhere.
84
A customer writes to your support app.
85
My payment failed twice.
86
The The support app takes that message, plus the list of actions it discovered earlier from all MCP servers,
87
and sends all of it to the model.
88
The model reads everything and writes back, run the JIRA action, create a ticket, title payment failing, priority high.
89
Remember, the model just wrote text, nothing has actually happened yet.
90
The app hands that request to its MCP client.
91
The client sends it to the JIRA MCP server.
92
And the JIRA MCP server is the only piece that actually talks to JIRA it calls Jira's normal API, the same API that existed all along,
93
and the ticket gets created.
94
Jira answers with the ticket number.
95
That answer travels all the way back, from MCP server to MCP client, and then to the application,
96
and lands in front of the model as plain text.
97
The model reads it and writes the final reply.
98
I have created ticket 42 for the payment issue.
99
Now notice who did what.
100
The model only decided and replied.
101
The client and the server carried the messages.
102
And Jira's own API did the real work, exactly like it always has.
103
That is the whole trick.
104
So, does MCP replace APIs?
105
No, it doesn't.
106
If your system already has an API, the MCP server sits in front of that API as a translator,
107
and your API stays exactly where it is.
108
So MCP is not a replacement for APIs.
109
MCP is a common, AI -facing layer that can sit in front of APIs.
110
Now, let's get to the confusions I promised.
111
The argument that I get all the time is, why do I need MCP at all?
112
I already have the API docs available.
113
I can give my AI agent the open API spec, and the agent can figure out which API calls to make, right?
114
And it is a good question, because you actually can do this, and it will work.
115
But there are some advantages if we use MCP server.
116
To understand those advantages, we will give both approaches the exact same task and see exactly where MCP provides the advantage.
117
So the task is that our team has a Slack channel called Incident.
118
We want an AI agent to fetch yesterday's messages from that channel and write a short summary.
119
A human would do this in one minute.
120
They'll open Slack, find the channel, read the messages, and summarize.
121
Now let's watch an AI application do the same thing.
122
But before we compare anything, remember the secret from the first half.
123
The model cannot make an API call.
124
The model only writes what it wants.
125
Software outside the model has to pick up that request and actually do it.
126
The software that actually makes the API calls needs a name, so let's call it the execution layer.
127
We are calling this execution layer because it executes whatever the model asks for.
128
Keep this term in your head because both approaches in this comparison,
129
API docs and MCP, are really just two different ways of building the execution layer.
130
Approach 1.
131
The Direct API Route We give the agent two things, Slack's full API documentation and a sandbox.
132
This sandbox acts as a locked room where the agent can run Python code.
133
We have our Slack credentials available inside this sandbox.
134
Now trace it with me, step by step.
135
Step 1.
136
The model reads the docs.
137
Slack has hundreds of API methods.
138
We dump the whole API specification into the model's context so
139
that it knows what code it needs to write to call APIs.
140
Step 2.
141
The model writes Python code.
142
And this is where the little problems start showing up.
143
Slack's API does not understand the name Incident Channel.
144
It wants a channel ID.
145
So the code first looks up the channel to grab its ID.
146
Then the code calls
147
Slack's Message History API.
148
Then it converts the word
149
Yesterday into the exact time format Slack expects.
150
And the messages that come back are full of raw user IDs.
151
So the code may need to turn those into readable names too.
152
One Python script, but underneath, several API calls chained in the right order.
153
Step 3.
154
The sandbox runs that script.
155
The clean messages come back to the model, and the model writes the summary.
156
So did it work?
157
Yes, completely.
158
For one application, this is perfectly fine.
159
But notice, the agent wrote the code.
160
Your team set up the credentials.
161
Your team runs the sandbox.
162
And when the script or sandbox breaks, your team fixes it, not the model.
163
That is a real
164
Slack integration, and somebody has to maintain it.
165
Your application can save that code and reuse it in future.
166
But the moment a second AI application needs
167
Slack, your team has to decide, share this integration somehow, or build it again from scratch.
168
Now, let's see approach 2 and we use MCP this time.
169
We do the same task, but this time, we do not hand the agent any documentation.
170
We connect the application to a Slack MCP server instead.
171
Think of the MCP server as a ready -made execution layer sitting in front of Slack.
172
The server already understands
173
Slack's API, and it offers the model a short menu of actions written for AI applications.
174
Search for a channel.
175
Read messages from a channel.
176
Search messages by date.
177
Send a message.
178
The model sees the menu, and it picks the action that matches.
179
In this case, model just selects.
180
Read messages from a channel.
181
The MCP server does the rest.
182
The channel ID lookup, the time formats, the pagination, the authentication.
183
The server hands back clean, readable messages, and the model writes the summary.
184
Our model never touched a low -level
185
Slack API method.
186
And here is the difference that matters.
187
All the Slack -specific knowledge now lives in one reusable piece, the MCP server.
188
So let's say the difference plainly.
189
In the direct approach, the model reads documentation, and your own custom code, written partly by the agent itself, is the execution layer.
190
In the MCP approach, the model reads a menu of actions, and the MCP server is the execution layer.
191
Now you can argue, and people do, that the direct version can also be shared.
192
Build one internal
193
Slack service, put it in front of all your applications.
194
Done.
195
And that is a perfectly valid design.
196
But notice what you just did.
197
You invented your own private format for describing actions, sending requests, and returning results.
198
MCP is that same idea, except the format is public, and compatible AI applications already speak it.
199
Why would you design something that is already available?
200
It's like designing your own database when ready -made solutions like Postgres already exist.
201
Which brings us back to the original question.
202
Why not simply give the model the open API spec?
203
You can.
204
And now you know exactly what that gets you.
205
It educates your agent about the available API calls, but it does not build the execution layer.
206
You still need the software that holds the credentials, makes the request, handles the failures, and hands the result back to the model.
207
You can absolutely build that yourself.
208
What MCP gives you is a standard execution layer.
209
There is a second difference.
210
The question you need to ask yourself is who the OpenAPI docs were written for.
211
Raw API methods are written for developers.
212
It has a lot of granular details about small actions that developers need to chain up to get results
213
an mcp server can wrap all of
214
that into one action with a clear name and
215
when slack changes an api method underneath the hosted mcp server gets fixed in one place
216
you don't have to dump new API method again to your AI agent.
217
And one more.
218
OpenAPI only describes web APIs.
219
Your local files, your terminal, your database.
220
No OpenAPI document exists for them.
221
All of them can have an MCP server.
222
Two honest warnings before we finish.
223
Because MCP does not solve everything.
224
First, context cost, and this can affect both approaches.
225
API documents can be very large, so loading all of them can fill the model's context and use many tokens.
226
MCP can have the same problem if the app loads every action from every connected server.
227
Newer AI apps can now search for the right actions and load only the ones needed for the current task.
228
This saves tokens and leaves more room for the actual conversation.
229
Second, API keys.
230
API keys are like passwords, so the model should never see them.
231
Execution layer outside the model stores the keys and uses them to connect to the service.
232
MCP can support login, permissions, and approval before a risky action runs.
233
But developers still have to set up those protections correctly.
234
So when do you use which?
235
If you are building one application, calling a few API operations you already know, a quick experiment, a one -off task,
236
a direct integration is completely reasonable.
237
Same if no useful MCP server exists yet, or the one that exists does not offer the action you need.
238
Plenty of teams run secure, reusable, direct integrations without MCP.
239
And that is fine.
240
MCP starts paying for itself when several AI applications need the same systems.
241
And remember, MCP gives the model no new abilities.
242
Everything underneath is still normal APIs and normal code.
243
What MCP gives you is a standard.
244
And a standard is what lets 10 applications share one execution layer instead of building 10.
245
So here is the one -liner for the next time someone asks.
246
The AI model never executes the API call.
247
The execution layer around it does.
248
You can build that layer yourself for one application.
249
Or you can use MCP when you want a standard layer that many AI applications can discover and reuse.
250
For one application, a direct integration can be simpler.
251
When the same capabilities need to serve many AI applications and many systems, that is exactly what MCP is for.

تنزيل التطبيق

كل ما تحتاجه للتحدث بطلاقة

تقييم النطق بالذكاء الاصطناعيتقييم كل جملة
تدريب IPAأتقن كل صوت
المفرداتابنِ رصيدك من الكلمات
لعبة المفرداتتعلّم أثناء اللعب

نفس القناة

FOR YOU

فيديو موصى به

المفردات وملاحظات التحدث لهذا الدرس

هذا الدرس في المحادثة مبني على الفيديو “MCP vs API Explained: Do You Really Need MCP?”. أكثر الكلمات تكرارًا في الفيديو: api, mcp, model, server, slack. يحتوي هذا الفيديو على 251 جملة و2685 كلمة للتدرب على الترديد. مدة الكلام 17:12. يتكلم المتحدث بسرعة طبيعية، نحو 156 كلمة في الدقيقة، قريبة من المحادثة اليومية. 80% فقط من الكلمات ضمن أكثر 3,000 كلمة شيوعًا في الإنجليزية، فالمفردات صعبة نسبيًا.

أهم المفردات في هذا الفيديو

15 كلمة من الفيديو تستحق التعلّم، مع النطق والمعنى:

الكلمةالنطقالمعنى
server اسم/ˈsɝvɚ/خَادُوم m or خَادِم, مُلَقِّم
layer اسم/ˈleɪ̯ɚ/طَبَقَة
integration اسم/ˌɪn.tɪˈɡɹeɪ.ʃən/مُكَامَلَة
execution اسم/ˌɛk.sɪˈkjuː.ʃən/تَنْفِيذ
database اسم/ˈdeɪtəˌbeɪs/قَاعِدَة بَيَانَات
connect فعل/kəˈnɛkt/رَبَطَ
summary اسم/ˈsʌm.ə.ɹi/خُلَاصَة, مُلَخَّص
script اسم/skɹɪpt/كِتَابَة
menu اسم/ˈmɛn.juː/قَائِمَة, قَائِمَةُ الطَّعَام
underneath ظرف/ˌʌndɚˈniθ/تَحْت, أَسْفَل
execute فعل/ˈɛksɪˌkjuːt/أَعْدَمَ
compare فعل/kəmˈpɛɚ/قَارَنَ
confusion اسم/kənˈfjuːʒən/اِلْتِبَاس
scratch فعل/skɹæt͡ʃ/خَرْبَشَ
token اسم/ˈtoʊkən/رَمْز

الأفعال المركبة التي ستسمعها

الكلمةالمعنى
come back فعلعَادَ, رَجَعَ
pick up فعلقَطَفَ

القواعد في هذا الفيديو

أكثر التراكيب التي يستخدمها المتحدث، مع العبارات نفسها من الفيديو:

التركيبفي الفيديو
المضارع التام have/has + اسم المفعول — حدث ماضٍ ما زال له أثر الآنhave probably seen · have written · hasn't changed
المبني للمجهول be + اسم المفعول — التركيز على ما يحدث لا على من يفعلهshould be called · is called · be shared

نطق يحتاج إلى انتباه

يستخدم المتحدث 5 من الصيغ المختصرة، مثل doesn't, don't, hasn't. انطقها بصيغتها القصيرة كما تسمعها.

  • أصوات “th”: underneath /ˌʌndɚˈniθ/, authentication /ɔːˌθɛntɪˈkeɪʃn̩/
  • أصوات “sh” و“zh”: integration /ˌɪn.tɪˈɡɹeɪ.ʃən/, execution /ˌɛk.sɪˈkjuː.ʃən/, documentation /ˌdɑkjəmɛnˈteɪʃən/, confusion /kənˈfjuːʒən/, credential /kɹɪˈdɛnʃəl/
  • الكلمات الطويلة — انتبه لموضع النبر: integration /ˌɪn.tɪˈɡɹeɪ.ʃən/, execution /ˌɛk.sɪˈkjuː.ʃən/, developer /dɪˈvɛləpɚ/, documentation /ˌdɑkjəmɛnˈteɪʃən/, priority /pɹaɪˈɒɹɪti/

أصوات يجدها متحدثو العربية صعبة:

  • /p/ — ليس /b/: انطقه مع نفخة هواء: developer /dɪˈvɛləpɚ/, script /skɹɪpt/, compare /kəmˈpɛɚ/, dump /dʌmp/, spec /ˈspɛk/
  • /v/ — ليس /f/: مع اهتزاز الأوتار الصوتية: server /ˈsɝvɚ/, developer /dɪˈvɛləpɚ/, discovery /dɪˈskʌv.ɹi/, solve /sɒlv/, discover /dɪˈskʌvə/
  • تتابع الصوامت — لا تضف حركة بينها: slack /slæk/, connect /kəˈnɛkt/, script /skɹɪpt/, confusion /kənˈfjuːʒən/, scratch /skɹæt͡ʃ/

كيف تتدرب بهذا الفيديو

  1. استمع إلى الفيديو كاملًا مرة واحدة دون أن تتكلم، ودوّن الكلمات التي لا تعرفها.
  2. ابدأ بسرعة 0.75×، وردّد جملة جملة، ثم عُد إلى السرعة العادية عندما يصبح الأمر سهلًا.
  3. سجّل صوتك وقارنه بالأصل، مع الانتباه إلى كلمات مثل server, layer, integration.

ما هي تقنية التظليل الصوتي؟

التظليل الصوتي (Shadowing) تقنية تعلم لغة مدعومة علمياً، طُورت أصلاً لتدريب المترجمين الفوريين المحترفين. الطريقة بسيطة لكنها قوية: تستمع لصوت إنجليزي أصلي وتكرره فوراً بصوت عالٍ — كظل يتبع المتحدث بتأخير 1-2 ثانية. تُظهر الأبحاث تحسناً كبيراً في دقة النطق والتنغيم والإيقاع وربط الأصوات والاستماع والطلاقة.

تقنية الشادوينغ: اقرأ الدليل الكامل خطوة بخطوة →