TeamDay.ai
← Docs

Installer des serveurs MCP

Ce guide vous accompagne dans l’installation, la configuration et la gestion des serveurs MCP pour étendre les capacités de vos agents IA.

Aperçu de l’installation

Prérequis

Avant d’installer des serveurs MCP, assurez-vous d’avoir :

  • Un compte TeamDay avec les permissions appropriées
  • Accès au panneau de configuration des agents
  • Compréhension des outils et intégrations dont vous avez besoin
  • Clés API et identifiants requis pour les services externes

Méthodes d’installation

  • Serveurs intégrés : Serveurs pré-configurés disponibles dans TeamDay
  • Serveurs communautaires : Serveurs open-source de la communauté
  • Serveurs personnalisés : Serveurs auto-hébergés ou construits sur mesure
  • Serveurs d’entreprise : Serveurs commerciaux avec fonctionnalités d’entreprise

Serveurs MCP intégrés

Serveurs intégrés disponibles

TeamDay est livré avec plusieurs serveurs MCP pré-configurés :

Serveur de base de données

  • PostgreSQL : Se connecter aux bases de données PostgreSQL
  • MySQL : Intégration de base de données MySQL
  • MongoDB : Accès à la base de données NoSQL
  • SQLite : Opérations de base de données légères

Serveur de système de fichiers

  • Fichiers locaux : Accès aux systèmes de fichiers locaux
  • Stockage cloud : AWS S3, Google Drive, Dropbox
  • FTP/SFTP : Accès au protocole de transfert de fichiers
  • Dépôts Git : Accès aux fichiers basé sur Git

Serveur d’intégration API

  • APIs REST : Client API REST générique
  • GraphQL : Support de requête GraphQL
  • Gestionnaire de webhook : Recevoir et traiter les webhooks
  • Gestionnaire OAuth : Gestion de l’authentification OAuth

Installation de serveurs intégrés

Étape 1 : Accéder à la gestion des serveurs

  1. Accéder à la page de configuration de votre agent
  2. Cliquer sur “Tools & Integrations”
  3. Sélectionner “MCP Servers” dans la barre latérale
  4. Cliquer sur “Add New Server”

Étape 2 : Sélectionner le type de serveur

  1. Parcourir la section “Built-in Servers”
  2. Sélectionner le serveur que vous souhaitez installer
  3. Examiner la description et les capacités du serveur
  4. Cliquer sur “Install”

Étape 3 : Configurer le serveur

  1. Fournir les paramètres de configuration requis
  2. Configurer les identifiants d’authentification
  3. Configurer les permissions d’accès aux ressources
  4. Tester la connexion

Exemple : Installation d’un serveur de base de données

{
  "server_type": "postgresql",
  "configuration": {
    "host": "localhost",
    "port": 5432,
    "database": "myapp",
    "username": "agent_user",
    "password": "${DATABASE_PASSWORD}",
    "ssl": true,
    "pool_size": 10
  },
  "permissions": {
    "read": true,
    "write": true,
    "schema": false
  }
}

Serveurs MCP communautaires

Trouver des serveurs communautaires

  • Marketplace TeamDay : Marketplace officiel pour serveurs vérifiés
  • Dépôts GitHub : Serveurs communautaires open-source
  • Registre NPM : Serveurs MCP basés sur Node.js
  • Docker Hub : Serveurs MCP conteneurisés

Serveurs communautaires populaires

Serveur d’intégration GitHub

Se connecter aux dépôts GitHub :

# Installer via TeamDay CLI
teamday mcp install github-server

# Ou via npm
npm install @teamday/mcp-github-server

Configuration :

{
  "name": "github-server",
  "type": "community",
  "source": "npm:@teamday/mcp-github-server",
  "config": {
    "github_token": "${GITHUB_TOKEN}",
    "default_org": "my-organization",
    "rate_limit": 100
  }
}

Serveur d’intégration Slack

teamday mcp install slack-server

Configuration :

{
  "name": "slack-server",
  "type": "community",
  "source": "npm:@teamday/mcp-slack-server",
  "config": {
    "bot_token": "${SLACK_BOT_TOKEN}",
    "app_token": "${SLACK_APP_TOKEN}",
    "default_channel": "#general"
  }
}

