MCP OAuth + écosystème étendu

Pourquoi ce module

Entre 2024 et 2026, le Model Context Protocol (MCP) est devenu le standard de facto pour intégrer des outils tiers à Claude. Mais pas juste Anthropic : Cursor, Windsurf, ChatGPT, et maintenant Gemini (Google 2026) implémentent tous MCP. En parallèle, OAuth 2.1 + PKCE renforce la sécurité des connexions utilisateur et des intégrations sensibles, coexistant avec les clés API dans les contextes appropriés. Et la découverte se centralise via le registre officiel (registry.modelcontextprotocol.io) et des marketplaces communautaires (Smithery.ai, Glama).

Pour les devs et intégrateurs, connaître ce paysage évite le couplage technique à Anthropic. Vous apprenez le flux OAuth complet, comment connecter HubSpot / Linear / Slack en sécurité, et comment explorer l'écosystème MCP 2026.

🔄 Révision majeure du protocole (été 2026). La spec stable est 2025-11-25, mais une release candidate (verrouillée le 21 mai 2026) prépare la plus grosse révision depuis le lancement de MCP, avec publication finale prévue le 28 juillet 2026. Voir la section « MCP 2026 : la révision stateless » plus bas — elle change la façon de déployer et de sécuriser un serveur MCP.

Prérequis : compréhension basique OAuth 2.0, avoir suivi M1 (Tool Use), et disposer d'un compte test (Linear, HubSpot, ou autre SaaS compatib MCP).

Objectifs pédagogiques

À l'issue de ce module, vous serez capable de :

1. Comprendre OAuth 2.1 vs 2.0 : pourquoi PKCE est obligatoire, flow Authorization Code complet, refresh token rotation
2. Implémenter un MCP server OAuth : configurer authorization_endpoint, token_endpoint, gérer access tokens + refresh
3. Découvrir et installer des MCP servers : naviguer Smithery.ai, Glama, évaluer la confiance d'un serveur tiers
4. Configurer MCP serveurs commerciaux : HubSpot, Linear, Slack en production avec bonnes pratiques sécurité
5. Comprendre l'interopérabilité multi-client : un même MCP fonctionne dans Claude Code, Cursor, ChatGPT, Gemini
6. Évaluer l'impact A2A protocol Google (2026) et quand l'utiliser vs MCP

Plan détaillé

1. Évolution OAuth 2.0 vers 2.1 : PKCE obligatoire
2. Authorization Code flow étape par étape avec exemples curl
3. Refresh tokens et token rotation
4. Marketplace MCP : Smithery.ai, Glama, MCP Hub (Anthropic officiel)
5. MCP servers commerciaux en production (HubSpot, Linear, Slack, GitHub)
6. Sécurité : deny rules, signatures, audits
7. Adoption multi-client : Cursor, Windsurf, ChatGPT, Gemini
8. Google A2A protocol : quand et comment
9. Atelier : configurer MCP OAuth Linear en production
10. Pièges et best practices

Évolution OAuth 2.0 vers 2.1 : PKCE obligatoire

OAuth 2.0 (2012) : basé sur client_secret statique.

Client A obtient le secret: "abc123xyz789"
↓
Si leak (git expose) = catastrophe

OAuth 2.1 (consolidation du draft IETF, 2024–2025) : client_secret n'est plus recommandé pour clients mobiles/SPA. PKCE obligatoire (Proof Key for Code Exchange, défini par RFC 7636 publiée en 2015).

PKCE flow :

1. Client génère un random string (code_verifier)
   code_verifier = "abcdefghijklmnopqrstuvwxyz123456789"

2. Hash le verifier en SHA256 (code_challenge)
   code_challenge = SHA256(code_verifier) base64url-encoded
   = "LCa0a2j_xo_5m0U8HTBx4_-H8MXvHuVQrZvAKQ318Z4"

3. Redirection auth avec challenge (pas le verifier!)
   https://provider.com/authorize?
     client_id=...
     &code_challenge=LCa0a2j_xo_5m0U8HTBx4_-H8MXvHuVQrZvAKQ318Z4
     &code_challenge_method=S256
     &redirect_uri=...
     &state=xyz

