CompatAir MCP

Le différenciateur vérifiable

Un service de décision technique, pas une surcouche conversationnelle

CompatAir ne demande jamais au modèle de deviner si deux produits fonctionnent ensemble. Le serveur expose les entrées, la méthode, le verdict, les limites, les sources et la page web correspondante dans une réponse structurée.

22 400 combinaisons sont explorables, pas pré-calculées. Le snapshot contient 20 860 verdicts audités pour les 149 outils à débit fixe. Les 1 540 combinaisons restantes exigent une cadence ou un volume et un temps cible. Le catalogue machine publie aussi les MPN normalisés, EAN/GTIN, SKU distributeur sourcés, la couverture champ par champ, le rôle des sources et le SLA de fraîcheur.

Démarrage rapide

Tester le protocole sans SDK

Ces requêtes utilisent le transport Streamable HTTP courant. Chaque requête JSON-RPC part dans un nouveau POST et annonce les deux types de réponse acceptés par le protocole.

1 · Initialisercurl

curl --request POST 'https://compatair.fr/mcp' \
  --header 'Content-Type: application/json' \
  --header 'Accept: application/json, text/event-stream' \
  --data '{
    "jsonrpc": "2.0",
    "id": 1,
    "method": "initialize",
    "params": {
      "protocolVersion": "2025-11-25",
      "capabilities": {},
      "clientInfo": { "name": "example-client", "version": "1.0.0" }
    }
  }'

2 · Découvrir les toolscurl

curl --request POST 'https://compatair.fr/mcp' \
  --header 'Content-Type: application/json' \
  --header 'Accept: application/json, text/event-stream' \
  --header 'MCP-Protocol-Version: 2025-11-25' \
  --data '{"jsonrpc":"2.0","id":2,"method":"tools/list","params":{}}'

3 · Identifier un produit par EANcurl

curl --request POST 'https://compatair.fr/mcp' \
  --header 'Content-Type: application/json' \
  --header 'Accept: application/json, text/event-stream' \
  --header 'MCP-Protocol-Version: 2025-11-25' \
  --data '{
    "jsonrpc": "2.0",
    "id": 3,
    "method": "tools/call",
    "params": {
      "name": "identify_product",
      "arguments": { "ean": "4006825660630" }
    }
  }'

Intégrations vérifiées

ChatGPT, Claude, Gemini et SDK d’agents

L’URL reste la même dans tous les clients. Seuls le vocabulaire de configuration, les permissions et le lieu d’exécution changent.

ChatGPT

1. Dans ChatGPT, ouvrez Réglages → Sécurité et connexion, puis activez le mode développeur.
2. Ouvrez Réglages → Plugins ou chatgpt.com/plugins, sélectionnez le bouton + et créez une app en mode développeur avec l’URL https://compatair.fr/mcp. Le serveur CompatAir ne demande aucune authentification.
3. Dans une nouvelle conversation, sélectionnez l’app et testez un cas concluant, un cas incompatible et un cas insufficient_data. Répétez le contrôle dans Deep Research si cette surface est disponible dans votre espace de travail.

Référence officielle : OpenAI · Connect in ChatGPT.

Claude Code

claude mcp add --transport http compatair https://compatair.fr/mcp
claude mcp get compatair
# Dans Claude Code : /mcp

{
  "mcpServers": {
    "compatair": {
      "type": "http",
      "url": "https://compatair.fr/mcp"
    }
  }
}

Pour partager la configuration, utilisez --scope project. Le type streamable-http est aussi accepté comme alias de http. Référence officielle : Connect Claude Code to tools via MCP.

Gemini Interactions API

Remote MCP dans l’API Interactions accepte les serveurs Streamable HTTP et permet de restreindre la surface via allowed_tools.

from google import genai

client = genai.Client()
interaction = client.interactions.create(
    model="gemini-3.5-flash",
    input="Cette clé à chocs est-elle compatible avec mon compresseur ?",
    tools=[{
        "type": "mcp_server",
        "name": "compatair",
        "url": "https://compatair.fr/mcp",
    }],
)

print(interaction.output_text)

import { GoogleGenAI } from '@google/genai';

const client = new GoogleGenAI({});
const interaction = await client.interactions.create({
  model: 'gemini-3.5-flash',
  input: 'Build a documented compressed-air system for this tool.',
  tools: [{
    type: 'mcp_server',
    name: 'compatair',
    url: 'https://compatair.fr/mcp',
  }],
});

console.log(interaction.output_text);

Vérifiez les modèles actuellement compatibles dans la documentation Remote MCP de Gemini.