Serveur email

teamday mcp install email-server

Configuration :

{
  "name": "email-server",
  "type": "community",
  "source": "npm:@teamday/mcp-email-server",
  "config": {
    "smtp_host": "smtp.gmail.com",
    "smtp_port": 587,
    "username": "${EMAIL_USERNAME}",
    "password": "${EMAIL_PASSWORD}",
    "use_tls": true
  }
}

Installation de serveurs communautaires

Méthode 1 : Marketplace TeamDay

  1. Aller dans “MCP Servers” → “Marketplace”
  2. Parcourir ou rechercher des serveurs
  3. Cliquer sur un serveur pour voir les détails
  4. Cliquer sur “Install” et suivre l’assistant de configuration
  5. Configurer l’authentification et les permissions

Méthode 2 : Installation manuelle

  1. Télécharger le package du serveur
  2. Télécharger vers votre instance TeamDay
  3. Configurer les paramètres du serveur
  4. Tester et activer le serveur

Méthode 3 : Installation CLI

# Installer TeamDay CLI
npm install -g @teamday/cli

# Se connecter à votre compte
teamday login

# Installer le serveur MCP
teamday mcp install <server-name>

# Configurer le serveur
teamday mcp configure <server-name>

Serveurs MCP personnalisés

Serveurs auto-hébergés

Pour des besoins d’entreprise ou spécialisés, vous pouvez héberger vos propres serveurs MCP.

Déploiement Docker

FROM node:18-alpine

WORKDIR /app
COPY package.json package-lock.json ./
RUN npm ci --only=production

COPY src/ ./src/
EXPOSE 3000

CMD ["node", "src/server.js"]

Configuration Docker Compose

version: '3.8'
services:
  mcp-server:
    build: .
    ports:
      - "3000:3000"
    environment:
      - MCP_PORT=3000
      - DATABASE_URL=${DATABASE_URL}
    volumes:
      - ./config:/app/config
    restart: unless-stopped

Configuration TeamDay

{
  "name": "custom-server",
  "type": "custom",
  "endpoint": "https://my-mcp-server.example.com",
  "authentication": {
    "type": "bearer",
    "token": "${CUSTOM_SERVER_TOKEN}"
  },
  "timeout": 30000,
  "retry_attempts": 3
}

Serveurs hébergés sur le cloud

Déployer sur des plateformes cloud :

AWS Lambda

# serverless.yml
service: mcp-server

provider:
  name: aws
  runtime: nodejs18.x
  environment:
    DATABASE_URL: ${env:DATABASE_URL}

functions:
  mcpHandler:
    handler: handler.mcp
    events:
      - http:
          path: /
          method: any

Google Cloud Functions

# cloud-function.yaml
runtime: nodejs18
entry_point: mcpHandler
env_variables:
  DATABASE_URL: ${DATABASE_URL}

Déploiement Vercel

{
  "name": "mcp-server",
  "version": 2,
  "builds": [
    {
      "src": "api/mcp.js",
      "use": "@vercel/node"
    }
  ],
  "routes": [
    {
      "src": "/(.*)",
      "dest": "/api/mcp.js"
    }
  ]
}

Gestion de configuration

Variables d’environnement

Stocker la configuration sensible dans les variables d’environnement :

# Fichier .env
DATABASE_PASSWORD=secure_password
GITHUB_TOKEN=ghp_your_token_here
SLACK_BOT_TOKEN=xoxb-your-token
EMAIL_PASSWORD=your_email_password
CUSTOM_SERVER_TOKEN=your_custom_token

Fichiers de configuration

Utiliser des fichiers de configuration pour les configurations complexes :

// mcp-config.json
{
  "servers": [
    {
      "name": "database-server",
      "enabled": true,
      "config": {
        "host": "localhost",
        "port": 5432,
        "database": "myapp"
      }
    },
    {
      "name": "github-server",
      "enabled": true,
      "config": {
        "default_org": "my-org"
      }
    }
  ],
  "global_settings": {
    "timeout": 30000,
    "retry_attempts": 3,
    "rate_limit": 100
  }
}

Gestion des secrets

Pour les déploiements d’entreprise, utiliser une gestion appropriée des secrets :

AWS Secrets Manager

