Model Context Protocol : une vue d'ensemble complète

Derrière l'abréviation MCP se cache la spécification ouverte du Model Context Protocol. Cette spécification définit la manière dont les grands modèles de langage peuvent interagir avec les outils et les fonctions. Le clou : les outils et les modèles de langage peuvent être échangés de manière flexible et utilisés de manière universelle, car ils parlent le même "langage".

Le MCP est aux outils et aux agents ce que les API REST sont aux applications - un lien standardisé pour une intégration et une communication transparentes.

Qu'est-ce que le Model Context Protocol (MCP) ?

Le Model Context Protocol est une norme technique ouverte publiée par Anthropic. Il définit comment les grands modèles de langage obtiennent un contexte ciblé et un accès à des outils, et comment se déroule la communication entre le modèle de langage et l'outil. Cela permet au modèle de langage de récupérer exactement les informations, les outils et les fonctionnalités dont le modèle a besoin pour fournir des réponses pertinentes ou effectuer des tâches.

MCP crée donc une interface unique qui réduit la complexité. Au lieu de construire à chaque fois de nouvelles solutions spéciales, MCP crée de l'ordre et de la réutilisabilité. Qu'il s'agisse d'accès à des fichiers, de services web ou d'automatisation, le MCP permet de relier plus facilement de nombreuses choses et de les rendre utilisables pour les LLM.

Pourquoi le MCP est utile

Les modèles linguistiques peuvent saisir le contenu de textes et d'images et agir sur la base des connaissances du modèle linguistique (connaissances acquises). Ce savoir est une limite qui est rapidement atteinte. Par exemple, un LLM ne sait rien des événements actuels, car l'entraînement du modèle linguistique a généralement été achevé des mois auparavant et aucun événement actuel n'a été entraîné, ergo le LLM ne sait rien des nouvelles ou de la météo d'aujourd'hui.  

Le MCP a le potentiel de combler cette lacune. Il associe un modèle linguistique à la boîte à outils appropriée et permet ainsi de résoudre la limitation des connaissances statiques.

Un modèle linguistique peut, par exemple, avoir accès à un moteur de recherche et à un service météo, de sorte que le LLM puisse utiliser activement ces outils pour consulter les dernières nouvelles ou la météo du jour et utiliser ces informations. Cette combinaison du LLM et de l'outil peut par exemple être utilisée pour une mise à jour matinale quotidienne, dans laquelle le LLM résume les principales nouvelles et un bulletin météo pour aujourd'hui.

Un autre cas d'application, un peu particulier mais utile, est le Utilisation d'un serveur MCP pour optimiser les processus d'archivage.

Même dans le NLWeb (Web en langage naturel) le protocole MCP fait partie intégrante du système et fait valoir ses atouts.

L'architecture derrière le MCP

Le Model Context Protocol (MCP) suit un modèle client-serveur typique. La pièce maîtresse est l'hôte MCP, un modèle de langage qui exécute des commandes. Le client MCP fait office d'interface et transmet les requêtes entre le modèle et le serveur MCP. Un serveur MCP peut fournir une variété d'outils, tels que des fonctions, des fichiers ou des API. Ces outils permettent au modèle d'accéder à des ressources externes telles que des bases de données ou des services. Les invites définissent des tâches spécifiques pour le modèle, et les outils sont des fonctions exécutables que le modèle peut utiliser pour accomplir ces tâches.

• Hôte MCP - le modèle qui exécute des tâches
• Client MCP - sert d'intermédiaire entre le modèle et le serveur
• Serveur MCP - fournit des outils sous forme de fonctions, de fichiers ou d'API
• Ressources - Bases de données, fichiers ou services
• Prompts - tâches prédéfinies
• Outils - fonctions exécutables

Le Model Context Protocol utilise une structure client-serveur dans laquelle une application centrale peut communiquer simultanément avec plusieurs serveurs.

De la même manière que l'USB-C regroupe différentes fonctions sur un seul port, comme le chargement, les données et le signal d'image, le MCP relie les modèles avec des données, des outils et des services via une interface unique.

Avantages de la norme MCP

