ITSkillsCenter
Intelligence Artificielle

Claude MCP : Model Context Protocol en pratique

8 min de lecture
Miniature - Claude MCP : Model Context Protocol en pratique

Ce que vous saurez faire à la fin

  1. Comprendre le protocole MCP (Model Context Protocol) et son intérêt face aux function calls classiques
  2. Connecter Claude Desktop à 3 serveurs MCP officiels (filesystem, GitHub, SQLite)
  3. Créer votre propre serveur MCP en Python qui expose des outils métiers (gestion factures FCFA)
  4. Tester votre serveur avec le MCP Inspector et le déployer en production
  5. Sécuriser un serveur MCP exposé à des utilisateurs internes d’une PME

Durée : 5h. Pré-requis : Python 3.10+ ou Node 20+, Claude Desktop installé, un compte GitHub, 2 000 FCFA de crédit Anthropic, terminal correct.

Étape 1 — MCP : pourquoi un protocole standard ?

Avant MCP, chaque application qui voulait donner des outils à Claude devait coder son propre wrapper, gérer le format JSON, l’authentification, les erreurs. Anthropic a publié MCP fin 2024 pour standardiser ce dialogue. Un serveur MCP est comme un « USB pour LLM » : vous le branchez à n’importe quel client compatible (Claude Desktop, IDE, agents personnalisés) et il expose ses outils, ses ressources et ses prompts. Pour une PME sénégalaise, cela signifie écrire une seule fois la connexion à Sage, à un Google Sheet de stocks, ou à une base SQLite OHADA, et la réutiliser partout.

Étape 2 — Architecture MCP : client, serveur, transport

┌────────────────┐         ┌─────────────────────┐
│  Client MCP    │ ◄─────► │   Serveur MCP       │
│  (Claude Desk) │  JSON-  │   (votre code)      │
│                │   RPC   │                     │
└────────────────┘         └─────────────────────┘
        ▲                           │
        │                           ▼
        │                  ┌─────────────────────┐
        │                  │ Ressources réelles  │
        │                  │ (FS, API, base SQL) │
        │                  └─────────────────────┘

Trois types d'objets exposés par un serveur MCP :
- Tools     : actions exécutables (créer_facture, envoyer_email)
- Resources : données lisibles (fichier, requête SQL, page web)
- Prompts   : modèles réutilisables (générer_devis, analyser_bilan)

Étape 3 — Installer Claude Desktop et activer MCP

Téléchargez Claude Desktop depuis claude.ai/download. Une fois installé, le fichier de configuration MCP se trouve à :

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

# Windows
%APPDATA%\Claude\claude_desktop_config.json

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

Étape 4 — Connecter le serveur MCP filesystem

Le serveur officiel filesystem permet à Claude de lire, écrire, lister vos fichiers locaux. Utile pour qu’il rédige directement vos rapports dans votre dossier Comptabilité.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-filesystem",
        "/Users/vous/Documents/Compta_PME"
      ]
    }
  }
}

Redémarrez Claude Desktop. Une icône d’outils apparaît en bas du chat. Demandez : « Liste les fichiers de mon dossier Compta_PME et résume le dernier bilan. » Claude exécutera list_directory puis read_file automatiquement.

Étape 5 — Connecter le serveur MCP GitHub

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_VotreTokenIci"
      }
    }
  }
}

Avec ce serveur, Claude peut créer des issues, lire des PR, commiter du code. Pour une PME développant son ERP en interne, c’est l’équivalent d’un développeur junior qui suit vos instructions en français.

Étape 6 — Connecter une base SQLite (stocks PME)

{
  "mcpServers": {
    "stocks_pme": {
      "command": "uvx",
      "args": [
        "mcp-server-sqlite",
        "--db-path",
        "/Users/vous/data/stocks.db"
      ]
    }
  }
}

Demandez ensuite : « Quels articles de stocks.db sont en rupture (quantité < 5) ? Affiche le résultat en tableau Markdown avec les valeurs en FCFA. »

