Créer un serveur MCP en Python et le connecter à Claude Desktop ainsi qu’à SQLite.

Tout ceux qui développent des agents d’entreprise connaissent les difficultés liées à l’écriture de code de liaison. Un wrapper pour la base de données, une couche d’intégration pour les tickets Jira, une autre pour Slack. Multipliez cela par dix bases de données et cinq frameworks de LLM tels que Claude, AutoGen et LangChain, et la conception s’effondre sous son propre poids. C’est le problème d’intégration N par M : l’IA doit comprendre la forme exacte de chaque source de données qu’elle touche.

Le Model Context Protocol (MCP) est une norme ouverte conçue spécifiquement pour résoudre ce problème. Imaginez un câble USB-C universel pour l’IA. Une connexion à la base de données est écrite une seule fois et mise à disposition via un serveur standardisé, permettant à tout client compatible de se connecter, de découvrir les outils proposés et de les utiliser. Voici un serveur MCP local en moins de 50 lignes de Python, connecté à Claude Desktop et soutenu par une base de données SQLite en temps réel.

Prérequis

Le package officiel Python mcp s’occupe de la majeure partie du travail. Il cache les détails JSON-RPC, de sorte qu’un seul décorateur suffit pour exposer une fonctionnalité au modèle. Installez-le d’abord dans votre environnement virtuel :

pip install mcp

Claude Desktop doit également être installé sur la machine.

Écriture du serveur

Créez un fichier nommé mcp_server.py, importez les bibliothèques et initialisez le serveur. Un détail est important ici : le module os lie le fichier SQLite au même répertoire que le script. Claude Desktop lance le serveur en arrière-plan, et sans emplacement fixe, vous pouvez rencontrer des erreurs de permissions.

import sqlite3
import json
import os
import sys
from mcp.server.mcpserver import MCPServer

# Initialize the MCP server
mcp = MCPServer(name="Enterprise_SQL_Agent")

# Force the database to be created in the exact same folder as this script
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DB_PATH = os.path.join(BASE_DIR, "enterprise.db")

Ensuite, une base de données temporaire est créée afin que le modèle ait quelque chose à interroger. La configuration du journalage s’effectue vers l’erreur standard (sys.stderr). La sortie standard est le canal que MCP utilise pour communiquer avec le client, et des impressions accidentelles à cet endroit pourraient le corrompre.

def setup_dummy_db():
    """Create a sample employee database for the demo"""
    try:
        conn = sqlite3.connect(DB_PATH)
        cursor = conn.cursor()

        cursor.execute('''CREATE TABLE IF NOT EXISTS employees
                          (id INTEGER PRIMARY KEY, name TEXT, role TEXT, salary INTEGER)''')
        cursor.execute("DELETE FROM employees")

        employees = [
            ("Alice", "Data Scientist", 120000),
            ("Bob", "DevOps Engineer", 115000),
            ("Charlie", "AI Researcher", 135000)
        ]

        cursor.executemany("INSERT INTO employees (name, role, salary) VALUES (?, ?, ?)", employees)
        conn.commit()
        conn.close()
        print("Database initialized successfully.", file=sys.stderr)
    except Exception as e:
        print(f"Database setup error: {e}", file=sys.stderr)

Exposer la base de données en tant qu’outil

L’étape clé consiste en une fonction Python ordinaire qui exécute une requête SQL et renvoie les lignes. En ajoutant le décorateur @mcp.tool(), le serveur lit la documentation et les indications de type pour générer automatiquement un schéma JSON pour le modèle.

@mcp.tool()
def query_employee_database(sql_query: str) -> str:
    """
    Executes a SQL SELECT query against the enterprise.db database.

    The database contains an 'employees' table with columns:
    - id (INTEGER PRIMARY KEY)
    - name (TEXT)
    - role (TEXT)
    - salary (INTEGER)

    SECURITY: Only READ operations (SELECT) are permitted.
    """

    # Safety Check: Block destructive SQL commands
    dangerous_keywords = ["DROP", "DELETE", "UPDATE", "INSERT", "ALTER"]
    if any(keyword in sql_query.upper() for keyword in dangerous_keywords):
        return "Error: Only SELECT queries are authorized for this tool."

    try:
        conn = sqlite3.connect(DB_PATH)
        cursor = conn.cursor()
        cursor.execute(sql_query)
        results = cursor.fetchall()

        # Format the output as JSON so the LLM can read it cleanly
        column_names = [description[0] for description in cursor.description]
        formatted_results = [dict(zip(column_names, row)) for row in results]

        conn.close()
        return json.dumps(formatted_results, indent=2)

    except Exception as e:
        return f"Database error: {str(e)}"

Un bref bloc de démarrage termine le fichier :

if __name__ == "__main__":
    setup_dummy_db()
    mcp.run()

Connexion de Claude Desktop

Il faut indiquer au client l’emplacement du serveur. Sous Windows, allez dans le dossier %APPDATA%\Claude, ouvrez claude_desktop_config.json dans un éditeur et ajoutez une entrée mcpServers.

Un détail sous Windows qui pose problème : si vous exécutez le programme dans un environnement virtuel comme Conda ou venv, indiquez le chemin absolu vers python.exe de cet environnement au lieu de la commande globale python, et écrivez tous les chemins avec des barres obliques doublées.

{
  "mcpServers": {
    "enterprise-sql": {
      "command": "C:\\Users\\YourName\\.conda\\envs\\your_env\\python.exe",
      "args": [
        "D:\\Your\\Project\\Path\\mcp_server.py"
      ]
    }
  }
}

Enregistrez le fichier et redémarrez complètement Claude Desktop.

Vérifier le fonctionnement

Ouvrez Claude Desktop et cherchez l’icône du marteau (Outils) en bas à droite de la boîte de chat. L’outil query_employee_database devrait déjà y être enregistré. Un bon premier test consiste à demander qui gagne le plus dans la table des employés et quel est le poste occupé par cette personne.

Le modèle lit la description de l’outil, écrit lui-même la requête SQL (SELECT * FROM employees ORDER BY salary DESC LIMIT 1;), la exécute sur votre serveur et transforme le résultat en une réponse en langue simple. Aucune couche API personnalisée n’a été écrite, et le schéma a été découvert dynamiquement.

Le même schéma s’applique à Slack, Jira, GitHub ou toute API interne de l’entreprise, et c’est ce qui modifie les aspects économiques de la création de systèmes agents au sein d’une entreprise : chaque système est encapsulé une seule fois, et tout assistant compatible peut l’utiliser.