La norme MCP offre de nombreux avantages pratiques qui rendent l'avenir du développement logiciel basé sur le LLM plus efficace et plus modulaire. Cette standardisation permet de dissoudre les solutions spéciales coûteuses et les implémentations logicielles rigides, ce qui conduit à un développement et une utilisation plus agiles du logiciel.
Les principaux avantages de la norme MCP sont présentés ci-dessous :

• Standardisation - Le principe "configurer une fois, utiliser plusieurs fois" est au cœur de la démarche. Comme pour l'USB-C, tous les composants s'adaptent parfaitement les uns aux autres, indépendamment du fabricant ou du fournisseur. Cette uniformisation réduit considérablement les efforts d'intégration et favorise la réutilisation des modules et des services.
• Flexibilité - Les modèles, les outils ou les fournisseurs peuvent être partiellement ou totalement remplacés, car ils parlent tous le même "langage" (MCP). Cette flexibilité permet de s'adapter rapidement à de nouvelles exigences ou technologies sans devoir revoir l'ensemble du système.
• Sécurité - L'accès aux outils et aux données peut être contrôlé avec précision et encapsulé. Des interfaces et des autorisations définies garantissent que seuls les composants autorisés peuvent accéder aux informations et aux fonctions sensibles.
• Modularité - Les serveurs MCP sont de petits modules autonomes qui peuvent être facilement combinés, échangés et étendus. Cette architecture modulaire favorise le développement de systèmes évolutifs et faciles à entretenir, car les différents composants peuvent être mis à jour ou remplacés indépendamment les uns des autres.

Grâce à ces avantages, la norme MCP permet une utilisation plus efficace, plus sûre et plus flexible des applications et des services basés sur LLM.

Ce que les serveurs MCP peuvent faire

En substance, un serveur MCP étend le modèle linguistique à des capacités concrètes.
En termes simples, les serveurs MCP sont des outils que le modèle linguistique peut utiliser lorsqu'il lui est utile.

Cas d'utilisation typiques qu'un serveur MCP peut couvrir :

• Accès à des dossiers ou fichiers définis ou directement à une base de données
• Connexion à des services web tels que le moteur de recherche Google
• Utilisation d'applications comme Outlook ou Teams
• Application d'invites et de workflows prédéfinis

Exemples de serveurs MCP populaires

La page Github punkpeye/awesome-mcp-servers répertorie de nombreux serveurs utiles qui peuvent être utilisés immédiatement. 

En voici quelques exemples :

Ces serveurs fonctionnent sur le même principe que les adaptateurs : branchez et c'est parti.

Cette diversité de serveurs MCP montre à quel point le Model Context Protocol est flexible et extensible. La communauté développe constamment de nouveaux serveurs qui répondent à des besoins spécifiques et élargissent les possibilités des LLM.

Premiers pas avec les serveurs MCP

Pour un démarrage rapide

Ceux qui souhaitent se lancer facilement utilisent une application comme Claude Desktop. Elle permet d'associer ses propres fichiers au modèle. Les instructions sur modelcontextprotocol.io/quickstart/user aide à cela.

Voici un exemple de configuration de la claude_desktop_config.json Fichier qui intègre un serveur MCP Github et Brave-Search et le rend directement utilisable.

{
  "mcpServers": {
    "brave-search": {
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "-e",
        "BRAVE_API_KEY",
        "mcp/brave-search"
      ],
      "env": {
        "BRAVE_API_KEY": "YOUR_ACTUAL_BRAVE_API_KEY"
      }
    },
    "github": {
      "command": "npx",
      "args": [
        "-y",
        "@modelcontextprotocol/server-github"
      ],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "YOUR_ACTUAL_GITHUB_TOKEN"
      }
    }
  }
}

Pour les personnes intéressées par la technique

Le site Démarrage rapide du serveur MCP montre comment construire soi-même un serveur. Tout ce qu'il faut, c'est de l'expérience en Python ou TypeScript, le SDK officiel et un peu de curiosité.

Le code suivant représente un serveur MCP minimal qui peut être utilisé par un LLM pour convertir correctement les heures pour différents fuseaux horaires.

