Talki Academy
TutorielDébutant22 min de lecture

Serveurs MCP : Créez Votre Premier Serveur en 20 Minutes

MCP (Model Context Protocol) vous permet de donner à Claude des outils personnalisés : vos bases de données, vos APIs, vos fichiers. Ce tutoriel vous guide pas à pas pour créer un serveur MCP Notion en Python : installation, code complet, connexion à Claude Desktop, tests en conditions réelles et workflow d'automatisation n8n. Aucune connaissance préalable de MCP requise.

Par Talki Academy·Publié le 9 avril 2026

Qu'est-ce que MCP et Pourquoi Créer un Serveur ?

MCP (Model Context Protocol) est un standard ouvert développé par Anthropic fin 2024. Il définit comment les assistants IA communiquent avec des outils et des sources de données externes. Avant MCP, intégrer Claude à vos propres systèmes nécessitait du prompt engineering personnalisé, le parsing manuel des sorties et du code fragile pour chaque intégration. MCP standardise tout ça avec un protocole propre.

Imaginez une prise de courant standard : elle n'a pas besoin de connaître l'appareil branché. MCP est cette prise pour les outils IA. Vous construisez un serveur qui expose des capacités (lire une page Notion, interroger une base de données, envoyer un message Slack) et n'importe quel client MCP compatible — Claude, VS Code Copilot, Cursor — peut utiliser ces capacités sans configuration supplémentaire.

Ce que vous allez construire dans ce tutoriel

Un serveur MCP Python qui connecte Claude à votre workspace Notion. Claude pourra chercher des pages, lire du contenu, créer des notes et mettre à jour des pages — tout ça en conversation naturelle. Vous configurerez aussi un workflow n8n qui déclenche ce serveur automatiquement.

L'architecture MCP en 30 secondes

Trois composants interagissent dans chaque configuration MCP :

  • Host — le client IA (Claude Desktop, VS Code, Cursor) qui orchestre tout
  • Client — le client MCP intégré au Host qui gère les connexions aux serveurs
  • Server — votre programme qui expose des outils, ressources et prompts à l'IA

La communication se fait via JSON-RPC 2.0 en stdio (sous-processus local) ou HTTP/SSE (serveur distant). Le LLM n'appelle jamais directement votre API — le serveur MCP agit comme un intermédiaire contrôlé et sandboxé.

CapacitéSans MCPAvec MCP
Intégration NotionParser la sortie de Claude, détecter l'intention, appeler l'API Notion, gérer les erreursDéfinir les outils une fois, Claude les appelle automatiquement
Workflows multi-outilsLogique d'orchestration complexe, gestion d'état manuelleClaude décide de l'ordre et des arguments nativement
RéutilisabilitéCode couplé à un seul prompt ou une seule appLe même serveur fonctionne dans Claude Desktop, VS Code, Cursor, n8n
SécuritéDifficile d'auditer ce à quoi le LLM a accèsListe d'outils explicite, exécution sandboxée, pas d'accès API direct depuis le LLM

Cas d'Usage Réel : Notion + Claude

Notion est utilisé par des millions d'équipes comme base de connaissances, outil de gestion de projet et wiki personnel. Le problème : chercher et mettre à jour Notion manuellement interrompt votre flux de travail. Vous changez d'application, naviguez vers la bonne base de données, trouvez la bonne page — et vous avez perdu le fil de vos pensées.

Avec un serveur MCP Notion, vous restez dans Claude et dites simplement :

Vous :
Trouve mes notes de réunion de mardi dernier et résume les points d'action.
Claude (utilise les outils MCP) :
J'ai trouvé "Sync Équipe — 1er avril 2026" dans votre base Meeting Notes. Voici les points d'action :

1. Alexandre : finaliser le schéma API avant le 5 avril (responsable : Alexandre)
2. Sophie : livrer les maquettes onboarding v2 (échéance : 8 avril)
3. Thomas : planifier la revue d'architecture avec toute l'équipe

Voulez-vous que je crée des tâches dans votre Project Tracker pour chacun de ces points ?

