Des simples chatbots à une automatisation puissante : l'essor du Model Context Protocol

Les grands modèles linguistiques (LLM) ont transformé la façon dont nous interagissons avec les ordinateurs, passant de simples outils de réponse à des questions à de puissants orchestrateurs de services externes. Cela se passe très vite : ChatGPT a explosé en 2022, 2025 pourrait être l'année du Model Context Protocol (MCP) qui permet aux LLM d'agir dans le monde réel.

Cela va si vite que, selon certains, le PDG de Microsoft, Satya Nadella, a déclaré que « le SaaS est mort » (Source : Podcast BG2 avec Brad Gerstner et Bill Gurley, décembre 2024. Cette phrase est sujette à une interprétation controversée). J'étais sceptique, mais je suis devenu nettement moins sceptique après avoir découvert et utilisé le MCP. Il s'agit d'un protocole créé par Anthropic. Et ils le présentent comme l'USB-C des LLM.

Mais prenons du recul et voyons ce qu'est le MCP et quel problème il résout.

‍

Les bases : les LLM et leurs limites

‍Les LLM comme GPT-4 peuvent générer du texte, répondre à des questions et même simuler des conversations avec une fluidité impressionnante. Mais il y a un hic : ils fonctionnent dans un environnement fermé : ils ne peuvent générer des réponses qu'en fonction de leurs données d'entraînement et de ce que l'utilisateur fournit sous forme d'invite et de réponse sous forme de texte. Si vous demandez à un LLM des informations météorologiques en temps réel, si vous lui envoyez un e-mail ou même l'heure exacte, il ne peut pas le faire de manière native. Pourquoi ? Parce qu'il n'a aucun accès direct au monde extérieur, aucun moyen d'exécuter du code, d'accéder à des API ou de récupérer des données en direct.

Quelque chose de simple comme le code ci-dessous produira la réponse « Je ne suis pas en mesure de fournir l'heure actuelle ».

response = client.chat.completions.create(
    model = model
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        {"role": "user", "content": "What is the current time?"}
    ]
)

L'étape suivante : l'utilisation de l'outil

‍Pour surmonter ce problème, les développeurs du LLM ont introduit l'idée d'un appel de fonction ou d'une utilisation d'un outil : le LLM peut décider de ne pas répondre en texte mais de générer un jeton spécifique qui signifie « appeler un outil ». Le LLM est informé des outils qu'il peut utiliser à l'aide de JSON et est tenu de fournir les arguments appropriés et des instructions sur le format de la sortie de ces outils. Cela permet de combler le fossé entre le monde statique du LLM et les données dynamiques du monde réel.

Par exemple, si le LLM décide qu'il a besoin de connaître l'heure actuelle, il peut appeler un obtenir_l'heure_actuelle fonction, puis intégrez le résultat dans sa réponse finale. Il s'agit d'une amélioration considérable, mais les développeurs doivent tout de même prédéfinir tous les outils et la manière de les appeler. Pour mieux comprendre le problème résolu par MCP, allons un peu plus en détail et voyons quel code est nécessaire pour fournir cette solution simple obtenir_l'heure_actuelle outil pour un LLM utilisant les bibliothèques OpenAI.

# Define the function to be called, namely “the tool”
def get_current_time():
    return datetime.now().isoformat()

# Create an object that describes the function and its input in natural language
# but that can be converted to JSON to be passed to the LLM.
tools = [
    {
        "type": "function",
        "function": {
            "name": "get_current_time",
            "description": "Returns the current time in ISO format",
            "parameters": {"type": "object", "properties": {}, "required": []}
        }
    }
]

# Call the LLM now passing the tool
response = client.chat.completions.create(
    model=model,
    messages=[
        {"role": "system", "content": "You are a helpful assistant"},
        {"role": "user", "content": "What is the current time?"}
    ],
    tools=tools,
    tool_choice="auto"
)