4. User approuve
   ↓ Redirect to http://localhost:3000/callback?code=AUTH_CODE&state=xyz

5. Client échange code + verifier (pas secret)
   POST /token
   {
     "grant_type": "authorization_code",
     "code": "AUTH_CODE",
     "code_verifier": "abcdefghijklmnopqrstuvwxyz123456789",
     "client_id": "...",
     "redirect_uri": "..."
   }
   ↓ Reçois access_token + refresh_token

Avantage PKCE : même si AUTH_CODE leake, sans le code_verifier (jamais transmis en clair), attaquant ne peut pas l'échanger. Sécurité par défaut.

Voici le flux PKCE complet visualisé :

Authorization Code flow étape par étape avec exemples curl

Cas concret : configurer MCP Linear (serveur tiers OAuth).

Étape 1 : Inscrire app dans Linear

Dans Linear → Settings → API → Create OAuth App

Client ID     : linear-mcp-app-123
Client Secret : (skip si PKCE seul)
Redirect URI  : http://localhost:3001/callback
Scopes        : issues:read, issues:write, comments:read

Étape 2 : Générer code_verifier et code_challenge

# Générer verifier (43–128 caractères, alphanumériques + - + _)
code_verifier=$(openssl rand -base64 32 | sed 's/[^a-zA-Z0-9_-]//g' | cut -c1-128)
echo "code_verifier: $code_verifier"

# Générer challenge (SHA256 + base64url)
code_challenge=$(echo -n "$code_verifier" | openssl dgst -sha256 -binary | \
  openssl enc -base64 | sed 's/+/-/g; s#/#_#g; s/=//g')
echo "code_challenge: $code_challenge"

Étape 3 : Redirection utilisateur (authorization endpoint)

client_id="linear-mcp-app-123"
redirect_uri="http://localhost:3001/callback"
state=$(openssl rand -hex 16)

auth_url="https://linear.app/oauth/authorize?\
client_id=${client_id}\
&code_challenge=${code_challenge}\
&code_challenge_method=S256\
&redirect_uri=${redirect_uri}\
&state=${state}\
&response_type=code"

echo "Ouvre ce lien : $auth_url"

Utilisateur clique, approuve les scopes, redirigeance vers http://localhost:3001/callback?code=XXX&state=YYY.

Étape 4 : Échange du code (token endpoint)

auth_code="XXX"  # Du redirect callback

curl -X POST https://linear.app/oauth/token \
  -H "Content-Type: application/json" \
  -d "{
    \"grant_type\": \"authorization_code\",
    \"code\": \"${auth_code}\",
    \"code_verifier\": \"${code_verifier}\",
    \"client_id\": \"${client_id}\",
    \"redirect_uri\": \"${redirect_uri}\"
  }"

Réponse :

{
  "access_token": "lin_tk_abc123...",
  "refresh_token": "lin_ref_xyz789...",
  "expires_in": 3600,
  "token_type": "Bearer"
}

Étape 5 : Utiliser l'access token dans MCP server

curl -H "Authorization: Bearer lin_tk_abc123..." \
  https://api.linear.app/graphql \
  -d '{"query":"{ viewer { id name } }"}'

Refresh tokens et token rotation

Les access_token expirent (ici 1h). Utiliser refresh_token pour renouveler sans user re-approval.

curl -X POST https://linear.app/oauth/token \
  -H "Content-Type: application/json" \
  -d "{
    \"grant_type\": \"refresh_token\",
    \"refresh_token\": \"lin_ref_xyz789...\",
    \"client_id\": \"${client_id}\"
  }"

Réponse : nouvel access_token + nouveau refresh_token (rotation).

Best practice : stocker refresh tokens dans une DB, jamais en code. Et rotate : à chaque refresh, sauvegarder le nouveau token.