Le serveur MCP gère les appels API Notion de façon transparente — Claude reçoit le contenu des pages comme résultats d'outils et applique son raisonnement par-dessus.

Prérequis

Avant de commencer, assurez-vous d'avoir :

  • Python 3.11+ — vérifiez avec python --version
  • Claude Desktop installé — télécharger ici
  • Un compte Notion — le plan gratuit fonctionne parfaitement
  • Bases de Python — fonctions, dictionnaires, async/await
# Vérifier la version Python python --version # → Python 3.11.8 (ou supérieur) pip --version # → pip 24.0 # Si Python n'est pas installé : # macOS : brew install python@3.11 # Ubuntu : sudo apt install python3.11 python3.11-venv # Windows : télécharger depuis python.org

Installer le SDK Python MCP

Étape 1 : Créer un environnement virtuel

# Créer le dossier du projet mkdir notion-mcp-serveur cd notion-mcp-serveur # Créer l'environnement virtuel (isole les dépendances) python -m venv venv # L'activer source venv/bin/activate # macOS / Linux # venv\Scripts\activate.bat # Windows # Vérifier l'activation — le prompt doit afficher (venv) which python # → /chemin/vers/notion-mcp-serveur/venv/bin/python

Étape 2 : Installer les dépendances

# Installer le SDK MCP avec support FastMCP pip install "mcp[cli]>=1.4.0" # Installer le client Notion pip install notion-client>=2.2.1 # Vérifier pip show mcp # → Name: mcp # → Version: 1.4.x pip show notion-client # → Name: notion-client # → Version: 2.2.x
Pourquoi FastMCP ? Le SDK officiel MCP Python propose deux APIs : la classe bas niveau Server (verbeux mais flexible) et FastMCP (basé sur des décorateurs, 3× moins de code). Ce tutoriel utilise FastMCP. Les deux sont production-ready.

Étape 3 : Obtenir votre clé API Notion

  1. Allez sur notion.so/my-integrations
  2. Cliquez sur "Nouvelle intégration"
  3. Nommez-la "Claude MCP", sélectionnez votre workspace, cliquez Enregistrer
  4. Copiez le Token d'intégration interne (commence par secret_...)
  5. Ouvrez les pages/bases Notion que vous voulez que Claude utilise → menu "..."Connexions → ajouter "Claude MCP"
Important : Claude ne peut accéder qu'aux pages que vous partagez explicitement avec l'intégration. C'est voulu — cela évite l'accès accidentel à des notes privées. Partagez uniquement les bases de données ou pages que vous souhaitez que Claude lise et modifie.

Créer le Serveur MCP Notion

Créez serveur.py dans votre dossier de projet. Le code complet ci-dessous définit 5 outils : chercher des pages, lire une page, créer une page, lister les bases de données et ajouter du contenu à une page. Chaque outil est une fonction async Python décorée avec @mcp.tool().

