# Ajouter Shager à Cursor avec .cursor/mcp.json : vos notes de version deviennent des brouillons pour chaque compte client

_2026-08-28 · Configurez le serveur MCP de Shager dans Cursor avec une url et un en-tête Authorization lu dans l'environnement, puis transformez un changelog en brouillons._

Pour connecter Shager à Cursor, créez `.cursor/mcp.json` dans votre projet (ou `~/.cursor/mcp.json` pour tous vos projets) avec une entrée `shager` dont l'`url` est `https://app.shager.ai/api/mcp` et dont les `headers` définissent `Authorization` à `Bearer ${env:SHAGER_API_KEY}`. Cursor résout la variable depuis votre environnement, se connecte en HTTP, et l'agent récupère les outils de Shager. Ni serveur local, ni passerelle.

Cursor est un endroit intéressant pour piloter la diffusion, parce que la matière première se trouve déjà dans le dépôt : changelogs, documentation, notes de version, brouillons d'articles. Ce guide met la connexion en place proprement, puis l'utilise pour ce travail.

## À quoi ressemble la configuration MCP de Cursor pour un serveur distant ?

La [documentation MCP](https://cursor.com/docs/context/mcp) de Cursor décrit un serveur distant comme une `url` accompagnée d'un objet `headers` facultatif, et documente l'interpolation `${env:NAME}` dans les champs `url` et `headers`. Elle indique aussi deux emplacements : `.cursor/mcp.json` dans un projet pour les outils propres à ce projet, et `~/.cursor/mcp.json` dans votre répertoire personnel pour les outils disponibles partout.

Pour Shager :

```json
{
  "mcpServers": {
    "shager": {
      "url": "https://app.shager.ai/api/mcp",
      "headers": {
        "Authorization": "Bearer ${env:SHAGER_API_KEY}"
      }
    }
  }
}
```

Et dans le profil de votre shell :

```bash
export SHAGER_API_KEY="shgr_live_your_key_here"
```

Cursor lit les variables d'environnement du processus qui l'a lancé. Sur macOS, une application ouverte depuis le Dock peut ne pas voir les variables définies dans `~/.zshrc`. Si le serveur échoue avec un 401 alors que la clé est correcte, quittez Cursor et relancez-le depuis un terminal avec `cursor .` pour vérifier que c'est bien la cause.

## Fichier de projet ou fichier global ?

| Emplacement | Idéal pour | Point d'attention |
|---|---|---|
| `.cursor/mcp.json` dans le dépôt | Un site marketing ou un dépôt de documentation où se fait le travail de contenu | Ne le committez qu'avec la forme `${env:...}`, jamais avec une clé en clair |
| `~/.cursor/mcp.json` | Vous voulez Shager dans tous vos espaces de travail | L'agent de chaque projet peut alors atteindre vos espaces de travail Shager |

Pour un développeur d'agence qui maintient plusieurs sites clients, le fichier de projet est généralement le meilleur choix. Le dépôt du client A ne devrait pas héberger un agent capable de rédiger, sans y penser, dans l'espace de travail du client B. Associez le fichier de projet à une clé dont l'organisation ne contient que les espaces de travail pertinents pour ce dépôt, ou, à défaut, nommez explicitement les espaces de travail dans vos prompts.

## D'où vient la clé ?

Une personne la crée sur https://app.shager.ai/dashboard/agents et choisit les scopes. Pour travailler dans un éditeur, `read` plus `write` est le bon réglage par défaut : l'agent peut importer des médias et créer des brouillons, mais Shager refuse de programmer ou de publier sans le scope `publish`. Si vous faites un prototype sans avoir encore de compte, un agent peut créer une sandbox par [auto-inscription](/fr/blog/agent-self-signup-and-claim) ; la marche à suivre est publiée sur shager.ai/auth.md.

## Comment vérifier que Cursor voit les outils ?

Ouvrez les réglages MCP de Cursor et cherchez `shager`, avec un statut connecté et sa liste d'outils : `whoami`, `list_workspaces`, `create_workspace`, `list_channels`, `create_connect_link`, `list_groups`, `create_group`, `upload_media_from_url`, `create_post`, `schedule_post`, `request_approval`, `get_post`, `list_posts`, `cancel_post` et `get_analytics`. Si le serveur affiche une erreur, les trois causes habituelles sont une variable d'environnement manquante, l'absence de `Bearer` dans la valeur de l'en-tête, ou une erreur de syntaxe JSON dans le fichier.

Puis, dans le chat de l'agent :

```text
Call shager whoami and tell me which scopes this key has.
```

## Le flux de travail : un changelog devient des brouillons par compte

Voici une tâche concrète qui convient bien à Cursor. Imaginons que vous mainteniez le site d'un revendeur de logiciels qui compte douze pages de partenaires régionaux sur Facebook et Instagram. À chaque version, quelqu'un réécrit le changelog à la main en publications pour les réseaux sociaux. Avec Shager connecté, l'agent peut faire le premier jet.

```text
Read CHANGELOG.md and take the entry for v4.2 only.
In Shager workspace "Brightline Partners":
1. list_groups and use the group "Regional partners".
2. list_channels so you know each channel's name and network.
3. Write one short post about v4.2 for a non-technical audience.
4. Create a DRAFT with create_post (no schedule_at):
   group_ids: the "Regional partners" group
   per_channel: a caption per channel that names the region from the channel
   name and varies the opening line; keep facts identical
   cta_url: https://brightline.example/releases/4-2
   campaign: "release-4-2"
   first_comment: "Full notes: " followed by the link
5. Print the post id and a table of channel, caption first line, format.
```

Plusieurs choix de ce prompt sont délibérés.

Les faits restent identiques, la formulation varie. `per_channel` remplace la légende pour chaque compte, ce qui est la pratique recommandée. Douze copies du même texte sur des pages liées entre elles, c'est exactement le genre de répétition contre lequel met en garde notre article sur [les blocages pour spam quand on publie à grande échelle](/fr/blog/avoid-spam-blocks-when-posting-at-scale), et cela se lit mal pour quiconque suit deux de ces pages.

Le lien est suivi compte par compte. Avec `cta_url`, Shager crée un lien court et un jeu d'UTM distincts pour chaque compte, avec `utm_content` qui l'identifie. Plus tard, `get_analytics` renvoie les clics par compte et par publication : le partenaire d'une région voit ce que sa page a généré.

Le résultat est un brouillon. Quelqu'un le relit encore dans Shager avant sa sortie, qu'il s'agisse d'un relecteur interne ou du client via un lien de validation.

## Et si vous préférez appeler l'API depuis le code ?

Parfois, vous voudrez un script dans le dépôt plutôt qu'un chat. Un workflow de release en CI, par exemple, ne doit pas dépendre de quelqu'un qui ouvre Cursor. Les mêmes opérations sont exposées en REST, décrites dans le [document OpenAPI](https://app.shager.ai/api/v1/openapi.json). L'équivalent de l'étape 4 ci-dessus en TypeScript :

```typescript
const API = "https://app.shager.ai/api/v1";
const headers = {
  Authorization: `Bearer ${process.env.SHAGER_API_KEY}`,
  "Content-Type": "application/json",
};

const res = await fetch(`${API}/workspaces/${workspaceId}/posts`, {
  method: "POST",
  headers,
  body: JSON.stringify({
    caption: defaultCaption,
    group_ids: [groupId],
    per_channel: captions.map((c) => ({ channel_id: c.channelId, caption: c.text })),
    cta_url: "https://brightline.example/releases/4-2",
    campaign: "release-4-2",
    first_comment: "Full notes: https://brightline.example/releases/4-2",
  }),
});

const body = await res.json();
if (!res.ok) throw new Error(`${body.error.code}: ${body.error.message}`);
console.log(body.data.id, body.data.status); // a DRAFT post
```

Les réponses sont enveloppées dans `{ "data": ... }` et les erreurs dans `{ "error": { "code", "message" } }` : la gestion des erreurs est donc la même partout. Le [guide de démarrage REST](/fr/blog/shager-rest-api-quickstart) couvre toute la séquence.

## Des règles à ajouter au projet

Cursor prend en charge les règles de projet, et une règle courte vous évite de répéter les contraintes dans chaque prompt. Par exemple :

```text
When using the shager MCP server:
Never pass schedule_at unless I explicitly give a date and time.
Always use per_channel captions when posting to more than one account.
Always pass cta_url for any link instead of pasting raw URLs into captions.
Use ISO 8601 with an offset for any time, in the workspace timezone.
```

Les règles orientent le modèle, elles ne contraignent rien. La contrainte réelle, c'est le scope de la clé. Laissez `publish` hors de la clé de l'éditeur, et la première règle ne pourra pas être enfreinte, même si le modèle l'ignore.

## FAQ

### Cursor fonctionne-t-il avec Shager sans OAuth ?

Oui. Cursor envoie tous les en-têtes que vous configurez : la clé API bearer fonctionne directement. Le serveur MCP de Shager prend aussi en charge la connexion OAuth pour les clients qui la préfèrent, mais dans Cursor, la clé suffit.

### Puis-je utiliser la même clé dans Cursor et dans Claude Code ?

C'est possible, mais des clés séparées sont préférables. Chaque appel est enregistré dans le journal d'audit de Shager sous la clé qui l'a émis, et des clés distinctes vous permettent de révoquer un outil sans casser l'autre. La configuration de Claude Code a son propre guide dans cette série.

### L'agent publiera-t-il immédiatement si je lui dis « publie ça » ?

Seulement si la clé possède le scope `publish`, que le compte a été revendiqué par un humain et que l'espace de travail n'exige pas d'abord la validation du client. Avec une clé read et write, la demande échoue avec un 403 explicite, et rien ne part.

## Et ensuite ?

Une fois la connexion en place, le vrai gain vient d'une procédure reproductible plutôt que de prompts ingénieux. Lisez [comment créer un skill Claude pour Shager](/fr/blog/build-a-claude-skill-for-shager) pour la structure, car les mêmes instructions se transposent bien en règles Cursor, et gardez la [page agents](/fr/agents) ouverte comme référence de chaque outil et de chaque champ.

---
Source: https://shager.ai/fr/blog/connect-shager-to-cursor