What is MCP and why is it making a lot of noise lately

on

 Model Context Protocol (MCP) — a hot topic in the world of AI infrastructure and agent orchestration.


Over the past few days, I have been hearing about this thing called MCP everywhere in my tech feed. As I am enthusiastic about Generative AI myself, I couldn't resist searching for this topic and get to know what exactly it is. So, I learnt about it to some extent and want to share it with you.


Ever wondered how multiple AI systems or tools can work together smoothly — like chatting, solving tasks, and remembering things across time?

That magic glue is something we're beginning to call Model Context Protocol (MCP).

Let’s break it down like you’ve never heard of it before.

Introduction and Definitions

A protocol is just a fancy word for "rules for communication."
Think of how HTTP lets your browser talk to websites. Or how Bluetooth lets your phone talk to your headphones.

In AI, we now have many powerful parts:

  • Chatbots (like ChatGPT)

  • Image analyzers

  • Web tools

  • Memory modules

  • Personal assistants

But… they don’t speak the same language by default.
That’s where MCP comes in.

The most simplest definition and understanding I found here : MCP Definition

It says: 



Basic Job of MCP

Model Context Protocol (MCP) helps different AI components understand and share the same context.
Context here means:

  • What’s the task?

  • Who is the user?

  • What tools have been used?

  • What’s been said already?

  • What do we remember from last time?

Without shared context, one AI tool might say:

“I don’t know what’s going on.” 

With MCP, it says:

“Got it! I know what we’re working on, which tool to use, and what’s been said earlier.” 

For the starters, a Context is like the memory, goal, background, and ongoing conversation all rolled into one.


Context is a term that is very important in the field of Generative AI, so don't consider it as some washed-up word!!

MCP is the foundation for smart, helpful, multi-tasking AI apps.
If you want:

  • An AI that remembers your preferences

  • An assistant who uses tools to get things done

  • A system that can talk to other AIs or models

Then, MCP is the skeleton that holds it all together.

Understanding with Example

Let’s say you’re building an AI app that helps people plan vacations.

Your app might use:

  • GPT-4 to chat with the user

  • An API to fetch flight prices

  • An image model to show maps

  • A memory store to remember preferred destinations

Here’s what MCP would do behind the scenes:

  1. Store the user's goal: “I want a beach vacation under $1500.”

  2. Track tools used: “Already checked flights with Skyscanner.”

  3. Remember preferences: “User prefers Bali over Goa.”

  4. Send this full context to all models so they’re all on the same page.

No confusion. No lost info. No repeat questions.
That’s the power of a good protocol like MCP.

Now you might be wondering how it might look under the hood, don't worry, I've got you covered:

Here’s a simple JSON-style schema that shows how context is packaged:

```

{

  "user_id": "123",

  "session_id": "abc456",

  "goal": "Plan a beach vacation under $1500",

  "conversation_history": [

    { "role": "user", "message": "I want a vacation in June." },

    { "role": "assistant", "message": "Any place in mind?" }

  ],

  "tools_used": ["flight_search", "weather_api"],

  "memory": {

    "preferred_destinations": ["Bali", "Maldives"],

    "budget_limit": 1500

  },

  "next_action": "call_weather_api"

}

```

This above “context packet” can be shared with:

  • GPT-4 for reasoning

  • A weather plugin

  • A memory module

  • A visual map tool

Everything is in sync. That’s MCP.

What's in store for the Future?

MCP is still evolving, but it's becoming a core building block for:

  • AI agents like AutoGPT, LangGraph, and OpenDevin

  • Tool-using LLMs like GPT-4 with plugins

  • Smart assistants that learn and grow with you

If you're building GenAI systems, understanding MCP will help you create modular, memory-aware, intelligent assistants, not just chatbots.

My Conclusion

MCP might sound technical, but at heart, it’s simple: It helps AI systems share memory, tools, goals, and history, just like a good team should.

And as we head into an era of multi-agent, tool-using, memory-backed AI, Model Context Protocol is the secret sauce that makes everything click together....

You may learn all about MCP from here : All about MCP

Location: Pune, Maharashtra, India

Comments

Post a Comment