# serveur.py import asyncio import os from mcp.server.fastmcp import FastMCP from notion_client import AsyncClient # Initialiser le serveur FastMCP mcp = FastMCP("Assistant Notion") # Initialiser le client Notion # Définissez la variable d'environnement NOTION_API_KEY avant de lancer notion = AsyncClient(auth=os.environ["NOTION_API_KEY"]) # ── OUTIL 1 : Rechercher des pages ──────────────────────────────────────────── @mcp.tool() async def rechercher_notion(requete: str) -> str: """Chercher des pages et bases de données dans Notion par mot-clé. Args: requete: Le terme de recherche (ex : "notes réunion", "suivi projets") Returns: Une liste des pages correspondantes avec titre et URL. """ response = await notion.search(query=requete, page_size=10) if not response["results"]: return f"Aucun résultat pour '{requete}'" lignes = [f"Trouvé {len(response['results'])} résultat(s) pour '{requete}' :\n"] for item in response["results"]: type_item = item["object"] if type_item == "page": titre = _obtenir_titre_page(item) url = item.get("url", "") lignes.append(f"- [Page] {titre}\n URL : {url}\n ID : {item['id']}") elif type_item == "database": titre = item.get("title", [{}])[0].get("plain_text", "Sans titre") url = item.get("url", "") lignes.append(f"- [Base] {titre}\n URL : {url}\n ID : {item['id']}") return "\n".join(lignes) # ── OUTIL 2 : Lire une page ─────────────────────────────────────────────────── @mcp.tool() async def lire_page(page_id: str) -> str: """Lire le contenu complet d'une page Notion. Args: page_id: L'identifiant de la page Notion (issu des résultats de recherche ou de l'URL) Returns: Le titre de la page et tout son contenu textuel, bloc par bloc. """ # Nettoyer l'ID (supprimer les tirets si besoin) page_id = page_id.replace("-", "") # Récupérer les métadonnées de la page page = await notion.pages.retrieve(page_id=page_id) titre = _obtenir_titre_page(page) # Récupérer tous les blocs (contenu de la page) blocs_response = await notion.blocks.children.list(block_id=page_id) blocs = blocs_response["results"] lignes = [f"# {titre}\n"] for bloc in blocs: type_bloc = bloc["type"] if type_bloc == "paragraph": texte = _extraire_texte_riche(bloc["paragraph"]["rich_text"]) if texte: lignes.append(texte) elif type_bloc in ("heading_1", "heading_2", "heading_3"): niveau = type_bloc[-1] texte = _extraire_texte_riche(bloc[type_bloc]["rich_text"]) lignes.append(f"{'#' * int(niveau)} {texte}") elif type_bloc == "bulleted_list_item": texte = _extraire_texte_riche(bloc["bulleted_list_item"]["rich_text"]) lignes.append(f"- {texte}") elif type_bloc == "numbered_list_item": texte = _extraire_texte_riche(bloc["numbered_list_item"]["rich_text"]) lignes.append(f"• {texte}") elif type_bloc == "to_do": texte = _extraire_texte_riche(bloc["to_do"]["rich_text"]) coche = "✅" if bloc["to_do"]["checked"] else "☐" lignes.append(f"{coche} {texte}") elif type_bloc == "code": texte = _extraire_texte_riche(bloc["code"]["rich_text"]) lang = bloc["code"].get("language", "") lignes.append(f"\n```{lang}\n{texte}\n```\n") return "\n".join(lignes) # ── OUTIL 3 : Créer une nouvelle page ──────────────────────────────────────── @mcp.tool() async def creer_page( parent_id: str, titre: str, contenu: str, ) -> str: """Créer une nouvelle page dans une base Notion ou comme sous-page. Args: parent_id: ID de la base ou page parente titre: Titre de la nouvelle page contenu: Contenu textuel de la page (texte brut, double saut de ligne pour les paragraphes) Returns: Confirmation avec l'URL de la page créée. """ parent_id = parent_id.replace("-", "") # Déterminer si le parent est une base ou une page try: await notion.databases.retrieve(database_id=parent_id) parent = {"database_id": parent_id} propriete_titre = "Name" # Propriété titre par défaut dans les bases except Exception: parent = {"page_id": parent_id} propriete_titre = "title" # Construire les blocs à partir du contenu blocs = [] for paragraphe in contenu.split("\n\n"): paragraphe = paragraphe.strip() if paragraphe: blocs.append({ "object": "block", "type": "paragraph", "paragraph": { "rich_text": [{"type": "text", "text": {"content": paragraphe}}] } }) # Créer la page response = await notion.pages.create( parent=parent, properties={ propriete_titre: { "title": [{"type": "text", "text": {"content": titre}}] } }, children=blocs, ) url = response.get("url", "") return f"✅ Page '{titre}' créée avec succès.\nURL : {url}\nID : {response['id']}" # ── OUTIL 4 : Lister les bases de données ──────────────────────────────────── @mcp.tool() async def lister_bases() -> str: """Lister toutes les bases Notion partagées avec cette intégration. Returns: Noms et IDs de toutes les bases accessibles. """ response = await notion.search( filter={"value": "database", "property": "object"}, page_size=20 ) if not response["results"]: return "Aucune base trouvée. Assurez-vous d'avoir partagé au moins une base avec l'intégration." lignes = [f"Trouvé {len(response['results'])} base(s) :\n"] for db in response["results"]: titre = db.get("title", [{}])[0].get("plain_text", "Sans titre") db_id = db["id"] url = db.get("url", "") lignes.append(f"- {titre}\n ID : {db_id}\n URL : {url}") return "\n".join(lignes) # ── OUTIL 5 : Ajouter du contenu à une page ────────────────────────────────── @mcp.tool() async def ajouter_a_page(page_id: str, contenu: str) -> str: """Ajouter du contenu textuel à une page Notion existante. Args: page_id: ID de la page à modifier contenu: Texte à ajouter (double saut de ligne pour les paragraphes) Returns: Message de confirmation. """ page_id = page_id.replace("-", "") blocs = [] for paragraphe in contenu.split("\n\n"): paragraphe = paragraphe.strip() if paragraphe: blocs.append({ "object": "block", "type": "paragraph", "paragraph": { "rich_text": [{"type": "text", "text": {"content": paragraphe}}] } }) if not blocs: return "Aucun contenu à ajouter." await notion.blocks.children.append(block_id=page_id, children=blocs) return f"✅ {len(blocs)} paragraphe(s) ajouté(s) à la page {page_id}" # ── Fonctions utilitaires ───────────────────────────────────────────────────── def _obtenir_titre_page(page: dict) -> str: """Extraire le titre d'un objet page Notion.""" properties = page.get("properties", {}) for prop in properties.values(): if prop.get("type") == "title": rich_text = prop.get("title", []) if rich_text: return rich_text[0].get("plain_text", "Sans titre") return "Sans titre" def _extraire_texte_riche(rich_text_array: list) -> str: """Concaténer le texte brut d'un tableau rich_text Notion.""" return "".join(item.get("plain_text", "") for item in rich_text_array) # ── Point d'entrée ──────────────────────────────────────────────────────────── if __name__ == "__main__": mcp.run()

