Créer un serveur et un client MCP avec FastMCP 2.0

Dans l’univers de l’IA, le Model Context Protocol (MCP) est rapidement devenu un sujet incontournable. MCP est une norme ouverte qui offre aux modèles d’IA comme Claude 4 un moyen cohérent de se connecter à des outils externes, des services et des sources de données en temps réel. Cette connectivité change la donne : elle permet aux grands modèles de langage (LLM) de fournir des réponses plus pertinentes, à jour et exploitables en comblant le fossé entre l’IA et les systèmes existants.

Dans ce tutoriel, nous allons découvrir FastMCP 2.0, un puissant framework qui simplifie la création d’un serveur MCP en quelques lignes de code. Nous verrons les composants clés de FastMCP, comment construire à la fois un serveur et un client MCP, puis comment les intégrer sans friction dans votre flux de travail. Si vous débutez avec MCP, consultez notre guide du Model Context Protocol avec projet démo pour en savoir plus. 

Qu’est-ce que FastMCP 2.0 ?

FastMCP 2.0 est un framework Python open source conçu pour rendre la création de serveurs et de clients MCP à la fois simple et efficace. En quelques lignes, les développeurs peuvent créer des serveurs MCP sur mesure et les connecter à leurs applications d’IA, comme des éditeurs de code ou des assistants conversationnels.

FastMCP 2.0 succède à FastMCP 1.0, désormais appelé MCP Python SDK, et propose une boîte à outils complète pour travailler dans l’écosystème MCP.

La force de FastMCP 2.0 réside dans un ensemble de fonctionnalités très complet, qui va bien au-delà du cœur de la spécification MCP. Il simplifie le déploiement, l’authentification, le proxy côté client et serveur, et permet même de générer des serveurs à partir d’API REST.  

Composants clés de FastMCP 2.0

FastMCP 2.0 s’articule autour de trois composants essentiels : Tools, Resources et Prompts.

1. Tools

Les Tools sont des fonctions Python exposées aux LLM via le protocole MCP. En décorant une fonction avec @mcp.tool, vous autorisez le modèle d’IA à l’appeler pendant une conversation. Cela permet aux LLM d’effectuer des actions concrètes : interroger des bases de données, appeler des API ou exécuter des calculs.

from fastmcp import FastMCPmcp = FastMCP(name="UtilityServer")@mcp.tooldef convert_usd_to_eur(amount: float, rate: float = 0.91) -> float:    """Converts a given amount in USD to EUR using the provided rate."""    return round(amount * rate, 2)

2. Resources

Les Resources offrent aux LLM ou aux applications clientes un accès en lecture seule à des données : fichiers, enregistrements de base de données, configurations ou contenus générés dynamiquement. Par exemple :

from fastmcp import FastMCPmcp = FastMCP(name="WeatherResourceServer")@mcp.resource("config://weather-settings")def get_weather_settings() -> dict:    """Provides weather configuration."""    return {        "default_units": "metric",        "default_location": "Berlin",        "features_enabled": ["forecast", "alerts"]    }@mcp.resource("resource://welcome-message")def welcome_message() -> str:    """Returns a dynamic greeting for users based on time of day."""    from datetime import datetime    hour = datetime.now().hour    if hour < 12:        return "Good morning! Here's your weather update."    elif hour < 18:        return "Good afternoon! Need a forecast?"    else:        return "Good evening! Let's check the weather."

3. Prompts

Les Prompts sont des modèles de messages réutilisables et paramétrables qui guident les réponses des LLM. En définissant des prompts comme des fonctions, vous garantissez des instructions cohérentes et riches en contexte, invoquées par les clients. 

Ils sont nécessaires pour enchaîner plusieurs outils et guider le LLM afin d’accomplir certaines tâches en utilisant les outils et ressources disponibles.

from fastmcp import FastMCPfrom fastmcp.prompts.prompt import PromptMessage, TextContentmcp = FastMCP(name="TutorPromptServer")@mcp.promptdef explain_math_concept(concept: str) -> PromptMessage:    """Creates a message asking an AI tutor to explain a math concept simply."""    text = f"Can you explain the math concept of '{concept}' in a way that's easy for a 12-year-old to understand?"    return PromptMessage(role="user", content=TextContent(type="text", text=text))

Créer un ArXiv Explorer avec FastMCP 2.0 et Tavily

