🧠 Model Context Protocol (MCP) Example – Python Implementation

by srivatssan

1 stars

124 downloads

Not rated

GitHub

Other

About

This project is a simple vibe coded example of how an MCP Server could return a tool to the requesting client.

Details

Author: srivatssan
GitHub stars: 1
Downloads: 124
Categories: Other

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

Download and install Highlight from highlightai.com/download
Navigate to the plugins tab and select "Add Custom Plugin"
Configure the plugin with the settings below

Plugin Name 🧠 Model Context Protocol (MCP) Example – Python Implementation

Command (node, npx, python, etc.)

Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.
Enable "Start Automatically" if you want the plugin to start when Highlight launches

Setting up with Cursor

Open Cursor's settings
Navigate to the MCP section
Click "Add new Global MCP server"
Copy and paste the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

Setting up with Claude Desktop

Open Claude Desktop's settings
Go to the Integrations tab
Click "Add MCP Server"
Use the configuration below based on your operating system

Note: Make sure Claude Desktop is running before attempting to connect.

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

Setting up with Windsurf

Open Windsurf's preferences
Go to the Integrations section
Click "Add MCP Integration"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

Setting up with Cline

Open Cline's settings
Navigate to the Integrations section
Click "Add MCP Server"
Copy and paste the configuration below based on your operating system

Note: Make sure to restart Cline after adding the configuration.

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

Setting up with Goose

Open Goose's preferences
Go to the Integrations tab
Select "MCP Servers"
Click "Add New Server"
Use the configuration below based on your operating system

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

From the repository

Install FastAPI and Uvicorn, then start the server with uvicorn main:app --reload inside the server/ directory. Install the requests package and run python main.py from the client/ directory to interact with the server. The server exposes endpoints POST /rpc for JSON-RPC tool listing/invocation and GET /events for simulated SSE heartbeat messages.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "\ud83e\udde0 model context protocol (mcp) example \u2013 python implementation": {
            "MCP-Demo": {
                "command": "python",
                "args": [
                    "main.py"
                ]
            }
        }
    }
}

McpServers

{
    "MCP-Demo": {
        "command": "python",
        "args": [
            "main.py"
        ]
    }
}

🧠 Model Context Protocol (MCP) Example – Python Implementation

This repository provides a minimal yet functional example of the Model Context Protocol (MCP) using Python. It demonstrates how a Large Language Model (LLM) agent can communicate with enterprise systems through a standardized client-server interface using JSON-RPC over HTTP, including support for Server-Sent Events (SSE).

You can read my blog to understand the subject better: https://srivatssan.medium.com/model-context-protocol-exhaustively-explained-f5a30a87a3ff?sk=1b971265640303c66b04377371c82102

---

📦 Repository Structure

mcp-protocol-example/
├── client/
│   └── main.py       # Python MCP client using JSON-RPC
├── server/
│   └── main.py       # FastAPI-based MCP server with /rpc and /events endpoints

---

🚀 How to Run This Example

1️⃣ Start the Server

Make sure you have FastAPI and Uvicorn installed:

pip install fastapi uvicorn

Then, start the MCP server:

cd server
uvicorn main:app --reload

This starts a FastAPI server with:
- POST /rpc: JSON-RPC handler for tool listing and invocation
- GET /events: Simulated SSE endpoint emitting heartbeat messages every 5 seconds

---

2️⃣ Run the Client

Install the required Python requests package:

pip install requests

Then run the client to interact with the server:

cd client
python main.py

Output:

Tools: [{'name': 'greet', 'description': 'Greets the user', ...}]

Response: {'message': 'Hello, Sri!'}

You can run http://localhost:8000/events
and you should see the heartbeat event being returned
like the one shown below.

_data: {'event': 'heartbeat'}

data: {'event': 'heartbeat'}
_
...

**
---

⚙️ What It Demonstrates

- A basic MCP server exposing tools via tools/list and tools/call
- A client sending JSON-RPC requests to list and call tools
- Simulated real-time connection using /events SSE endpoint
- Modular structure ready to extend for resources/ and prompts/ support

---

🧩 Next Steps

You can expand this prototype by:
- Adding more tools with different schemas
- Supporting resources/list and resources/read
- Managing prompt templates with prompts/get
- Implementing authentication and access control
- Handling streaming responses from server to client

---

📚 References

- Model Context Protocol (official site)
- JSON-RPC 2.0 Specification
- FastAPI Documentation
- Server-Sent Events (MDN)

---

Created with ❤️ by Srivatssan Srinivasan

No reviews yet — be the first

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

About

Details

Jump to

Setting up with Highlight

From the repository

Claude Desktop / Cursor

McpServers

🧠 Model Context Protocol (MCP) Example – Python Implementation

📦 Repository Structure

🚀 How to Run This Example

1️⃣ Start the Server

2️⃣ Run the Client

⚙️ What It Demonstrates

🧩 Next Steps

📚 References

Install

More like this

Sequential Thinking

Filesystem

EverArt

Google Drive

Reactive Resume

FastMCP v2 🚀