Ce que vous saurez faire à la fin
- Comprendre le protocole MCP (Model Context Protocol) et son intérêt face aux function calls classiques
- Connecter Claude Desktop à 3 serveurs MCP officiels (filesystem, GitHub, SQLite)
- Créer votre propre serveur MCP en Python qui expose des outils métiers (gestion factures FCFA)
- Tester votre serveur avec le MCP Inspector et le déployer en production
- 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 mcpCré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 | MoyennePour 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çaisMCP — le protocole qui standardise l acces aux outils pour les IA
Model Context Protocol (MCP), publie par Anthropic en novembre 2024, est devenu en 2026 le standard de facto pour connecter les modeles de langage aux outils externes (bases de donnees, APIs, systemes de fichiers, services SaaS). Le principe : au lieu que chaque developpeur reinvente l integration LLM-outil, un protocole commun permet a tout serveur MCP de fonctionner avec tout client MCP. Comme USB pour les peripheriques.
Concretement, un serveur MCP expose des outils (functions appelables par le LLM), des ressources (donnees disponibles), et des prompts (templates reutilisables). Un client MCP (Claude Desktop, Cursor, Continue, applications custom) decouvre ces capacites et permet au LLM de les utiliser. Le protocole utilise JSON-RPC sur stdio ou HTTP/SSE.
Pourquoi MCP change le jeu
Avant MCP, integrer un LLM a un systeme metier exigeait du code custom pour chaque source. Connecter Claude a un Notion, un Slack, et une base Postgres signifiait trois integrations distinctes a maintenir. MCP transforme cette equation : il existe deja en 2026 des centaines de serveurs MCP communautaires (Notion, Slack, GitHub, Postgres, MongoDB, Google Drive, Brave Search, AWS S3, …). Installer un serveur prend 2 minutes, et le LLM y accede immediatement.
L impact pratique : une organisation qui veut un assistant interne pour interroger sa base de connaissances + son CRM + son helpdesk passe de plusieurs semaines de developpement custom a quelques heures de configuration MCP. Pour les agences et SaaS d IA, c est l acceleration majeure de l annee 2025.
Anatomie d un serveur MCP
Un serveur MCP minimal expose trois categories de capacites. Tools : functions invocables par le LLM avec parametres types et description (search_users, create_invoice, get_weather). Le LLM choisit quand invoquer selon le contexte de la conversation. Resources : donnees accessibles par URI (file:///docs/manual.pdf, postgres://table/orders, sheets:///DOC_ID/Sheet1). Le LLM les lit sur demande utilisateur ou autonomement. Prompts : templates parametrables (analyse_transcript, ecrire_email_commercial) que l utilisateur invoque explicitement.
Le SDK officiel Anthropic (mcp-typescript, mcp-python) abstrait toute la mecanique JSON-RPC. Un developpeur expose ses functions metier, le SDK gere le reste. Un serveur MCP de base s ecrit en 50-100 lignes.
Usage en production — exemples concrets
Assistant commercial interne. Un serveur MCP qui expose : search_customer(name) -> CRM, get_orders(customer_id) -> ERP, create_quote(items) -> outil de devis. Le LLM interroge en langage naturel : Voici les clients qui n ont pas commande depuis 6 mois et leur historique. La conversation devient un copilote commercial reel.
Helpdesk augmente. Serveurs MCP exposant : search_kb(query), get_ticket_history(customer), update_ticket(id, status). Les agents support utilisent Claude Desktop pour repondre 3x plus vite, avec acces complet aux outils internes sans changement d application.
DevOps assistance. Serveurs MCP exposant les logs Datadog, les metriques Prometheus, les deploys Kubernetes. Un ingenieur demande au LLM Pourquoi le service X est ralenti ? — le LLM interroge les outils, identifie la cause, propose une action.
Securite et garde-fous
Donner a un LLM acces a des outils en production est puissant et dangereux. Trois disciplines.
Permissions least-privilege. Chaque serveur MCP doit s authentifier au backend avec des credentials dedies (pas l admin), avec acces minimum necessaire. Un MCP CRM peut lire les clients, pas supprimer les comptes.
Confirmation utilisateur sur actions destructives. Le LLM peut suggerer une action (supprimer ce ticket), mais l execution requiert validation explicite de l utilisateur. Le SDK MCP permet ce flow.
Logs d audit complets. Chaque appel MCP est journalise avec : qui (utilisateur), quoi (tool, parametres), quand, resultat. Indispensable pour les audits ulterieurs et les investigations en cas d incident.
FAQ
MCP est-il limite a Claude ?
Non. Anthropic a publie le protocole comme standard ouvert. Cursor, Continue, et autres clients IA l implementent. OpenAI a annonce un support MCP en 2025 dans ChatGPT Enterprise. C est devenu interoperable.
MCP vs Function Calling OpenAI ?
Complementaires. Function Calling est l API d un fournisseur (OpenAI) qui permet au LLM d invoquer des fonctions. MCP est un protocole de transport qui peut etre utilise avec n importe quel LLM. MCP utilise Function Calling sous le capot, mais standardise la decouverte et l invocation des fonctions au-dela d un fournisseur.
Comment commencer ?
(1) Installer Claude Desktop. (2) Configurer 2-3 serveurs MCP existants (filesystem, GitHub, Postgres) depuis le repo communautaire modelcontextprotocol.io. (3) Tester en utilisation reelle pendant 1-2 semaines. (4) Ecrire son premier serveur MCP custom pour une integration metier (typiquement le CRM ou la base de donnees produit).
References
- MCP specification — modelcontextprotocol.io
- Anthropic MCP announcement — anthropic.com/news/model-context-protocol
- MCP TypeScript SDK — github.com/modelcontextprotocol/typescript-sdk
- MCP Python SDK — github.com/modelcontextprotocol/python-sdk
- Serveurs MCP communautaires — github.com/modelcontextprotocol/servers