MCP Containers : Des centaines de déploiements conteneurisés de MCP basés sur Docker

Introduction générale

MCP Containers est un projet open source, hébergé sur GitHub, qui vise à fournir des solutions conteneurisées pour les serveurs Model Context Protocol (MCP). Il simplifie le déploiement de centaines de serveurs MCP via des conteneurs Docker, couvrant une large gamme d'outils d'IA tels que GitHub, Notion, Firecrawl, etc. Le protocole MCP prend en charge l'interaction des modèles d'IA avec des données et des outils externes, et MCP Containers permet aux utilisateurs d'exécuter rapidement des serveurs en tirant simplement des images. Le projet utilise Nixpacks pour construire automatiquement des images de conteneurs, assurant des mises à jour quotidiennes pour les maintenir à jour. Il prend en charge les déploiements locaux et dans le cloud et est compatible avec Kubernetes, ce qui permet d'équilibrer la sécurité et la flexibilité. Le modèle de développement axé sur la communauté encourage les utilisateurs à contribuer à de nouveaux serveurs, ce qui le rend adapté aux développeurs, aux passionnés d'IA et aux utilisateurs en entreprise.

Liste des fonctions

• Offre des centaines d'images de conteneurs Docker de serveurs MCP avec prise en charge de plusieurs outils d'IA.
• Utilisez Nixpacks pour construire des images automatiquement, assurer des mises à jour quotidiennes et rester synchronisé avec vos dépôts de sources.
• Prend en charge le fonctionnement local et le déploiement dans le cloud, s'adapte aux environnements Docker et Kubernetes.
• Fournit une liste détaillée des serveurs et de la documentation pour faciliter la sélection et la configuration.
• Accepter les contributions de la communauté via GitHub pour soutenir l'ajout de nouveaux serveurs ou optimiser les miroirs existants.
• Assurez-vous que les conteneurs s'exécutent de manière isolée, limitez les options Docker sensibles et améliorez la sécurité.
• Avec le soutien de Claude, GitHub Copilote et d'autres outils d'intelligence artificielle sont intégrés pour étendre les fonctionnalités.
• Fournit des scripts et des outils pour simplifier la gestion des conteneurs et le processus de construction.

Utiliser l'aide

Processus d'installation

MCP Containers s'appuie sur Docker pour exécuter des serveurs MCP conteneurisés. Voici les étapes détaillées de l'installation et de l'utilisation :

1. Installation de Docker
   Assurez-vous que Docker est installé sur votre système. Pour ceux qui ne l'ont pas installé, visitez la documentation officielle de Docker (https://docs.docker.com/get-docker/) pour le télécharger et l'installer, en fonction de votre système Windows, macOS ou Linux. Une fois installé, exécutez la commande suivante pour le vérifier :

   docker --version
   

   est similaire à Docker version 20.x.x L'installation a réussi. Assurez-vous que le démon Docker fonctionne correctement.

2. Extraction d'une image de conteneur MCP
   MCP Containers offre une variété d'images de serveurs stockées dans le GitHub Container Registry (https://ghcr.io/metorial). Les utilisateurs peuvent visiter le référentiel du projet (https://github.com/metorial/mcp-containers) pour consulter la liste des serveurs disponibles. En supposant que vous souhaitiez utiliser metoro-mcp-serverExécutez la commande suivante pour extraire l'image :

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

   l'interchangeabilité metoro-mcp-server pour le nom du serveur souhaité. Une fois l'extraction terminée, vérifiez le miroir :

   docker images
   

