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 MCP
Avec MCP
Intégration Notion
Parser la sortie de Claude, détecter l'intention, appeler l'API Notion, gérer les erreurs
Définir les outils une fois, Claude les appelle automatiquement
Claude décide de l'ordre et des arguments nativement
Réutilisabilité
Code couplé à un seul prompt ou une seule app
Le même serveur fonctionne dans Claude Desktop, VS Code, Cursor, n8n
Sécurité
Difficile d'auditer ce à quoi le LLM a accès
Liste 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.
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.
Copiez le Token d'intégration interne (commence par secret_...)
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
Outil
Ce qu'il fait
Exemple de prompt
rechercher_notion
Recherche plein texte dans pages et bases
"Trouve mes notes sur la revue Q1"
lire_page
Lit tous les blocs d'une page spécifique
"Lis le contenu de ma page roadmap"
creer_page
Crée une page dans une base ou en sous-page
"Crée une note de réunion pour le standup d'aujourd'hui"
lister_bases
Affiche toutes les bases accessibles
"Quelles bases de données j'ai ?"
ajouter_a_page
Ajoute 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 :
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ôme
Cause probable
Solution
Serveur absent de Claude Desktop
Chemin relatif dans la config ou Claude pas redémarré complètement
Utilisez des chemins absolus. Quittez avec Cmd+Q (pas fermer la fenêtre), relancez
ModuleNotFoundError: mcp
Mauvais chemin Python — pointe vers Python système et non le venv
Lancez which pythonavec le venv activé, utilisez ce chemin dans la config
APIResponseError: unauthorized
Clé API Notion incorrecte ou absente
Vé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égration
Ouvrez la page dans Notion → menu "..." → Connexions → ajouter "Claude MCP"
Outils visibles mais appels toujours en échec
Serveur qui plante silencieusement au démarrage
Lancez python serveur.py directement dans le terminal pour voir l'erreur réelle
Serveur HTTP OK mais stdio ne fonctionne pas
Configurations de transport différentes
Assurez-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.