Model Context Protocol (MCP) avec Claude : guide d'implémentation complet

Le Model Context Protocol (MCP) est le nouveau standard d'Anthropic pour connecter des agents Claude à vos outils, bases de données et services métier. Lancé officiellement en juin 2026 et intégré à Claude Sonnet 5, MCP permet à vos agents IA d'accéder directement à vos données sans passer par des intégrations bidons ou des bricolages d'API.

Si vous buildez des agents IA en 2026, MCP n'est plus optionnel — c'est la fondation. Voici comment l'implémenter.

Qu'est-ce que le model context protocol vraiment ?

Le MCP n'est pas une nouvelle API pour appeler Claude (vous avez déjà ça). C'est un protocole d'interopérabilité qui définit comment une application cliente (Claude, Cursor, Grok Build, ou votre propre IA) se connecte à des serveurs MCP qui exposent des outils, des ressources et des données.

Analogie : MCP est à Claude ce que les plugins sont à un navigateur. Sauf que c'est standardisé, bidirectionnel, et pensé pour l'IA.

Composants clés :

• Client MCP : Claude, votre agent IA, ou votre application
• Serveur MCP : endpoint qui expose des outils et des ressources
• Ressources : données que le serveur met à disposition (base de données, fichiers, API)
• Outils : fonctions que l'agent peut appeler pour accomplir une action
• Prompts : templates réutilisables pour guider Claude

C'est exactement ce que Simple Booking a fait en juin 2026 — ils ont construit un serveur MCP qui expose leur système de réservation CRS, et maintenant Claude peut directement consulter/modifier les réservations hôtelières.

Architecture : comment ça s'emboîte

Avant MCP, l'architecture était chaotique :

Claude (via API)
    ↓ [manual prompt engineering]
    ↓ [tool_use call]
Application → [You parse the response] → Custom integration
    ↓
Database

Avec MCP :

Claude (via MCP client)
    ↓
MCP Client Protocol (standardisé JSON-RPC)
    ↓
Votre Serveur MCP
    ↓ [reconnection automatique]
    ↓
Vos outils (fonctions), ressources (données), prompts

L'agent Claude peut maintenant :

• Interroger vos ressources directement : "Quel est le nombre de commandes en attente ?" → MCP requête → votre base de données
• Appeler vos outils atomiquement : "Crée une facture" → MCP tool call → votre logique métier
• Réutiliser des prompts optimisés : use_mcp_resource("context_facturation") → template cohérent à travers tous les agents

Comment implémenter un serveur MCP minimal

Le protocole MCP utilise JSON-RPC 2.0 sur stdio ou HTTP. Voici un serveur minimal en Python qui expose une base de données PostgreSQL :

from mcp.server import Server
from mcp.types import Tool, Resource, TextContent
import asyncio
import psycopg2

app = Server("my-database-server")

# Déclare une ressource : la liste des clients
@app.resource("db://customers")
async def get_customers():
    conn = psycopg2.connect("dbname=mydb user=postgres")
    cur = conn.cursor()
    cur.execute("SELECT id, name, email FROM customers LIMIT 100")
    rows = cur.fetchall()
    conn.close()
    
    return TextContent(
        type="text/plain",
        text="\n".join([f"ID: {r[0]}, Name: {r[1]}, Email: {r[2]}" for r in rows])
    )

# Déclare un outil : créer une nouvelle commande
@app.tool("create_order")
async def create_order(customer_id: int, items: list, total: float):
    conn = psycopg2.connect("dbname=mydb user=postgres")
    cur = conn.cursor()
    cur.execute(
        "INSERT INTO orders (customer_id, items, total, status) VALUES (%s, %s, %s, %s)",
        (customer_id, str(items), total, "pending")
    )
    conn.commit()
    order_id = cur.lastrowid
    conn.close()
    
    return f"Order {order_id} created successfully"

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

C'est 30 lignes. Pas de parsing manuel, pas de prompt engineering compliqué. Claude sait maintenant qu'il peut :