Étape 7 — Créer son propre serveur MCP en Python

Installation du SDK officiel :

pip install mcp anthropic
# ou avec uv (recommandé)
uv add mcp

Création d’un serveur exposant la gestion de factures FCFA :

from mcp.server.fastmcp import FastMCP
from datetime import datetime
import json
from pathlib import Path

mcp = FastMCP("Factures PME Sénégal")
DB = Path("factures.json")
if not DB.exists():
    DB.write_text("[]")

def _charger():
    return json.loads(DB.read_text(encoding="utf-8"))

def _sauver(data):
    DB.write_text(json.dumps(data, ensure_ascii=False, indent=2),
                  encoding="utf-8")

@mcp.tool()
def creer_facture(client: str, montant_ht: float,
                   description: str) -> dict:
    """Crée une facture conforme OHADA (TVA 18% Sénégal)."""
    factures = _charger()
    tva = montant_ht * 0.18
    ttc = montant_ht + tva
    facture = {
        "numero": f"F{datetime.now():%Y%m}{len(factures)+1:04d}",
        "date": datetime.now().isoformat(),
        "client": client,
        "description": description,
        "ht_fcfa": montant_ht,
        "tva_fcfa": round(tva),
        "ttc_fcfa": round(ttc),
        "statut": "brouillon"
    }
    factures.append(facture)
    _sauver(factures)
    return facture

Étape 8 — Ajouter d’autres outils au serveur

@mcp.tool()
def lister_factures(statut: str = "tous") -> list:
    """Liste les factures, filtrables par statut (brouillon, payee, impayee)."""
    factures = _charger()
    if statut != "tous":
        factures = [f for f in factures if f["statut"] == statut]
    return factures

@mcp.tool()
def total_ca_mois(annee: int, mois: int) -> dict:
    """Calcule le CA HT d'un mois donné."""
    factures = _charger()
    cible = f"{annee}-{mois:02d}"
    total = sum(
        f["ht_fcfa"] for f in factures
        if f["date"].startswith(cible) and f["statut"] == "payee"
    )
    return {
        "periode": cible,
        "ca_ht_fcfa": total,
        "format": f"{total:,.0f} FCFA".replace(",", " ")
    }

@mcp.resource("factures://{numero}")
def lire_facture(numero: str) -> str:
    """Expose une facture comme ressource lisible."""
    factures = _charger()
    facture = next((f for f in factures if f["numero"] == numero), None)
    return json.dumps(facture, ensure_ascii=False, indent=2) \
           if facture else "Facture introuvable"

Étape 9 — Lancer le serveur en mode stdio

if __name__ == "__main__":
    # Mode stdio : standard pour Claude Desktop
    mcp.run(transport="stdio")

Sauvegardez ce fichier sous serveur_factures.py et déclarez-le dans claude_desktop_config.json :

{
  "mcpServers": {
    "factures_pme": {
      "command": "python",
      "args": ["/chemin/absolu/serveur_factures.py"]
    }
  }
}

Étape 10 — Tester avec MCP Inspector

L’Inspector est un outil graphique web qui permet de tester vos serveurs sans passer par Claude Desktop, idéal pour le débogage.

npx @modelcontextprotocol/inspector python serveur_factures.py

# Ouvre http://localhost:5173
# Onglets : Tools, Resources, Prompts
# Cliquez sur creer_facture, remplissez les paramètres, voyez le résultat

Étape 11 — Tableau comparatif des transports MCP

Transport  | Cas d'usage                  | Sécurité   | Performance
-----------|------------------------------|------------|-------------
stdio      | Local (Claude Desktop)       | Excellente | Très rapide
sse        | Serveur HTTP distant         | Bonne      | Bonne
websocket  | Bidirectionnel temps réel    | Bonne      | Excellente
http       | API REST classique           | Variable   | Moyenne

Pour 95 % des cas PME, stdio est le bon choix : pas de serveur à maintenir, latence minimale, sécurité maximale (le serveur tourne sur la machine de l’utilisateur).

