https://github.com/user-attachments/assets/33e38719-6ac1-42fb-9e9c-20efb4d0f240

MCP (Model Context Protocol)

What is MCP?

MCP, or Model Context Protocol, is an open standard that defines how AI models themeselves can securely connect to external data sources, tools, and workflows. It standardizes communication so models can fetch information or execute actions without custom-built integrations, expanding their capabilities dynamically.

Manual vs Automatic Car Analogy

All the focus is on reducing the developer's effort — much like how automatic transmission cars reduce driver effort compared to manual ones.

MCP vs REST APIs

Definitions

• Model Context Protocol (MCP): An open standard designed for AI models and agents to interact with external tools, data sources, and workflows in a unified, contextual manner. It enables dynamic discovery of capabilities, maintains session-based context, and supports real-time updates, reducing integration complexity for AI systems.
• REST APIs: An architectural style for web services using HTTP methods (e.g., GET, POST) to perform stateless operations on resources. It's widely used for application-to-application communication with fixed endpoints and explicit request-response patterns.

Similarities to RESTful APIs

Both MCP and REST APIs facilitate communication between systems in a client-server model, allowing one component to request data or actions from another. MCP often leverages REST internally as an underlying transport layer, wrapping existing APIs to make them AI-compatible without replacing them.

Key Differences and Why It's Not Identical

When to Use Each

• Use REST APIs for traditional, non-AI projects needing predictable, low-level control. Opt for MCP in AI-driven applications where context persistence and seamless tool integration accelerate development and enable more intelligent, autonomous behaviors.

Running the FastMCP Server & Client

Start the Server

# Install FastMCP
pip install fastmcp

# Run with SSE transport (for testing via inspector or client)
fastmcp run main.py --transport sse --port 8000

Test with MCP Inspector (You can test on browser)

# Launch the dev inspector UI in your browser
npx @modelcontextprotocol/inspector

Then connect to http://127.0.0.1:8000/sse in the inspector.

Run the Client Programmatically

# Make sure the server is running first, then in a separate terminal:
python client.py

MCP Protocol Methods

Understanding http://localhost:8000/sse

This is where both worlds meet. Let's break it down piece by piece:

http://localhost:8000/sse

But what is this actually?

This is the transport address of a remote MCP server.

Remember our layers:

MCP Client needs to FIND the MCP Server first
        ↓
Where is it?  →  http://localhost:8000/sse  (this is just the address)
        ↓
Once connected, they TALK in JSON-RPC  →  { "method": "getUser" ... }

Analogy

The MCP server is a person sitting in a room.

http://localhost:8000/sse is the room number — so the client knows WHERE to go.

JSON-RPC is the language they speak once they're in the room.

REST vs MCP — How the URL is Used

REST → you visit https://api.example.com/users/42 and the URL itself IS the request

MCP  → you go to http://localhost:8000/sse just to find the server,
        then you send JSON-RPC messages to actually talk

The URL is just the door. JSON-RPC is the conversation inside.