Contêineres MCP: centenas de implementações em contêineres MCP baseadas no Docker

Introdução geral

MCP Containers é um projeto de código aberto, hospedado no GitHub, focado no fornecimento de soluções em contêineres para servidores MCP (Model Context Protocol). Ele simplifica a implantação de centenas de servidores MCP por meio de contêineres do Docker, abrangendo uma ampla gama de ferramentas de IA, como GitHub, Notion, Firecrawl etc. O protocolo MCP oferece suporte à interação de modelos de IA com dados e ferramentas externos, e o MCP Containers permite que os usuários executem servidores rapidamente simplesmente extraindo imagens. O projeto usa Nixpacks para criar automaticamente imagens de contêineres, garantindo atualizações diárias para mantê-las atualizadas. Ele oferece suporte a implementações locais e na nuvem e é compatível com o Kubernetes, equilibrando segurança e flexibilidade. O modelo de desenvolvimento orientado pela comunidade incentiva os usuários a contribuir com novos servidores, tornando-o adequado para desenvolvedores, entusiastas de IA e usuários corporativos.

Lista de funções

• Oferece centenas de imagens de contêineres do Docker de servidores MCP com suporte para várias ferramentas de IA.
• Use o Nixpacks para criar imagens automaticamente, garantir atualizações diárias e manter a sincronia com seus repositórios de origem.
• Suporta operação local e implantação em nuvem, adapta-se a ambientes Docker e Kubernetes.
• Fornece uma lista detalhada de servidores e documentação para facilitar a seleção e a configuração.
• Aceitar contribuições da comunidade via GitHub para apoiar a adição de novos servidores ou otimizar os espelhos existentes.
• Garanta que os contêineres sejam executados de forma isolada, limite as opções confidenciais do Docker e melhore a segurança.
• Com suporte do Claude, GitHub Copiloto e outras ferramentas de IA são integradas para ampliar a funcionalidade.
• Fornece scripts e ferramentas para simplificar o gerenciamento de contêineres e o processo de criação.

Usando a Ajuda

Processo de instalação

Os contêineres MCP dependem do Docker para executar servidores MCP em contêineres. Veja a seguir as etapas detalhadas de instalação e uso:

1. Instalando o Docker
   Certifique-se de que o Docker esteja instalado em seu sistema. Para aqueles que não o têm instalado, visite a documentação oficial do Docker (https://docs.docker.com/get-docker/) para fazer o download e instalá-lo, dependendo do seu sistema Windows, macOS ou Linux. Depois de instalado, execute o seguinte comando para verificar:

   docker --version
   

   A saída é semelhante a Docker version 20.x.x A instalação foi bem-sucedida. Certifique-se de que o daemon do Docker esteja sendo executado corretamente.

2. Extração de uma imagem de contêiner MCP
   O MCP Containers oferece uma variedade de imagens de servidor armazenadas no GitHub Container Registry (https://ghcr.io/metorial). Os usuários podem visitar o repositório do projeto (https://github.com/metorial/mcp-containers) para ver uma lista dos servidores disponíveis. Supondo que você queira usar o metoro-mcp-serverExecute o seguinte comando para extrair a imagem:

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

   intercambialidade metoro-mcp-server para o nome do servidor desejado. Quando a extração estiver concluída, verifique o espelho:

   docker images
   

3. Execução de contêineres
   para metoro-mcp-server Como exemplo, execute o contêiner:

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

   • -iAtivar o modo interativo para manter o terminal conectado.
   • --rmContêineres: Os contêineres são excluídos automaticamente quando parados para economizar espaço.
   • -e API_KEY=<your-api-key>API key: Defina a chave de API necessária (conforme exigido pelo servidor).
     Se você precisar expor portas externamente (por exemplo, serviços da Web), adicione o mapeamento de portas:

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

   A porta 8080 do host será mapeada para a porta 8080 do contêiner.

4. Configuração do cliente MCP
   O servidor MCP precisa estar conectado a um cliente que suporte o protocolo MCP (como o Claude Desktop, VS Code Copiloto do GitHub plugin). Tome o Claude Desktop como exemplo e edite seu arquivo de configuração (caminho do macOS:~/Library/Application Support/Claude/claude_desktop_config.json):

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

   Depois de salvo, o Claude pode invocar as funções do servidor por meio do protocolo MCP. Outros clientes são configurados de forma semelhante e precisam consultar a respectiva documentação.

Funções principais

• Execução de vários servidores MCP
  O projeto oferece suporte a uma variedade de servidores, como github-mcp-server(gerenciamento de repositórios do GitHub),firecrawl-mcp-server(rastreador da Web),notion-mcp-server(Operações) Noção (Banco de dados). Os usuários podem escolher de acordo com suas necessidades. Por exemplo, executar o servidor GitHub MCP:

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

  Um token de acesso pessoal (PAT) do GitHub é necessário e pode ser gerado por meio das configurações do GitHub (Configurações > Configurações do desenvolvedor > Tokens de acesso pessoal).

• Atualizações automatizadas
  Os contêineres MCP usam Nixpacks (https://nixpacks.com/) para criar imagens automaticamente. Os espelhos são reconstruídos automaticamente todos os dias quando o repositório de origem é atualizado. Os usuários simplesmente obtêm a imagem mais recente:

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

  Não há necessidade de atualizar manualmente o código ou a configuração.

• Exibir lista de servidores
  README do repositório do projeto ou servers lista todos os servidores compatíveis e seus recursos. Os usuários podem visualizar o repositório local navegando pelo GitHub ou executando o seguinte comando:

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

Operação da função em destaque

• Implantação do Kubernetes
  O MCP Containers oferece suporte ao Kubernetes para implementações de nuvem em grande escala. Pegue metoro-mcp-server Por exemplo, crie um arquivo de implantação do Kubernetes (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
  

  Implementar em um cluster:

  kubectl apply -f deployment.yaml
  

  aceitável kubectl get pods Verifique o status operacional.

• isolamento seguro
  O projeto é protegido pelo isolamento do contêiner, que desativa as opções de alto risco do Docker (como o --privileged). Os usuários podem acessar o site do Docker security-opt restringe ainda mais as permissões, por exemplo:

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

• Contribuições da comunidade
  Os usuários podem adicionar novos servidores ou otimizar espelhos enviando um problema ou uma solicitação pull via GitHub. Etapas de contribuição:
  1. repositório de bifurcações:https://github.com/metorial/mcp-containers.
  2. Crie um Dockerfile para o novo servidor e coloque-o no diretório servers/<server-name>.
  3. atualização README.md e listas de servidores.
  4. Envie um pull request descrevendo a funcionalidade do servidor e a compatibilidade com o MCP.

advertência

• Certifique-se de que sua rede esteja aberta, pois o acesso à imagem pode exigir acesso científico à Internet.
• Alguns servidores exigem chaves de API ou autenticação, que precisam ser registradas com um provedor de serviços (por exemplo, GitHub, Notion) com antecedência.
• Verifique a documentação do servidor para confirmar as configurações específicas (por exemplo, portas, volumes de armazenamento).
• A implantação do Kubernetes requer familiaridade kubectl e gerenciamento de clusters.

cenário do aplicativo

1. Desenvolvimento de ferramentas de IA
   Implementação rápida para desenvolvedores firecrawl-mcp-serverO modelo de IA será usado para testar a capacidade de rastreamento de dados da Web do modelo de IA e para validar a função de pesquisa ou análise de conteúdo.
2. automação empresarial
   Uso corporativo make-mcp-server Integre-se à plataforma de automação Make para acionar fluxos de trabalho, como processamento de dados em lote ou entrega de notificações por meio de IA.
3. Serviços de IA na nuvem
   Execute vários servidores MCP em um cluster Kubernetes para oferecer suporte a análises de dados em tempo real, chatbots ou aplicativos de IA multiusuário.
4. Educação e pesquisa
   Estudantes e pesquisadores podem usar notion-mcp-serverA IA é uma ótima maneira de simplificar seu trabalho acadêmico, organizando seus dados experimentais ou anotações na literatura.

QA

1. Quais servidores são compatíveis com o MCP Containers?
   Centenas de servidores MCP são compatíveis, incluindo GitHub, Notion, Firecrawl, Make e outros; consulte o repositório do projeto (https://github.com/metorial/mcp-containers) para obter uma lista completa dos servidores MCP. servers Pasta.
2. Como faço para proteger o contêiner?
   O projeto usa o isolamento de contêineres, desativando as opções de alto risco do Docker (por exemplo --privileged). Os usuários devem evitar executar espelhos não autenticados e podem ser capazes de security-opt Restrições aprimoradas.
3. É necessário ter experiência em programação?
   O uso básico requer apenas o conhecimento dos comandos do Docker. A contribuição de novos servidores requer familiaridade com o Dockerfile e o protocolo MCP e é adequada para usuários com experiência em desenvolvimento.
4. Com que frequência os espelhos são atualizados?
   Os espelhos são atualizados automaticamente todos os dias e são criados no Nixpacks para garantir a sincronização com os repositórios de origem.