Model Context Protocol (MCP) : guide complet pour devs et ops

Qu’est-ce que le Model Context Protocol (MCP)

Le Model Context Protocol (MCP) est un protocole open source publié par Anthropic en novembre 2024. Il standardise la façon dont un modèle IA (ou un agent) communique avec des sources de données externes : APIs, bases de données, outils système, services internes.

Avant MCP, chaque intégration était un bricolage propriétaire. Un agent Claude devait avoir sa propre intégration Slack, sa propre intégration GitHub, etc. Avec MCP, on sépare clairement :

• Le client : l’agent IA (Claude, un agent custom, OpenClaw…)
• Le serveur : le connecteur qui expose des outils et ressources via un protocole standardisé

Pourquoi c’est important pour les devs et ops :

• Interopérabilité : un serveur MCP fonctionne avec n’importe quel client compatible
• Sécurité : le serveur contrôle précisément ce que l’agent peut faire
• Composabilité : on chaîne plusieurs serveurs MCP sans effort
• Open source : la spec est publique, pas de lock-in vendor

Architecture et fonctionnement de MCP

Les trois piliers de MCP

Un serveur MCP expose trois types de primitives :

1. Tools (Outils)

Les tools sont des fonctions que l’agent peut appeler. C’est le mécanisme principal d’action : exécuter une commande, interroger une API, créer un ticket, déployer un conteneur.

// Exemple : définition d'un tool dans un serveur MCP
{
  "name": "deploy_service",
  "description": "Déploie un service sur le cluster Kubernetes cible",
  "inputSchema": {
    "type": "object",
    "properties": {
      "service_name": { "type": "string" },
      "namespace": { "type": "string", "default": "production" },
      "image_tag": { "type": "string" }
    },
    "required": ["service_name", "image_tag"]
  }
}

2. Resources (Ressources)

Les resources sont des données que le serveur met à disposition : fichiers, logs, résultats de requêtes. L’agent les lit pour comprendre le contexte avant d’agir.

// Exemple : une resource MCP
{
  "uri": "k8s://pods/production",
  "name": "Liste des pods en production",
  "mimeType": "application/json"
}

3. Prompts

Les prompts sont des templates préconfigurés que l’agent peut utiliser pour structurer ses interactions avec le serveur. Utile pour standardiser les workflows récurrents.

Le modèle client-serveur

MCP utilise le transport JSON-RPC 2.0. Deux modes de communication :

• stdio : le client lance le serveur comme processus fils, communique via stdin/stdout. Idéal pour les outils locaux.
• HTTP + SSE (Server-Sent Events) : communication réseau. Idéal pour les serveurs distants, partagés entre plusieurs agents.

Installer et configurer un serveur MCP

Plusieurs serveurs MCP officiels et communautaires existent déjà. Voici les plus utiles pour un environnement DevOps.

Prérequis

Exemple 1 : serveur MCP de système de fichiers

# Installer le serveur MCP officiel pour le filesystem
npx -y @anthropic-ai/mcp-server-filesystem /chemin/vers/dossier

# Ou via npm global
npm install -g @anthropic-ai/mcp-server-filesystem

Configuration côté client (exemple Claude Desktop, fichier claude_desktop_config.json) :

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@anthropic-ai/mcp-server-filesystem",
        "/home/user/projects"
      ]
    }
  }
}

Exemple 2 : serveur MCP pour Docker

# Installer le serveur MCP Docker
npx -y @anthropic-ai/mcp-server-docker

# Configuration côté client
{
  "mcpServers": {
    "docker": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-server-docker"]
    }
  }
}

Exemple 3 : serveur MCP GitHub

# Installer le serveur MCP GitHub
npx -y @anthropic-ai/mcp-server-github

# Configuration avec un token d'accès
{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_votre_token_ici"
      }
    }
  }
}

Context7 : documentation technique en temps reel via MCP

Context7 est un serveur MCP particulier : il donne acces a la documentation officielle de n’importe quelle librairie ou framework, directement depuis un agent IA. Plus besoin de chercher sur Google : l’agent interroge la doc en temps reel.

Installer Context7

# Via npm (recommande)
npm install -g @upstash/context7-mcp

# Verifier l’installation
npx @upstash/context7-mcp --version

Configurer Context7 avec un agent

Context7 fonctionne comme n’importe quel serveur MCP : il suffit de l’ajouter dans la configuration de votre client.

Utiliser Context7 : workflow type

# 1. Trouver l’ID d’une librairie
mcporter call context7 resolve-library-id --args '{"query": "ansible"}'

# 2. Interroger la documentation
mcporter call context7 query-docs --args '{"libraryId": "ansible", "query": "module copy"}'

Le premier appel retourne un identifiant de librairie, le second renvoie des extraits de documentation pertinents que l’agent peut utiliser immediatement pour ecrire du code fiable.

Créer un serveur MCP custom

Créer un serveur MCP permet d’exposer vos outils internes, APIs privées ou workflows métier à n’importe quel agent IA compatible.

En Python avec le SDK officiel

# Installation du SDK MCP
pip install mcp