Dans cette section, nous allons construire un serveur MCP « ArXiv Explorer ». Il comportera deux outils : l’un pour extraire les liens et titres d’articles de recherche, l’autre pour résumer ces articles. En complément, le serveur inclura des ressources et des prompts pour produire un rapport complet sur le sujet choisi.

1. Mise en place

Avant de commencer, récupérez la clé API Tavily. Vous pouvez obtenir une clé gratuite avec 1 000 requêtes mensuelles sur tavily.com. Ensuite, installez les bibliothèques Python nécessaires :

pip install fastmcp tavily-python

2. Construire le serveur « ArxivExplorer »

Nous allons d’abord créer le fichier Python du serveur. Il se compose des éléments suivants :

1. Initialisation : créez une instance de FastMCP en donnant au serveur le nom « ArxivExplorer ».
2. Resource : le décorateur @mcp.resource expose notre fonction arxiv_topics comme source de données en lecture seule. Un client IA peut récupérer ces sujets pour s’inspirer si l’utilisateur n’a pas d’idée précise.
3. Tools : le décorateur @mcp.tool transforme des fonctions Python ordinaires en actions qu’un LLM peut exécuter.
1. search_arxiv : cet outil utilise l’API Tavily pour restreindre la recherche à un domaine spécifique (arxiv.org), garantissant des articles scientifiques pertinents issus d’arxiv.org uniquement.
2. summarize_paper : cet outil s’appuie sur qna_search de Tavily, optimisé pour fournir des réponses directes et concises, idéal pour générer un résumé.
4. Prompt : le décorateur @mcp.prompt crée un modèle réutilisable. Ce n’est pas un simple prompt : c’est un plan d’action qui indique à un LLM comment enchaîner les outils du serveur pour accomplir une tâche complexe.
5. Transport HTTP : mcp.run(transport="http") est une ligne essentielle. Au lieu d’utiliser « stdio » pour des processus locaux, cela démarre un serveur web. Tout client du réseau (ou de la même machine) peut ainsi se connecter via une URL, en faisant un outil réellement distant et partageable.

server.py :

import osfrom typing import Dict, Listfrom fastmcp import FastMCPfrom tavily import TavilyClient# --- Configuration ---TAVILY_API_KEY = os.environ.get("TAVILY_API_KEY")if not TAVILY_API_KEY:    raise ValueError("Please set the TAVILY_API_KEY environment variable.")tavily = TavilyClient(api_key=TAVILY_API_KEY)mcp = FastMCP(name="ArxivExplorer")print("✅ ArxivExplorer server initialized.")# --- Dynamic Resource: Suggested AI research topics ---@mcp.resource("resource://ai/arxiv_topics")def arxiv_topics() -> List[str]:    return [        "Transformer interpretability",        "Efficient large-scale model training",        "Federated learning privacy",        "Neural network pruning",    ]print("✅ Resource 'resource://ai/arxiv_topics' registered.")# --- Tool: Search ArXiv for recent papers ---@mcp.tool(annotations={"title": "Search Arxiv"})def search_arxiv(query: str, max_results: int = 5) -> List[Dict]:    """    Queries ArXiv via Tavily, returning title + link for each paper,    and *only* ArXiv results.    """    resp = tavily.search(        query=f"site:arxiv.org {query}",        max_results=max_results    )    return [        {"title": r["title"].strip(), "url": r["url"]} for r in resp.get("results", [])    ]# --- Tool: Summarize an ArXiv paper ---@mcp.tool(annotations={"title": "Summarize Paper"})def summarize_paper(paper_url: str) -> str:    """    Returns a one-paragraph summary of the paper at the given URL.    """    prompt = f"Summarize the key contributions of this ArXiv paper: {paper_url}"    return tavily.qna_search(query=prompt)print("✅ Tools 'Search Arxiv' and 'Summarize Paper' registered.")# --- Prompt Template: Explore a topic thoroughly ---@mcp.promptdef explore_topic_prompt(topic: str) -> str:    return (        f"I want to explore recent work on '{topic}'.\n"        f"1. Call the 'Search Arxiv' tool to find the 5 most recent papers.\n"        f"2. For each paper URL, call 'Summarize Paper' to extract its key contributions.\n"        f"3. Combine all summaries into an overview report."    )print("✅ Prompt 'explore_topic_prompt' registered.")if __name__ == "__main__":    print("\n🚀 Starting ArxivExplorer Server...")    mcp.run(transport="http")

