MCP Architect

Ce que fait ce skill

• Conçoit un serveur MCP à partir d'une description : primitifs (tools/resources/prompts), surface à moindre privilège
• Écrit des **schémas d'outils corrects** (JSON Schema 2020-12), descriptions, schémas de sortie et annotations honnêtes
• Génère du code exécutable pour **Python (FastMCP)** ou **TypeScript (SDK)** — avec un stdout propre
• Choisit le **transport** (stdio local / Streamable HTTP distant) et planifie **OAuth 2.1** pour le distant
• Guide les **tests** (MCP Inspector) et les échecs courants (le classique stdout « disconnected »)
• Génère un **`server.json`** valide et accompagne la publication au Registre MCP officiel
• Deux scripts Node défensifs : **générateur de serveur** + **validateur server.json** (sans dépendances)

Description

MCP Architect est un skill pour construire des serveurs Model Context Protocol (MCP) — il transforme une description (« laisse Claude interroger notre Postgres », « expose notre API en outils ») en un serveur MCP bien conçu, sûr et **exécutable**. La règle centrale : **un serveur MCP ne vaut que ses schémas d'outils** — environ 80 % de la qualité. Il conçoit donc l'interface d'abord, puis le code : les bons **primitifs** (tools, resources, prompts — seulement ce dont le cas d'usage a besoin), des noms clairs, des **descriptions lisibles par le modèle**, des schémas d'entrée contraints (JSON Schema 2020-12, racine objet — jamais une `url`/`path`/`cmd` libre sur une action puissante), des sorties structurées, et des **annotations** honnêtes (readOnly/destructive/idempotent/openWorld — des indices informatifs, pas une frontière de sécurité). Il connaît la réalité de la **spec 2026-07-28** : un cœur stateless, **stdout est le canal JSON-RPC** (un seul `print()` casse le serveur → « disconnected », d'où les logs sur stderr), **Streamable HTTP** plutôt que le transport SSE déprécié, et que Roots/Sampling/Logging sont dépréciés. Il choisit le **transport** selon la complexité : stdio pour le local (pas d'auth), Streamable HTTP pour le distant — puis **OAuth 2.1 bien fait** (resource server, métadonnées RFC 9728, resource indicators RFC 8707, PKCE S256, validation de l'`aud`, validation de l'Origin, bind sur 127.0.0.1 en local). Il génère du code exécutable pour **Python (FastMCP 2.x)** ou **TypeScript (@modelcontextprotocol/sdk)** — avec deux scripts Node fournis, sans dépendances : un **générateur de serveur** (starter correct avec stdout propre, schéma, annotations) et un **validateur server.json** pour le **Registre MCP** officiel. Les tests passent par le **MCP Inspector** ; la publication via `server.json` + Registre. Il est **verify-live** (MCP change chaque mois → spec/SDK à jour avec version), n'invente aucun détail d'API et est **secure-by-design** (moindre privilège, validations humaines) — pour l'audit de sécurité approfondi d'un serveur fini, il renvoie vers **Agent Warden**.

Exemples

Testé avec Claude Code

import logging, sys; logging.basicConfig(stream=sys.stderr)   # logs sur stderr — stdout est du JSON-RPC
from fastmcp import FastMCP
mcp = FastMCP("pg-reader")

REPORTS = {"active_users": "select id,email from users where active"}  # allow-list, paramétré

@mcp.tool(annotations={"readOnlyHint": True, "openWorldHint": True})
def run_report(report: str, limit: int = 100) -> str:
    """Exécute un rapport pré-approuvé, en lecture seule."""
    if report not in REPORTS: return f"Erreur : rapport inconnu. Disponibles : {', '.join(REPORTS)}"
    return "(stub) lignes…"

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

Ce qu’il ne fait pas

• **Pas d'hébergement/runtime** — il conçoit et génère ; l'exécution/déploiement t'incombe
• **Pas un auditeur de sécurité** — pour l'audit approfondi d'un serveur fini (injection de prompt, tool poisoning, agentivité excessive) → Agent Warden
• **N'invente aucun détail de spec/API** — MCP change chaque mois, verify-live avec version
• **Pas d'ingénierie backend/API classique** au-delà de la couche MCP, ni de construction de client/agent

Compatibilité & technique

Testé (interne)

3 scénarios

Runtime recommandé

Claude Opus ou Sonnet ; avec accès web pour le verify-live face aux API de la spec/SDK MCP actuelles. Les scripts nécessitent Node (sans paquets) ; sans Node, le skill produit le code/les métadonnées à la main depuis les références.

Modes

Design (façonner l'interface) · Génération / build (produire du code) · Design d'outils (schéma, annotations, erreurs) · Auth & transport · Publication (server.json / Registre)

Entrées

description du serveur souhaité · spéc API / base de données / outil · code de serveur MCP existant (à améliorer) · préférence de langage/SDK (Python/TypeScript)

Format de sortie

Design du serveur MCP (primitifs + tableau d'outils) + code exécutable (Python/TypeScript) + plan auth/transport + étapes de test et publication

Sous-catégorie

Serveurs MCP & intégration d'outils IA

Licence

Proprietär

Profil de sécurité

Contenu livré

• mcp-architect-1.0.0/11 fichiers
  • .claude-plugin/marketplace.json
  • plugins/mcp-architect/skills/mcp-architect/11 fichiers

    • SKILL.md
    • manifest.json
    • references/7 fichiers

      • mcp-architect-auth-transport.md
      • mcp-architect-publish.md
      • mcp-architect-python-fastmcp.md
      • mcp-architect-spec.md
      • mcp-architect-test-debug.md
      • mcp-architect-tool-design.md
      • mcp-architect-typescript-sdk.md
    • scripts/2 fichiers

      • scaffold-mcp.mjs
      • validate-server-json.mjs
  • .agents/skills/mcp-architect/→ universel — même contenu (Codex, Cursor, Copilot, Gemini, Windsurf, Cline)
  • LICENSE.txt

Installation

Aussi comme prompt de chat

Remarque

MCP évolue chaque mois — avec accès web, MCP Architect vérifie la spec actuelle (modelcontextprotocol.io) et les API des SDK en direct et cite la version (ce skill vise la spec 2026-07-28). Il conçoit et génère ; l'exécution/déploiement du serveur t'incombe. Pour un audit de sécurité approfondi d'un serveur fini → Agent Warden. Les scripts fournis nécessitent Node (sans paquets).

Journal des modifications

• v1.0.021.08.2026Première version : transforme une description en un serveur MCP (Model Context Protocol) propre, sûr et exécutable. Conçoit les primitifs (tools/resources/prompts), écrit des schémas d'outils + annotations corrects, choisit le transport (stdio vs Streamable HTTP), génère du code Python (FastMCP) ou TypeScript (@modelcontextprotocol/sdk) avec un stdout propre, planifie OAuth 2.1 pour les serveurs distants, et guide les tests (MCP Inspector) et la publication (server.json / Registre officiel). Vise la spec MCP 2026-07-28 (cœur stateless, SSE déprécié). Deux scripts Node (générateur de serveur, linter server.json), 7 références. Verify-live ; audit de sécurité approfondi → Agent Warden.

Questions fréquentes