Récapitulatif des 5 outils

OutilCe qu'il faitExemple de prompt
rechercher_notionRecherche plein texte dans pages et bases"Trouve mes notes sur la revue Q1"
lire_pageLit tous les blocs d'une page spécifique"Lis le contenu de ma page roadmap"
creer_pageCrée une page dans une base ou en sous-page"Crée une note de réunion pour le standup d'aujourd'hui"
lister_basesAffiche toutes les bases accessibles"Quelles bases de données j'ai ?"
ajouter_a_pageAjoute du contenu sans écraser la page existante"Ajoute les points d'action à ma note de réunion"

Connecter à Claude Desktop

Étape 1 : Localiser le fichier de configuration

# macOS ~/Library/Application Support/Claude/claude_desktop_config.json # Windows %APPDATA%\Claude\claude_desktop_config.json # Linux ~/.config/Claude/claude_desktop_config.json # Si le fichier n'existe pas, créez-le # (Claude Desktop le crée normalement au premier lancement)

Étape 2 : Ajouter votre serveur à la configuration

Ouvrez claude_desktop_config.json (créez-le s'il n'existe pas) et ajoutez cette configuration. Remplacez les chemins par vos valeurs réelles :

{ "mcpServers": { "assistant-notion": { "command": "/chemin/absolu/notion-mcp-serveur/venv/bin/python", "args": ["/chemin/absolu/notion-mcp-serveur/serveur.py"], "env": { "NOTION_API_KEY": "secret_VOTRE_CLE_API_NOTION_ICI" } } } }
Utilisez des chemins absolus. Claude Desktop lance le serveur comme un sous-processus — les chemins relatifs comme ./venv/bin/python ne fonctionneront pas. Exécutez which python (avec le venv activé) et pwd pour obtenir les chemins absolus corrects.

Étape 3 : Obtenir le bon chemin Python