3. Créer le client interactif

Nous devons tester les fonctionnalités et endpoints du serveur MCP avant de l’intégrer à l’application d’IA. Pour cela, FastMCP fournit une API simple pour se connecter au serveur MCP et tester toutes ses fonctions.

Le fichier client comprend :

1. Transport HTTP : StreamableHttpTransport est spécialement conçu pour se connecter à un serveur FastMCP en mode HTTP.
2. Assistant unwrap_tool_result : utilitaire crucial : le client FastMCP ne renvoie pas des données brutes mais des objets structurés. Cette fonction inspecte la réponse et en extrait en toute sécurité les données Python attendues.
3. Workflow : la fonction principale exécute une batterie de tests complète.
1. Elle ping le serveur pour vérifier qu’il est en ligne.
2. Elle liste tous les outils, ressources et prompts disponibles.
3. Elle lit la ressource arxiv_topics et analyse correctement le résultat.
4. Elle appelle l’outil search_arxiv et utilise la fonction d’assistance pour déballer la liste des articles.
5. Elle enchaîne les outils en prenant l’URL du premier résultat et en la passant à l’outil summarize_paper.
6. Enfin, elle récupère le explore_topic_prompt, montrant les instructions finales, prêtes à être envoyées à un LLM.

client.py :

import astimport asyncioimport pprintfrom fastmcp import Clientfrom fastmcp.client.transports import StreamableHttpTransport# --- Configuration ---SERVER_URL = "http://localhost:8000/mcp"  # adjust if hosted elsewherepp = pprint.PrettyPrinter(indent=2, width=100)def unwrap_tool_result(resp):    """    Safely unwraps the content from a FastMCP tool call result object.    """    if hasattr(resp, "content") and resp.content:        # The content is a list containing a single content object        content_object = resp.content[0]        # It could be JSON or plain text        if hasattr(content_object, "json"):            return content_object.json        if hasattr(content_object, "text"):            try:                # Use ast.literal_eval for safely evaluating a string containing a Python literal                return ast.literal_eval(content_object.text)            except (ValueError, SyntaxError):                # If it's not a literal, return the raw text                return content_object.text    return respasync def main():    transport = StreamableHttpTransport(url=SERVER_URL)    client = Client(transport)    print("\n🚀 Connecting to FastMCP server at:", SERVER_URL)    async with client:        # 1. Ping to test connectivity        print("\n🔗 Testing server connectivity...")        await client.ping()        print("✅ Server is reachable!\n")        # 2. Discover server capabilities        print("🛠️  Available tools:")        pp.pprint(await client.list_tools())        print("\n📚 Available resources:")        pp.pprint(await client.list_resources())        print("\n💬 Available prompts:")        pp.pprint(await client.list_prompts())        # 3. Fetch the topics resource        print("\n\n📖 Fetching resource: resource://ai/arxiv_topics")        res = await client.read_resource("resource://ai/arxiv_topics")        topics = ast.literal_eval(res[0].text)        print("Today's AI topics:")        for i, t in enumerate(topics, 1):            print(f"  {i}. {t}")        # 4. Test the search tool        print("\n\n🔍 Testing tool: search_arxiv")        raw_search = await client.call_tool(            "search_arxiv",            {"query": "Transformer interpretability", "max_results": 3},        )        search_results = unwrap_tool_result(raw_search)        for i, paper in enumerate(search_results, 1):            print(f"  {i}. {paper['title']}\n     {paper['url']}")                # 5. Test the summarize tool on the first result        if search_results:            first_url = search_results[0]["url"]            print("\n\n📝 Testing tool: summarize_paper")            raw_summary = await client.call_tool(                "summarize_paper", {"paper_url": first_url}            )            summary = unwrap_tool_result(raw_summary)            print("\nSummary of first paper:\n", summary)        # 6. Test the prompt generator        print("\n\n🚀 Testing prompt: explore_topic_prompt")        prompt_resp = await client.get_prompt(            "explore_topic_prompt", {"topic": "Transformer interpretability"}        )        print("\nGenerated prompt for an LLM:")        for msg in prompt_resp.messages:            print(f"{msg.role.upper()}: {msg.content.text}\n")if __name__ == "__main__":    asyncio.run(main())