#!/usr/bin/env python3
"""Minimal MCP-Server - Timezone Converter"""
import json
import sys
from datetime import datetime
import pytz
def convert_timezone(time_str, from_tz, to_tz):
    """Convert time between timezones"""
    dt = datetime.strptime(time_str, "%Y-%m-%d %H:%M")
    dt_with_tz = pytz.timezone(from_tz).localize(dt)
    converted = dt_with_tz.astimezone(pytz.timezone(to_tz))
    return {
        "original": f"{time_str} {from_tz}",
        "converted": f"{converted.strftime('%Y-%m-%d %H:%M')} {to_tz}",
        "offset": converted.strftime('%z')
    }
def handle_request(request):
    """Route and handle MCP requests"""
    method = request["method"]
    params = request.get("params", {})
    
    if method == "initialize":
        return {
            "protocolVersion": "0.1.0",
            "capabilities": {"tools": {}},
            "serverInfo": {"name": "timezone-converter", "version": "1.0.0"}
        }
    
    elif method == "tools/list":
        return {
            "tools": [{
                "name": "convert_timezone",
                "description": "Convert time between timezones",
                "inputSchema": {
                    "type": "object",
                    "properties": {
                        "time": {"type": "string", "description": "Time 'YYYY-MM-DD HH:MM'"},
                        "from_tz": {"type": "string", "description": "Source timezone"},
                        "to_tz": {"type": "string", "description": "Target timezone"}
                    },
                    "required": ["time", "from_tz", "to_tz"]
                }
            }]
        }
    
    elif method == "tools/call":
        if params.get("name") != "convert_timezone":
            raise Exception(f"Unknown tool: {params.get('name')}")
        
        args = params["arguments"]
        try:
            result = convert_timezone(args["time"], args["from_tz"], args["to_tz"])
            return {"content": [{"type": "text", "text": json.dumps(result, indent=2)}]}
        except Exception as e:
            raise Exception(f"Tool error: {str(e)}")
    
    else:
        raise Exception(f"Unknown method: {method}")
def main():
    """Main server loop"""
    while True:
        try:
            line = sys.stdin.readline()
            if not line:
                break
            
            request = json.loads(line.strip())
            
            try:
                response = handle_request(request)
                output = {
                    "jsonrpc": "2.0",
                    "id": request.get("id"),
                    "result": response
                }
            except Exception as e:
                output = {
                    "jsonrpc": "2.0",
                    "id": request.get("id"),
                    "error": {"code": -32000, "message": str(e)}
                }
            
            print(json.dumps(output))
            sys.stdout.flush()
            
        except json.JSONDecodeError:
            error = {
                "jsonrpc": "2.0",
                "id": None,
                "error": {"code": -32700, "message": "Parse error"}
            }
            print(json.dumps(error))
            sys.stdout.flush()
if __name__ == "__main__":
    main()

Tutoriel de plongée profonde

Pour un aperçu plus détaillé, Mahesh Murag d'Anthropic montre dans la vidéo suivante un aperçu détaillé de la construction d'agents avec Model Context Protocol. 

En chargeant la vidéo, vous acceptez la déclaration de confidentialité de YouTube.
En savoir plus

Charger la vidéo

Toujours déverrouiller YouTube

Conclusion

Le Model Context Protocol met de l'ordre et de la modularité dans le monde des modèles de langage. Au lieu de construire constamment de nouvelles interfaces, le MCP assure une norme stable. Les serveurs MCP rendent les LLM non seulement plus intelligents, mais aussi plus opérationnels. MCP permet de relier proprement les données, les services et les modèles, que ce soit dans l'entreprise, dans un projet ou pour des tâches quotidiennes. Cette standardisation et la flexibilité qui en découle signifient que les solutions basées sur le LLM sont plus faciles à faire évoluer et à adapter aux nouvelles exigences. De plus, MCP favorise le développement d'une communauté vivante au sein de laquelle les développeurs et les entreprises peuvent partager leurs propres serveurs et outils et les faire évoluer ensemble. En fin de compte, MCP ouvre la voie à un avenir dans lequel les modèles linguistiques seront encore plus profondément intégrés dans notre quotidien numérique et pourront nous aider dans une multitude de tâches.