# Préchauffer son cache depuis Claude, Cursor ou n'importe quel client MCP — CacheBoost Blog

> CacheBoost propose désormais un serveur MCP distant. Préchauffez votre cache et suivez vos runs depuis Claude, Cursor ou tout client compatible MCP, avec votre clé API existante — sans code d'intégration.

Source: https://www.cache-boost.com/fr/blog/prechauffer-son-cache-depuis-claude-avec-mcp.md
Language: fr

---


Tags: mcp, api, devops, automation
Published: 2026-09-15
Author: Nicolas Hodin
Reading time: 4 min

---

**En résumé:**
- CacheBoost expose un serveur MCP (Model Context Protocol) distant
- Pilotez le préchauffage depuis Claude Desktop, Claude Code ou Cursor, en langage naturel
- Réutilise votre clé API cb_live_ et ses scopes — rien de nouveau à provisionner
- Idéal pour le post-déploiement : préchauffer les URLs critiques et suivre le run jusqu'au bout
CacheBoost propose désormais un serveur **MCP** distant. Si vous travaillez dans Claude Desktop, Claude Code, Cursor ou tout autre client compatible MCP, vous pouvez préchauffer votre cache et consulter vos runs directement depuis votre assistant — avec la même API et les mêmes clés que vous utilisez déjà. Pas de SDK, pas de code de liaison, aucune nouvelle information d'identification.

Cet article explique ce qu'est ce serveur MCP, comment le connecter et ce qu'il permet de faire.

## Qu'est-ce que MCP, et pourquoi en exposer un ?

Le Model Context Protocol (MCP) est un standard ouvert qui permet aux assistants IA d'appeler des outils externes de façon structurée et authentifiée. Plutôt que de copier-coller des commandes `curl` ou de câbler une intégration à la main, vous indiquez à votre client une URL de serveur, et l'assistant découvre les outils disponibles et les appelle pour vous.

Le serveur MCP de CacheBoost est une fine couche sécurisée au-dessus de notre API REST publique. Chaque outil correspond à un endpoint `/v1` existant : le comportement — scopes, quotas, restriction par sites de la clé, validation same-origin — est exactement celui sur lequel vous vous appuyez déjà.

## Authentification : votre clé API existante

Le serveur MCP réutilise les clés API CacheBoost. Créez-en une dans l'application sous **Profil → Clés API**, accordez-lui les scopes nécessaires et copiez la valeur `cb_live_…`. La clé est transmise dans l'en-tête `X-API-Key` :

```
X-API-Key: cb_live_...
```

Les scopes sont vérifiés par outil : une clé en lecture seule peut lister les sites et les runs, mais ne peut pas déclencher de préchauffage. N'accordez `boosts:write` qu'aux clés autorisées à préchauffer.

## Connecter un client

Le serveur MCP est un endpoint distant en **Streamable HTTP** :

```
https://api.cache-boost.com/mcp
```

CacheBoost est référencé au registre MCP officiel sous `com.cache-boost/cacheboost`. Si votre client sait parcourir le registre, cherchez-y **CacheBoost** et collez votre clé quand il demande `X-API-Key` — l'endpoint et le transport viennent de la fiche, et vous pouvez sauter le reste de cette section.

Pour un client sans annuaire, l'équivalent manuel est un petit bloc de configuration — une URL et un en-tête `X-API-Key` :

```json
{
  "mcpServers": {
    "cacheboost": {
      "type": "http",
      "url": "https://api.cache-boost.com/mcp",
      "headers": { "X-API-Key": "cb_live_..." }
    }
  }
}
```

Dans Claude Code, la même opération en ligne de commande :

```bash
claude mcp add --transport http cacheboost https://api.cache-boost.com/mcp \
  --header "X-API-Key: cb_live_..."
```

Dans Claude, ajoutez-le comme **connecteur personnalisé** (Paramètres → Connecteurs → Ajouter un connecteur personnalisé) avec l'URL ci-dessus. CacheBoost s'authentifie par clé API, pas par OAuth, donc :

- **Authentification** : choisissez **Aucune connexion**.
- **En-têtes de requête** : ajoutez `X-API-Key` avec votre clé `cb_live_…`.

Utilisez bien `X-API-Key` et non `Authorization` : le connecteur ne transmet pas d'en-tête `Authorization` personnalisé.

Les étapes précises par client sont dans la [documentation support MCP](/fr/support/mcp/overview).

## Ce que vous pouvez faire

Le serveur expose un ensemble ciblé d'outils, chacun relié à un endpoint `/v1` et protégé par le même scope :

| Outil | Rôle | Scope requis |
|-------|------|--------------|
| `whoami` | Identité de la clé courante | — |
| `list_sites` | Lister les sites accessibles à la clé | `sites:read` |
| `get_site` | Récupérer un site | `sites:read` |
| `warm_site` | Préchauffer une liste d'URLs same-origin, renvoie un `run_id` | `boosts:write` |
| `list_warm_runs` | Lister les runs de préchauffage d'un site (pour suivre le statut) | `boosts:read` |
| `get_run` | Statut détaillé et statistiques de cache-hit d'un run | `runs:read` |
| `list_runs` | Lister les runs sur les sites de la clé | `runs:read` |

## Le cas d'usage naturel : préchauffer après un déploiement

Le workflow le plus utile est le préchauffage post-déploiement. Au lieu de le scripter, vous pouvez simplement demander :

> « Préchauffe les URLs critiques de example.com, puis préviens-moi quand le cache est chaud. »

L'assistant appelle `warm_site` avec vos URLs, reçoit un `run_id`, puis interroge `list_warm_runs` / `get_run` jusqu'à ce que le run se termine — en rapportant le taux de cache-hit une fois terminé. Le préchauffage lui-même s'exécute de façon asynchrone sur notre infrastructure, exactement comme via l'API ou le tableau de bord.

Cela **complète** l'[approche CI/CD](/fr/blog/prechauffage-de-cache-pipeline-deploiement) sans la remplacer : les pipelines restent l'outil adapté au préchauffage automatisé et sans surveillance, tandis que le serveur MCP est là pour les moments interactifs — valider une mise en production, préchauffer un ensemble d'URLs ad hoc, ou comprendre pourquoi un run a sous-performé.

## À propos des versions de protocole

Le serveur implémente aujourd'hui la lignée stateful du protocole MCP, de `2024-11-05` à `2025-11-25`, prise en charge par les clients MCP actuels. La révision stateless plus récente `2026-07-28` n'est pas encore supportée ; elle suivra à mesure que les SDK l'adopteront.

## Pour démarrer

1. Créez une clé API dans **Profil → Clés API** avec les scopes nécessaires.
2. Ajoutez `https://api.cache-boost.com/mcp` à votre client MCP avec un en-tête `X-API-Key` (dans Claude : connecteur personnalisé, **Aucune connexion**).
3. Demandez à votre assistant de préchauffer un site — et regardez le run se terminer.

Les instructions complètes d'installation, la configuration par client et la référence complète des outils sont dans la [documentation support MCP](/fr/support/mcp/overview).


---

**CacheBoost** — Automatic cache warming for faster websites.

- Website: https://www.cache-boost.com
- Full content (all pages): https://www.cache-boost.com/llms-full.txt
- LLM index: https://www.cache-boost.com/llms.txt
- Documentation: https://www.cache-boost.com/support/getting-started/introduction
- Start free: https://www.cache-boost.com/try