Étape 12 — Mode SSE pour serveur partagé en réseau local

from mcp.server.fastmcp import FastMCP
import uvicorn

mcp = FastMCP("Factures PME Sénégal")

# (...définitions des outils identiques...)

if __name__ == "__main__":
    # Mode SSE pour exposer en HTTP
    app = mcp.sse_app()
    uvicorn.run(app, host="0.0.0.0", port=8765)

Côté Claude Desktop, on indique l’URL :

{
  "mcpServers": {
    "factures_partage": {
      "url": "http://192.168.1.10:8765/sse"
    }
  }
}

Étape 13 — Sécuriser un serveur MCP en production

import os
from functools import wraps

API_KEY = os.getenv("MCP_API_KEY")

def authentifier(func):
    @wraps(func)
    def wrapper(*args, **kwargs):
        token = kwargs.pop("api_key", None)
        if token != API_KEY:
            return {"erreur": "Authentification échouée"}
        return func(*args, **kwargs)
    return wrapper

@mcp.tool()
@authentifier
def supprimer_facture(numero: str, api_key: str) -> dict:
    """Supprime définitivement une facture (action sensible)."""
    factures = _charger()
    factures = [f for f in factures if f["numero"] != numero]
    _sauver(factures)
    return {"statut": "supprimee", "numero": numero}

Étape 14 — Cas d’usage concret : intégration cabinet comptable Dakar

Un cabinet d’expertise comptable à Dakar gère 80 PME clientes. En créant un serveur MCP qui se connecte à leur logiciel Sage, leurs comptables interrogent Claude en français : « Sors-moi le solde du compte 411 client BTP Plus pour janvier 2026 et envoie un mail de relance si supérieur à 5 millions FCFA. » Claude utilise lire_compte_sage, calcule, puis appelle envoyer_mail_relance. Économie estimée : 12 heures/mois par comptable, ROI atteint en 6 semaines.

Erreurs classiques à éviter

  • Erreur : chemin relatif dans la config Claude Desktop. Le serveur ne démarre pas car cwd est inconnu. Toujours utiliser des chemins absolus.
  • Erreur : oublier de redémarrer Claude Desktop. La config n’est lue qu’au démarrage. Quittez via menu, ne fermez pas juste la fenêtre.
  • Erreur : nom d’outil trop générique. « create » sera ambigu si plusieurs serveurs sont actifs. Préférez « creer_facture_fcfa ».
  • Erreur : docstring manquante. Claude utilise la docstring pour décider quand appeler l’outil. Sans elle, il devine mal et génère des erreurs.
  • Erreur : exposer SSE sur 0.0.0.0 sans auth. N’importe qui sur le réseau peut piloter votre serveur. Utilisez localhost ou ajoutez une auth.
  • Erreur : retourner None depuis un outil. Le client MCP affiche « null » et Claude est perdu. Toujours retourner un dict ou une string informative.

Checklist déploiement MCP

✓ Claude Desktop installé et à jour
✓ claude_desktop_config.json créé au bon emplacement
✓ Chemins absolus dans la configuration
✓ Au moins un serveur officiel testé (filesystem)
✓ SDK MCP installé (pip install mcp)
✓ Serveur custom créé avec FastMCP
✓ Chaque @mcp.tool() a une docstring claire
✓ Types Python annotés (str, float, dict)
✓ Testé via MCP Inspector avant Desktop
✓ Transport stdio pour usage local
✓ Mode SSE uniquement si réseau interne sécurisé
✓ Authentification sur outils sensibles
✓ Logs serveur dans fichier rotatif
✓ Backup automatique des données métier
✓ Documentation utilisateurs PME en français
#audited
Besoin d'un site web ?

Confiez-nous la Création de Votre Site Web

Site vitrine, e-commerce ou application web — nous transformons votre vision en réalité digitale. Accompagnement personnalisé de A à Z.

À partir de 250.000 FCFA
Parlons de Votre Projet
Publicité

Articles Similaires