const AWS = require('aws-sdk');
const secretsManager = new AWS.SecretsManager();

const getSecret = async (secretName) => {
  const result = await secretsManager.getSecretValue({
    SecretId: secretName
  }).promise();

  return JSON.parse(result.SecretString);
};

Azure Key Vault

const { DefaultAzureCredential } = require('@azure/identity');
const { SecretClient } = require('@azure/keyvault-secrets');

const credential = new DefaultAzureCredential();
const client = new SecretClient(vaultUrl, credential);

const getSecret = async (secretName) => {
  const secret = await client.getSecret(secretName);
  return secret.value;
};

Tests et validation

Vérifications de santé

Vérifier l’installation et la santé du serveur :

# Vérifier le statut du serveur
teamday mcp status

# Tester un serveur spécifique
teamday mcp test github-server

# Voir les logs du serveur
teamday mcp logs github-server --tail 100

Tests d’intégration

Tester la fonctionnalité du serveur :

// Tester la connexion à la base de données
const testDatabaseServer = async () => {
  try {
    const result = await agent.callTool('database-server', 'query', {
      sql: 'SELECT 1 as test'
    });
    console.log('Serveur de base de données fonctionnel:', result);
  } catch (error) {
    console.error('Erreur serveur de base de données:', error);
  }
};

// Tester le serveur API
const testApiServer = async () => {
  try {
    const result = await agent.callTool('api-server', 'get', {
      url: 'https://api.github.com/user'
    });
    console.log('Serveur API fonctionnel:', result);
  } catch (error) {
    console.error('Erreur serveur API:', error);
  }
};

Surveillance et maintenance

Surveillance du serveur

Surveiller les performances et la santé du serveur :

  • Temps de réponse : Suivre les temps de réponse moyens
  • Taux d’erreur : Surveiller la fréquence des erreurs
  • Utilisation des ressources : CPU, mémoire, utilisation réseau
  • Disponibilité : Métriques de disponibilité du serveur

Mises à jour automatiques

Activer les mises à jour automatiques pour les serveurs communautaires :

{
  "update_policy": {
    "auto_update": true,
    "update_schedule": "weekly",
    "allowed_versions": "patch",
    "rollback_on_failure": true
  }
}

Sauvegarde et récupération

Implémenter des stratégies de sauvegarde :

  • Sauvegarde de configuration : Snapshots réguliers de configuration
  • Sauvegarde d’état : Sauvegarde de l’état et des données du serveur
  • Récupération de désastre : Procédures de récupération en cas de défaillances
  • Contrôle de version : Suivre les changements de configuration

Dépannage

Problèmes d’installation courants

Échecs d’authentification

# Vérifier les identifiants
teamday mcp validate-auth github-server

# Rafraîchir les tokens
teamday mcp refresh-auth github-server

Problèmes de connexion

# Tester la connectivité
teamday mcp ping database-server

# Vérifier les paramètres réseau
teamday mcp network-test

Problèmes de permissions

# Vérifier les permissions
teamday mcp check-permissions

# Mettre à jour les permissions
teamday mcp update-permissions github-server

Résolution d’erreurs

Analyse des logs

# Voir les logs détaillés
teamday mcp logs --level error --since 1h

# Exporter les logs pour analyse
teamday mcp logs --export logs.json

Problèmes de performance

# Vérifier les performances du serveur
teamday mcp performance github-server

# Optimiser la configuration
teamday mcp optimize github-server

Bonnes pratiques de sécurité

Contrôle d’accès

  • Utiliser le principe du moindre privilège pour les permissions du serveur
  • Faire tourner régulièrement les clés API et tokens
  • Implémenter la liste blanche IP lorsque possible
  • Surveiller les logs d’accès pour activité suspecte

Protection des données

  • Chiffrer les données de configuration sensibles
  • Utiliser des canaux de communication sécurisés (HTTPS/TLS)
  • Implémenter la validation et l’assainissement des entrées
  • Audits et mises à jour de sécurité réguliers

Conformité

  • S’assurer que les serveurs respectent les exigences de conformité de votre organisation
  • Documenter les configurations de sécurité
  • Implémenter la journalisation d’audit
  • Évaluations de sécurité régulières

Prochaines étapes