When I first heard about MCP, everyone kept saying:

"MCP stands for Model Context Protocol."

Honestly, that definition alone did not help me much.

I kept asking myself:

• What exactly is a protocol?
• Why do AI models need a protocol?
• Why is everyone suddenly talking about MCP?
• Why did Anthropic introduce MCP?
• Where should I use MCP?
• When should I avoid using MCP?

After spending some time building my own MCP servers, exploring MCP Inspector, and integrating local models, things finally started making sense.

In this blog, I want to explain MCP from a developer's perspective.

First, What is a Protocol?

A protocol is simply:

A set of rules that two or more systems agree to follow while communicating.

We use protocols in everyday life without even realizing it.

Imagine you want to meet your manager.

You usually don't directly walk into the manager's cabin.

Instead, you follow a process:

1. Send a request.
2. Wait for approval.
3. Receive confirmation.
4. Attend the meeting.

Both parties follow predefined rules.

This process itself is a protocol.

Similarly, computers also need protocols to communicate.

Examples:

• HTTP → Communication between browsers and web servers.
• SMTP → Communication for sending emails.
• TCP/IP → Communication on the Internet.

Without protocols, systems simply would not know how to talk to each other.

So, What is MCP?

MCP (Model Context Protocol) is an open standard that enables AI applications to communicate with external tools, resources, and systems in a standardized manner.

In simple words:

MCP is a common language between AI models and external systems.

Examples of external systems:

• Weather APIs
• Databases
• Google Drive
• GitHub
• Local files
• Slack
• Jira
• Enterprise applications
• Internal company systems

Why Was MCP Invented?

Before MCP, AI applications directly integrated with external systems.

For example:

LangGraph App
   ├── Weather API Integration
   ├── GitHub Integration
   ├── Database Integration
   ├── Gmail Integration
   └── Slack Integration

Every framework required separate integrations.

Suppose you built an AI application using LangGraph and later decided to migrate to:

• CrewAI
• OpenAI Agents SDK
• Agno
• LlamaIndex

You would often end up rewriting large portions of integration code.

This created multiple problems:

❌ Duplicate code

❌ Tight coupling

❌ Poor maintainability

❌ Reduced reusability

MCP solves this by standardizing integrations.

Instead of:

AI Application → External API

we now have:

User
   ↓
LLM
   ↓
MCP Client
   ↓
MCP Server
   ↓
External Systems

The AI application only needs to know:

How to communicate with MCP servers.

The MCP server handles everything else.

Who Invented MCP?

MCP was introduced and open-sourced by Anthropic.

The vision behind MCP was simple:

Create a universal standard for connecting AI systems with external capabilities.

Today, MCP is rapidly becoming an industry standard across the AI ecosystem.

Why Do AI Models Need MCP?

Large Language Models are excellent at generating text.

However, they cannot directly:

• Read your local files.
• Access databases.
• Send emails.
• Query enterprise systems.
• Execute business workflows.
• Access real-time information.

They require external tools.

MCP acts as a bridge.

User
   ↓
LLM (GPT/Claude/Ollama)
   ↓
MCP Client
   ↓
MCP Server
   ↓
External Tool

The model thinks:

"I need additional information."

Then, using MCP, it discovers and invokes the appropriate tool.

The Most Important Thing I Learned

MCP itself does not make decisions.

The LLM decides which tool to use.

MCP simply standardizes:

1. Tool discovery.
2. Tool execution.
3. Result retrieval.
4. Context sharing.

Real-Life Analogy

Think of MCP as a restaurant.

• Customer → AI Model
• Waiter → MCP Server
• Kitchen → External Tool

Conversation:

Customer:

"I want coffee."

Waiter:

"Let me check with the kitchen."

Kitchen prepares coffee.

Waiter returns:

"Here is your coffee."

Similarly:

User:

"Summarize this invoice."

LLM:

"I need the invoice extraction tool."

MCP server executes the tool.

Tool returns extracted information.

LLM generates the final response.

My First MCP Server

Since I am familiar with Python, I started by installing MCP.

pip install mcp

Then I created my first server.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Demo Server")

Creating a server is surprisingly simple.

The real focus should be on understanding what capabilities MCP provides and how to expose them to AI models.

Creating Your First Tool

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("Demo Server")


@mcp.tool()
def add(a: int, b: int) -> int:
    #Add two numbers
    return a + b


if __name__ == "__main__":
    mcp.run()

Now your server exposes a capability called:

add(a, b)

Similarly, enterprises can expose capabilities such as:

