Content
# MCP SSE Server POC
A proof-of-concept server for STDIO transport of Model Context Protocol (MCP) into instant Server-Sent Events (SSE) streaming, deployable as a service. Instant remote hosted MCP servers with zero infrastructure work.
## Features
- Create and manage MCP server configurations via a simple UI
- Generate stable SSE endpoints for each configuration
- Stream real-time model responses via SSE
- Built with Express, Drizzle ORM, and PostgreSQL
- One-click deployment on Render
## Local Development
### Prerequisites
- Node.js (v18 or later)
- PostgreSQL database
### Setup
1. Clone this repository:
```bash
git clone https://github.com/yourusername/mcp-sse-poc.git
cd mcp-sse-poc
```
2. Install dependencies:
```bash
npm install
```
3. Set up your local PostgreSQL database and create a `.env` file with your database connection string:
```
DATABASE_URL=postgresql://username:password@localhost:5432/mcp_sse_db
```
4. Generate and run migrations:
```bash
npm run generate
npm run migrate
```
5. Start the development server:
```bash
npm run dev
```
6. Open your browser and navigate to `http://localhost:3000`
## Deployment on Render
### 1. Push Your Code to GitHub/GitLab
Make sure your repository includes all the files in this project.
### 2. Create a Web Service on Render
1. Log in to your [Render Dashboard](https://dashboard.render.com/)
2. Click **New → Web Service**
3. Connect your GitHub/GitLab repository
4. Configure the service:
- **Name**: Choose a name (e.g., `mcp-sse-poc`)
- **Environment**: Node
- **Build Command**: `npm install` (this will trigger the postinstall script that builds and migrates)
- **Start Command**: `npm start`
5. Click **Create Web Service**
### 3. Add a PostgreSQL Database
1. In Render, click **New → PostgreSQL Database**
2. Name it (e.g., `mcp-sse-db`)
3. Select the free plan
4. Click **Create Database**
5. Copy the provided `DATABASE_URL` connection string
### 4. Configure Environment Variables
1. Go back to your Web Service
2. Navigate to the **Environment** tab
3. Add the following environment variable:
- **Key**: `DATABASE_URL`
- **Value**: Paste the connection string you copied
### 5. Deploy
Render will automatically deploy your application. Once deployed, you can access it at the URL provided by Render.
## Usage
1. Open your deployed application in a browser
2. Create a new MCP server configuration by entering a name and JSON configuration
3. Save the configuration to generate an SSE URL
4. Use the SSE URL in your client application to stream model responses
### Example Configuration
```json
{
"mcpServers": {
"playwright": {
"command": "npx",
"args": ["@playwright/mcp@latest"]
}
}
}
```
## Model Context Protocol (MCP)
The Model Context Protocol is a lightweight, STDIO-based specification for interacting with language models over a standard input/output interface. It allows for real-time streaming of model responses and is designed to be simple and extensible.
### Core Concepts
1. **STDIO Transport**
- Input: JSON blob describing context messages
- Output: Incremental response tokens streamed to stdout
- Errors & Events: Non-blocking notifications on stderr
2. **JSON Message Format**
```json
{
"context": [
{ "role": "system", "content": "You are a helpful assistant." },
{ "role": "user", "content": "Translate to French: Hello, world!" }
],
"stream": true
}
```
3. **Server-Sent Events (SSE)**
- Each JSON chunk becomes an SSE event
- Perfect mapping to MCP's unidirectional streaming model
## License
MIT
MCP Store