쉐도잉 연습: 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.

앱 다운로드

유창하게 말하는 데 필요한 모든 것

AI 발음 평가문장마다 점수 확인
IPA 발음 연습모든 소리 마스터
단어 학습나만의 단어장 만들기
단어 게임놀면서 외우기

같은 채널

FOR YOU

추천 영상

이 레슨의 어휘와 말하기 포인트

이 말하기 레슨은 영상 “MCP vs API Explained: Do You Really Need MCP?”을(를) 바탕으로 합니다. 가장 자주 반복되는 단어는 다음과 같습니다: api, mcp, model, server, slack. 이 영상에는 섀도잉할 문장 251개와 단어 2685개가 있습니다. 말하는 구간의 길이는 17:12입니다. 화자는 분당 약 156단어로, 일상 대화에 가까운 자연스러운 속도로 말합니다. 영어에서 가장 많이 쓰이는 3,000단어에 속하는 단어가 80%뿐이라 어휘가 어려운 편입니다.

이 영상의 핵심 어휘

영상에 나오는 익혀 둘 만한 단어 15개를 발음, 뜻과 함께 정리했습니다.

단어발음뜻
server 명사/ˈsɝvɚ/서버, 봉사기
layer 명사/ˈleɪ̯ɚ/층
integration 명사/ˌɪn.tɪˈɡɹeɪ.ʃən/통합, 융합
execution 명사/ˌɛk.sɪˈkjuː.ʃən/실행, 집행
database 명사/ˈdeɪtəˌbeɪs/데이터베이스
format 명사/ˈfɔːɹ.mæt/포맷
connect 동사/kəˈnɛkt/잇다, 연결하다
summary 명사/ˈsʌm.ə.ɹi/요약, 개요
script 명사/skɹɪpt/문서, 문장
menu 명사/ˈmɛn.juː/메뉴, 메뉴판
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

주의할 발음

화자는 doesn't, don't, hasn't 같은 축약형과 약화된 형태를 5번 사용합니다. 들리는 대로 짧게 발음하세요.

  • “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/

한국어 화자가 어려워하는 소리:

  • /f/ — ㅍ(/p/)으로 바꾸지 말고 윗니를 아랫입술에 대기: format /ˈfɔːɹ.mæt/, confusion /kənˈfjuːʒən/, roughly /ˈɹʌf.li/, framework /ˈfɹeɪm.wɜːk/, fetch /fɛt͡ʃ/
  • /v/ — ㅂ(/b/)과 구별하기: server /ˈsɝvɚ/, developer /dɪˈvɛləpɚ/, discovery /dɪˈskʌv.ɹi/, solve /sɒlv/, discover /dɪˈskʌvə/
  • /z/ — ㅈ이 아니라 성대를 울리는 /s/: expose /ɪkˈspoʊz/, zoom /zuːm/, translator /ˈtɹænzleɪtɚ/, summarize /ˈsʌməˌɹaɪz/

이 영상으로 연습하는 방법

  1. 먼저 말하지 않고 영상을 끝까지 듣고 모르는 단어를 적어 둡니다.
  2. 0.75배속으로 한 문장씩 섀도잉을 시작하고, 익숙해지면 보통 속도로 돌아갑니다.
  3. 자신의 목소리를 녹음해 원본과 비교하고, server, layer, integration 같은 단어에 특히 주의합니다.

쉐도잉이란? 영어 실력을 빠르게 키우는 과학적 방법

쉐도잉(Shadowing)은 원래 전문 통역사 훈련을 위해 개발된 언어 학습 기법으로, 다언어 학자인 Dr. Alexander Arguelles에 의해 대중화된 방법입니다. 핵심 원리는 간단하지만 매우 강력합니다: 원어민의 영어를 들으면서 1~2초의 짧은 지연으로 즉시 소리 내어 따라 말하는 것——마치 '그림자(shadow)'처럼 화자를 따라가는 것입니다. 문법 공부나 수동적인 청취와 달리, 쉐도잉은 뇌와 입 근육이 동시에 실시간으로 영어를 처리하고 재현하도록 훈련합니다. 연구에 따르면 이 방법은 발음 정확도, 억양, 리듬, 연음, 청취력, 말하기 유창성을 크게 향상시킵니다. IELTS 스피킹 준비와 자연스러운 영어 소통을 원하는 분들에게 특히 효과적입니다.

섀도잉 방법: 단계별 전체 가이드 읽기 →