Guide des serveurs OpenClaw MCP : intégration du protocole de contexte de modèle

La puissance d’OpenClaw vient de sa capacité à se connecter à des outils et services externes. Alors que les compétences étendent les capacités d’OpenClaw, les serveurs MCP (Model Context Protocol) fournissent un moyen standardisé de se connecter aux API, bases de données et services externes. Ce guide couvre tout sur les serveurs MCP dans OpenClaw.

Qu’est-ce que MCP ?

MCP (Model Context Protocol) est un protocole qui permet aux assistants IA de se connecter en toute sécurité à des outils et sources de données externes. Considérez les serveurs MCP comme des ponts entre OpenClaw et les services externes.

Sans MCP :

• OpenClaw ne peut utiliser que les capacités intégrées
• Les intégrations externes nécessitent un code personnalisé
• Chaque intégration est unique et complexe

Avec MCP :

• Manière standardisée de connecter des outils externes
• Serveurs réutilisables pour les services communs
• Facile à ajouter de nouvelles fonctionnalités
• Interface sécurisée et bien définie

Pourquoi MCP est important

Les serveurs MCP permettent à OpenClaw de :

• Accéder aux API externes (GitHub, Notion, Slack, etc.)
• Bases de données de requêtes (PostgreSQL, MySQL, MongoDB)
• Interagissez avec les services (e-mail, calendrier, stockage cloud)
• Étendez les capacités sans modifier le code principal
• Partager les intégrations au sein de la communauté

Au lieu de créer des intégrations personnalisées pour chaque service, vous pouvez utiliser (ou créer) des serveurs MCP qui suivent un protocole standard.

Comment fonctionne MCP

Architecture

MCP suit un modèle client-serveur :

• OpenClaw = Client MCP (demande des actions)
• MCP Server = Connecteur de service (exécute les actions)
• Protocole = Communication standardisée

Lorsque vous demandez à OpenClaw de faire quelque chose qui nécessite un service externe, OpenClaw :

1. Identifie quel serveur MCP peut gérer la demande
2. Envoie une requête à ce serveur
3. Le serveur exécute l’action (appel API, requête de base de données, etc.)
4. Le serveur renvoie les résultats à OpenClaw
5. OpenClaw vous présente les résultats

Types de connexion

Les serveurs MCP peuvent se connecter via :

• stdio : Entrée/sortie standard (serveurs locaux)
• HTTP : points de terminaison de l’API REST
• WebSocket : connexions en temps réel
• SSH : connexions au serveur distant

La plupart des serveurs MCP utilisent stdio pour les connexions locales, ce qui est simple et sécurisé.

Serveurs MCP disponibles

L’écosystème MCP comprend des serveurs pour de nombreux services populaires :

Outils de développement

Serveur GitHub MCP

• Accéder aux référentiels
• Créer des tickets et des pull request
• Gérer le code
• Examiner les modifications

Serveur GitLab MCP

• Similaire à GitHub
• Fonctionnalités spécifiques à GitLab
• Intégration CI/CD

Serveur Jira MCP

• Gérer les billets
• Suivre les projets
• Problèmes de mise à jour

Outils de productivité

Notion Serveur MCP

• Lire et écrire des pages
• Interroger des bases de données
• Gérer le contenu
• Synchroniser les données

Serveur Slack MCP

• Envoyer des messages
• Lire les chaînes
• Gérer l’espace de travail
• Gérer les notifications

Serveur MCP Google Workspace

• Accès à Gmail
• Gestion du calendrier
• Piloter l’intégration
• Documents et feuilles

Sources de données

Serveur PostgreSQL MCP

• Interroger des bases de données
• Exécuter SQL
• Gérer les schémas
• Analyse des données

Serveur MySQL MCP

• Requêtes de base de données
• Gestion des tables
• Opérations de données

Serveur MongoDB MCP

• Requêtes documentaires
• Gestion des collections
• Pipelines d’agrégation

Services cloud

Serveur AWS MCP

• Gestion EC2
• Opérations S3
• Fonctions Lambda
• Métriques CloudWatch

