Communitygithub.com

DataShrimp/skills

Guide pour créer des serveurs MCP (Model Context Protocol) de haute qualité permettant aux LLMs d'interagir avec des services externes via des outils bien conçus. À utiliser lors de la construction de serveurs MCP pour intégrer des API ou services externes, que ce soit en Python (FastMCP) ou Node/TypeScript (MCP SDK).

Qu'est-ce que skills ?

Ce skill sert de guide complet et progressif pour la construction de serveurs MCP (Model Context Protocol) de qualité professionnelle. Il couvre l'ensemble du cycle de vie d'un serveur MCP, depuis la recherche et la planification (compréhension du protocole, choix du stack technique TypeScript recommandé, etc.) jusqu'à l'implémentation concrète d'outils avec des schémas d'entrée/sortie, en passant par la création d'évaluations automatisées. Son utilité principale est d'aider les développeurs à concevoir des serveurs MCP qui permettent réellement aux LLMs de résoudre des tâches complexes, en mettant l'accent sur la découverte des outils, la gestion du contexte et les messages d'erreur actionnables. Il supporte les implémentations en Python (via FastMCP) et en TypeScript (via le SDK MCP officiel), et est conçu pour être utilisé par des agents IA comme Claude Code ou Codex, qui peuvent suivre ses instructions étape par étape. Enfin, il inclut des exemples d'intégration avec les systèmes de skills modernes (Claude Code, OpenAI Codex, et le format de script autonome PEP 723).

Compatible avec✓Claude Code✓Codex CLI~Cursor
npx skills add https://github.com/DataShrimp/skills/tree/HEAD/MetaPrompt/02-official-and-frameworks/anthropic-mcp-builder
Voir l'original→Voir toutes les compétences

Demander à votre IA préférée

Ouvre une nouvelle conversation avec cette compétence d'agent déjà préchargée.

OpenAIChatGPTClaudeClaudeGeminiGeminiGrokGrokPerplexityPerplexityDeepSeekDeepSeek

Documentation

Provenance de la source

Partie 1 : mcp-builder/SKILL.md officiel d'Anthropic (Exemple de divulgation progressive à 3 niveaux)

Aperçu

Créez des serveurs MCP (Model Context Protocol) qui permettent aux LLMs d'interagir avec des services externes via des outils bien conçus. La qualité d'un serveur MCP se mesure à sa capacité à permettre aux LLMs d'accomplir des tâches concrètes.

Processus

🚀 Flux de travail de haut niveau

La création d'un serveur MCP de haute qualité implique quatre phases principales :

Phase 1 : Recherche et planification approfondies

1.1 Comprendre la conception MCP moderne

Couverture d'API vs. Outils de workflow : Trouvez un équilibre entre une couverture complète des points d'accès API et des outils de workflow spécialisés. Les outils de workflow peuvent être plus pratiques pour des tâches spécifiques, tandis qu'une couverture complète offre aux agents la flexibilité de composer des opérations. Les performances varient selon le client — certains clients bénéficient de l'exécution de code qui combine des outils de base, tandis que d'autres fonctionnent mieux avec des workflows de plus haut niveau. En cas d'incertitude, privilégiez une couverture API complète.

Nommage et découvrabilité des outils : Des noms d'outils clairs et descriptifs aident les agents à trouver rapidement les bons outils. Utilisez des préfixes cohérents (par exemple, github_create_issue, github_list_repos) et un nommage orienté action.

Gestion du contexte : Les agents bénéficient de descriptions d'outils concises et de la possibilité de filtrer/paginer les résultats. Concevez des outils qui renvoient des données ciblées et pertinentes. Certains clients prennent en charge l'exécution de code, ce qui peut aider les agents à filtrer et traiter les données efficacement.

Messages d'erreur actionnables : Les messages d'erreur doivent guider les agents vers des solutions avec des suggestions spécifiques et les prochaines étapes.