OpenAI Agents SDK

En Python, HostedMCPTool délègue l’appel du serveur public à l’API Responses. En JavaScript, MCPServerStreamableHttp connecte directement le processus au serveur.

import asyncio
from agents import Agent, HostedMCPTool, Runner

async def main() -> None:
    agent = Agent(
        name="Conseiller air comprimé",
        instructions=(
            "Conserver verdict, limitations et source_urls. "
            "Toujours citer canonical_url."
        ),
        tools=[HostedMCPTool(tool_config={
            "type": "mcp",
            "server_label": "compatair",
            "server_url": "https://compatair.fr/mcp",
            "require_approval": "never",
        })],
    )
    result = await Runner.run(agent, "Explique ce verdict CompatAir")
    print(result.final_output)

asyncio.run(main())

import { Agent, MCPServerStreamableHttp, run } from '@openai/agents';

const server = new MCPServerStreamableHttp({
  name: 'CompatAir',
  url: 'https://compatair.fr/mcp',
  cacheToolsList: true,
});

await server.connect();
try {
  const agent = new Agent({
    name: 'Compressed air advisor',
    instructions: 'Preserve limitations and cite canonical_url.',
    mcpServers: [server],
  });
  const result = await run(agent, 'Build a documented complete air system.');
  console.log(result.finalOutput);
} finally {
  await server.close();
}

Références officielles : Agents SDK Python et Agents SDK JavaScript.

Contrat agent → utilisateur

Chaque réponse devient vérifiable et citable

Tous les tools publient un outputSchema. Le résultat est renvoyé à la fois dans structuredContent et sous forme JSON sérialisée dans un bloc texte pour les clients plus anciens.

{
  "verdict": "insufficient_data",
  "verdict_scope": "complete_air_system",
  "verdict_schema_version": "2.0.0",
  "overall_system_verdict": {
    "schema_version": "2.0.0",
    "scope": "complete_air_system",
    "verdict": "insufficient_data",
    "limitations": ["Network components remain unverified."]
  },
  "air_supply_verdict": {
    "schema_version": "2.0.0",
    "scope": "air_supply",
    "verdict": "compatible",
    "engine_verdict": "continuous",
    "limitations": []
  },
  "canonical_url": "https://compatair.fr/calculateur/?outil=...&compresseur=...",
  "product_urls": [],
  "source_urls": [],
  "method_version": "2026.07",
  "catalog_version": "2026-07-15",
  "observed_at": "2026-07-15",
  "limitations": [],
  "next_actions": []
}

Surface MCP 3.0.0

Une surface principale courte, deux extensions explicites

Un client généraliste n’ingère que sept schémas compacts. Les contrats exhaustifs restent lisibles dans compatair://responses/schema. Les outils d’audit et de synchronisation passent par le profil extended ; les anciens contrats passent par legacy.

Profil decision-core recommandé

Une intégration généraliste ne charge que ces sept tools. Le profil, ses endpoints et les successeurs legacy sont aussi lisibles dans compatair://tools/core-profile.

• orient_decision
• identify_product
• evaluate_air_compatibility
• build_complete_air_system
• find_compatible_alternatives
• search_knowledge
• get_current_offers

Tools avancés à charger à la demande

• get_compatibility_evidence
• explain_compatibility_verdict
• compare_complete_systems
• get_changefeed

Tools historiques maintenus

Ils restent disponibles sur https://compatair.fr/mcp/legacy, mais chaque définition porte fr.compatair/lifecycle=legacy et un fr.compatair/successor explicite.

• search_tools
• get_tool_requirements
• search_compressors
• get_compressor_specs
• size_compressor
• check_compatibility
• compare_compressors
• find_accessories
• find_offers

Ressources de contexte

• compatair://catalog/version
• compatair://methodology
• compatair://tools/taxonomy
• compatair://confidence-scale
• compatair://affiliation-policy
• compatair://engine/version
• compatair://airgraph/schema
• compatair://responses/schema
• compatair://tools/core-profile
• compatair://receipts/schema
• compatair://changefeed/current

Prompts réutilisables

• choisir_un_compresseur
• auditer_une_installation
• comparer_des_configurations

Modèle de données sectoriel

L’AirGraph relie le besoin, le réseau et la preuve

Le graphe ne relie pas seulement un outil à un compresseur. Il décrit les exigences techniques, les composants du réseau, le verdict et les preuves sous des identifiants stables.

