ServicesÀ proposNotesContact Me contacter →
EN FR
Note

Ressources et prompts MCP

Au-delà des outils — utiliser les ressources MCP pour l'exposition de données en lecture seule, les prompts pour des modèles réutilisables, et l'objet Context pour le rapport de progression sur les opérations longues.

Planté
mcpdata engineering

MCP Protocol Architecture décrit trois primitives du serveur : outils, ressources et prompts. Les ressources et les prompts résolvent des problèmes différents de ceux des outils ; utiliser la mauvaise primitive conduit à des outils traitant des cas que les ressources ou les prompts géreraient plus proprement.

Ressources : exposition de données en lecture seule

Les ressources exposent des données que l’IA peut lire, à l’instar des endpoints GET. Contrairement aux outils, les ressources sont contrôlées par l’application (c’est le client qui décide quand les récupérer, pas l’IA) et elles n’ont pas d’effets de bord. Elles sont la bonne primitive lorsque vous souhaitez rendre des informations disponibles sans que l’IA exécute activement quoi que ce soit.

@mcp.resource("schema://{table_name}")
def get_table_schema(table_name: str) -> str:
    """Expose table schema as a readable resource.


    URI pattern: schema://analytics.orders
    """
    # Fetch from your metadata store
    return f"""
    Table: {table_name}
    Columns:
      - id: INT (Primary Key)
      - customer_id: INT (Foreign Key)
      - total_amount: DECIMAL(10,2)
      - created_at: TIMESTAMP
    """


@mcp.resource("config://pipelines/{pipeline_id}")
def get_pipeline_config(pipeline_id: str) -> str:
    """Expose pipeline configuration."""
    return f"Pipeline {pipeline_id} configuration: schedule=daily, owner=data-team"

Les ressources utilisent des modèles URI avec des espaces réservés {variable}. L’IA peut parcourir les ressources disponibles et les lire sans exécuter d’actions. Le schéma URI (schema://, config://) est arbitraire — choisissez quelque chose qui rend l’objectif de la ressource clair.

Quand utiliser les ressources plutôt que les outils

La distinction importe pour les serveurs d’ingénierie de données :

Les schémas de tables sont mieux représentés comme des ressources. L’IA les lit pour le contexte avant de décider quoi faire ensuite. Pas d’effets de bord, pas de paramètres au-delà de l’identifiant de table.

Les configurations de pipelines sont mieux représentées comme des ressources. Ce sont des données statiques que l’IA peut lire pour comprendre un système avant d’agir.

L’exécution de requêtes est mieux représentée comme un outil. Elle a des effets de bord (coûte de l’argent, utilise du calcul), prend des paramètres complexes, et l’IA choisit explicitement de l’invoquer.

Les déclenchements de pipelines sont mieux représentés comme des outils. Ils ont des effets de bord et nécessitent une invocation explicite avec le consentement de l’utilisateur.

La règle empirique : si l’IA lit des informations pour éclairer son raisonnement, utilisez une ressource. Si l’IA effectue une action, utilisez un outil.

Prompts : modèles réutilisables

Les prompts sont des modèles contrôlés par l’utilisateur qui guident les interactions avec l’IA. Ils sont différents des outils (invoqués par l’IA) et des ressources (contrôlés par l’application) — les prompts sont initiés par l’utilisateur, qui les choisit dans un menu de l’interface client.

@mcp.prompt(title="Data Quality Report")
def data_quality_prompt(table_name: str) -> str:
    """Generate a data quality analysis prompt.


    Args:
        table_name: Table to analyze
    """
    return f"""Analyze the data quality of the '{table_name}' table.


Please check:
1. Completeness: What percentage of required fields are populated?
2. Uniqueness: Are there duplicate records?
3. Freshness: When was the data last updated?
4. Validity: Do values conform to expected formats and ranges?


Provide a summary with specific recommendations for improvement."""


@mcp.prompt(title="Schema Review")
def schema_review_prompt(table_name: str, changes: str) -> str:
    """Generate a schema change review prompt."""
    return f"""Review the proposed schema changes for {table_name}:


{changes}


Evaluate:
- Backward compatibility with existing queries
- Impact on downstream dependencies
- Performance implications
- Data migration requirements"""

Les prompts encodent la connaissance institutionnelle sur la façon de poser de bonnes questions. Au lieu que les membres de l’équipe écrivent des requêtes ad hoc, ils choisissent « Data Quality Report » dans un menu et renseignent le nom de la table. Le prompt garantit que l’IA reçoit une requête complète et bien structurée à chaque fois.

Pour les équipes d’ingénierie de données, les prompts sont utiles pour standardiser les workflows de revue (revues de schéma, revues de migration), les patterns d’analyse de qualité, et les modèles d’investigation d’incidents.

Rapport de progression avec Context

Les opérations longues devraient signaler leur progression pour que l’IA puisse informer les utilisateurs de ce qui se passe. FastMCP fournit un objet Context pour cela :

from mcp.server.fastmcp import FastMCP, Context


mcp = FastMCP("DataEngineering")


@mcp.tool()
async def process_large_dataset(dataset_id: str, ctx: Context) -> str:
    """Process a large dataset with progress updates.


    Args:
        dataset_id: Identifier of the dataset to process
        ctx: MCP context for progress reporting (injected automatically)


    Returns:
        Processing summary
    """
    await ctx.info(f"Starting processing of {dataset_id}")


    total_batches = 10
    for i in range(total_batches):
        # Simulate batch processing
        await ctx.report_progress(
            progress=(i + 1) / total_batches,
            total=1.0,
            message=f"Processing batch {i + 1}/{total_batches}"
        )


    await ctx.info("Processing complete")
    return f"Processed dataset {dataset_id}: 10 batches, 100,000 rows"

L’objet Context est injecté automatiquement lorsque vous l’incluez comme paramètre — vous ne le construisez pas vous-même. Il fournit :

  • ctx.info(), ctx.warning(), ctx.error() — journalisation à différents niveaux de sévérité, routée via le protocole MCP vers le client
  • ctx.report_progress() — barres de progression dans les clients qui les prennent en charge

Context est particulièrement précieux pour les outils d’ingénierie de données qui interagissent avec des entrepôts ou des orchestrateurs. Un contrôle de qualité qui scanne des millions de lignes, un déclenchement de pipeline qui attend la complétion, une recherche de catalogue qui interroge plusieurs back-ends — tous bénéficient du rapport de progression pour que l’utilisateur sache que l’outil travaille, et non qu’il est bloqué.

Notez que les outils utilisant Context doivent être des fonctions async. FastMCP gère la boucle d’événements, mais votre fonction d’outil a besoin du mot-clé async pour utiliser await avec les méthodes de contexte.

Combiner les primitives

Un serveur MCP bien conçu utilise généralement les trois primitives ensemble :

  • Les ressources exposent votre catalogue de données, vos schémas et vos configurations pour que l’IA les lise comme contexte
  • Les outils permettent à l’IA d’exécuter des requêtes, de lancer des contrôles, de déclencher des pipelines
  • Les prompts donnent aux utilisateurs des workflows standardisés pour les tâches courantes

Le MCP Data Catalog Server Pattern illustre cette combinaison en pratique — ressources pour parcourir les schémas, outils pour rechercher et interroger la lignée, et prompts pour des workflows d’analyse standardisés.