# Dans votre terminal, avec le venv activé : cd notion-mcp-serveur source venv/bin/activate which python # → /Users/votreprenom/notion-mcp-serveur/venv/bin/python # Obtenir le chemin absolu vers serveur.py pwd # → /Users/votreprenom/notion-mcp-serveur # Chemin complet vers serveur.py : # /Users/votreprenom/notion-mcp-serveur/serveur.py

Étape 4 : Redémarrer Claude Desktop

Quittez complètement Claude Desktop (Cmd+Q sur macOS, pas seulement fermer la fenêtre) et relancez-le. En bas à gauche de la zone de saisie, vous devriez voir une icône d'outils avec "assistant-notion" listé.

L'icône outils n'apparaît pas ? Vérifiez la Developer Console : View → Developer → Developer Console. Cherchez les erreurs "Failed to start server" qui indiquent généralement un mauvais chemin ou une variable d'environnement manquante.

Tester avec de Vraies Conversations

Test 1 : Découvrir vos bases de données

Vous :
Quelles bases de données Notion ai-je à disposition ?
Claude (utilise l'outil lister_bases) :
J'ai trouvé 3 bases de données dans votre workspace Notion :

1. Notes de réunion — ID : abc123...
2. Suivi de projets — ID : def456...
3. Wiki personnel — ID : ghi789...

Laquelle souhaitez-vous explorer ?

Test 2 : Chercher et lire du contenu

Vous :
Cherche mes notes sur le lancement produit et résume les décisions clés.
Claude (utilise rechercher_notion + lire_page) :
J'ai trouvé 2 pages pertinentes. Après lecture des deux, voici les décisions clés de "Lancement Produit Q2" :

• Date de lancement confirmée : 15 mai 2026
• Cible initiale : clients PME sur le marché européen
• Tarification : EUR 49/mois (pas de plan gratuit au lancement)
• Go-to-market : campagne email + 3 webinaires partenaires

Point d'action en attente : revue juridique des Conditions d'Utilisation (responsable : non attribué).

Test 3 : Créer une note structurée

Vous :
Crée une note de réunion dans ma base Notes de réunion pour le standup d'aujourd'hui. Participants : Alice, Bob, Carol. On a discuté : problème de performance API (responsable : Bob, échéance vendredi), maquettes du nouveau flow d'onboarding approuvées, Carol absente la semaine prochaine.
Claude (utilise l'outil creer_page) :
✅ Note de réunion créée : "Standup — 9 avril 2026"
URL : notion.so/votre-workspace/standup-9-avril...

La note inclut les participants, le résumé des échanges et le point d'action (correction performance API, Bob, vendredi).

Automatiser avec n8n

n8n est un outil d'automatisation de workflow open-source (auto-hébergeable, 400+ intégrations) qui permet de déclencher Claude + votre serveur MCP automatiquement. Voici un exemple concret : résumer automatiquement les nouvelles pages ajoutées à une base Notion et poster le résumé sur Slack.

Option A : n8n avec l'API Claude + définitions d'outils (sans serveur HTTP)

Cette approche utilise le nœud Anthropic de n8n pour appeler Claude avec des définitions d'outils qui reproduisent vos outils MCP. Elle fonctionne sans déployer de serveur HTTP.

# Workflow n8n (JSON — importez-le dans votre instance n8n) # Déclencheur : base Notion mise à jour (nouvelle page ajoutée) # Action : Claude lit la page et poste un résumé sur Slack # Étape 1 : Nœud Notion Trigger # - Événement : "Page Added" # - Base : ID de votre base Notes de réunion # Étape 2 : Nœud Anthropic # - Modèle : claude-opus-4-5-20251001 # - Outils : définir en ligne l'outil de lecture de page Notion # - Prompt système : "Tu es un assistant de réunion. Résume les notes # et extrais : date, participants, décisions, points d'action." # - Message utilisateur : "Résume cette page de réunion : {{ $json.id }}" # Étape 3 : Nœud Slack # - Canal : #résumés-réunions # - Message : "{{ $json.message.content[0].text }}" # Définition de l'outil pour lire une page dans le nœud Anthropic : { "name": "lire_page_notion", "description": "Lire le contenu d'une page Notion", "input_schema": { "type": "object", "properties": { "page_id": {"type": "string", "description": "L'identifiant de la page Notion"} }, "required": ["page_id"] } }

Option B : Exposer le serveur MCP en HTTP (partage d'équipe)

FastMCP supporte le transport HTTP/SSE avec une seule modification. Cela permet à n8n, à d'autres membres de l'équipe et aux workflows distants de se connecter à votre serveur :

# serveur.py — variante transport HTTP # Remplacez la dernière ligne par : if __name__ == "__main__": # stdio local (pour Claude Desktop) : # mcp.run() # HTTP/SSE (pour n8n, accès distant, partage d'équipe) : mcp.run(transport="sse", host="0.0.0.0", port=8000) # Lancer : # python serveur.py # → Serveur MCP démarré sur http://0.0.0.0:8000 # Tester l'endpoint SSE : # curl http://localhost:8000/sse

Une fois lancé, configurez le nœud MCP Client de n8n (disponible depuis n8n 1.60+) pour se connecter à http://votre-serveur:8000/sse. Vos cinq outils Notion apparaissent automatiquement — aucune définition manuelle nécessaire.

Workflow n8n pratique : Digest Notion quotidien

Voici un workflow complet qui tourne chaque matin à 8h, lit les pages mises à jour la veille et vous envoie un résumé par email :

Workflow : Digest Notion Quotidien ────────────────────────────────────────────────────────────── 1. Schedule Trigger Cron : 0 8 * * 1-5 # 8h du matin en semaine 2. HTTP Request (chercher pages mises à jour) Méthode : POST URL : http://votre-serveur-mcp:8000/call_tool Body : { "tool": "rechercher_notion", "arguments": {"requete": "last modified:yesterday"} } 3. Split in Batches (traiter chaque page) Taille du lot : 1 4. HTTP Request (lire chaque page) Méthode : POST URL : http://votre-serveur-mcp:8000/call_tool Body : { "tool": "lire_page", "arguments": {"page_id": "{{ $json.id }}"} } 5. Nœud Anthropic Modèle : claude-haiku-4-5-20251001 (le plus rapide et économique) Prompt : "Résume en 3 points clés : {{ $json.contenu }}" 6. Nœud Gmail / SMTP À : vous@votreentreprise.com Objet : "Digest Notion Quotidien — {{ $today }}" Corps : Résumés agrégés de l'étape 5 Coût estimé : ~0,002 €/jour (tarification Haiku, moyenne 10 pages)

Troubleshooting

SymptômeCause probableSolution
Serveur absent de Claude DesktopChemin relatif dans la config ou Claude pas redémarré complètementUtilisez des chemins absolus. Quittez avec Cmd+Q (pas fermer la fenêtre), relancez
ModuleNotFoundError: mcpMauvais chemin Python — pointe vers Python système et non le venvLancez which python avec le venv activé, utilisez ce chemin dans la config
APIResponseError: unauthorizedClé API Notion incorrecte ou absenteVérifiez que NOTION_API_KEY dans la config correspond à la clé de notion.so/my-integrations
Claude dit "Je n'ai pas accès à cette page"Page non partagée avec l'intégrationOuvrez la page dans Notion → menu "..." → Connexions → ajouter "Claude MCP"
Outils visibles mais appels toujours en échecServeur qui plante silencieusement au démarrageLancez python serveur.py directement dans le terminal pour voir l'erreur réelle
Serveur HTTP OK mais stdio ne fonctionne pasConfigurations de transport différentesAssurez-vous que mcp.run() (sans args) pour stdio ; mcp.run(transport="sse") pour HTTP

Mode debug : voir chaque appel d'outil

# Ajouter en haut de serveur.py pour les logs verbeux import logging logging.basicConfig(level=logging.DEBUG) # Ou consulter les logs Claude Desktop : # macOS : ~/Library/Logs/Claude/mcp-server-assistant-notion.log # Windows : %APPDATA%\Claude\Logs\ # Tester le serveur manuellement : NOTION_API_KEY=secret_xxx python serveur.py # → Doit afficher : "Starting MCP server 'Assistant Notion'" # → Si crash immédiat, le message d'erreur indique exactement ce à corriger

Prochaines Étapes

Étendre votre serveur Notion

  • Requêter les bases — utilisez notion.databases.query() pour filtrer par propriétés (ex : "toutes les tâches dues cette semaine")
  • Mettre à jour les propriétés — changer statut, responsable, date limite sur les éléments d'une base
  • Opérations en lot — archiver plusieurs pages, déplacer des éléments entre bases
  • Webhooks — les webhooks Notion (bêta) déclenchent des workflows n8n en temps réel

Créer d'autres serveurs MCP

  • MCP GitHub — chercher des issues, créer des PR, commenter des reviews depuis Claude
  • MCP PostgreSQL — requêtes en langage naturel avec asyncpg
  • MCP Slack — chercher des messages, poster dans des canaux, créer des canvases
  • MCP Email — lire/envoyer des emails via l'API Gmail ou IMAP

Il existe plus de 2 000 serveurs MCP open-source déjà disponibles. Consultez le registre officiel MCP avant de repartir de zéro.

Aller plus loin avec l'API Claude

Ce tutoriel utilise Claude Desktop pour les tests locaux. Pour les systèmes en production — applications multi-utilisateurs, pipelines automatisés, interfaces personnalisées — vous intégrerez directement avec l'API Claude. Notre formation Claude API pour Développeurs couvre l'API complète (Messages, Tool Use, streaming), les patterns MCP avancés et le déploiement en production. 3 jours, financement OPCO disponible.

Questions Fréquentes

Dois-je maîtriser Python pour créer un serveur MCP ?

Un niveau basique suffit : si vous comprenez les fonctions, les dictionnaires et async/await, ce tutoriel est accessible. La syntaxe FastMCP (décorateurs @mcp.tool()) est volontairement simple. Si vous préférez TypeScript, le SDK officiel MCP TypeScript propose une API très similaire.

L'API Notion est-elle gratuite ?

Oui. L'API publique Notion est gratuite sans limite d'usage pour un usage personnel ou d'équipe raisonnable. Vous créez une intégration gratuite sur notion.so/my-integrations, récupérez une clé API et partagez les pages de votre choix avec l'intégration. Aucune carte bancaire requise.

Ce serveur MCP fonctionne-t-il avec d'autres outils que Claude Desktop ?

Oui. MCP est un standard ouvert. Votre serveur fonctionne avec tous les clients MCP compatibles : VS Code (extension Copilot Chat + MCP), Cursor, Windsurf, Zed, JetBrains IDEs. Pour l'automatisation n8n, exposez le serveur en transport HTTP/SSE et appelez-le depuis n'importe quel outil d'orchestration.

Quelle différence entre MCP et appels directs à l'API Notion ?

MCP est un protocole de communication entre un assistant IA et des fournisseurs d'outils. Sans MCP, vous devez parser les sorties de Claude, détecter l'intention, appeler l'API Notion et gérer les erreurs manuellement. Avec MCP, Claude choisit lui-même quels outils appeler et formate les arguments — vous ne faites que définir les outils. Cela élimine environ 80 % du code de glue et rend le système robuste aux variations de prompt.

Comment passer du transport local (stdio) au transport HTTP pour la production ?

FastMCP supporte les deux transports avec une seule modification. Pour HTTP/SSE : remplacez `mcp.run()` par `mcp.run(transport='sse', host='0.0.0.0', port=8000)`. Configurez ensuite Claude Desktop ou n8n pour pointer vers `http://votre-serveur:8000/sse` au lieu de lancer un sous-processus. Cela permet de partager le serveur avec toute une équipe.

Maîtrisez MCP et l'API Claude en 3 Jours

Formation pratique pour développeurs. Financement OPCO disponible — reste à charge potentiel : 0 EUR.

Voir la Formation Claude APIVérifier Éligibilité OPCO