Central MCP Proxy

This project builds a centralized MCP server hosting environment through Docker and Traefik, integrating services such as Notion, Linear, GitHub, and Memory Bank, and uses SuperGateway to achieve communication protocol conversion.

Developer tools Knowledge management and memory #Multi-service Integration #Protocol Conversion #Containerized Deployment #Reverse Proxy

rating : 2 points

downloads : 9.6K

update time : 2025-04-28

Open Site

What is Model Context Protocol (MCP)?

MCP is a protocol used to connect different tools and services. It allows you to access data and functions from multiple platforms through a unified interface. With the MCP server, you can easily manage and operate tools such as GitHub, Notion, and Linear.

How to use the MCP server?

Simply install Docker and Docker Compose, and then start the service by following simple steps. You can quickly start using it without complex configuration.

Applicable Scenarios

Suitable for workflows that need to integrate multiple tools, such as project management, knowledge recording, and task tracking scenarios.

Main Features

Multi-tool Support

Supports integration with multiple tools such as GitHub, Notion, Linear, and Memory Bank.

Efficient Path Routing

Implements path-based request distribution through Traefik to simplify the access process.

Real-time Communication Support

Utilizes SuperGateway to achieve seamless conversion between standard input and SSE transmission.

Advantages

Easy to deploy and use

Supports integration with multiple tools

Powerful path routing capabilities

Limitations

Requires a Docker environment to be installed

Some tools may require specific API tokens

How to Use

Clone the Project Repository

Use Git to clone this project to your local machine.

Configure Environment Variables

Copy the.env.example file and fill in the necessary API tokens.

Start the Service

Use Docker Compose to start all services.

Usage Examples

Get GitHub Repository Information

Query information about a specific repository through the GitHub MCP server.

Record Project Notes

Use the Memory Bank MCP server to record learning notes related to the project.

Frequently Asked Questions

How to solve path routing problems?

What if the MCP server fails to start?

Related Resources

Official Documentation

Complete documentation for the MCP protocol and server.

GitHub Repository

Source code and examples of the project.

MCP Inspector

A tool for testing the MCP server.

🚀 Central MCP Server Hub

This project offers a centralized hosting environment for running Model Context Protocol (MCP) servers, utilizing Docker, Traefik, and SuperGateway. It provides a unified solution for managing multiple MCP servers, streamlining the process of interacting with various services.

✨ Features

Overview

This setup employs Traefik as a reverse proxy to route requests to different MCP servers. SuperGateway is used to convert between stdio and SSE transports, enabling MCP servers to communicate with clients via SSE.

Included MCP Servers

Notion: Interact with Notion databases and pages.
Linear: Interact with Linear tickets.
GitHub: Interact with GitHub repositories, issues, and pull requests.
Memory Bank: A tool for recording project notes, thought processes, and learnings.

📦 Installation

Prerequisites

Docker and Docker Compose
Notion API token
Linear API token
GitHub API token

Setup Steps

Clone this repository.

Copy the .env.example file to .env and fill in your API tokens:

cp .env.example .env
# Edit the .env file and enter your API tokens

Start the services:
```
docker compose up -d
```

📚 Documentation

Docker Compose Structure

The project uses a modular Docker Compose structure:

docker-compose.yml: The main file containing Traefik configuration and referencing service-specific files.
docker-compose/github.yml: Configuration for the GitHub MCP server.
docker-compose/notion.yml: Configuration for the Notion MCP server.
docker-compose/memory-bank.yml: Configuration for the Memory Bank MCP server.
docker-compose/linear.yml: Configuration for the Linear MCP server.

This modular approach allows you to:

Start all services: docker compose up -d (using the default all profile).
Start specific services using profiles:
- Only GitHub: docker compose --profile github up -d
- Only Notion: docker compose --profile notion up -d
- Only Memory Bank: docker compose --profile memory-bank up -d
- Only Linear: docker compose --profile linear up -d
- Explicitly start all services: docker compose --profile all up -d
Easily add new services by creating a new file in the docker-compose folder.

⚠️ Important Note

This project follows modern Docker Compose practices by omitting the version keyword (no longer required in Docker Compose V2 and above).

Network configuration is only defined in the main docker-compose.yml file to avoid conflicts. All services reference this network without redefining it.

The default profile is set to all in the .env file using the COMPOSE_PROFILES environment variable, allowing you to run docker compose up without explicitly specifying a profile.

Accessing Services

Once the services are running, you can access them via the corresponding path routes for each tool:

Path-based Routing

Traefik Dashboard: http://$HOSTNAME/dashboard/
Notion MCP Server:
- SSE Endpoint: http://$HOSTNAME/notion/sse
- Message Endpoint: http://$HOSTNAME/notion/message
GitHub MCP Server:
- SSE Endpoint: http://$HOSTNAME/github/sse
- Message Endpoint: http://$HOSTNAME/github/message
Linear MCP Server:
- SSE Endpoint: http://$HOSTNAME/linear/sse
- Message Endpoint: http://$HOSTNAME/linear/message
Memory-bank MCP Server:
- SSE Endpoint: http://$HOSTNAME/memory-bank/sse
- Message Endpoint: http://$HOSTNAME/memory-bank/message

🔧 Technical Details

How it Works

SuperGateway

SuperGateway is used to convert between stdio and SSE transports:

SuperGateway is installed in a container.
It runs the MCP server command with the --stdio flag.
It exposes HTTP endpoints for SSE connections and message sending.

Traefik Configuration

Traefik is configured as follows:

Routes requests based on path prefixes (e.g., /notion, /github).
Reverse proxies traffic to the correct service.
Provides a secure communication channel using HTTPS.

📄 Additional Information

Project URL: https://github.com/nat-n/MCP-Server-Hub
Issue Reporting: Submit issues or feature requests in this repository.
Contribution Guidelines: Check the project README to learn how to contribute to this project.