CompatAir MCP

The verifiable difference

A technical decision service, not a conversational wrapper

CompatAir never asks a language model to guess whether two products work together. The server returns inputs, method, verdict, limitations, evidence and the matching web page in a structured response.

22,400 combinations are explorable, not precomputed. The snapshot contains 20,860 audited verdicts for 149 fixed-flow tools. The remaining 1,540 combinations require an action rate or volume and target time. Machine data also publishes normalized MPNs, EAN/GTIN, evidenced distributor SKUs, field-level coverage, source roles and the data freshness SLA.

Quickstart

Test the protocol without an SDK

These requests use the current Streamable HTTP transport. Each JSON-RPC message is sent in a new POST and advertises both response media types required by the protocol.

1 · Initializecurl

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 · Discover 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 · Identify a product by 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" }
    }
  }'

Verified integrations

ChatGPT, Claude, Gemini and agent SDKs

The endpoint is identical in every client. Configuration vocabulary, permissions and execution location are the only differences.

ChatGPT

1. In ChatGPT, open Settings → Security and login, then turn on Developer mode.
2. Open Settings → Plugins or chatgpt.com/plugins, select the + button and create a developer-mode app using https://compatair.fr/mcp. The CompatAir server does not require authentication.
3. In a new chat, select the app and test a positive case, an incompatible case and an insufficient_data case. Repeat the check in Deep Research when that surface is available in your workspace.

Official reference: OpenAI · Connect in ChatGPT.

Claude Code

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

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

Use --scope project to share the configuration. streamable-http is also accepted as an alias of http. Official reference: Connect Claude Code to tools via MCP.

Gemini Interactions API

Remote MCP in the Interactions API accepts Streamable HTTP servers and can restrict the exposed surface with allowed_tools.

from google import genai

client = genai.Client()
interaction = client.interactions.create(
    model="gemini-3.5-flash",
    input="Is this impact wrench compatible with my compressor?",
    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);

Check currently supported models in Google’s Gemini Remote MCP documentation.

OpenAI Agents SDK

In Python, HostedMCPTool lets the Responses API call the public server. In JavaScript, MCPServerStreamableHttp connects the application process directly to it.

import asyncio
from agents import Agent, HostedMCPTool, Runner

async def main() -> None:
    agent = Agent(
        name="Compressed air advisor",
        instructions=(
            "Preserve verdict, limitations and source_urls. "
            "Always cite 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, "Explain this CompatAir verdict")
    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();
}

Official references: Python Agents SDK and JavaScript Agents SDK.

Agent-to-user contract

Every result is verifiable and citable

Every tool publishes an outputSchema. Results are returned both as structuredContent and as serialized JSON in a text block for older clients.

{
  "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": []
}

MCP 3.0.0 surface

A short main surface and two explicit extensions

A general client ingests seven compact schemas. Exhaustive contracts remain available from compatair://responses/schema. Audit and synchronization tools use the extended profile; historical contracts use legacy.

Recommended decision-core profile

A general integration loads only these seven tools. The profile, endpoints and legacy successors are also available at compatair://tools/core-profile.

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

Advanced tools loaded on demand

• get_compatibility_evidence
• explain_compatibility_verdict
• compare_complete_systems
• get_changefeed

Maintained legacy tools

They remain available from https://compatair.fr/mcp/legacy, but each definition carries fr.compatair/lifecycle=legacy and an explicit fr.compatair/successor.

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

Context resources

• 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

Reusable prompts

• choisir_un_compresseur
• auditer_une_installation
• comparer_des_configurations

Sector data model

AirGraph connects demand, distribution and evidence

The graph does more than connect one tool to one compressor. It models technical requirements, distribution components, verdicts and evidence under stable identifiers.

A missing requirement remains missing. CompatAir does not infer pressure drop from an unknown hose and never converts intake displacement into FAD. The graph also records this absence in limitations.

Decisions can be frozen into a compatibility_receipt. Response fidelity is measurable with the public 100-scenario benchmark. MCP profile and tool selection are tested separately with the 50-request agent-selection suite, without publishing a score before execution through real models and tokenizers. Evidence changes are mapped to portfolios through the Compatibility Impact Feed.

Trust boundary

A public server designed to limit its own power

The service’s strongest defense is its narrow scope. CompatAir MCP cannot modify state, accepts no secrets, fetches no user-supplied URL and exposes neither the proprietary engine nor the filesystem.

References: transport specification and MCP security best practices.

Reusable checklist

What a production MCP server should be able to demonstrate

This list audits CompatAir and can also be used to review any remote server. A tool annotation or documentation claim is never sufficient evidence on its own.

• A single Streamable HTTP endpoint and a server.json manifest using remotes.
• Closed, bounded input schemas validated before processing.
• A conforming outputSchema and structuredContent for every tool.
• A text fallback for older clients.
• Annotations that match the server’s actual authority.
• Origin validation, loopback binding and an HTTPS proxy for remote access.
• Documented rate limits, timeouts, maximum sizes and pagination.
• A clear split between protocol errors and tool execution errors.
• An explicit policy for data, logs, secrets and retention.
• Stable identifiers, method versions and dated snapshots.
• A canonical page and retained evidence in every domain result.
• A changefeed for safe cache and decision invalidation.
• Negative tests for origins, media types, JSON, arguments, quotas and destinations.
• Human-readable and machine-readable documentation released together.

The specification states that clients must treat tool annotations as untrusted unless the server itself is trusted. Clients should also validate structured results and keep a human in the loop for sensitive operations. See the MCP tools specification.

Operational honesty

What the server refuses to assume

• Intake displacement is never presented as free air delivery.
• FAD is compared at the required pressure with no extrapolation outside a documented curve.
• Leaks and pressure drop are added only from explicit measurements.
• Per-action demand requires an action rate. Inflation requires volume, pressures and target time.
• A complete system remains insufficient_data when decisive hose, connector, filtration or lubrication requirements are undocumented.
• An absent, expired or non-allowlisted offer is never replaced or invented.
• An MCP result does not replace a manufacturer manual, an in-load measurement, pressure-equipment rules or workplace safety requirements.

Diagnostics

Understand HTTP responses

Discovery and governance

Versions, manifest and reference documents

The registry manifest versioned with CompatAir declares the official remote through remotes:

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

The complete text contract remains available in llms-full.txt. The version compatibility matrix separates product, MCP server, engine, method and schema versions.

Normative and integration sources

• MCP Registry · publishing remote servers
• MCP · Streamable HTTP transport
• MCP · tools, schemas and structured results
• MCP · security best practices
• OpenAI · connect an MCP server in ChatGPT
• Anthropic · MCP in Claude Code
• Google · Remote MCP in Gemini

To report a data or integration issue, use the contact page. For a vulnerability, follow the security policy.