Serveur Google Cloud MCP

• Moteur de calcul
• Stockage en nuage
• BigQuery
• Fonctions cloud

Installation des serveurs MCP

Méthode 1 : serveurs intégrés

Certains serveurs MCP sont livrés avec OpenClaw ou sont facilement installables :

openclaw mcp install github
openclaw mcp install notion
openclaw mcp install postgres

Méthode 2 : Installation manuelle1. Installez le serveur MCP (généralement via npm ou le gestionnaire de packages)

2. Configurez OpenClaw pour l’utiliser
3. Ajouter des informations d’identification (clés API, jetons, etc.)
4. Tester la connexion

Exemple de configuration dans ~/.openclaw/config.json :

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "your-token-here"
      }
    },
    "notion": {
      "command": "node",
      "args": ["/path/to/notion-mcp-server"],
      "env": {
        "NOTION_API_KEY": "your-key-here"
      }
    }
  }
}

Méthode 3 : serveurs communautaires

Parcourez le répertoire du serveur MCP pour les serveurs gérés par la communauté :

• GitHub : github.com/modelcontextprotocol/servers
• Contributions communautaires
• Serveurs personnalisés

Utilisation des serveurs MCP

Une fois installés, les serveurs MCP sont disponibles automatiquement. OpenClaw connaît les fonctionnalités fournies par chaque serveur et les utilise le cas échéant.

Exemple : intégration GitHub

You: "Create a new issue in my openclaw project titled 'Add feature X'"
OpenClaw: [Uses GitHub MCP server to create issue]

OpenClaw :

1. Identifie que le serveur GitHub MCP peut gérer cela
2. Se connecte à l’API GitHub via le serveur MCP
3. Crée le problème
4. Confirme la création

Exemple : requête de base de données

You: "Query my PostgreSQL database and show me all users created this month"
OpenClaw: [Uses PostgreSQL MCP server to query database]

OpenClaw :

1. Utilise le serveur PostgreSQL MCP
2. Exécute la requête SQL
3. Formate les résultats
4. Présente les données

Exemple : Notion d’intégration

You: "Add a new page to my Notion workspace with today's meeting notes"
OpenClaw: [Uses Notion MCP server to create page]

Création de serveurs MCP personnalisés

Vous pouvez créer des serveurs MCP personnalisés pour les services qui n’en ont pas encore.

Structure du serveur MCP

Un serveur MCP est un programme qui :

1. Écoute les messages du protocole MCP
2. Exécute des actions (appels API, requêtes, etc.)
3. Renvoie les résultats au format MCP
4. Gère les erreurs avec élégance

Exemple simple de serveur MCP

Voici un serveur MCP minimal dans Node.js :

#!/usr/bin/env node

import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';

const server = new Server({
  name: 'my-custom-server',
  version: '1.0.0',
}, {
  capabilities: {
    tools: {},
  },
});

// Define a tool
server.setRequestHandler('tools/list', async () => ({
  tools: [{
    name: 'custom_action',
    description: 'Performs a custom action',
    inputSchema: {
      type: 'object',
      properties: {
        param: {
          type: 'string',
          description: 'A parameter',
        },
      },
    },
  }],
}));

// Handle tool execution
server.setRequestHandler('tools/call', async (request) => {
  const { name, arguments: args } = request.params;
  
  if (name === 'custom_action') {
    // Perform your custom action here
    const result = await performCustomAction(args.param);
    return {
      content: [{
        type: 'text',
        text: JSON.stringify(result),
      }],
    };
  }
  
  throw new Error(`Unknown tool: ${name}`);
});

// Start server
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error('MCP server running');
}

main().catch(console.error);

Meilleures pratiques du serveur MCP

1. Suivez le protocole : implémentez correctement la spécification MCP
2. Gérer les erreurs : renvoie des messages d’erreur clairs
3. Valider l’entrée : vérifier les paramètres avant l’exécution
4. Outils de documentation : fournissez des descriptions claires
5. Identifiants sécurisés : stockez les clés API en toute sécurité
6. Testez minutieusement : assurez la fiabilité

