What every tech and non-tech guy needs to know about the MCPs

How MCP is different from an API

One thing we programmers love is standards, patterns, or frameworks, as these bring some structure to the computer architectures and systems and make our lives easier amidst the chaos. One such standard that helps us communicate between computers is the REST API, which you might have heard of. The Application Programming Interface (API), the interface that allows two systems, or say client-server, to communicate with each other.

In a broader sense API acts as a bridge between programs, you send a request and you recieve a response and something useful happens, for example say you click a button, a request is sent, and the backend does some useful work like email is sent, or a payment is processed, and you recieve a response saying payment successful or payment failed etc.

But in this API based approach, everything is happening via a UI frontend written in code and a backend API written in code, which does the job. Everything is driven by code.

Now imagine replacing this code interaction with natural language, meaning, imagine just instructing using prompts or normal English, and you get what you want.
for example :

“do some editing for me on adobe premeier pro, or design a figma for me just through text prompt”

This is where LLMs enter the story.

The Reality of LLMs

LLMs are good at understanding and are masters in predicting the next token or text in simpler terms, and generating human language, but LLMs by themselves are not capable of doing anything meaningful.

If you tell ChatGPT to send an email or do some specific task, it won’t be able to do, as LLMs are not capable of doing it.

LLMs are not as magical and smart as you think.

Where Tools Come In

So, Anthorpic Inc. came up with this standard that gives LLM access to tools which are basically small, specialized programs that actually do things.

You can think of tools as specialized functions each responsible for doing a specific task, say tool 1 does sending an email, tool 2 does sending a slack message.
So by combining LLMs with tools, it gives LLMs the access to external services, and LLMs start becoming powerful.
So instead of just saying, “Sure, I can write that SQL query,” the LLM could now actually run it against a database.

But here’s the problem: So if you want your AI (like ChatGPT) to connect to different tools, say Slack, Gmail, Notion, or Google Sheets, you’ll find that each one speaks a different “language.”

For example:

• Slack might want messages sent in JSON format.
• Older systems might use XML.
• Google Sheets might expect the data in another custom format.
• And each one has its own way to log in (some use passwords, others use API keys or OAuth tokens).

So, if you want your LLM to use all of these tools, you would have to write special connection code for every single one telling it exactly how to talk to Slack, Gmail, Notion, etc.

That becomes a huge headache when you have 10, 50, or 100 different tools, all changing and updating constantly.

It becomes a nightmare at scale.

Enters MCP: Model Context Protocol

MCP (Model Context Protocol) is a new open standard created by Anthropic that acts as a bridge between LLMs and external tools, APIs, and services.

In simple terms:

MCP helps LLMs understand what tools are available, how to use them, and when to use them in a consistent, standardized unified way.

MCP stands for Model Context Protocol

• Model → refers to the LLM (like ChatGPT, Claude, or Gemini).
• Context → refers to the data and knowledge the model can access. For example, check if the error that I am getting is mentioned in any issue on Jira or is being discussed on Teams.
• Protocol → defines the structured set of rules
  

So an MCP setup typically looks like this:

1. MCP Client: The LLM side that wants to perform a task, where we enter the prompt.
2. MCP Server: The tool side that offers capabilities (like “fetch user data” or “create Jira ticket”).
3. MCP Protocol: The bridge defines how the two exchange information safely.

Real-World Example

Imagine you use a trading app to buy and sell stocks.

Normally, you’d open the app, search for the stock, choose how many shares you want, and tap “Buy.”
Behind the scenes, all of that is handled by code APIs, logins, and data moving between systems.

Now imagine instead of doing all that, you could simply type a message like:

“Buy 5 shares of Apple for $180 each.” or “Sell Tesla if the price goes above $250.”

That’s what becomes possible with MCP.

Without MCP: the LLM (like ChatGPT) understands what you mean but can’t actually place the trade it has no connection to your trading app.

With MCP: the LLM connects safely through a standardized layer. It knows which tool to use, how to log in, how to send the trade order, and how to confirm it all automatically.

So instead of writing code or navigating menus, you just say what you want in plain English, and the AI + MCP handles the rest behind the scenes.

The Future

We’re still in the early days of MCP adoption, but it’s a big deal. There are still challenges in setting up MCP., These advancements in MCP standards have led to an entire ecosystem of “MCP App Stores,” where developers publish MCP-compatible tools that any AI model can use safely and consistently.

It’s the same revolution REST APIs brought to the web, only this time, it’s for AI systems.