Configurer un Serveur MCP Local (STDIO)

Votre premier serveur MCP local

Le mode STDIO est le point de départ idéal pour développer et tester un serveur MCP. Tout tourne sur votre machine, pas besoin de déploiement ni d’URL publique. Dans cette leçon, vous allez configurer un serveur MCP local en Python et le connecter à un client.

Prérequis techniques

Avant de commencer, assurez-vous d’avoir :

• Python 3.10+ installé
• pip à jour
• Un environnement virtuel (recommandé)

Installation des dépendances :

# Créer un environnement virtuel
python -m venv mcp-env
source mcp-env/bin/activate  # Linux/Mac
# mcp-env\Scripts\activate   # Windows

# Installer les packages MCP
pip install mcp fastmcp
pip install mistralai  # Pour le client Mistral

Créer le serveur MCP

Un serveur MCP local avec FastMCP se crée en quelques lignes :

# serveur_local.py
from mcp.server.fastmcp import FastMCP

# Initialiser le serveur avec un nom descriptif
app = FastMCP("Serveur Démo Local")

@app.tool()
def greet(name: str) -> str:
    """Salue une personne par son nom.

    Args:
        name: Le prénom de la personne à saluer

    Returns:
        Un message de salutation personnalisé
    """
    return f"Bonjour {name} ! Bienvenue dans le monde MCP."

@app.tool()
def calculate(operation: str, a: float, b: float) -> str:
    """Effectue un calcul mathématique simple.

    Args:
        operation: L opération à effectuer (add, sub, mul, div)
        a: Premier nombre
        b: Second nombre

    Returns:
        Le résultat du calcul
    """
    ops = {
        "add": a + b,
        "sub": a - b,
        "mul": a * b,
        "div": a / b if b != 0 else "Erreur: division par zéro"
    }
    result = ops.get(operation, "Opération inconnue")
    return f"{a} {operation} {b} = {result}"

Ce fichier définit un serveur avec deux tools. Notez l’importance des docstrings : elles servent de description pour le modèle de langage.

Configurer le client STDIO

Côté client, vous utilisez StdioServerParameters pour indiquer comment lancer le serveur :

# client_stdio.py
from mcp import StdioServerParameters
from mistralai.extra.mcp.stdio import MCPClientSTDIO
from pathlib import Path

# Chemin vers votre serveur
path_to_server = Path("serveur_local.py")

# Configuration du serveur STDIO
server_params = StdioServerParameters(
    command="python",           # La commande pour lancer le serveur
    args=[str(path_to_server)], # Les arguments (le fichier Python)
    env=None,                   # Variables d environnement (optionnel)
)

# Créer le client MCP
mcp_client = MCPClientSTDIO(stdio_params=server_params)

Les paramètres de StdioServerParameters

Détaillons chaque paramètre :

command

La commande système pour lancer le processus serveur. Typiquement "python" ou "node" selon le langage de votre serveur.

# Python
command="python"

# Node.js
command="node"

# Un exécutable compilé
command="./mon_serveur_mcp"

args

La liste des arguments passés à la commande. Pour un script Python, c’est le chemin du fichier :

# Script simple
args=["serveur_local.py"]

# Avec des arguments supplémentaires
args=["serveur_local.py", "--port", "8080", "--verbose"]

env

Les variables d’environnement transmises au processus serveur. Utile pour passer des clés API ou des configurations :

import os

server_params = StdioServerParameters(
    command="python",
    args=["serveur_local.py"],
    env={
        **os.environ,  # Hériter de l environnement courant
        "API_KEY": "votre_cle_api",
        "DATABASE_URL": "postgresql://...",
        "DEBUG": "true",
    },
)

Attention : si vous passez env=None, le serveur hérite de toutes les variables d’environnement du processus parent. Si vous passez un dictionnaire, seules les variables listées seront disponibles.

Tester le serveur avec MCP Inspector

Avant de connecter votre serveur à un agent, testez-le avec l’outil MCP Inspector :

npx @modelcontextprotocol/inspector python serveur_local.py

L’inspector ouvre une interface web locale où vous pouvez :

• Lister tous les tools disponibles
• Voir les descriptions et paramètres de chaque tool
• Tester un tool manuellement avec des arguments
• Vérifier le format de retour

C’est votre meilleur allié pendant le développement. Utilisez-le systématiquement avant d’intégrer votre serveur dans un agent.

Structure de projet recommandée

mon-projet-mcp/
├── serveur_local.py     # Le serveur MCP
├── client_stdio.py      # Le script client
├── requirements.txt     # Dépendances
├── .env                 # Variables d environnement (jamais commité)
└── tests/
    └── test_tools.py    # Tests unitaires des tools

Points clés à retenir

• Un serveur STDIO se lance comme un processus local
• StdioServerParameters configure la commande, les arguments et les variables d’environnement
• Les docstrings de vos tools servent de description pour le modèle
• L’MCP Inspector (npx @modelcontextprotocol/inspector) est indispensable pour tester
• env=None hérite de tout l’environnement ; un dict explicite limite les variables