# Handle the response. When the LLM tells us to use the function run it instead of returning its output.
# If the result has to be then integrated into a natural language response a second LLM call
# needs to happen where the result is passed in the context.
message = response.choices[0].message
if message.tool_calls:
    for tool_call in message.tool_calls:
        if tool_call.function.name == "get_current_time":
            current_time = get_current_time()
            print(f"The current time is: {current_time}")
else:
    print(message.content)

Alors que la fonction permettant d'obtenir l'heure elle-même ne comporte que 2 lignes de code, sa description au LLM et la gestion de sa réponse nécessitent beaucoup de travail. Consultez les commentaires du code pour comprendre ce qui se passe.

Entrez dans MCP : la révolution du protocole Model Context

‍Nous avons donc vu que, si l'appel de fonction permet aux LLM de travailler avec des outils locaux ponctuels, il est assez fastidieux de les interfacer avec les LLM. Le MCP est un protocole inventé par Anthropic, les créateurs du modèle LLM Claude, qui porte l'utilisation des outils à un tout autre niveau en effectuant deux étapes cruciales :

• standardisation comment les LLM découvrent, appellent et intègrent des outils externes lors de l'exécution en fournissant un protocole de communication commun que n'importe quel outil peut implémenter
• gestion des environnements externes en faisant tourner et en coordonnant automatiquement plusieurs contextes informatiques isolés : il peut s'agir de serveurs spécialisés, de conteneurs Docker ou d'API.

Même si le MCP n'est qu'un standard, n'oubliez pas que le HTML n'est « qu'un standard », mais qu'il a permis à des milliards de serveurs et de clients de communiquer efficacement, générant ainsi Internet.

La particularité de MCP réside dans sa capacité à orchestrer des flux de travail complexes : un LLM peut faire fonctionner un serveur pour l'envoi d'e-mails, un autre pour la navigation sur le Web et un autre pour le stockage en mémoire persistante. Avec MCP, ces outils deviennent des composants intégrés d'un flux de travail d'IA cohérent, plutôt que des services isolés.

Cependant, ce n'est toujours pas la raison pour laquelle le MCP explose et est si utile par rapport aux méthodes de transmission des outils disponibles auparavant. La vraie raison est que la standardisation permet de créer une place de marché. Désormais, n'importe qui peut créer un outil qui peut ensuite être utilisé par n'importe quel LLM en quelques lignes de code.

Vous pouvez consulter les liens ci-dessous pour trouver littéralement des milliers d'outils déjà créés et qui peuvent être utilisés pour équiper vos LLM en un instant :

• https://mcp.so
• https://glama.ai/mcp
• https://smithery.ai/
• https://huggingface.co/blog/LLMhacker/top-11-essential-mcp-libraries

MCP : exemple de cas d'utilisation

‍Pour avoir une meilleure idée de l'ampleur du changement apporté par le MCP, imaginons un cas d'utilisation assez complexe. Nous aimerions que notre LLM ouvre un navigateur, aille sur Internet, cherche une recette de tarte aux pommes et l'écrive enfin dans un fichier sur disque plutôt que dans le chat. Découvrez ci-dessous comment procéder.

# Import the library
from agents.mcp import MCPServerStdio

# Define the parameters to download the prebuilt tools from the web
fetch_params = {"command": "uvx", "args": ["mcp-server-fetch"]}
playwright_params = {"command": "npx", "args": ["@playwright/mcp@latest"]}
files_params = {"command": "npx", "args": ["-y", "@modelcontextprotocol/server-filesystem", "./sandbox"]}