// Node.js
async function refreshAccessToken(oldRefreshToken: string) {
  const response = await fetch("https://linear.app/oauth/token", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      grant_type: "refresh_token",
      refresh_token: oldRefreshToken,
      client_id: process.env.LINEAR_CLIENT_ID,
    }),
  });

  const { access_token, refresh_token } = await response.json();

  // Sauvegarder dans DB
  await db.updateToken(userId, {
    access_token,
    refresh_token, // NOUVEAU token — sauvegarder!
    expires_at: Date.now() + 3600 * 1000,
  });

  return access_token;
}

Marketplace MCP : Smithery.ai, Glama, registre officiel

Official MCP Registry (gouvernance Agentic AI Foundation / Linux Foundation)

• URL : https://registry.modelcontextprotocol.io
• Contenu : registre officiel de MCP servers
• Format : registry JSON, installation via mcp.json
• Curation : communauté ; MCP a été donné par Anthropic à la Linux Foundation (Agentic AI Foundation) en décembre 2025 — ce n'est plus un produit Anthropic seul

Smithery.ai (marketplace community-first)

• URL : https://smithery.ai
• Contenu : 200+ MCP servers (payants, gratuits, open-source)
• Features : ratings, usage stats, source code checks
• Installation : guide automatisé

Glama (analytics + marketplace)

• URL : https://glama.ai
• Contenu : stats d'usage, benchmark MCP servers
• Unique : "most popular MCPs last month" dashboard
• Installation : export config for Claude Code

Découverte workflow :

1. Aller sur Smithery.ai
2. Chercher "Linear"
3. Voir rating (4.8/5), dernière mise à jour, code source
4. Cliquer "Install" → génère config mcp.json snippet
5. Ajouter à ~/.claude/mcp.json
6. Redémarrer Claude Code
7. Tester /mcp list → voir "linear" dans liste

MCP servers commerciaux en production

Les principaux serveurs à connaître 2026 :

Setup HubSpot MCP (voir aussi M15 — CRM pipeline) :

npm install -g @hubspot/cli@latest
hs auth          # OAuth interactif
hs mcp setup     # Génère ~/.claude/mcp.json automatiquement

Setup Linear MCP (this atelier) :

// ~/.claude/mcp.json
{
  "mcpServers": {
    "linear": {
      "command": "npx",
      "args": ["-y", "@linear/mcp"],
      "env": {
        "LINEAR_API_KEY": "${LINEAR_API_KEY}",
        "LINEAR_WORKSPACE_ID": "${LINEAR_WORKSPACE_ID}"
      }
    }
  }
}

Sécurité : deny rules, signatures, audits

Deny rules dans settings.json (voir M15) :

{
  "permissions": {
    "tools": {
      "mcp__linear__create_*": "needs-approval",
      "mcp__linear__update_*": "needs-approval",
      "mcp__linear__delete_*": "deny",
      "mcp__linear__search_*": "allow"
    }
  }
}

Code signatures : certains MCP servers 2026 supportent signed binaries (hash SHA256 du code).

Audit trail : tous les tool calls MCP sont loggés automatiquement (Claude Code logs).

Adoption multi-client : Cursor, Windsurf, ChatGPT, Gemini

Un MCP server configuré dans ~/.claude/mcp.json est utilisable dans :

