Serveur MCP en Python — Tout ce que j'aurais aimé savoir dès le premier jour

Introduction

En tant que développeur travaillant avec des modèles de langage de grande taille (LLM), j'ai exploré les serveurs du protocole de contexte de modèle (MCP) ces dernières semaines. Malgré le buzz, j'ai initialement trouvé cela difficile à comprendre, à construire un serveur ou à saisir comment cela pourrait améliorer mon flux de travail. Cette expérience est probablement familière à de nombreux développeurs qui peinent à intégrer les LLM avec des outils externes et des sources de données, ce qui entrave leur capacité à effectuer des tâches au-delà de la génération de texte.

Après avoir investi des heures à lire la documentation, à regarder des vidéos et à effectuer des essais et des erreurs, j'ai réussi à créer quelques serveurs personnalisés. Ces serveurs permettent désormais des tâches telles que l'interrogation de bases de données, l'envoi d'emails et de SMS, et même le déploiement d'applications sur DigitalOcean - le tout intégré de manière transparente dans Cursor et Claude Desktop. Cette intégration résout le problème des LLMs étant limités à la génération de texte en fournissant un moyen standardisé de les connecter à des outils externes et à des sources de données, les rendant finalement plus capables et utiles.

Ce que vous apprendrez

• Pourquoi MCP est important.
• Comment créer un serveur MCP Python.
• Comment le brancher sur Cursor et Claude Desktop.
• Comment écrire un outil de requêtes SQLite simple.
• Comment tout tester de bout en bout.

Conditions préalables

Avant de commencer, assurez-vous d'avoir :

• Python 3.7+ installé sur votre système.
• SQLite (avec un fichier community.db).
• Cursor Pro et Claude Desktop.
• Un terminal (macOS/Linux) ou PowerShell/CMD (Windows).

Qu'est-ce que le MCP et pourquoi en avons-nous besoin ?

Les grands modèles de langage (LLMs) comme GPT ou Claude sont incroyables pour générer du texte, mais au fond, ils ne font que prédire le prochain token dans une séquence. Par eux-mêmes, ils ne peuvent pas récupérer vos fichiers, interroger une base de données ou déclencher des actions dans le monde réel. Ils ont besoin d'un pont vers le monde extérieur.

Le Protocole de Contexte de Modèle (MCP) est un protocole ouvert qui standardise la manière dont les applications fournissent un contexte aux LLM. Pensez-y comme à un port USB-C pour les applications d'IA : tout comme l'USB-C offre un moyen universel de connecter vos appareils à une gamme de périphériques, le MCP offre une connexion standardisée pour les LLM afin d'accéder aux sources de données et aux outils externes. En résumé, le MCP donne à vos LLM la capacité non seulement de discuter, mais aussi réellement de faire des choses et d'interagir avec le monde extérieur.

Comment les pièces s'imbriquent

Imaginez que vous discutez avec un LLM à l'intérieur d'une application comme Cursor ou Claude Desktop - cette application est votre hôte. C'est l'interface que vous voyez et avec laquelle vous interagissez.

Sous le capot, chaque hôte comprend un client MCP, un morceau de logiciel qui parle le protocole MCP et sait comment transmettre les requêtes aux serveurs MCP.

Mais voici où cela devient intéressant : bien que le LLM (que ce soit Claude, GPT ou un autre modèle) soit excellent pour générer du texte, il ne peut pas à lui seul interroger une base de données SQLite, envoyer un e-mail ou appeler une API SMS. C'est là qu'intervient le serveur MCP.

Voici comment cela fonctionne étape par étape :

1. Vous envoyez une demande au LLM dans votre application hôte (par exemple, « Listez les meilleurs bavards. »).

2. Le LLM (client) traite votre texte et vérifie si un outil MCP est disponible pour cette demande.

3. Si un outil pertinent est configuré, le client MCP transmet la demande via le protocole MCP à un serveur MCP.

4. Le serveur MCP exécute la tâche demandée :

   1. Il peut interroger une source de données locale, comme votre base de données SQLite.
   2. Ou cela peut appeler des services distants, tels qu'une API d'email ou de SMS.

5. Le serveur renvoie les résultats au client MCP, qui les renvoie au LLM.

6. Le LLM formate ensuite ces résultats et vous les présente dans l'application hôte.

En résumé, l'hôte fournit l'interface utilisateur, le client gère les requêtes, et le serveur effectue le travail lourd—établissant un lien entre les capacités linguistiques de votre IA et les données et actions du monde réel.

