Central MCP Host

by odgrim

189 downloads

Not rated

GitHub

Other

About

Centralize mcp server to run on a home lab instead of individually on every machine.

Details

Author: odgrim
Downloads: 189
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 Central MCP Host

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": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

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": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

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": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

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": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

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": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

JSON

{
    "mcpServers": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

From the repository

Clone the repository, copy .env.example to .env and fill in API tokens, then run docker compose up -d. You can start all services or specific ones using Docker Compose profiles (e.g., docker compose --profile github up -d).

Claude Desktop / Cursor

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

{
    "mcpServers": {
        "central mcp host": {
            "central-mcp-proxy": {
                "command": "docker",
                "args": [
                    "compose",
                    "up",
                    "-d"
                ]
            }
        }
    }
}

McpServers

{
    "central-mcp-proxy": {
        "command": "docker",
        "args": [
            "compose",
            "up",
            "-d"
        ]
    }
}

Central MCP Host

This project provides a centralized hosting environment for Model Context Protocol (MCP) servers using Docker, Traefik, and SuperGateway.

Overview

This setup runs a Traefik reverse proxy to route requests to various MCP servers. SuperGateway is used to convert between stdio and SSE transports, allowing the MCP servers to communicate with clients using SSE.

MCP Servers Included

- Notion: Interact with Notion databases and pages
- Linear: Interact with Linear Tickets
- GitHub: Interact with GitHub repositories, issues, and pull requests
- Memory Bank: Tools for recording project notes, thought trails and learnings

Prerequisites

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

Setup

1. Clone this repository
2. Copy the .env.example file to .env and fill in your API tokens:

   cp .env.example .env

   # Edit .env with your API tokens

3. Start the services:

   docker compose up -d

Docker Compose Structure

The project uses a modular Docker Compose structure:

- docker-compose.yml: Main file that includes Traefik configuration and references to service-specific files
- docker-compose/github.yml: GitHub MCP server configuration
- docker-compose/notion.yml: Notion MCP server configuration
- docker-compose/memory-bank.yml: Memory Bank MCP server configuration
- docker-compose/linear.yml: Linear MCP server configuration

This modular approach allows you to:
- Start all services: docker compose up -d (uses the default all profile set in .env)
- Start specific services using profiles:
- GitHub only: docker compose --profile github up -d
- Notion only: docker compose --profile notion up -d
- Memory Bank only: docker compose --profile memory-bank up -d
- Linear only: docker compose --profile linear up -d
- All services explicitly: docker compose --profile all up -d
- Add new services easily by creating a new file in the docker-compose directory

> Note: This project follows modern Docker Compose practices by omitting the version key, which is no longer required in Docker Compose V2 and above.

> Note: The network configuration is defined only in the main docker-compose.yml file to avoid conflicts. All services reference this network but don't redefine it.

> Note: 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 the Services

Once running, you can access the services using each tool's respective path-based route

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

How It Works

SuperGateway

SuperGateway is used to convert between stdio and SSE transports:

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

Traefik Configuration

Traefik is configured to:

1. Route requests based on path prefix e.g. (/notion, /github, /dashboard)
2. Strip the path prefix before forwarding to the appropriate service
3. Set appropriate make sure connections don't die
4. Provide a dashboard for monitoring

Testing the Setup

To test the setup, you can use the MCP Inspector:

npx @modelcontextprotocol/inspector node build/index.js

Troubleshooting

- Path routing issues: Verify the path prefixes in traefik labels, SuperGateway baseUrl option and strip middleware configuration
- MCP server errors: Check the logs of the container:

  docker compose logs -f notion-gateway

  docker compose logs -f github-gateway

- SuperGateway issues: Ensure the MCP server command is correct and the package exists in node registry- some packages advertise under different names in mcp vs node registries.

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

Central MCP Host

Overview

MCP Servers Included

Prerequisites

Setup

Docker Compose Structure

Accessing the Services

Path-based Routing

How It Works

SuperGateway

Traefik Configuration

Testing the Setup

Troubleshooting

Install

More like this

Sequential Thinking

Filesystem

EverArt

Google Drive

Reactive Resume

FastMCP v2 🚀