Une exigence absente reste absente. Par exemple, CompatAir ne déduit pas une perte de charge à partir d’un flexible inconnu et ne transforme pas un débit aspiré en FAD. Le graphe encode aussi cette absence dans limitations.

Les décisions peuvent être figées dans un compatibility_receipt. La fidélité des réponses se mesure sur le benchmark public de 100 scénarios. La sélection du bon profil et du bon tool MCP se teste séparément sur le banc de 50 requêtes agentiques, sans publier de score avant exécution avec de vrais modèles et tokenizers. Les changements de preuve sont reliés aux portefeuilles dans le Compatibility Impact Feed.

Frontière de confiance

Un serveur public conçu pour réduire sa propre puissance

La meilleure défense de cette surface est son périmètre. Le MCP CompatAir ne modifie rien, ne reçoit aucun secret, ne télécharge aucune URL utilisateur et ne donne pas accès au moteur propriétaire ni au système de fichiers.

Références : spécification des transports et bonnes pratiques de sécurité MCP.

Checklist réutilisable

Ce qu’un serveur MCP de production devrait pouvoir démontrer

Cette liste sert à auditer CompatAir, mais aussi à évaluer un autre serveur distant. Une annotation ou une promesse documentaire n’est jamais une preuve suffisante à elle seule.

• Un endpoint unique Streamable HTTP et un manifeste server.json avec remotes.
• Des schémas d’entrée fermés, bornés et validés avant tout traitement.
• Un outputSchema et un structuredContent conformes pour chaque tool.
• Une représentation texte de secours pour les clients plus anciens.
• Des annotations cohérentes avec la puissance réelle du serveur.
• Une validation d’Origin, une écoute locale et un proxy HTTPS pour les remotes.
• Des quotas, délais, tailles maximales et paginations documentés.
• Une séparation nette entre erreurs de protocole et erreurs d’exécution.
• Une politique explicite de données, journaux, secrets et rétention.
• Des identifiants stables, versions de méthode et snapshots datés.
• Une page canonique et des preuves conservées dans chaque résultat métier.
• Un changefeed pour invalider proprement caches et décisions anciennes.
• Des tests négatifs pour origines, types MIME, JSON, arguments, quotas et destinations.
• Une documentation humaine et machine lisible, maintenue dans les mêmes versions.

La spécification rappelle que les clients doivent considérer les annotations des tools comme non fiables tant que le serveur n’est pas lui-même digne de confiance. Les clients devraient aussi valider les résultats structurés et conserver un humain dans la boucle pour les opérations sensibles. Voir la spécification MCP des tools.

Honnêteté opérationnelle

Ce que le serveur refuse de supposer

• Un débit aspiré n’est jamais présenté comme un débit d’air effectivement restitué.
• Le FAD provient d’un point exact, d’une interpolation encadrée ou d’un point mesuré à pression supérieure utilisé comme borne conservatrice explicite ; aucun point n’est inventé et rien n’est prolongé au-dessus du dernier point publié.
• Les fuites et pertes de charge ne sont ajoutées que depuis une mesure explicite.
• Un besoin par action exige une cadence. Un gonflage exige le volume, les pressions et le temps cible.
• Un système complet reste insufficient_data si flexible, raccord, filtration ou lubrification déterminants ne sont pas documentés.
• Une offre absente, expirée ou hors liste blanche n’est ni remplacée ni inventée.
• Un résultat MCP ne remplace pas une notice constructeur, une mesure en charge, les règles relatives aux équipements sous pression ou la sécurité au travail.

Diagnostic

Comprendre les réponses HTTP

Découverte et gouvernance

Versions, manifeste et documents de référence

Le manifeste de registre versionné avec CompatAir déclare le remote officiel sous la propriété remotes :

{
  "name": "io.github.bluetouff/compatair",
  "version": "3.0.0",
  "remotes": [{
    "type": "streamable-http",
    "url": "https://compatair.fr/mcp"
  }]
}

Le contrat textuel complet reste disponible dans llms-full.txt. La matrice de compatibilité des versions distingue version produit, serveur MCP, moteur, méthode et schémas.

Sources normatives et intégrations

• MCP Registry · publication des serveurs distants
• MCP · transport Streamable HTTP
• MCP · tools, schémas et résultats structurés
• MCP · bonnes pratiques de sécurité
• OpenAI · connecter un serveur MCP dans ChatGPT
• Anthropic · MCP dans Claude Code
• Google · Remote MCP dans Gemini

Pour signaler une donnée ou une intégration défaillante, utilisez la page de contact. Pour une vulnérabilité, suivez la politique de sécurité.