Ci-dessous se trouve un diagramme simplifié qui montre comment ces composants interagissent :

Tout dans le diagramme fonctionne sur votre ordinateur. Votre application hôte (Cursor ou Claude Desktop) pointe simplement vers le serveur MCP que vous exécutez localement. Ce serveur peut communiquer avec votre base de données SQLite ou appeler des API d'email/SMS.

Construire votre premier serveur MCP

Créons un serveur MCP local en Python qui interroge une base de données SQLite pour les principaux bavards d'une communauté. Vous discuterez avec votre LLM dans Cursor ou Claude Desktop, et le serveur s'occupera du travail de base de données.

Étape 1 - Configurez votre environnement

• Créer un environnement virtuel :

python -m venv mcp-env
source mcp-env/bin/activate  # For Windows: mcp-env\Scripts\activate

• Installez le SDK Python MCP :

pip install mcp

Étape 2 - Prenez la base de données d'échantillons

Téléchargez community.db (il contient une table de chatteurs avec des données d'exemple).

Étape 3 : Écrivez votre serveur MCP

Créez un fichier nommé sqlite-server.py et insérez le code suivant :

sqlite-server.py
from mcp.server.fastmcp import FastMCP
import sqlite3

Initialize the MCP server with a friendly name
mcp = FastMCP("Community Chatters")

Define a tool to fetch the top chatters from the SQLite database
@mcp.tool()
def get_top_chatters():
    """Retrieve the top chatters sorted by number of messages."""
    # Connect to the SQLite database
    conn = sqlite3.connect('community.db')
    cursor = conn.cursor()
    
    # Execute the query to fetch chatters sorted by messages
    cursor.execute("SELECT name, messages FROM chatters ORDER BY messages DESC")
    results = cursor.fetchall()
    conn.close()
    
    # Format the results as a list of dictionaries
    chatters = [{"name": name, "messages": messages} for name, messages in results]
    return chatters

Run the MCP server locally
if __name__ == '__main__':
    mcp.run()

Ce serveur simple définit un outil, get_top_chatters, qui se connecte à votre base de données SQLite, récupère les données triées et les renvoie dans un format facile à lire.

Ajouter votre serveur MCP à Cursor

Une fois que votre serveur MCP est configuré, l'étape suivante consiste à l'ajouter à votre client Cursor. Voici comment faire :

• Ouvrez Cursor → Paramètres → MCP (nécessite Cursor Pro).

• Cliquez sur « Ajouter un nouveau serveur MCP global » pour ouvrir Cette action ouvrira le fichier de configuration du serveur MCP situé à ~/.cursor/mcp.json.

  

• Mettez à jour le fichier avec les détails de votre serveur. Cette configuration indique à Cursor d'exécuter votre serveur MCP local chaque fois qu'il doit récupérer des informations sur les interlocuteurs.

{
  "mcpServers": {
    "sqlite-server": {
      "command": "/path/to/your/project/venv/bin/python",
      "args": [
        "/path/to/your/project/sqlite-server.py"
      ],
      "description": "A simple MCP server to query top chatters from a community database"
    }
  }
}

• Sauvegarder et retourner aux paramètres MCP.
• Vérifiez que votre serveur et son outil sont listés. Vous devriez voir un point vert à côté du serveur.

Tester votre serveur MCP dans le curseur

Avec votre serveur ajouté à Cursor, il est temps de le tester :

1. Ouvrez une discussion dans Cursor et posez une question, comme : « Combien de chatterbots sont dans la base de données ? »

   

2. Le LLM détectera qu'il doit accomplir une tâche qu'il ne peut pas gérer seul.

3. Une invite apparaîtra vous demandant votre autorisation pour exécuter l'outil. Approuvez la demande.

4. Le serveur MCP interrogera la base de données SQLite, récupérera les données et les renverra. L'IA présentera ensuite les informations dans le chat.

Si tout est correctement configuré, vous devriez voir le nombre de participants affiché avec les noms et le nombre de messages, confirmant que l'outil fonctionne comme prévu.

Ajouter votre serveur MCP à Claude Desktop

Vous pouvez également intégrer votre serveur MCP avec Claude Desktop. Voici comment :

• Ouvrez Claude Bureau → Paramètres → Développeur → Modifier la configuration.
• Ajoutez le même bloc de serveur à claude_desktop_config.json
• Enregistrez, fermez et rouvrez Claude Desktop. Cette mise à jour garantit que la nouvelle configuration est prise en compte.

{
  "servers": [
    {
      "name": "Community Chatters Server",
      "command": "python",
      "args": ["server.py"],
      "description": "A simple MCP server to query top chatters from a community database"
    }
  ]
}

• Vérifiez dans les paramètres de Claude Desktop que le serveur MCP est répertorié, et assurez-vous que vous voyez une icône d'outil dans la fenêtre de chat indiquant que des outils externes sont connectés. Cliquer sur cette icône devrait révéler plus de détails.

  

Tester votre serveur MCP dans Claude Desktop

Maintenant que votre serveur est ajouté à Claude Desktop, testons-le :

1. Ouvrez une conversation dans Claude Desktop et posez une question comme : « Montrez-moi la liste des utilisateurs les plus actifs. » Claude Desktop reconnaîtra que la requête nécessite un outil externe.

   

2. Une invite apparaîtra pour demander votre autorisation d'exécuter l'outil MCP. Approuvez l'invite.

3. Révisez la sortie : Le serveur MCP traitera la demande, interrogera la base de données SQLite et renverra les données, que Claude Desktop affichera ensuite.

Ceci montre que votre serveur MCP est accessible à partir de deux applications hôtes différentes - Cursor et Claude Desktop, permettant à la fois à GPT et à Claude d'exploiter des données externes pour leurs réponses.

FAQ

Quel est le but du serveur MCP dans ce tutoriel ?

Le serveur MCP est conçu pour interroger la base de données SQLite et fournir le nombre de participants au chat, leurs noms et le nombre de messages à l'application cliente, telle que Cursor ou Claude Desktop. Cela permet à l'application cliente d'afficher les meilleurs participants au chat de la communauté, améliorant ainsi l'expérience utilisateur et fournissant des informations précieuses. Pour plus d'informations sur les capacités du serveur MCP, consultez la documentation du serveur MCP.

Comment puis-je intégrer mon serveur MCP avec Claude Desktop ?

Pour intégrer votre serveur MCP avec Claude Desktop, vous devez ajouter le bloc serveur dans claude_desktop_config.json, enregistrer, fermer et rouvrir Claude Desktop. Cela garantit que la nouvelle configuration est prise en compte. Pour un guide étape par étape sur l'intégration de votre serveur MCP avec Claude Desktop, consultez le Guide d'intégration de Claude Desktop.

Quelle est l'importance de l'écosystème MCP ?

L'écosystème MCP comble le fossé entre les modèles de langage de grande taille (LLMs) et les sources de données externes, permettant l'intégration de données externes dans les réponses de l'IA. Cette intégration permet des réponses plus précises et informatives des modèles d'IA, les rendant plus efficaces dans diverses applications. Pour une compréhension plus approfondie de l'écosystème MCP et de son importance, veuillez consulter l'aperçu de l'écosystème MCP.

Puis-je utiliser ce tutoriel comme point de départ pour des applications MCP plus avancées ?

Oui, ce tutoriel fournit une base pour la création d'applications MCP plus avancées, telles que l'envoi d'e-mails et de notifications SMS, le déploiement de serveurs MCP sur des plateformes cloud, et plus encore. Les compétences et les connaissances acquises grâce à ce tutoriel peuvent être appliquées à un large éventail d'applications MCP, ce qui en fait un excellent point de départ pour une exploration plus approfondie. Pour des idées et des conseils sur la construction d'applications MCP avancées, consultez les exemples d'applications MCP.

Conclusion

Dans ce tutoriel complet, nous avons appris sur MCP, une interface standardisée qui comble le fossé entre les grands modèles de langage (LLM) et les sources de données externes. Nous avons également appris l'importance de MCP, son écosystème, et le processus de construction d'un serveur MCP de base en utilisant Python et SQLite.

À travers ce tutoriel, vous avez acquis une expérience pratique dans la mise en place d'un environnement virtuel, l'utilisation d'une base de données existante, la création d'un serveur MCP minimal et son intégration avec une application cliente comme Cursor. Cette réalisation marque le début de votre parcours de développement MCP.

Alors que nous regardons vers l'avenir, les possibilités sont infinies. Vous pouvez créer des applications MCP avancées, telles que l'envoi d'e-mails et de notifications SMS, le déploiement de serveurs MCP sur des plateformes cloud comme DigitalOcean, et plus encore. L'écosystème MCP est vaste et les opportunités d'innovation sont illimitées.

Nous espérons que ce tutoriel vous a inspiré à continuer à apprendre sur le MCP et ses applications. Bonne programmation !