Serveurs MCP : Connecter l'IA aux Données en Temps Réel
Les serveurs MCP révolutionnent la façon dont les modèles de langage interagissent avec les sources de données externes. Considérez-les comme des plugins sophistiqués qui étendent les capacités de l'IA au-delà de leurs données d'entraînement. Dans ce tutoriel complet, nous construirons un serveur MCP météorologique qui connecte Claude, GPT-4, ou tout autre LLM aux informations météorologiques en temps réel en utilisant Python et l'API Open-Meteo.
Les serveurs MCP étendent les capacités des modèles de langage en les connectant aux sources de données et services. Ce sont des applications agnostiques qui facilitent l'intégration avec n'importe quelle donnée ou service que vous pouvez imaginer. Pensez aux appels de fonction, mais les fonctions sont des plugins qui peuvent virtuellement tout faire.
Les serveurs MCP exposent trois primitives principales :
- Ressources (contrôlées par le client) : Exposition passive de données pour le contexte
- Outils (contrôlés par le modèle) : Fonctionnalité exécutable pour les actions
- Prompts (contrôlés par l'utilisateur) : Workflows réutilisables et modèles
Les données météorologiques fournissent un excellent exemple pour le développement de serveurs MCP car elles démontrent l'intégration d'API du monde réel avec des applications pratiques. Les modèles de langage excellent à transformer les données météorologiques brutes (température, vitesse du vent, humidité) en descriptions en langage naturel et recommandations actionnables.
Nous utiliserons l'API Open-Meteo car elle est :
- Gratuite pour un usage non commercial
- Aucune clé API requise
- Facilement configurable via les paramètres de requête
- Parfaite pour l'intégration LLM
Avant de plonger dans le code, assurez-vous d'avoir les outils nécessaires installés. Nous utiliserons uv, un gestionnaire de paquets Python basé sur Rust qui rend la gestion des dépendances transparente.
# Créer le répertoire du projet
mkdir mcp-server-weather
cd mcp-server-weather
# Initialiser le projet uv
uv init
# Créer et activer l'environnement virtuel
uv venv
source .venv/bin/activate
# Installer les dépendances
uv add "mcp[cli]" httpx
[{"type": "text", "text": "Prévisions pour 40.7128, -74.006 :\n\nAujourd'hui :\nTempérature : 66°F\nVent : 13 à 16 mph O\nPrincipalement Ensoleillé\n---\nCe soir :\nTempérature : 55°F\nVent : 5 à 13 mph O\nPartiellement Nuageux\n---\nLundi :\nTempérature : 71°F\nVent : 8 mph O\nEnsoleillé\n---\nLundi Soir :\nTempérature : 59°F\nVent : 3 à 8 mph O\nPrincipalement Dégagé\n---\nMardi :\nTempérature : 77°F\nVent : 3 à 7 mph SO\nEnsoleillé\n---\nMardi Soir :\nTempérature : 65°F\nVent : 5 à 8 mph S\nPrincipalement Dégagé\n---\nMercredi :\nTempérature : 82°F\nVent : 5 à 12 mph SO\nEnsoleillé\n---\nMercredi Soir :\nTempérature : 69°F\nVent : 8 à 12 mph SO\nPrincipalement Dégagé\n---\nJeudi :\nTempérature : 85°F\nVent : 7 à 12 mph SO\nPrincipalement Ensoleillé\n---\nJeudi Soir :\nTempérature : 72°F\nVent : 7 à 12 mph SO\nPartiellement Nuageux\n---\nVendredi :\nTempérature : 82°F\nVent : 7 à 12 mph SO\nPossibilité d'Averses\n---\nVendredi Soir :\nTempérature : 70°F\nVent : 7 à 12 mph SO\nPossibilité d'Averses\n---\nSamedi :\nTempérature : 76°F\nVent : 9 mph O\nPossibilité d'Averses\n---\nSamedi Soir :\nTempérature : 67°F\nVent : 6 à 9 mph NO\nPossibilité d'Averses\n---", "uuid": "fb196843-938b-4a75-b1a5-b660892f9817"}]
Ici vous pouvez voir une réponse de l'API get-weather d'un serveur MCP !
Commencez par créer l'échafaudage du serveur. Cela établit la fondation pour notre serveur MCP en utilisant FastMCP, qui simplifie la création et la gestion de serveurs.
FastMCP fournit une interface simplifiée pour définir les outils, ressources et prompts. En tirant parti de ses fonctionnalités intégrées, vous pouvez vous concentrer sur l'implémentation de la fonctionnalité sans vous soucier des détails de serveur de bas niveau.
from typing import Any
import httpx
from mcp.server.fastmcp import FastMCP
# Initialiser le serveur FastMCP
mcp = FastMCP("weather")
# Constantes
OPENMETEO_API_BASE = "https://api.open-meteo.com/v1"
USER_AGENT = "weather-app/1.0"
# Fonction d'aide pour les requêtes API
async def make_openmeteo_request(url: str) -> dict[str, Any] | None:
"""Effectuer une requête vers l'API Open-Meteo avec gestion d'erreur appropriée."""
headers = {
"User-Agent": USER_AGENT,
"Accept": "application/json"
}
async with httpx.AsyncClient() as client:
try:
response = await client.get(url, headers=headers, timeout=30.0)
response.raise_for_status()
return response.json()
except Exception:
return None
if __name__ == "__main__":
mcp.run(transport='stdio')
Les outils sont le cœur des serveurs MCP. Ils exposent des fonctionnalités exécutables que les modèles de langage peuvent invoquer. Notre outil météorologique récupérera les conditions actuelles et les prévisions basées sur les coordonnées géographiques.
@mcp.tool()
async def get_current_weather(latitude: float, longitude: float) -> str:
"""Obtenir la météo actuelle pour un emplacement.
Args:
latitude: Latitude de l'emplacement
longitude: Longitude de l'emplacement
"""
url = f"{OPENMETEO_API_BASE}/forecast?latitude={latitude}&longitude={longitude}¤t=temperature_2m,is_day,showers,cloud_cover,wind_speed_10m,wind_direction_10m,pressure_msl,snowfall,precipitation,relative_humidity_2m,apparent_temperature,rain,weather_code,surface_pressure,wind_gusts_10m"
data = await make_openmeteo_request(url)
if not data:
return "Impossible de récupérer les données météorologiques actuelles pour cet emplacement."
return data
@mcp.tool()
async def get_forecast(latitude: float, longitude: float, days: int = 7) -> str:
"""Obtenir les prévisions météorologiques pour un emplacement.
Args:
latitude: Latitude de l'emplacement
longitude: Longitude de l'emplacement
days: Nombre de jours à prévoir (1-16)
"""
url = f"{OPENMETEO_API_BASE}/forecast?latitude={latitude}&longitude={longitude}&daily=temperature_2m_max,temperature_2m_min,precipitation_sum,wind_speed_10m_max,weather_code&forecast_days={days}"
data = await make_openmeteo_request(url)
if not data:
return "Impossible de récupérer les données de prévision pour cet emplacement."
return data
Le MCP Inspector fournit une interface web pour tester votre serveur avant de l'intégrer avec les modèles de langage. Cet outil est inestimable pour le débogage et la validation.
# Démarrer le serveur MCP en mode développement
mcp dev server.py
# Ouvrir le navigateur sur http://localhost:5173
# Se connecter au serveur
# Naviguer vers l'onglet Outils
# Tester get_current_weather avec des coordonnées
# Exemple : latitude=63.4463991, longitude=10.8127596
Lors de la construction de serveurs MCP, résistez à la tentation de formater les données retournées dans vos outils. Au lieu de cela, retournez les données brutes et laissez le modèle de langage les traiter et les formater de manière appropriée. Cette approche tire parti des capacités de langage naturel du LLM tout en maintenant l'intégrité des données.
Meilleures Pratiques :
- Retourner des jeux de données complets plutôt que des résumés filtrés
- Utiliser des noms d'outils descriptifs et de la documentation
- Implémenter une gestion d'erreur appropriée pour les échecs d'API
- Garder les outils focalisés sur des responsabilités uniques
- Tirer parti d'async/await pour de meilleures performances
Une fois que vous avez un serveur météorologique de base fonctionnel, considérez l'ajout de ces améliorations :
Services de Localisation : Intégrer l'API de Géocodage Open-Meteo pour convertir les noms de villes en coordonnées, réduisant la dépendance au LLM pour la génération de coordonnées.
Données Historiques : Ajouter des outils pour accéder aux modèles météorologiques historiques et aux données climatiques.
Alertes et Avertissements : Implémenter la surveillance d'alertes météorologiques pour les conditions météorologiques sévères.
Emplacements Multiples : Supporter les requêtes par lot pour comparer la météo à travers plusieurs emplacements.
@mcp.tool()
async def get_location(city: str, country: str = "") -> str:
"""Obtenir les coordonnées d'une ville en utilisant le géocodage.
Args:
city: Nom de la ville
country: Nom du pays optionnel pour désambiguïsation
"""
query = f"{city},{country}" if country else city
url = f"https://geocoding-api.open-meteo.com/v1/search?name={query}&count=1&language=fr&format=json"
data = await make_openmeteo_request(url)
if not data or not data.get('results'):
return "Emplacement non trouvé."
return data['results'][0]
Votre serveur MCP peut s'intégrer avec divers modèles de langage incluant Claude Desktop, GPT-4 à travers des clients compatibles, et d'autres applications compatibles MCP. Le serveur communique à travers l'entrée/sortie standard (stdio), le rendant universellement compatible.
Pour utiliser avec Claude Desktop, ajoutez votre configuration de serveur au fichier de paramètres MCP, typiquement situé à ~/Library/Application Support/Claude/claude_desktop_config.json sur macOS.
{
"mcpServers": {
"weather": {
"command": "uv",
"args": ["run", "python", "server.py"],
"cwd": "/chemin/vers/votre/mcp-server-weather"
}
}
}
La construction de serveurs MCP ouvre de nouvelles possibilités pour l'intégration de l'IA avec les sources de données du monde réel. Ce serveur météorologique démontre les concepts fondamentaux qui s'appliquent à toute intégration d'API externe ou de service. Le Model Context Protocol représente un pas significatif vers des systèmes d'IA plus capables et connectés.
Le code source complet pour ce tutoriel est disponible dans le dépôt des fichiers d'exercice. Expérimentez avec différentes APIs, ajoutez de nouveaux outils, et explorez les possibilités infinies du développement de serveurs MCP.
Pratiques de Sécurité pour MCP Utilisant JSON-RPC
Problèmes critiques de sécurité, meilleures solutions et outils pratiques pour des systèmes MCP robustes et sécurisés utilisant JSON-RPC.
Qualité : Comment protéger les Frontends alimentés par l'IA ?
Aujourd'hui, l'IA n'est plus limitée aux projets spécialisés — elle est intégrée dans presque tout ce que nous construisons. Qu'il s'agisse d'une fonction de recherche, d'un moteur de recommandation, d'un chatbot ou d'un tableau de bord prédictif, l'IA devient un élément standard de la pile technologique.
Pratiques de Sécurité pour MCP Utilisant JSON-RPC
Problèmes critiques de sécurité, meilleures solutions et outils pratiques pour des systèmes MCP robustes et sécurisés utilisant JSON-RPC.
Qualité : Comment protéger les Frontends alimentés par l'IA ?
Aujourd'hui, l'IA n'est plus limitée aux projets spécialisés — elle est intégrée dans presque tout ce que nous construisons. Qu'il s'agisse d'une fonction de recherche, d'un moteur de recommandation, d'un chatbot ou d'un tableau de bord prédictif, l'IA devient un élément standard de la pile technologique.