Tous les fichiers et configurations sont disponibles dans le dépôt GitHub kingabzpro/FastMCP-Project. Vous pouvez vous y référer en cas de difficulté. J’y ai également inclus un guide de configuration pour l’exécuter en local.

4. Exécuter l’application

Nous allons maintenant lancer le serveur et le client MCP. 

Commencez par définir la clé API Tavily comme variable d’environnement sur votre machine locale :  

export TAVILY_API_KEY='your_tavily_api_key'

Ensuite, lancez le serveur :  

python server.py

En quelques secondes, vous verrez que le serveur FastMCP est accessible à l’adresse http://localhost:8000/mcp.

Ouvrez un nouveau terminal et exécutez le script client pour vérifier que tout fonctionne correctement :  

python client.py

Comme vous pouvez le constater, toutes les fonctions, ressources, tools et prompts fonctionnent parfaitement. Notre serveur MCP répond bien, même avec plusieurs requêtes à l’API Tavily.

🚀  Connecting to FastMCP server at: http://localhost:8000/mcp🔗 Testing server connectivity...✅ Server is reachable!🛠️  Available tools:[ Tool(name='search_arxiv', title='Search Arxiv', description='Queries ArXiv via Tavily, returning title + link for each paper,\nand *only* ArXiv results.', inputSchema={'properties': {'query': {'title': 'Query', 'type': 'string'}, 'max_results': {'default': 5, 'title': 'Max Results', 'type': 'integer'}}, 'required': ['query'], 'type': 'object'}, outputSchema={'properties': {'result': {'items': {'additionalProperties': True, 'type': 'object'}, 'title': 'Result', 'type': 'array'}}, 'required': ['result'], 'title': '_WrappedResult', 'type': 'object', 'x-fastmcp-wrap-result': True}, annotations=ToolAnnotations(title='Search Arxiv', readOnlyHint=None, destructiveHint=None, idempotentHint=None, openWorldHint=None), meta=None),  Tool(name='summarize_paper', title='Summarize Paper', description='Returns a one-paragraph summary of the paper at the given URL.', inputSchema={'properties': {'paper_url': {'title': 'Paper Url', 'type': 'string'}}, 'required': ['paper_url'], 'type': 'object'}, outputSchema={'properties': {'result': {'title': 'Result', 'type': 'string'}}, 'required': ['result'], 'title': '_WrappedResult', 'type': 'object', 'x-fastmcp-wrap-result': True}, annotations=ToolAnnotations(title='Summarize Paper', readOnlyHint=None, destructiveHint=None, idempotentHint=None, openWorldHint=None), meta=None)]📚 Available resources:[ Resource(name='arxiv_topics', title=None, uri=AnyUrl('resource://ai/arxiv_topics'), description=None, mimeType='text/plain', size=None, annotations=None, meta=None)]💬 Available prompts:[ Prompt(name='explore_topic_prompt', title=None, description=None, arguments=[PromptArgument(name='topic', description=None, required=True)], meta=None)]📖 Fetching resource: resource://ai/arxiv_topicsToday's AI topics:  1. Transformer interpretability  2. Efficient large-scale model training  3. Federated learning privacy  4. Neural network pruning🔍 Testing tool: search_arxiv  1. Transformer Interpretability Beyond Attention Visualization     https://arxiv.org/abs/2012.09838  2. A Practical Review of Mechanistic Interpretability for ...     https://arxiv.org/abs/2407.02646  3. Mechanistic Interpretability of Fine-Tuned Vision ...     https://arxiv.org/abs/2503.18762📝 Testing tool: summarize_paperSummary of first paper: The paper proposes a novel method for interpreting Transformer networks beyond attention visualization, introducing a new way to compute relevancy. It aims to enhance interpretability in vision tasks. The method is shown to provide more accurate insights into model decisions.🚀 Testing prompt: explore_topic_promptGenerated prompt:USER: type='text' text="I want to explore recent work on 'Transformer interpretability'.\n1. Call the 'Search Arxiv' tool to find the 5 most recent papers.\n2. For each paper URL, call 'Summarize Paper' to extract its key contributions.\n3. Combine all summaries into an overview report." annotations=None meta=None

Intégrer le serveur MCP dans Cursor AI

Laissez le serveur MCP actif, car nous allons l’intégrer à l’éditeur de code Cursor AI. 

1. Allez dans « Settings ».
2. Cliquez sur l’onglet « Tools & Integrations ».
3. Cliquez sur le bouton « New MCP Server ».
4. Ajoutez la configuration suivante :