# serveur_mcp_custom.py
from mcp.server import Server
from mcp.server.stdio import stdio_server
import mcp.types as types
import asyncio

# Créer l'instance du serveur
server = Server("mon-serveur-mcp")

@server.list_tools()
async def lister_outils() -> list[types.Tool]:
    """Déclare les outils disponibles"""
    return [
        types.Tool(
            name="verifier_service",
            description="Vérifie le statut d'un service système",
            inputSchema={
                "type": "object",
                "properties": {
                    "service": {
                        "type": "string",
                        "description": "Nom du service à vérifier"
                    }
                },
                "required": ["service"]
            }
        ),
        types.Tool(
            name="lire_log",
            description="Lit les N dernières lignes d'un fichier de log",
            inputSchema={
                "type": "object",
                "properties": {
                    "fichier": {"type": "string"},
                    "lignes": {"type": "integer", "default": 50}
                },
                "required": ["fichier"]
            }
        )
    ]

@server.call_tool()
async def appeler_outil(name: str, arguments: dict) -> list[types.TextContent]:
    """Exécute l'outil demandé"""
    if name == "verifier_service":
        import subprocess
        resultat = subprocess.run(
            ["systemctl", "is-active", arguments["service"]],
            capture_output=True, text=True
        )
        return [types.TextContent(
            type="text",
            text=f"Service {arguments['service']}: {resultat.stdout.strip()}"
        )]
    
    elif name == "lire_log":
        import subprocess
        resultat = subprocess.run(
            ["tail", "-n", str(arguments.get("lignes", 50)), arguments["fichier"]],
            capture_output=True, text=True
        )
        return [types.TextContent(
            type="text",
            text=resultat.stdout or resultat.stderr
        )]

# Point d'entrée
async def main():
    async with stdio_server() as (read_stream, write_stream):
        await server.run(read_stream, write_stream, server.create_initialization_options())

if __name__ == "__main__":
    asyncio.run(main())

En TypeScript / Node.js

// Installation
// npm install @modelcontextprotocol/sdk

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

const serveur = new Server(
  { name: "mon-serveur-mcp", version: "1.0.0" },
  { capabilities: { tools: {} } }
);

// Déclarer les outils disponibles
serveur.setRequestHandler(
  { method: "tools/list" },
  async () => ({
    tools: [
      {
        name: "verifier_ssl",
        description: "Vérifie la validité du certificat SSL d'un domaine",
        inputSchema: {
          type: "object",
          properties: {
            domaine: { type: "string", description: "Le domaine à vérifier" },
            port: { type: "number", default: 443 }
          },
          required: ["domaine"]
        }
      }
    ]
  })
);

// Exécuter un outil
serveur.setRequestHandler(
  { method: "tools/call" },
  async (request) => {
    const { name, arguments: args } = request.params;
    
    if (name === "verifier_ssl") {
      const { execSync } = await import("child_process");
      try {
        const resultat = execSync(
          `echo | openssl s_client -connect ${args.domaine}:${args.port || 443} 2>/dev/null | openssl x509 -noout -dates -subject`
        ).toString();
        return {
          content: [{ type: "text", text: resultat }]
        };
      } catch (err: any) {
        return {
          content: [{ type: "text", text: `Erreur: ${err.message}` }],
          isError: true
        };
      }
    }
    
    throw new Error(`Outil inconnu: ${name}`);
  }
);

// Lancer le serveur
const transport = new StdioServerTransport();
await serveur.connect(transport);

Connecter MCP a un agent IA

Un serveur MCP seul ne sert a rien : il faut un client qui l’exploite. Voici comment configurer MCP avec Claude Desktop, OpenClaw et Codex.

Claude Desktop

Claude Desktop integre MCP nativement. Editez le fichier de configuration :

# macOS
~/Library/Application Support/Claude/claude_desktop_config.json

# Windows
%APPDATA%\Claude\claude_desktop_config.json

# Linux
~/.config/Claude/claude_desktop_config.json

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"]
    },
    "docker": {
      "command": "npx",
      "args": ["-y", "@anthropic-ai/mcp-server-docker"]
    },
    "mon-serveur-custom": {
      "command": "python",
      "args": ["/chemin/vers/serveur_mcp_custom.py"]
    }
  }
}

OpenClaw

OpenClaw supporte MCP via la commande mcporter. Pour ajouter Context7 :

# Lister les serveurs MCP configures
mcporter list

# Ajouter Context7 comme serveur MCP
mcporter add context7 --command npx --args -y @upstash/context7-mcp

# Verifier que Context7 est actif
mcporter list context7

# Utiliser Context7 pour interroger une doc
mcporter call context7 resolve-library-id --args '{"query": "docker"}'
mcporter call context7 query-docs --args '{"libraryId": "docker", "query": "multi-stage build"}'

Codex (OpenAI)

Codex, l’agent de coding d’OpenAI, supporte MCP depuis sa version CLI. Pour ajouter Context7 :

# Editer la config Codex (fichier ~/.codex/config.json ou via la commande)
# Ajouter le serveur MCP dans la section "mcpServers"