MCP vs compétences

Vous vous demandez peut-être : quand utiliser les serveurs MCP par rapport aux compétences ?

Utilisez les serveurs MCP lorsque :

• Connexion à des API/services externes
• Besoin d’un protocole standardisé
• Vous voulez des intégrations réutilisables
• Bâtiment à usage communautaire

Utilisez les compétences lorsque :

• Création de workflows personnalisés
• Combiner plusieurs capacités
• Besoin d’une logique spécifique à OpenClaw
• Création de fonctionnalités destinées aux utilisateurs

Souvent, les compétences utilisent des serveurs MCP sous le capot. Par exemple, une compétence de messagerie peut utiliser un serveur Gmail MCP pour accéder à la messagerie.

Considérations de sécurité

Gestion des informations d’identification

Les serveurs MCP ont besoin d’informations d’identification (clés API, jetons, etc.) :

• Stocker en toute sécurité dans les variables d’environnement
• Ne vous engagez jamais dans le contrôle de version
• Utiliser la gestion des informations d’identification d’OpenClaw
• Rotation régulière des informations d’identification

Contrôle d’accès

Contrôlez ce que les serveurs MCP peuvent faire :

• Examiner les capacités du serveur
• Limiter les autorisations lorsque cela est possible
• Surveiller l’utilisation du serveur
• Auditer les actions du serveur

Sécurité du réseau

Pour les serveurs MCP distants :

• Utiliser les connexions HTTPS/WSS
• Vérifier les certificats du serveur
• Utiliser l’authentification
• Surveiller le trafic réseau

Dépannage

Le serveur ne se connecte pas

1. Vérifiez que le serveur est installé : openclaw mcp list
2. Vérifiez la configuration dans ~/.openclaw/config.json
3. Vérifiez que les informations d’identification sont correctes
4. Examiner les journaux : openclaw logs

Erreurs du serveur

1. Vérifiez les journaux du serveur pour les erreurs
2. Vérifiez que les informations d’identification de l’API sont valides
3. Testez le serveur indépendamment
4. Vérifiez la compatibilité des versions du protocole MCP

Problèmes de performances

1. Surveiller les temps de réponse du serveur
2. Vérifiez la limitation des tarifs
3. Optimiser les requêtes/demandes
4. Pensez à la mise en cache

Cas d’utilisation populaires

Flux de travail de développement

Connectez le serveur GitHub MCP à :

• Créer des problèmes à partir du chat
• Examiner les demandes de tirage
• Gérer les référentiels
• Suivre les projets

Analyse des données

Connectez les serveurs MCP de base de données à :

• Interroger les données naturellement
• Générer des rapports
• Analyser les tendances
• Exporter des données### Productivité

Connectez les serveurs Notion/Slack MCP à :

• Gérer l’espace de travail depuis le chat
• Synchroniser les informations
• Automatiser les flux de travail
• Coordonner les équipes

Prochaines étapes

Maintenant que vous comprenez les serveurs MCP :

1. Parcourir les serveurs disponibles : recherchez des serveurs pour les services que vous utilisez
2. Installer un serveur : essayez le serveur GitHub ou Notion MCP
3. Utiliser dans les conversations : demandez à OpenClaw d’utiliser les fonctionnalités MCP
4. Créer un serveur personnalisé : créez-en un pour un service dont vous avez besoin
5. Partagez avec la communauté : contribuez à vos serveurs

Pour plus d’informations :

• Guide des compétences OpenClaw - Comment les compétences utilisent les serveurs MCP
• OpenClaw Browser Control - Alternative à MCP pour l’automatisation Web
• Guide d’installation - Configuration d’OpenClaw
• Intégrations - Intégrations disponibles
• FAQ - Questions courantes

Les serveurs MCP étendent les capacités d’OpenClaw de manière puissante. Commencez dès aujourd’hui à connecter des outils externes et débloquez de nouvelles possibilités pour votre assistant IA.