# Just create a MCPServerStdio object and pass it to the LLM call.
# This function call will download the tools if not already available locally and spin up environments for them to run.
# Finally, it will create the JSON scaffolding to advertise them to the LLM.
async with MCPServerStdio(params=files_params, client_session_timeout_seconds=30) as mcp_server_files:
    async with MCPServerStdio(params=playwright_params, client_session_timeout_seconds=30) as mcp_server_browser:

        agent = Agent(
            name="investigator",
            instructions="""
	You browse the internet to accomplish your instructions.
	You are highly capable at browsing the internet independently to accomplish your task, including accepting all cookies and clicking 'not now' as appropriate to get to the content you need. If one website isn't fruitful, try another. Be persistent until you have solved your assignment, trying different options and sites as needed.
			""",
            model="gpt-4.1-mini",
            mcp_servers=[mcp_server_files, mcp_server_browser]
        )
        with trace("investigate"):
            result = await Runner.run(agent, "Find a great recipe for Apple Pie, then summarize it in markdown to apple.md")

Je trouve incroyable que ces 19 lignes de code (dont 6 sont l'invite du système !) effectuez une recherche sur le Web et générez un fichier à partir d'une question écrite en langage naturel !

De plus, vous pouvez regarder la « trace ». En fait, ce dernier code utilise le SDK OpenAI Agent, un développement très récent, qui inclut également un site Web où les traces de vos appels LLM sont enregistrées. Par exemple, j'ai pu constater que dans certains cas, le LLM effectue plusieurs recherches sur le Web avant d'être satisfait de ses résultats. En d'autres termes, il dispose effectivement d'une certaine autonomie.

Au-delà des instructions statiques : flux de travail dynamiques et multi-outils

‍La beauté de MCP réside dans son extensibilité : il n'est pas limité à un seul outil à la fois. Vous pouvez avoir :

• Un outil de navigation pour la recherche en temps réel
• Un outil de système de fichiers pour créer des documents
• Une base de données mémoire pour stocker et récupérer les résultats
• Un outil de serveur de messagerie pour envoyer des messages
• Et bien plus encore, en explorant les milliers d'outils déjà créés

Ils sont tous gérés par le LLM, qui décide quoi utiliser, quand et combien de fois.

Je souhaite me concentrer ici sur 3 catégories spécifiques d'outils qui permettent aux applications LLM d'atteindre un niveau supérieur :

• Action: C'est le plus facile à comprendre et le plus discuté dans les exemples ci-dessus. Les « outils d'action » permettent à votre LLM d'agir réellement dans le monde réel.
• Mémoire: Une action particulière consiste à permettre aux LLM d'écrire dans une base de données, ce qui devient un outil spécial. Auparavant, les LLM ne pouvaient accéder à l'information qu'en incluant de grandes quantités de données potentiellement non pertinentes dans leur contexte. Le MCP permet aux LLM de stocker et de récupérer des données spécifiques et pertinentes selon les besoins, afin de se rapprocher davantage d'une véritable mémoire semblable à celle d'un humain.
• Agents: MCP permet des flux de travail multi-agents dans lesquels les LLM spécialisés peuvent être regroupés en tant que services appelés par d'autres LLM. Par exemple, vous pouvez créer un agent spécialisé dans la recherche et un agent spécialisé dans la messagerie, puis implémenter un coordinateur LLM pour les orchestrer via des connexions MCP. Cela diffère des outils simples car chaque agent possède ses propres capacités de raisonnement.
  Il peut par exemple être utilisé pour créer des e-mails personnalisés à partir de profils LinkedIn. Y voyez-vous un intérêt commercial (même si ce n'est pas légal) ? Je pense que l'exemple parle de lui-même.
  ‍

En conclusion, cette interaction dynamique permet aux agents d'IA de gérer des tâches de plus en plus complexes avec une flexibilité et une efficacité comparables à celles des humains, y compris en prenant des mesures concrètes dans le monde réel.

Conclusion : une nouvelle ère pour l'automatisation de l'IA

‍Le MCP représente une avancée majeure dans l'évolution des LLM, allant des moteurs conversationnels statiques aux orchestrateurs dynamiques et contextuels de tâches du monde réel. Qu'il s'agisse de résumer des informations, de naviguer sur le Web, d'automatiser la diffusion d'e-mails ou de gérer des données persistantes, MCP permet aux LLM de transcender leurs frontières statiques et d'agir véritablement dans le monde.

‍

Auteur :

Luca Pescatore