{
  "mcpServers": {
    "context7": {
      "command": "npx",
      "args": ["-y", "@upstash/context7-mcp"]
    }
  }
}

Une fois configure, Codex peut acceder a la documentation de n’importe quelle librairie pendant ses sessions de coding. Demandez simplement « check the Ansible copy module docs » et il interrogera Context7 automatiquement.

Agent custom avec le SDK MCP

# client_mcp.py : exemple de client MCP minimal
import asyncio
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def main():
    params = StdioServerParameters(
        command="npx",
        args=["-y", "@upstash/context7-mcp"]
    )
    
    async with stdio_client(params) as (read, write):
        async with ClientSession(read, write) as session:
            await session.initialize()
            
            # Lister les outils disponibles
            outils = await session.list_tools()
            for outil in outils.tools:
                print(f"Outil : {outil.name} - {outil.description}")
            
            # Interroger la doc d’une librairie
            resultat = await session.call_tool(
                "resolve-library-id",
                arguments={"query": "kubernetes"}
            )
            print(f"Resultat : {resultat.content[0].text}")

asyncio.run(main())

Cas d’usage concrets

MCP ouvre des possibilités concrètes pour l’automatisation DevOps et les workflows IA en entreprise.

Erreurs courantes et troubleshooting

Erreur : « Server not found » ou « Connection refused »

# Cause fréquente : le chemin vers le serveur est incorrect
# Vérifier que le binaire existe et est exécutable
which python3
ls -la /chemin/vers/serveur_mcp_custom.py

# Vérifier la config JSON (attention aux virgules, guillemets)
python3 -m json.tool ~/.config/Claude/claude_desktop_config.json

Erreur : « Tool not found »

Le client ne voit pas les outils du serveur. Causes possibles :

• Le serveur ne les déclare pas dans list_tools()
• Le transport stdio a un problème (logs du serveur dans stderr)
• L’initialisation MCP a échoué silencieusement

# Debug : lancer le serveur manuellement pour voir les erreurs
python3 /chemin/vers/serveur_mcp_custom.py

# Vérifier que le serveur répond bien au handshake MCP
# Envoyer une requête initialize via stdin et observer la réponse

Erreur : timeouts sur les outils longs

# Les tools MCP n'ont pas de timeout par défaut dans la spec
# Ajouter un timeout côté client si le SDK le supporte
# Pour les outils longs (backup, scan), utiliser un pattern async :

# Dans le serveur : retourner immédiatement un job ID
# Puis exposer un tool "check_status" pour suivre l'avancement

Problème de permissions

Checklist de diagnostic

Questions fréquentes sur le Model Context Protocol

{
« @context »: « https://schema.org »,
« @type »: « FAQPage »,
« mainEntity »: [
{
« @type »: « Question »,
« name »: « MCP est-il uniquement compatible avec Claude d’Anthropic ? »,
« acceptedAnswer »: {
« @type »: « Answer »,
« text »: « Non. MCP est un protocole open source. Si Anthropic en est l’initiateur, n’importe quel client ou serveur compatible peut l’utiliser. Des implémentations existent pour OpenAI, des agents custom, OpenClaw, et d’autres plateformes. »
}
},
{
« @type »: « Question »,
« name »: « Quelle est la différence entre MCP et un plugin classique ? »,
« acceptedAnswer »: {
« @type »: « Answer »,
« text »: « Un plugin est spécifique à une plateforme. MCP est un standard interopérable : un serveur MCP fonctionne avec n’importe quel client compatible. De plus, MCP sépare clairement les tools, resources et prompts. »
}
},
{
« @type »: « Question »,
« name »: « Est-ce que MCP remplace les APIs REST ? »,
« acceptedAnswer »: {
« @type »: « Answer »,
« text »: « Non, MCP s’appuie sur vos APIs existantes. Un serveur MCP encapsule des appels REST, GraphQL, CLI ou tout autre interface. MCP est une couche d’abstraction au-dessus de vos APIs, pas un remplacement. »
}
},
{
« @type »: « Question »,
« name »: « Comment sécuriser un serveur MCP en production ? »,
« acceptedAnswer »: {
« @type »: « Answer »,
« text »: « Utiliser le transport HTTP+SSE avec TLS, authentifier les clients, limiter les tools exposés par serveur, sandboxer l’exécution des tools, et journaliser tous les appels pour l’audit. »
}
},
{
« @type »: « Question »,
« name »: « Peut-on utiliser plusieurs serveurs MCP en même temps ? »,
« acceptedAnswer »: {
« @type »: « Answer »,
« text »: « Oui, c’est le design principal de MCP. Un client peut se connecter à plusieurs serveurs simultanément. L’agent choisit le tool approprié parmi tous les serveurs connectés. »
}
},
{
« @type »: « Question »,
« name »: « MCP est-il adapté à un environnement d’entreprise ? »,
« acceptedAnswer »: {
« @type »: « Answer »,
« text »: « Absolument. MCP est conçu pour la production : transport sécurisé, gestion fine des permissions par tool, support multi-utilisateurs via serveurs distants, et auditabilité. »
}
}
]
}