• ✅ Claude Code CLI (Anthropic)
• ✅ Cursor (2024+, même standard)
• ✅ Windsurf (2025+)
• ✅ ChatGPT desktop (support MCP déployé, Developer Mode)
• ✅ Gemini CLI (Google, lancé juin 2025, stable ; déprécié juin 18, 2026 au profit d'Antigravity CLI)

Implication : investir dans un MCP server bien codé paie pour 5 clients simultanément.

Google A2A protocol (2026)

A2A = Agent-to-Agent. Alternative Google à MCP, pour que deux agents IA puissent se parler.

Agent Claude (Anthropic)
    ↓ A2A call via gRPC
    ↓
Agent Vertex AI (Google)
    ↓ retourne résultat
    ↓
Claude reçoit réponse

Quand utiliser A2A vs MCP :

• MCP : intégrer des tools tiers (HubSpot, Linear, etc.)
• A2A : intégrer d'autres agents IA (Vertex AI, Claude Batch agents, etc.)

Status mai 2026 : en production, adopté par 150+ organisations, gouverné directement par la Linux Foundation depuis juin 2025, version 1.2+. (L'Agentic AI Foundation, créée en décembre 2025, fournit une gouvernance parapluie pour plusieurs protocoles d'agents, mais n'est pas le gouverneur direct du protocole A2A.) Docs publiques disponibles (cloud.google.com).

Atelier : configurer MCP OAuth Linear en production (90 min)

Vous configurez un MCP Linear OAuth en production, avec refresh tokens, permissions, et audit logs.

Livrable :

1. App Linear créée dans workspace (Settings → API)
2. ~/.claude/mcp.json configuré avec OAuth code_verifier/challenge
3. Script d'installation : install-linear-mcp.sh qui :
   • Génère code_verifier
   • Ouvre auth URL dans navigateur
   • Capture callback code
   • Échange pour access_token + refresh_token
   • Sauvegarde dans vault / env
4. MCP Linear testé : /mcp list inclut "linear"
5. Permissions restrictives : create/update = needs-approval, delete = deny
6. Audit log pour chaque Linear API call
7. Test : créer une issue, rechercher issues, (ne pas supprimer)

Critères de succès :

• ✅ OAuth flow complet (verifier, challenge, token exchange)
• ✅ Access token stocké en sécurité (env ou vault)
• ✅ Refresh token rotation implemented
• ✅ Permissions bien configurées
• ✅ Audit logs lisibles
• ✅ 2+ MCP calls réussis

Pièges courants

Passage à l'échelle : tool search, PTC, CLI ant

Quand un agent a accès à beaucoup de serveurs MCP (donc des dizaines/centaines d'outils), tout charger en contexte sature et dégrade le choix d'outil. Deux leviers natifs :

• Tool search (server tool) : Claude découvre dynamiquement les outils pertinents au lieu d'avoir tous les schémas en contexte d'emblée. Les schémas découverts sont ajoutés (pas remplacés) → le prompt cache est préservé.
• Programmatic tool calling (PTC) : Claude compose plusieurs appels d'outils dans un script exécuté côté conteneur ; seuls les résultats finaux remontent en contexte (au lieu d'un aller-retour par appel). Idéal pour enchaîner beaucoup d'appels MCP avec de gros résultats intermédiaires à filtrer.

Côté outillage, la CLI ant expose chaque ressource de l'API en sous-commande (ant models list, ant messages create …, ant beta:agents create < agent.yaml). C'est la voie recommandée pour gérer agents/environments/MCP en YAML versionné (Git + CI — control plane), pendant que le SDK pilote les sessions à l'exécution (data plane).

# Définir un agent + ses serveurs MCP en YAML, l'appliquer depuis la CI
AGENT_ID=$(ant beta:agents create < research.agent.yaml --transform id -r)

MCP 2026 : la révision stateless (MCP Apps, Tasks)

La spec 2025-11-25 reste la référence stable, mais la release candidate (verrouillée le 21 mai 2026, publication finale 28 juillet 2026) apporte la plus grosse refonte depuis le lancement. Cinq changements à connaître :

🎯 Impact concret pour vous. (1) Si vous écrivez un serveur MCP, concevez‑le stateless dès maintenant (pas d'état en mémoire de session). (2) Les MCP Apps ouvrent des UI riches côté serveur — mais auditez le HTML servi (sandbox iframe). (3) Pour les jobs longs, basez‑vous sur Tasks plutôt que sur des sessions persistantes. (4) La fenêtre de validation (mai→juillet 2026) sert aux mainteneurs de SDK : les SDK Tier 1 sont censés supporter la RC dans ce délai.

Pour aller plus loin

• 🆕 MCP — Release Candidate 2026-07-28 (blog officiel)
• 📖 MCP Spec 2025-11-25 (stable)
• 📖 RFC 7636 — PKCE (OAuth 2.0 Extension)
• 📖 OAuth 2.1 Specification
• 🔗 Smithery.ai — MCP marketplace
• 🔗 Official MCP Registry (Agentic AI Foundation)
• 🛠 Linear API documentation
• 📘 Cursor MCP Support
• 🎯 Modules complémentaires : M1 Tool Use, M15 CRM pipeline HubSpot