MCP Containers: Hundreds of MCP Containerized Deployments Based on Docker

General Introduction

MCP Containers is an open source project, hosted on GitHub, focused on providing containerized solutions for Model Context Protocol (MCP) servers. It simplifies the deployment of hundreds of MCP servers via Docker containers, covering a wide range of AI tools such as GitHub, Notion, Firecrawl, etc. The MCP protocol supports the interaction of AI models with external data and tools, and MCP Containers allows users to quickly run servers by simply pulling an image. The project uses Nixpacks to automatically build container images, ensuring daily updates to keep them current. It supports both local and cloud deployments and is Kubernetes compatible, balancing security and flexibility. The community-driven development model encourages users to contribute new servers, making it suitable for developers, AI enthusiasts, and enterprise users.

Function List

• Offers hundreds of Docker container images for MCP servers and supports a wide range of AI tools.
• Use Nixpacks to build images automatically, ensure daily updates, and stay in sync with source repositories.
• Supports both local runs and cloud deployments, and adapts to Docker and Kubernetes environments.
• Provides a detailed list of servers and documentation for easy selection and configuration.
• Accept community contributions via GitHub to support adding new servers or optimizing existing mirrors.
• Ensure containers run in isolation, limit sensitive Docker options, and improve security.
• Supported with Claude, GitHub Copilot and other AI tools are integrated to extend functionality.
• Provides scripts and tools to simplify the container management and build process.

Using Help

Installation process

MCP Containers relies on Docker to run containerized MCP servers. The following are detailed installation and usage steps:

1. Installing Docker
   Ensure that Docker is installed on your system. Users who do not have it installed can visit the official Docker documentation (https://docs.docker.com/get-docker/) to download and install it, depending on your Windows, macOS, or Linux system. Once the installation is complete, run the following command to verify:

   docker --version
   

   output is similar to Docker version 20.x.x The installation was successful. Make sure the Docker daemon is running properly.

2. Pulling an MCP container image
   MCP Containers offers a variety of server images stored in the GitHub Container Registry (https://ghcr.io/metorial). Users can visit the project repository (https://github.com/metorial/mcp-containers) to see a list of available servers. Assuming that you want to use metoro-mcp-server, run the following command to pull the image:

   docker pull ghcr.io/metorial/metoro-mcp-server:latest
   

   interchangeability metoro-mcp-server for the desired server name. Once the pull is complete, check the mirror:

   docker images
   

3. Running containers
   in order to metoro-mcp-server As an example, run the container:

   docker run -i --rm -e API_KEY=<your-api-key> ghcr.io/metorial/metoro-mcp-server:latest
   

   • -i: Enable interactive mode to keep the terminal connected.
   • --rm: Containers are automatically deleted when stopped to save space.
   • -e API_KEY=<your-api-key>: Set the required API key (as required by the server).
     If you need to expose ports externally (e.g., Web services), add port mapping:

   docker run -i --rm -p 8080:8080 ghcr.io/metorial/metoro-mcp-server:latest
   

   Host port 8080 will be mapped to container port 8080.

4. Configuring the MCP Client
   The MCP server needs to be connected to a client that supports the MCP protocol (e.g., the Claude Desktop, VS Code GitHub Copilot plugin) connection. Take Claude Desktop as an example and edit its configuration file (macOS path:~/Library/Application Support/Claude/claude_desktop_config.json):

   {
   "mcpServers": {
   "metoro": {
   "command": "docker",
   "args": ["run", "-i", "--rm", "ghcr.io/metorial/metoro-mcp-server:latest"]
   }
   }
   }
   

   Once saved, Claude can invoke server functions via the MCP protocol. Other clients are configured in a similar way and should refer to their documentation.

Main Functions

• Running multiple MCP servers
  The project supports a variety of servers, such as github-mcp-server(managing GitHub repositories),firecrawl-mcp-server(web crawler),notion-mcp-server(Operation) Notion (Database). Users can choose according to their needs. For example, running the GitHub MCP server:

  docker run -i --rm -e GITHUB_PERSONAL_ACCESS_TOKEN=<your-token> ghcr.io/metorial/github-mcp-server:latest
  

  A GitHub Personal Access Token (PAT) is required and can be generated through GitHub settings (Settings > Developer settings > Personal access tokens).

• Automated Updates
  MCP Containers uses Nixpacks (https://nixpacks.com/) to build images automatically. Mirrors are automatically rebuilt daily when the source repository is updated. Users simply pull the latest image:

  docker pull ghcr.io/metorial/<server-name>:latest
  

  No need to manually update code or configuration.

• View Server List
  README of the project repository or servers folder lists all supported servers and their features. Users can view the local repository by browsing through GitHub or by running the following command:

  git clone https://github.com/metorial/mcp-containers.git
  ls mcp-containers/servers
  

Featured Function Operation

• Kubernetes Deployment
  MCP Containers Supports Kubernetes for Large-Scale Cloud Deployments Take metoro-mcp-server For example, create a Kubernetes deployment file (deployment.yaml):

  apiVersion: apps/v1
  kind: Deployment
  metadata:
  name: metoro-mcp
  spec:
  replicas: 1
  selector:
  matchLabels:
  app: metoro-mcp
  template:
  metadata:
  labels:
  app: metoro-mcp
  spec:
  containers:
  - name: metoro-mcp
  image: ghcr.io/metorial/metoro-mcp-server:latest
  env:
  - name: API_KEY
  value: "<your-api-key>"
  ports:
  - containerPort: 8080
  

  Deploy to a cluster:

  kubectl apply -f deployment.yaml
  

  transferring entity kubectl get pods Check the operational status.

• secure isolation
  The project is secured by container isolation, which disables high-risk Docker options (such as the --privileged). Users can access Docker's security-opt parameter further restricts permissions, for example:

  docker run --security-opt=no-new-privileges -i --rm ghcr.io/metorial/metoro-mcp-server:latest
  

• Community Contributions
  Users can add new servers or optimize mirrors by submitting an issue or pull request via GitHub. Contribute Steps:
  1. fork repository:https://github.com/metorial/mcp-containersThe
  2. Create a Dockerfile for the new server, place it in the servers/<server-name>The
  3. update README.md and server lists.
  4. Submit a pull request describing server functionality and MCP compatibility.

caveat

• Ensure that your network is free, pulling up mirrors may require scientific internet access.
• Some servers require API keys or authentication, which need to be registered with a service provider (e.g. GitHub, Notion) in advance.
• Check the server documentation for specific configurations (e.g., ports, storage volumes).
• Kubernetes deployment requires familiarity kubectl and cluster management.

application scenario

1. AI tool development
   Rapid deployment for developers firecrawl-mcp-serverThe AI model is used to test the web data crawling ability of the AI model and to validate the search or content analytics functionality.
2. enterprise automation
   Corporate use make-mcp-server Integrate with the Make automation platform to trigger workflows such as batch data processing or notification delivery through AI.
3. AI Services in the Cloud
   Run multiple MCP servers in a Kubernetes cluster to support real-time data analytics, chatbots, or multi-user AI applications.
4. Education and Research
   Students and researchers can use notion-mcp-serverIn addition, AI organizes experimental data or literature notes to streamline academic work.

QA

1. Which servers does MCP Containers support?
   Hundreds of MCP servers are supported, including GitHub, Notion, Firecrawl, Make, and more; see the project repository (https://github.com/metorial/mcp-containers) for a complete list of the servers Folder.
2. How do I secure the container?
   The project uses container isolation, disabling high-risk Docker options (such as the --privileged). Users should avoid running unauthenticated mirrors and may be able to security-opt Enhanced restrictions.
3. Programming experience required?
   Basic use requires only knowledge of Docker commands. Contributing new servers requires familiarity with Dockerfile and MCP protocols and is suitable for users with development experience.
4. How often are the mirrors updated?
   The mirrors are automatically updated daily and are built on Nixpacks to ensure synchronization with the source repositories.