3. Exécution des conteneurs
   afin de metoro-mcp-server A titre d'exemple, lancez le conteneur :

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

   • -i: Activer le mode interactif pour maintenir le terminal connecté.
   • --rmLes conteneurs sont automatiquement supprimés lorsqu'ils sont arrêtés afin d'économiser de l'espace.
   • -e API_KEY=<your-api-key>: Définissez la clé API requise (telle qu'elle est exigée par le serveur).
     Si vous devez exposer des ports à l'extérieur (par exemple, des services Web), ajoutez le mappage des ports :

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

   Le port 8080 de l'hôte sera mappé au port 8080 du conteneur.

4. Configuration du client MCP
   Le serveur MCP doit être connecté à un client qui prend en charge le protocole MCP (tel que l'application Claude Bureau, VS Code Copilote GitHub ). Prenons l'exemple de Claude Desktop et modifions son fichier de configuration (chemin macOS :~/Library/Application Support/Claude/claude_desktop_config.json) :

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

   Une fois sauvegardé, Claude peut invoquer les fonctions du serveur via le protocole MCP. Les autres clients sont configurés de manière similaire et doivent se référer à leur documentation.

Principales fonctions

• Exécution de plusieurs serveurs MCP
  Le projet soutient une variété de serveurs, tels que github-mcp-server(gestion des dépôts GitHub),firecrawl-mcp-server(robot d'exploration),notion-mcp-server(Opérations) Notion (base de données). Les utilisateurs peuvent choisir en fonction de leurs besoins. Par exemple, l'exécution du serveur GitHub MCP :

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

  Un jeton d'accès personnel GitHub (PAT) est nécessaire et peut être généré via les paramètres GitHub (Paramètres > Paramètres développeur > Jetons d'accès personnels).

• Mises à jour automatisées
  MCP Containers utilise Nixpacks (https://nixpacks.com/) pour construire des images automatiquement. Les miroirs sont automatiquement reconstruits chaque jour lorsque le référentiel source est mis à jour. Les utilisateurs n'ont qu'à extraire la dernière image :

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

  Il n'est pas nécessaire de mettre à jour manuellement le code ou la configuration.

• Voir la liste des serveurs
  README du référentiel du projet ou servers répertorie tous les serveurs pris en charge et leurs fonctionnalités. Les utilisateurs peuvent consulter le dépôt local en naviguant sur GitHub ou en exécutant la commande suivante :

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

Fonction en vedette Fonctionnement

• Déploiement de Kubernetes
  MCP Containers prend en charge Kubernetes pour les déploiements cloud à grande échelle. Prendre metoro-mcp-server Par exemple, créer un fichier de déploiement 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
  

  Déployer vers un cluster :

  kubectl apply -f deployment.yaml
  

  passable kubectl get pods Vérifier l'état de fonctionnement.

• isolement sécurisé
  Le projet est sécurisé par l'isolation des conteneurs, qui désactive les options Docker à haut risque (telles que l'option --privileged). Les utilisateurs peuvent accéder au site Web de Docker security-opt restreint davantage les autorisations, par exemple :

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

• Contributions communautaires
  Les utilisateurs peuvent ajouter de nouveaux serveurs ou optimiser les miroirs en soumettant un problème ou une demande d'extension via GitHub. Contribuer aux étapes :
  1. dépôt de la fourche :https://github.com/metorial/mcp-containers.
  2. Créer un fichier Docker pour le nouveau serveur, le placer dans le répertoire servers/<server-name>.
  3. mise à jour README.md et des listes de serveurs.
  4. Soumettre une demande de téléchargement décrivant les fonctionnalités du serveur et la compatibilité avec MCP.

mise en garde

• Assurez-vous que votre réseau est ouvert, l'affichage de l'image peut nécessiter un accès à l'internet scientifique.
• Certains serveurs nécessitent des clés API ou une authentification, qui doivent être enregistrées à l'avance auprès d'un fournisseur de services (par exemple GitHub, Notion).
• Consultez la documentation du serveur pour confirmer les configurations spécifiques (par exemple, les ports, les volumes de stockage).
• Le déploiement de Kubernetes nécessite une certaine familiarité kubectl et la gestion des clusters.

scénario d'application

1. Développement d'outils d'IA
   Déploiement rapide pour les développeurs firecrawl-mcp-serverLe modèle d'IA sera utilisé pour tester la capacité d'exploration des données web du modèle d'IA et pour valider la fonction de recherche ou d'analyse de contenu.
2. automatisation des entreprises
   Utilisation en entreprise make-mcp-server Intégrer la plateforme d'automatisation Make pour déclencher des flux de travail tels que le traitement de données par lots ou l'envoi de notifications grâce à l'IA.
3. Services d'IA dans le nuage
   Exécutez plusieurs serveurs MCP dans un cluster Kubernetes pour prendre en charge des analyses de données en temps réel, des chatbots ou des applications d'IA multi-utilisateurs.
4. Éducation et recherche
   Les étudiants et les chercheurs peuvent utiliser notion-mcp-serverL'IA est un excellent moyen de simplifier votre travail universitaire en organisant vos données expérimentales ou vos notes dans la littérature.

QA

1. Quels sont les serveurs pris en charge par MCP Containers ?
   Des centaines de serveurs MCP sont pris en charge, notamment GitHub, Notion, Firecrawl, Make, et bien d'autres encore ; voir le référentiel du projet (https://github.com/metorial/mcp-containers) pour une liste complète des serveurs MCP. servers Dossier.
2. Comment sécuriser le conteneur ?
   Le projet utilise l'isolation des conteneurs, en désactivant les options Docker à haut risque (par ex. --privileged). Les utilisateurs doivent éviter d'exécuter des miroirs non authentifiés et peuvent être en mesure de security-opt Restrictions renforcées.
3. Expérience en programmation requise ?
   L'utilisation de base ne nécessite qu'une connaissance des commandes Docker. La contribution de nouveaux serveurs nécessite une bonne connaissance de Dockerfile et du protocole MCP et convient aux utilisateurs ayant une expérience en matière de développement.
4. À quelle fréquence les miroirs sont-ils mis à jour ?
   Les miroirs sont automatiquement mis à jour quotidiennement et sont construits sur Nixpacks pour assurer la synchronisation avec les dépôts sources.