1. Appeler get_customers pour voir les clients
2. Appeler create_order(customer_id, items, total) pour créer une commande

Mais attendez, il y a une piège. Vous exposez directement votre base de données. Et si Claude hallucine un customer_id invalide ? Il faut ajouter de la validation :

@app.tool("create_order")
async def create_order(customer_id: int, items: list, total: float):
    # Validation : le customer existe-t-il vraiment ?
    conn = psycopg2.connect("dbname=mydb user=postgres")
    cur = conn.cursor()
    cur.execute("SELECT id FROM customers WHERE id = %s", (customer_id,))
    if not cur.fetchone():
        return f"Error: customer {customer_id} does not exist"
    
    # Continue with order creation...

Limitation honnête : plus vous exposez de fonctionnalités via MCP, plus vous dépendez de Claude pour prendre de bonnes décisions. Un agent mal guidé peut quand même faire du dégât. Vous avez besoin de :

• Rate limiting sur les outils dangereux
• Logging et audit trails
• Des prompts système très clairs sur les contraintes métier
• Des tests chaos pour voir ce qui se passe si Claude appelle un outil avec des inputs étranges

Connecter claude sonnet 5 à votre serveur MCP

Une fois votre serveur MCP en place, vous l'appelez via le SDK Claude. Claude Sonnet 5 (lancé le 30 juin 2026) a un support MCP natif intégré.

from anthropic import Anthropic

client = Anthropic()

# Configure MCP server pour cette session
mcp_config = {
    "servers": {
        "my_database": {
            "command": "python",
            "args": ["./mcp_server.py"],
            "env": {"DATABASE_URL": "postgresql://..."}
        }
    }
}

response = client.messages.create(
    model="claude-sonnet-5",  # Nouveau, sorti 30 juin 2026
    max_tokens=2048,
    tools=[
        # MCP tools are auto-discovered from servers
    ],
    messages=[
        {
            "role": "user",
            "content": "Crée une commande pour le client #42 : 2x produit A, 1x produit B. Total : 150€"
        }
    ]
)

# Claude va maintenant :
# 1. Parser le message utilisateur
# 2. Vérifier qu'il a accès au tool "create_order" via MCP
# 3. Appeler create_order(customer_id=42, items=[...], total=150)
# 4. Recevoir la réponse du serveur MCP
# 5. Continuer le dialogue

Claude Sonnet 5 ajoute aussi des agentic loops améliorés — il peut appeler plusieurs outils en séquence sans revenir à votre code à chaque fois. Utile pour : "Récupère les commandes en attente, crée des factures pour chacune, puis envoie un email."

Cas d'usage réels en production

1. Intégrations hôtelières (Simple Booking, juin 2026)

Simple Booking expose son système de réservation CRS via MCP. Les agences de voyage utilisent Claude pour :

• "Quelles suites sont disponibles le 15 août dans l'hôtel de Lyon ?" → Claude interroge MCP → réponse en temps réel
• "Réserve la suite 42 pour les Dupont du 15 au 20 août" → Claude appelle l'outil de réservation

Avant MCP, c'était des webhooks customisés. Maintenant : un serveur MCP standardisé, et n'importe quel outil MCP-compatible peut l'utiliser.

2. Automatisation media buying (Nexxen, juin 2026)

Nexxen expose ses paramètres de campagne, budgets et audiences via MCP. Les agences construisent des agents Claude qui :

• Analysent les performances des campagnes ("Nos CPM baissent, pourquoi ?")
• Ajustent les budgets automatiquement ("Alloue 20% du budget à l'audience premium")
• Créent de nouvelles campagnes basées sur des brèfs texte

Avant : intégration Zapier + custom scripts. Maintenant : un serveur MCP, c'est fini.

3. Votre use case : gestion de contenu e-commerce

Vous avez une boutique Shopify ou un système de produits custom. Construisez un serveur MCP qui expose :

• Ressource : inventory/sku-123 → nombre de stocks
• Ressource : products/all → catalogue complet
• Outil : update_product_description(sku, new_desc) → met à jour votre base
• Outil : create_bundle(products, discount) → crée un bundle
• Prompt : contexte_refonte_catalogue → instructions pour Claude quand on lui demande de retravailler 100 fiches produits