• Process invoices
• Query SAP
• Search internal documents
• Trigger workflows
• Access Jira
• Query databases

At this point, you have a working MCP server and a simple tool.

The next step is to test whether the server is actually exposing that tool correctly.

Testing Your MCP Server Using MCP Inspector

After creating your first MCP server, the next question is:

How do I know whether my server is working correctly?

The easiest way is to use MCP Inspector, an official tool that provides a graphical user interface (GUI) for interacting with MCP servers.

Prerequisite: Install Node.js

Before using MCP Inspector, you must install Node.js because the Inspector is distributed through npm/npx.

You can verify the installation by running:

node -v
npm -v

If Node.js is not installed, download it from the official website:

https://nodejs.org/

Launching MCP Inspector

Once Node.js is installed, start your MCP server using MCP Inspector:

npx @modelcontextprotocol/inspector python run.py

Replace run.py with your actual MCP server file name if it is different.

After running the above command, MCP Inspector will automatically launch in your browser.

The Inspector UI allows you to:

• Discover all available tools.
• View resources exposed by the server.
• Test prompts.
• Execute tools interactively.
• Inspect raw JSON-RPC requests and responses.
• Debug server behavior.
• Monitor notifications and logs.

MCP Inspector is one of the best tools for learning and debugging MCP because it helps visualize exactly how MCP clients communicate with MCP servers.

I strongly recommend using MCP Inspector while learning MCP, as it makes understanding the protocol significantly easier.

Once you have tested your first server, it becomes much easier to understand the main building blocks MCP provides.

Components Available in MCP

1. Tools

Used to perform actions.

Examples:

• Send Email
• Query Database
• Process Invoice

@mcp.tool()

2. Resources

Used to expose read-only information.

Examples:

• Files
• Documents
• Configurations

@mcp.resource()

3. Prompts

Reusable prompt templates.

@mcp.prompt()

4. Sampling

Allows the server to request LLM generation through the client.

5. Elicitations

Allows the server to ask users for additional information.

6. Roots

Defines filesystem locations accessible to the server.

7. Authentication

Supports secure access to protected systems.

8. Notifications

Supports progress updates and logging.

Transport Mechanisms in MCP

MCP supports multiple communication mechanisms.

STDIO

Used primarily for local MCP servers.

Client
   ⇅ stdin/stdout
Server

Examples:

• Claude Desktop
• MCP Inspector
• Local development

SSE (Server-Sent Events)

Used for remote communication.

Client
   ⇅ HTTP/SSE
Server

Streamable HTTP

Primarily used in cloud and production deployments.

Traditional HTTP:

Request → Response → Connection Closed

Streamable HTTP:

Analysis Started
25% Complete
50% Complete
75% Complete
Completed

Extremely useful for long-running enterprise workflows.

Where is MCP Useful?

✅ Agentic AI Systems

✅ Multi-Agent Applications

✅ Enterprise Automation

✅ RAG Systems

✅ Internal Developer Platforms

✅ Shared Tool Ecosystems

Examples:

• LangGraph Agents
• CrewAI Agents
• Invoice Automation
• Enterprise Knowledge Systems

Where is MCP NOT Required?

Avoid MCP for:

❌ Small scripts

❌ Simple chatbots

❌ Single API integrations

❌ Very small applications

Example:

print(add(5, 10))

No MCP required.

Frameworks Compatible with MCP

MCP works seamlessly with:

• LangChain
• LangGraph
• CrewAI
• LlamaIndex
• OpenAI Agents SDK
• Agno
• AutoGen
• Semantic Kernel
• Claude Desktop
• Cursor
• Continue
• VS Code AI Extensions

Important Development Tip

Unlike traditional Python applications:

❌ Avoid:

print("Hello")

MCP uses standard output for protocol communication.

Instead, use:

import logging

logging.info("Hello")

or:

import sys

print("Hello", file=sys.stderr)

Final Thoughts

I think of MCP as:

A Tool Management Software for AI Systems.

MCP provides a standardized, reusable, and maintainable approach for exposing capabilities to AI models.

For me, the easiest way to understand MCP was:

MCP is to AI applications what HTTP is to web applications.

Just as HTTP standardized communication for the web, MCP is standardizing communication between AI models and external systems.

As Agentic AI adoption continues to grow, MCP is rapidly becoming one of the most important building blocks for modern AI applications.

What are your thoughts on MCP? Have you started building MCP servers yet? 🚀

AI #GenerativeAI #AgenticAI #MCP #ModelContextProtocol #LangChain #LangGraph #Python #LLM #ArtificialIntelligence #OpenSource