MCP : vers un nouveau standard pour les applications LLM ?

Le monde des applications autour des modèles de langage est en ébullition.

Tous les jours, des outils apparaissent... et disparaissent. Difficile de savoir sur quoi miser !

Parmi les initiatives récentes, MCP (Model Context Protocol) tente d'imposer un standard.

Alors, révolution ou simple effet de mode ? 🔍

MCP, en clair

Aujourd'hui, chaque framework définit ses propres outils. MCP propose une solution :

Unifier l'approche autour de trois concepts simples :

• Ressource : une donnée exposée à l’application.

• Prompt : un modèle de message prédéfini.

• Outil : une fonction utilisable par l’application.

Concrètement ?

• Un serveur MCP pour Google Drive expose les fichiers en ressources, et la recherche en outil.

• Un serveur MCP pour Redis propose 4 outils pour interagir avec la base : get, set, delete, list.

Architecture :

MCP repose sur un modèle client / serveur / hôte :

L'application héberge un client qui dialogue avec des serveurs MCP normalisés.

Un exemple concret pour mieux comprendre

Imaginons une application capable de résoudre des problèmes de maths simples.

On commence par installer les dépendances :

pip install "mcp[cli]" langchain langchain-mcp-adapters langchain-google-vertexai langgraph 

Puis on crée un serveur MCP minimaliste, comme on ferait avec une API FastAPI. Les outils sont définis comme des fonctions sur lesquelles ont vient placer un décorateur @mcp.tool. Ici, la docstring est importante puisque c’est elle qui va être exposée à l’application hôte pour la guider dans ses choix d’outils.

from mcp.server.fastmcp import FastMCP

mcp = FastMCP(
    "Basic Math MCP Server",
    port=8082,
)

@mcp.tool()
def add(a: int, b: int) -> int:
    """Add two numbers"""
    return a + b

@mcp.tool()
def multiply(a: int, b: int) -> int:
    """Multiply two numbers"""
    return a * b

if __name__ == "__main__":
    mcp.run(transport="sse") 

Pour lancer le serveur, il suffit de lancer la commande

python math_mcp_server.py 

Il ne reste plus qu’à implémenter une application LangGraph qui va utiliser ce serveur MCP.

import asyncio
import os

from langchain_core.messages import AIMessage, HumanMessage
from langchain_google_vertexai import ChatVertexAI
from langchain_mcp_adapters.client import MultiServerMCPClient
from langgraph.prebuilt import create_react_agent

model = ChatVertexAI(
    model=os.environ.get("APP_MODEL", "gemini-2.0-flash"),
    project=os.environ.get("GCP_PROJECT_ID"),
    location=os.environ.get("GCP_LOCATION")
)

async def run_agent():
    async with MultiServerMCPClient(
            {
                "math_tool": {
                    "url": "<http://localhost:8082/sse>",
                    "transport": "sse",
                },
            }
    ) as client:
        agent = create_react_agent(model, client.get_tools())

        async for event in agent.astream({"messages": [HumanMessage("What is (3 + 5) * 10 ?")]}):
            for key, value in event.items():
                if len(value["messages"]) > 0 and isinstance(value["messages"][0], AIMessage):
                    latest_response = value["messages"][-1].content

                print(f"Assistant[{key}]:", value)

        return latest_response

if __name__ == "__main__":
    result = asyncio.run(run_agent())
    print(result) 

Afin de l’exécuter, il suffira maintenant de lancer le programme Python en ayant pris le soin de configurer les variables d’environnement “GCP_PROJECT_ID” et “GCP_LOCATION”.

python langchain_app.py 

Résultat :

L'agent raisonne, appelle l’outil add, puis l’outil multiply, et affiche :

(3 + 5) * 10 = 80

Soit :

Assistant[agent]: {'messages': [AIMessage(content='', additional_kwargs={'function_call': {'name': 'add', 'arguments': '{"a": 3.0, "b": 5.0}'}}, ... }
Assistant[tools]: {'messages': [ToolMessage(content='8', name='add', ... }
Assistant[agent]: {'messages': [AIMessage(content='', additional_kwargs={'function_call': {'name': 'multiply', 'arguments': '{"a": 8.0, "b": 10.0}'}}, ... }
Assistant[tools]: {'messages': [ToolMessage(content='80', name='multiply', ... }
Assistant[agent]: {'messages': [AIMessage(content='(3 + 5) * 10 is 80.', ... }
(3 + 5) * 10 is 80. 

Alors, le MCP est-il vraiment mature ?

Pas tout à fait.

Certains éléments pourraient encore évoluer, ce que laissent notamment penser :

• Le peu d'usage des prompts malgré leur place dans le standard.

• La différence peu claire entre une ressource et un outil de type get.

En revanche, le potentiel autour des outils est énorme.

L’utilisation du MCP peut donc être très intéressante**,** notamment dans les cas suivants :

• Exposition d’outils en mode plugin, lorsque les équipes qui les développent n’ont pas la main sur les application embarquant le LLM.

• Mutualisation, lorsque plusieurs applications avec des besoins différents utilisent des outils partagés.

Et vous, comment imaginez-vous l'avenir des standards autour des LLM ?

Curieux d’avoir vos retours sur MCP et son avenir.