Exemple concret : vous dites à Claude "Relis toutes les descriptions produits et corrige les fautes, améliore le SEO, ajoute les dimensions en cm". Claude :

1. Interroge products/all via MCP
2. Analyse les 200 descriptions
3. Pour chaque produit, appelle update_product_description(sku, new_desc)
4. Fait un rapport

Temps humain : 10 minutes de supervision. Avant : une journée complète pour votre équipe.

Gestion des permissions et sécurité

Un risque majeur : si Claude a accès à tous vos outils, il pourrait appeler une fonction dangereuse. Ajouter des contrôles :

1. Scope les outils par use case

# Au lieu d'exposer "delete_order" globalement
@app.tool("delete_order", scopes=["admin_only"])
async def delete_order(order_id: int):
    # Nécessite une permission spéciale
    pass

2. Rate limiting

from functools import wraps

def rate_limit(max_calls=10, period=60):
    def decorator(func):
        calls = []
        async def wrapper(*args, **kwargs):
            now = time.time()
            calls = [c for c in calls if c > now - period]
            if len(calls) >= max_calls:
                raise Exception("Rate limit exceeded")
            calls.append(now)
            return await func(*args, **kwargs)
        return wrapper
    return decorator

@app.tool("create_order")
@rate_limit(max_calls=50, period=3600)
async def create_order(...):
    pass

3. Logging exhaustif

import logging

logger = logging.getLogger("mcp_audit")

@app.tool("delete_order")
async def delete_order(order_id: int):
    logger.warning(f"Claude called delete_order({order_id}) - action requires approval")
    # Optionnel : demander une confirmation humaine avant de supprimer
    return "Deletion queued for human approval"

Déployer un serveur MCP en production

Deux approches :

1. Stdio (pour développement rapide)

Votre serveur MCP s'exécute en tant que processus enfant du client Claude. Simple, mais limité pour la scalabilité.

{
  "servers": {
    "my_server": {
      "command": "python",
      "args": ["./mcp_server.py"]
    }
  }
}

2. HTTP avec authentification (pour production)

{
  "servers": {
    "my_server": {
      "url": "https://mcp.mycompany.com",
      "auth": {
        "type": "bearer",
        "token": "sk_live_..."
      }
    }
  }
}

Votre serveur MCP écoute sur un endpoint HTTPS sécurisé, avec certificats SSL et rate limiting à la gateway.

Déploiement recommandé :

• Serveur MCP : Docker sur ECS/K8s, derrière un load balancer
• Base de données : PostgreSQL ou MongoDB, strictement en VPC privé
• Monitoring : CloudWatch, logs structurés JSON, alertes sur erreurs
• Versioning : versionnez vos ressources et outils MCP (ex: /api/v1/resources)

{
  "servers": {
    "database": { "command": "python", "args": ["./db_mcp.py"] },
    "email": { "command": "node", "args": ["./email_mcp.js"] },
    "shopify": { "url": "https://mcp.shopify.com" }
  }
}

Conclusion

Le Model Context Protocol résout un problème réel : avant 2026, chaque intégration agent IA était une customisation one-shot. Maintenant, c'est standardisé.

Trois points clés à retenir :

1. MCP est le nouveau standard pour les agents IA en 2026 — il remplace les bricolages d'API custom
2. Implémenter un serveur MCP est simple — 50 lignes de code pour exposer vos outils et données
3. Claude Sonnet 5 a le meilleur support MCP natif — si vous buildez un agent aujourd'hui, c'est le bon modèle

Vous buildez un agent IA pour votre métier ? Commencez par exposer vos données et outils critiques via MCP. Puis reliez-les à Claude Sonnet 5. En une semaine, vous automatisez ce qui prenait une journée avant.

Besoin d'aide pour implémenter MCP chez vous ? On peut auditer votre architecture actuelle et vous proposer un plan d'intégration. Contactez-nous.