Sse MCP Server

This is an example implementation of a Model Context Protocol (MCP) server based on Server-Sent Events (SSE), designed for deployment on Netlify Edge Functions and providing real-time communication capabilities.

Communication tools Developer tools #Real-time communication #SSE protocol #Edge computing #MCP service .TypeScript

rating : 2 points

downloads : 10

update time : 2025-04-28

What is the SSE MCP Server?

The SSE MCP Server is a real-time communication server built using modern web technologies. It uses the Server-Sent Events (SSE) protocol to achieve one-way real-time data push between the server and clients. It is particularly suitable for scenarios that require real-time updates but do not require two-way communication.

How to use the SSE MCP Server?

You can connect to the server through a simple HTTP request, establish a persistent SSE connection, and then receive real-time messages pushed by the server. The server also provides an interface for sending messages.

Applicable scenarios

Scenarios that require the server to push data to clients, such as real-time notification systems, stock market quotes push, news updates, social media dynamics, and real-time log monitoring.

Main features

Real-time communicationUse the SSE protocol to achieve real-time data push from the server to clients.

Netlify integrationOptimized for Netlify Edge Functions and can be easily deployed to the Netlify platform.

Connection persistenceAutomatically send ping messages to keep the connection active and prevent timeout disconnection.

Simple interfaceProvide a simple and easy-to-use client interface for quick integration into existing systems.

Advantages and limitations

Advantages

Lightweight protocol, simpler and easier to use than WebSocket.

Automatic reconnection mechanism, attempts to reconnect when the connection is interrupted.

Based on the HTTP protocol, no special ports or complex configurations are required.

Optimized for edge computing, with fast response speed.

Limitations

Only supports one-way communication from the server to clients.

Some older browsers may not fully support SSE.

Long-term connections may consume more server resources.

How to use

Connect to the SSE server

Create an EventSource object in the client code to connect to the /sse endpoint.

Listen for message events

Add a listener for the message event to process messages pushed by the server.

Send a message to the server

Use the fetch API to send a POST request to the /message endpoint.

Usage examples

Real-time notification systemBuild a user notification system where the server pushes new notifications to clients in real-time.

Stock market quotes pushPush real-time stock price changes to all connected clients.

Frequently Asked Questions

What is the difference between SSE and WebSocket?

Will the connection be automatically reconnected?

How to ensure that the connection does not time out?

Which browsers are supported?

Related resources

SSE MDN documentation

Detailed documentation about Server-Sent Events on the Mozilla Developer Network.

Netlify Edge Functions documentation

Official documentation for Netlify Edge Functions.

GitHub repository

The project's source code repository.

🚀 SSE MCP Server

This repository is a server-side example implementation of the Model Context Protocol (MCP) using Server-Sent Events (SSE). It is designed to be deployed on Netlify Edge Functions.

🚀 Quick Start

Deployment Steps

Development Environment Setup

Clone the repository

git clone https://github.com/yourusername/sse-mcp-server.git
cd sse-mcp-server

Install dependencies
```
npm install
```
Start the development server
```
npm run dev
```

Deployment to Netlify

Install Netlify CLI (if not already installed)
```
npm install -g netlify-cli
```
Log in to Netlify
```
netlify login
```
Initialize the site (only for the first time)
```
netlify init
```
Deploy
```
npm run deploy
```

Verification Steps after Deployment to Netlify

After deployment, please follow these steps to verify:

Visit the deployed website URL
- When the deployment is complete, the URL will be displayed in the console or can be viewed in the Netlify dashboard.
- Example: https://your-site-name.netlify.app
After visiting the homepage, you will see the message: "SSE MCP Server is running. Visit /sse to connect."
- This indicates that the server is running properly.
Test the SSE connection using the example page
- The homepage (index.html) provides a user interface for testing the SSE connection.
- Click the "Connect" button to connect to the SSE server.
- After a successful connection, the status will show as "Connecting" and the connection ID will be displayed.
Test sending and receiving messages
- Enter a message in the text input field and click the "Send" button.
- The sent message will be returned by the server and displayed on the screen.
Confirm the following:
- Whether the status is displayed correctly
- Whether ping messages can be received periodically
- Whether message sending and receiving are working properly
- Whether error handling is appropriate
If necessary, use the Network tab of the developer tools (F12) to check the SSE connection in detail
- Check the request and event stream status of the /sse endpoint.
- Confirm that the POST requests to the /message endpoint are processed normally.

Successful completion of the above verification steps indicates that the server is running normally and users can connect and send/receive messages smoothly.

✨ Features

Real-time communication using SSE
Server-side implementation on Netlify Edge Functions
Simple client interface

📦 Installation

Development Environment

Clone the repository

git clone https://github.com/yourusername/sse-mcp-server.git
cd sse-mcp-server

Install dependencies
```
npm install
```

Deployment to Netlify

Install Netlify CLI (if not already installed)
```
npm install -g netlify-cli
```
Log in to Netlify
```
netlify login
```
Initialize the site (only for the first time)
```
netlify init
```
Deploy
```
npm run deploy
```

📚 Documentation

Latest Updates

2025/3/11: Fixed the 502 error in Netlify Edge Functions and added the function of sending ping messages periodically to maintain the SSE connection.

File Structure

everything.ts: The key logic file containing the core implementation of the MCP protocol.
sse.ts: The implementation of SSE-related logic.
Other files: Used to support the configuration and interface implementation of the entire project.