1.2 Étudier la documentation du protocole MCP

Naviguer dans la spécification MCP : Commencez par le plan du site pour trouver les pages pertinentes : https://modelcontextprotocol.io/sitemap.xml Récupérez ensuite les pages spécifiques avec le suffixe .md pour le format markdown (par exemple, https://modelcontextprotocol.io/specification/draft.md).

Pages clés à consulter :

  • Présentation et architecture de la spécification
  • Mécanismes de transport (HTTP streamable, stdio)
  • Définitions des outils, ressources et invites

1.3 Étudier la documentation du framework

Stack recommandé :

  • Langage : TypeScript (support SDK de haute qualité et bonne compatibilité dans de nombreux environnements d'exécution, par exemple MCPB. De plus, les modèles IA sont compétents pour générer du code TypeScript, bénéficiant de son utilisation répandue, de son typage statique et de ses bons outils de linting.)
  • Transport : HTTP streamable pour les serveurs distants, en utilisant du JSON sans état (plus simple à mettre à l'échelle et à maintenir, par opposition aux sessions avec état et aux réponses en streaming). stdio pour les serveurs locaux.

Charger la documentation du framework :

1.4 Planifier votre implémentation

Comprendre l'API : Consultez la documentation de l'API du service pour identifier les points d'accès clés, les exigences d'authentification et les modèles de données. Utilisez la recherche web et la récupération web si nécessaire.

Sélection des outils : Privilégiez une couverture API complète. Listez les points d'accès à implémenter, en commençant par les opérations les plus courantes.

Phase 2 : Implémentation

2.1 Mettre en place la structure du projet

Consultez les guides spécifiques au langage pour la configuration du projet :

2.2 Implémenter l'infrastructure de base

Créez des utilitaires partagés :

  • Client API avec authentification
  • Aides à la gestion des erreurs
  • Mise en forme des réponses (JSON et Markdown)
  • Support de la pagination

2.3 Implémenter les outils

Pour chaque outil :

Schéma d'entrée :

  • Utilisez Zod (TypeScript) ou Pydantic (Python)
  • Incluez des contraintes et des descriptions claires
  • Ajoutez des exemples dans les descriptions de champs

Schéma de sortie :

  • Définissez outputSchema lorsque cela est possible pour des données structurées
  • Utilisez structuredContent dans les réponses des outils (fonctionnalité du SDK TypeScript)
  • Aide les clients à comprendre et traiter les sorties des outils

Description de l'outil :

  • Résumé concis de la fonctionnalité
  • Descriptions des paramètres
  • Schéma de la valeur de retour

Implémentation :

  • Async/await pour les opérations d'E/S
  • Gestion des erreurs appropriée avec des messages actionnables
  • Support de la pagination le cas échéant
  • Renvoyez à la fois le contenu textuel et les données structurées lors de l'utilisation des SDK modernes

Annotations :

  • readOnlyHint : true/false
  • destructiveHint : true/false
  • idempotentHint : true/false
  • openWorldHint : true/false

Phase 3 : Révision et test

3.1 Qualité du code

Vérifiez :

  • Pas de code dupliqué (principe DRY)
  • Gestion des erreurs cohérente
  • Couverture complète des types
  • Descriptions d'outils claires

3.2 Compilation et test

TypeScript :

  • Exécutez npm run build pour vérifier la compilation
  • Testez avec MCP Inspector : npx @modelcontextprotocol/inspector

Python :

  • Vérifiez la syntaxe : python -m py_compile votre_serveur.py
  • Testez avec MCP Inspector

Consultez les guides spécifiques au langage pour des approches de test détaillées et des listes de contrôle de qualité.

Phase 4 : Créer des évaluations

Après avoir implémenté votre serveur MCP, créez des évaluations complètes pour tester son efficacité.

Chargez le ✅ Guide d'évaluation pour des directives d'évaluation complètes.

4.1 Comprendre l'objectif de l'évaluation

Utilisez les évaluations pour tester si les LLMs peuvent utiliser efficacement votre serveur MCP pour répondre à des questions réalistes et complexes.

4.2 Créer 10 questions d'évaluation

Pour créer des évaluations efficaces, suivez le processus décrit dans le guide d'évaluation :

  1. Inspection des outils : Listez les outils disponibles et comprenez leurs capacités
  2. Exploration du contenu : Utilisez des opérations READ-ONLY pour explorer les données disponibles
  3. Génération de questions : Créez 10 questions complexes et réalistes
  4. Vérification des réponses : Résolvez chaque question vous-même pour vérifier les réponses

4.3 Exigences d'évaluation

Assurez-vous que chaque question :

  • Est indépendante : Ne dépend pas d'autres questions
  • Est en lecture seule : Nécessite uniquement des opérations non destructives
  • Est complexe : Nécessite plusieurs appels d'outils et une exploration approfondie
  • Est réaliste : Basée sur des cas d'utilisation réels qui intéressent les humains
  • Est vérifiable : Réponse unique et claire pouvant être vérifiée par comparaison de chaînes
  • Est stable : La réponse ne changera pas avec le temps

4.4 Format de sortie

Créez un fichier XML avec cette structure :

<evaluation>
  <qa_pair>
    <question>Trouvez les discussions sur les lancements de modèles d'IA avec des noms de code d'animaux. Un modèle nécessitait une désignation de sécurité spécifique utilisant le format ASL-X. Quel nombre X était en cours de détermination pour le modèle nommé d'après un chat sauvage tacheté ?</question>
    <answer>3</answer>
  </qa_pair>
<!-- Plus de qa_pairs... -->
</evaluation>

Fichiers de référence

📚 Bibliothèque de documentation

Chargez ces ressources selon les besoins pendant le développement :

Documentation MCP de base (à charger en premier)

  • Protocole MCP : Commencez par le plan du site à https://modelcontextprotocol.io/sitemap.xml, puis récupérez les pages spécifiques avec le suffixe .md
  • 📋 Meilleures pratiques MCP - Directives MCP universelles incluant :
    • Conventions de nommage des serveurs et des outils
    • Directives de format des réponses (JSON vs Markdown)
    • Meilleures pratiques de pagination
    • Sélection du transport (HTTP streamable vs stdio)
    • Normes de sécurité et de gestion des erreurs

Documentation SDK (à charger pendant les phases 1/2)

  • SDK Python : Récupérez depuis https://raw.githubusercontent.com/modelcontextprotocol/python-sdk/main/README.md
  • SDK TypeScript : Récupérez depuis https://raw.githubusercontent.com/modelcontextprotocol/typescript-sdk/main/README.md

Guides d'implémentation spécifiques au langage (à charger pendant la phase 2)

Guide d'évaluation (à charger pendant la phase 4)

Partie 2 : Exemple de compétence avec injection de contexte dynamique Claude Code (!command``)

---
name: pr-summary
description: Résumer les modifications d'une pull request. À utiliser lorsque l'utilisateur demande de réviser, résumer ou auditer la PR actuelle ou la différence de branche.
context: fork
agent: Explore
allowed-tools: Bash(gh *)
---

## Contexte de la pull request
- Diff de la PR : !`gh pr diff`
- Commentaires de la PR : !`gh pr view --comments`
- Fichiers modifiés : !`gh pr diff --name-only`

## Votre tâche
Résumez cette pull request avec des risques concrets au niveau des fichiers, des changements cassants et des étapes de vérification...

Partie 3 : Schéma sidecar OpenAI Codex / ChatGPT agents/openai.yaml

interface:
  display_name: "Architecte de rôle et méta-prompt à auto-évolution"
  short_description: "Compiler, évaluer et adapter les invites, compétences et rôles d'agent entre les outils"
  icon_small: "./assets/icon-small.svg"
  icon_large: "./assets/icon-large.png"
  brand_color: "#2563EB"
  default_prompt: "Concevoir ou optimiser une définition d'invite, de compétence ou de rôle d'agent avec un tableau de bord d'évaluation."

policy:
  allow_implicit_invocation: true

dependencies:
  tools:
    - type: "mcp"
      value: "git"
      description: "Serveur MCP Git pour l'inspection du dépôt"

Partie 4 : Exemple de script autonome PEP 723 pour Agent Skills

# /// script
# dependencies = [
#   "pydantic>=2.0",
# ]
# requires-python = ">=3.10"
# ///
"""Script CLI autonome non interactif conçu pour l'invocation de compétences d'agent via `uv run`."""

import argparse
import json
import sys


def main() -> int:
    parser = argparse.ArgumentParser(
        description="Valider le frontmatter de la compétence ou du rôle et le budget de jetons sans invites interactives."
    )
    parser.add_argument("--input", required=True, help="Chemin vers le fichier Markdown cible")
    parser.add_argument("--max-chars", type=int, default=12000, help="Plafond du budget de caractères")
    parser.add_argument("--dry-run", action="store_true", help="Aperçu des vérifications sans écriture")
    args = parser.parse_args()

    try:
        with open(args.input, "r", encoding="utf-8") as f:
            text = f.read()
    except FileNotFoundError:
        sys.stderr.write(
            f"Erreur : Fichier '{args.input}' introuvable. Passez un chemin valide via --input <path>.\n"
        )
        return 1

    char_count = len(text)
    passed = char_count <= args.max_chars
    result = {
        "file": args.input,
        "char_count": char_count,
        "max_chars": args.max_chars,
        "passed": passed,
        "remediation": None if passed else f"Supprimez {char_count - args.max_chars} caractères ou déplacez les détails vers references/.",
    }
    sys.stdout.write(json.dumps(result, ensure_ascii=False, indent=2) + "\n")
    return 0 if passed else 2


if __name__ == "__main__":
    sys.exit(main())

Individual skills in this repo

This repo contains 3 individual skills — each has its own dedicated page.

DataShrimp/skills

Analyze raw prompts, identify intent and gaps, match ECC components (skills/commands/agents/hooks), and output a ready-to-paste optimized prompt. Advisory role only — never executes the task itself. TRIGGER when: user says "optimize prompt", "improve my prompt", "how to write a prompt for", "help me prompt", "rewrite this prompt", or explicitly asks to enhance prompt quality. Also triggers on Chinese equivalents: "优化prompt", "改进prompt", "怎么写prompt", "帮我优化这个指令". DO NOT TRIGGER when: user wants the task executed directly.

DataShrimp/skills

Generates optimized prompts for AI tools. Activates only when the user explicitly asks to write, fix, improve, or adapt a prompt for a specific AI tool (LLM, Cursor, Midjourney, image AI, video AI, coding agents, etc.). Does not activate for general conversation, coding tasks, document writing, or other non-prompt-engineering work.

DataShrimp/skills

Master Anthropic's prompt engineering techniques to generate new prompts or improve existing ones using best practices for Claude AI models.

Skills associés

steipete/sag

ElevenLabs text-to-speech with mac-style say UX.

community

steipete/oracle

Oracle CLI second-model review/debug/refactor/design with selected files, dry-run token checks, API or browser engine.

community

steipete/peekaboo

Capture and automate macOS UI with the Peekaboo CLI.

community

mattpocock/design-an-interface

Generate multiple radically different interface designs for a module using parallel sub-agents. Use when user wants to design an API, explore interface options, compare module shapes, or mentions "design it twice".

community

mattpocock/prototype

Build a throwaway prototype to flesh out a design — a runnable terminal app for state/business-logic questions, or several radically different UI variations toggleable from one route.

community

mattpocock/grill-me

Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".

community