{  "mcpServers": {    "ArxivExplorer": {      "url": "http://127.0.0.1:8000/mcp/"    }  }}

Une fois le fichier mcp.json enregistré avec cette configuration, vous verrez le nouveau serveur MCP apparaître dans la section « Tools & Integrations », qui affichera deux outils comme ci-dessous.

Tester le serveur MCP dans Cursor AI

Passons à la pratique. Voyons comment notre serveur MCP se comporte dans l’éditeur de code Cursor AI. Nous allons apprendre à utiliser des prompts pour invoquer des outils, accéder aux ressources et exécuter des prompts personnalisés, le tout depuis l’éditeur.

1. Tester les ressources

Commencez par vérifier que votre serveur MCP sait fournir des données utiles via ses ressources.

Prompt : « what are the some popular arxiv topics »

Si tout est correctement configuré, le modèle d’IA comprendra votre demande et récupérera automatiquement la liste des sujets depuis l’endpoint de ressource de votre serveur MCP.

2. Tester les outils individuellement

Essayons maintenant les outils exposés via MCP. Nous testerons d’abord l’outil search_arxiv en demandant au modèle d’IA de lister les dix meilleurs articles sur les grands modèles de langage.  

Prompt : « Please search for the top 10 research papers on large language models. »

L’IA appellera l’outil search_arxiv, et vous devriez obtenir une liste rapide et précise d’articles pertinents, directement issue d’arXiv.

Ensuite, testons l’outil de synthèse qui prend l’URL d’un article et renvoie un résumé du rapport.  

Prompt : « Please summarize the following paper for me: https://arxiv.org/abs/2402.06196 »

L’outil de synthèse récupérera l’article et renverra un résumé concis.

3. Tester le prompt

Nous allons maintenant invoquer un prompt personnalisé du MCP qui nous aidera à générer un rapport.

Prompt : « Create a report on Quantum computing using the latest work. »

En regardant le code du serveur, vous constaterez que le modèle d’IA comprend la tâche et utilise la fonction explore_topic_prompt.

@mcp.promptdef explore_topic_prompt(topic: str) -> str:    return (        f"I want to explore recent work on '{topic}'.\n"        f"1. Call the 'Search Arxiv' tool to find the 5 most recent papers.\n"        f"2. For each paper URL, call 'Summarize Paper' to extract its key contributions.\n"        f"3. Combine all summaries into an overview report."    )

Il appellera d’abord l’outil « Search Arxiv » pour trouver les liens vers les articles. 

Puis il transmettra les liens à l’outil « Summarize Paper » un par un pour générer les synthèses. Enfin, il créera le rapport.

Conclusion

FastMCP 2.0 offre bien plus qu’un moyen simple de créer des serveurs MCP. C’est un framework robuste pour concevoir des intégrations d’IA sécurisées, modulaires et évolutives. Avec des fonctions comme l’authentification, le proxy avancé (permettant à un serveur FastMCP de servir de frontal à un autre) et la possibilité de combiner plusieurs serveurs FastMCP dans une même application via le montage et l’import, vous pouvez architecturer des systèmes complexes et maintenables en toute simplicité.

La prise en charge de middleware permet d’ajouter des fonctionnalités transverses, comme la journalisation ou la modification de requêtes, à l’ensemble des requêtes et réponses MCP. Vous pouvez aussi renvoyer des messages de log et des mises à jour de progression vers les clients via le contexte MCP, ce qui facilite le suivi et la gestion des opérations de longue durée.

Dans ce tutoriel, nous avons appris à construire un serveur MCP pleinement fonctionnel et à tester ses fonctionnalités. Ces outils et le protocole MCP deviennent des éléments essentiels des applications d’IA modernes, permettant aux LLM d’accomplir des tâches plus avancées et d’automatiser les workflows plus efficacement. 

Pour poursuivre votre apprentissage sur les serveurs MCP, consultez nos autres ressources :

• Model Context Protocol (MCP) : guide avec projet démo
• Top 10 des serveurs et clients MCP pour automatiser les workflows d’IA en 2025
• Gradio MCP Server : créer, tester, déployer et intégrer
• Créer un agent d’IA avec LangGraph et le Model Context Protocol
• Chrome DevTools MCP : automatisation et débogage du navigateur avec l’IA