MCP (Model Context Protocol) : Le protocole Open-Source qui révolutionne l’intégration de l’IA
Découvrez comment MCP facilité l’intégration des modèles d’Intelligence Artificielle à un écosystème de données et d’outils grâce à une solution standardisée et flexible.
Ecrit par Vincent
Dans un écosystème où les modèles de langage (LLM) deviennent de plus en plus essentiels, connecter ces intelligences artificielles à une variété d’outils et de sources de données est devenu une nécessité. Pourtant, cette intégration est souvent un véritable casse-tête : API spécifiques, solutions maison, absence de normes claires, etc. C’est pour relever ces défis que le Model Context Protocol (MCP) a été créé.
Dans cet article, nous aborderons comment le MCP facilite cette intégration en offrant un cadre standardisé et flexible, permettant aux LLM de se connecter facilement à des sources de données locales et distantes. Nous explorerons son architecture, ses avantages, et son potentiel pour simplifier la gestion des flux de travail complexes, tout en rendant les agents IA plus autonomes et performants. Nous illustrerons également ce fonctionnement avec un exemple d’implémentation en Python, où nous créerons un serveur MCP et l’intégrerons à l’hôte Claude for Desktop pour récupérer des informations en temps réel sur le statut des capsules SpaceX via les API de SpaceX.
Model Context Protocol
Qu’est-ce que MCP ?
Le MCP est un protocole standard ouvert conçu pour faciliter la transmission de contexte entre les applications et les modèles de langage. Son objectif est de permettre à un LLM de se connecter facilement à différentes sources de données et outils, tout comme on connecterait divers périphériques à un ordinateur via un unique type de port universel. Cela simplifie l’écosystème, réduit les coûts de développement, et offre aux équipes techniques la liberté de choisir leurs fournisseurs de modèles ou leurs outils.
Au cœur du MCP se trouve une architecture client-serveur. Les hôtes MCP (par exemple, une plateforme de développement, un environnement d’édition de code ou un outil métier) se connectent via des clients standardisés et communiquent avec des serveurs MCP, chacun étant spécialisé dans un type d’intégration ou une capacité précise. Vous pouvez ainsi avoir un serveur dédié à la connexion avec votre base de données interne, un autre pour interagir avec un service externe via une API, ou encore un troisième pour accéder à vos fichiers locaux.
L’ensemble forme un “hub” central, où chaque serveur expose ses fonctionnalités de manière standardisée. L’agent IA ou le LLM utilisé peut alors facilement basculer entre différentes sources, outils et services, sans avoir à réécrire du code d’intégration à chaque nouveau besoin.
Architecture générale
Au cœur de MCP se trouve une architecture client-serveur dans laquelle une application hôte peut se connecter à plusieurs serveurs :
- Hôtes MCP : Des programmes tels que Claude Desktop, des IDE ou des outils d’IA qui souhaitent accéder à des données via MCP
- Clients MCP : Des clients du protocole qui maintiennent des connexions 1:1 avec les serveurs
- Serveurs MCP : Des programmes légers exposant chacun des capacités spécifiques via le Model Context Protocol standardisé
- Sources de données locales : Les fichiers, bases de données et services de votre ordinateur auxquels les serveurs MCP peuvent accéder en toute sécurité
- Services distants : Des systèmes externes disponibles sur Internet (par exemple via des API) auxquels les serveurs MCP peuvent se connecter
Exemple d’implémentation
Dans ce tutoriel, nous allons créer un serveur MCP et le connecter à un hôte Claude for Desktop.
Cet exemple très simple reposera sur les API SpaceX pour fournir des informations en temps réel sur le statut des capsules spatiales.
Mise en place de l’environnement
Initialisation du projet
uv init python-mcp --packageInstallation des dépendances
uv add mcp httpx spacexpy nest-asyncioCréation du module
mkdir src/python_mcp/spacex
touch src/python_mcp/spacex/__init__.py
touch src/python_mcp/spacex/server.pyImplémentation du serveur
Editons maintenant le fichier server.py du module spacex
Nous commencerons par importer les librairies nécessaires et définir quelques variables globales, notamment le serveur MCP et le framework MCP pour Python, qui repose largement sur les décorateurs.
import mcp.server.stdio
import mcp.types as types
import nest_asyncio
import spacexpy
from mcp.server import NotificationOptions, Server
from mcp.server.models import InitializationOptions
nest_asyncio.apply()
server = Server("spacex")
spacex = spacexpy.SpaceX()Ensuite, nous implémentons le point de terminaison qui liste les services exposés par notre serveur MCP. Ici, nous proposerons un seul service qui prend en paramètre le numéro de série des capsules SpaceX.
@server.list_tools()
async def handle_list_tools() -> list[types.Tool]:
"""
List available tools.
Each tool specifies its arguments using JSON Schema validation.
"""
print("*** handle_list_tools called")
return [
types.Tool(
name="get-capsule-last-update",
description="Get last update for a SpaceX capsule",
inputSchema={
"type": "object",
"properties": {
"serial": {
"type": "string",
"description": "Serial number of the capsule",
},
},
"required": ["serial"],
},
),
]Nous implémentons ensuite le point de terminaison qui traitera les requêtes.
@server.call_tool()
async def handle_call_tool(
name: str, arguments: dict | None
) -> list[types.TextContent | types.ImageContent | types.EmbeddedResource]:
"""
Handle tool execution requests.
Tools can fetch weather data and notify clients of changes.
"""
if not arguments:
raise ValueError("Missing arguments")
if name == "get-capsule-last-update":
serial = arguments.get("serial")
if not serial:
raise ValueError("Missing serial parameter")
# Convert serial to uppercase to ensure consistent format
serial = serial.upper()
if len(serial) != 4:
raise ValueError("Serial must be a four-character code (e.g. C106, C209)")
# Get info for the capsule
capsules = await spacex.capsules()
capsule_text = None
for capsule in capsules:
if capsule["serial"] != serial:
continue
capsule_text = (
f"Capsule serial number: {capsule['serial']}\\n"
f"Capsule type: {capsule['type']}\\n"
f"Capsule last update: {capsule['last_update']}\\n"
)
break
if not capsule_text:
return [
types.TextContent(
type="text",
text=f"Failed to retrieve information for capsule: {serial}.",
)
]
return [types.TextContent(type="text", text=capsule_text)]
else:
raise ValueError(f"Unknown tool: {name}")Enfin, nous instancions le serveur MCP.
async def run():
# Run the server using stdin/stdout streams
async with mcp.server.stdio.stdio_server() as (read_stream, write_stream):
await server.run(
read_stream,
write_stream,
InitializationOptions(
server_name="spacex",
server_version="0.1.0",
capabilities=server.get_capabilities(
notification_options=NotificationOptions(),
experimental_capabilities={},
),
),
)Nous ajoutons un point d’entrée dans le fichier __init__.py du module spacex.
import asyncio
from . import server
def run():
print("Starting weather server (from run)...")
asyncio.run(server.main())
__all__ = ["server"]Et nousdéclarons le script dans le fichier pyproject.toml
[project.scripts]
spacex = "python_mcp.spacex:run"Test du serveur
Le serveur est maintenant prêt ! Lancez uv run spacex pour confirmer que tout fonctionne.
Avant de connecter notre service à Claude, vous pouvez valider son bon fonctionnement avec le MCP Inspector :
npx @modelcontextprotocol/inspector uv run spacexCet outil permet de tester les réponses d’un serveur sur ses différents points de terminaison. Dans la capture ci-dessous, après avoir listé les outils, nous avons testé la réponse de la fonction get-capsule-last-update avec C108 comme paramètre.
Intégration avec Claude
Pour connecter notre serveur à Claude for Desktop, nous avons besoin d’éditer un fichier de configuration :
code ~/Library/Application\\ Support/Claude/claude_desktop_config.jsonEt déclarer notre service:
{
"mcpServers": {
"spacex": {
"command": "/Users/<local_user>/.local/bin/uv",
"args": [
"--directory",
"/Users/<local_user>/<project_folder>/python-mcp",
"run",
"spacex"
]
}
}
}Ensuite, lancez ou relancez Claude for Desktop :
Vérifiez que l’intégration fonctionne en posant la requête suivante : « Can you give me information on SpaceX capsule C108 ?«
MCP et Agent Intelligents
L’intérêt du MCP devient particulièrement évident lorsqu’il s’agit d’agents IA. Ces entités, souvent conçues pour effectuer des tâches complexes de manière autonome, doivent accéder à des informations variées, exécuter des actions spécifiques et interagir avec des environnements divers. Grâce au MCP, la création de tels agents est simplifiée. Ils peuvent se concentrer sur leurs capacités cognitives et décisionnelles, sans se soucier de la complexité technique de la collecte et de la mise en forme du contexte.
L’un des avantages majeurs du protocole MCP est son approche modulaire et évolutive, facilitant la création progressive de bibliothèques de connecteurs prêts à l’emploi. À mesure que la communauté élargit cet écosystème, il devient possible de connecter facilement des LLM à un nombre croissant de sources de données, d’API et de services tiers, sans devoir constamment repartir de zéro. Ainsi, chaque nouvelle intégration enrichit l’ensemble, offrant aux développeurs une gamme de solutions toujours plus large et diversifiée. Cette évolutivité permet non seulement de réduire le temps de mise en œuvre, mais aussi de faciliter l’adaptation rapide à de nouveaux besoins ou à de nouveaux fournisseurs, rendant le développement d’agents IA plus flexible, robuste et tourné vers l’avenir.
En résumé, MCP permet de construire des agents et des flux de travail complexes au-dessus des LLM, ces derniers ayant souvent besoin de s’intégrer à des données et à des outils. Ce protocole sert de passerelle standardisée et sécurisée entre les LLM et un écosystème varié de données et de services.
Ceci offre plusieurs avantages :
- Intégration facilitée : MCP simplifie la connexion entre les modèles d’IA et les ressources nécessaires (données locales, services distants, API, etc.), sans nécessiter d’intégrations spécifiques ou personnalisées à chaque nouvelle source.
- Flexibilité et indépendance du fournisseur : En utilisant un protocole standard, on peut aisément changer de fournisseur LLM ou d’outils sans avoir à repenser complètement l’architecture ou les connexions.
- Sécurité et bonnes pratiques : MCP propose un cadre cohérent pour protéger les données et contrôler les accès, ce qui permet de sécuriser les flux de travail des applications basées sur des modèles de langage.
Vous souhaitez transformer vos données en un avantage compétitif avec des applications d’IA avancées ? Contactez-nous pour discuter de la manière dont nous pouvons intégrer ces technologies dans vos projets et vous aider à optimiser vos processus métier, tout en améliorant l’expérience utilisateur et la qualité de vos services.
