# Shager per .cursor/mcp.json in Cursor einbinden: aus Release Notes werden Entwürfe für jedes Kundenkonto

_2026-08-28 · Konfiguriere den MCP-Server von Shager in Cursor mit url und Authorization-Header aus einer Umgebungsvariable und mach aus dem Changelog Entwürfe pro Konto._

Um Shager mit Cursor zu verbinden, legst du in deinem Projekt `.cursor/mcp.json` an (oder `~/.cursor/mcp.json` für alle Projekte). Darin steht ein Eintrag `shager` mit der `url` `https://app.shager.ai/api/mcp` und `headers`, die `Authorization` auf `Bearer ${env:SHAGER_API_KEY}` setzen. Cursor löst die Variable aus deiner Umgebung auf, verbindet sich per HTTP, und der Agent bekommt die Tools von Shager. Kein lokaler Server, keine Bridge.

Cursor ist ein spannender Ort, um Distribution zu steuern, denn das Ausgangsmaterial liegt schon im Repo: Changelogs, Doku, Release Notes, Blogentwürfe. Diese Anleitung richtet die Verbindung sauber ein und setzt sie dann genau dafür ein.

## Wie sieht die MCP-Konfiguration in Cursor für einen Remote-Server aus?

Die [MCP-Dokumentation](https://cursor.com/docs/context/mcp) von Cursor beschreibt einen Remote-Server als `url` plus optionales `headers`-Objekt und dokumentiert die Interpolation mit `${env:NAME}` in den Feldern `url` und `headers`. Sie nennt außerdem zwei Speicherorte: `.cursor/mcp.json` im Projekt für projektspezifische Tools und `~/.cursor/mcp.json` im Home-Verzeichnis für Tools, die überall verfügbar sein sollen.

Für Shager:

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

Und in deinem Shell-Profil:

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

Cursor liest Umgebungsvariablen aus dem Prozess, der es gestartet hat. Unter macOS sieht eine App, die über das Dock geöffnet wird, die Variablen aus `~/.zshrc` womöglich nicht. Schlägt der Server mit einem 401 fehl, obwohl der Schlüssel stimmt, beende Cursor und starte es mit `cursor .` aus einem Terminal. So siehst du, ob das die Ursache ist.

## Projektdatei oder globale Datei?

| Speicherort | Gut für | Worauf du achten solltest |
|---|---|---|
| `.cursor/mcp.json` im Repo | Ein Repo für Marketing-Website oder Doku, in dem die Content-Arbeit passiert | Nur in der Form `${env:...}` committen, nie mit einem echten Schlüssel |
| `~/.cursor/mcp.json` | Shager soll in jedem Workspace verfügbar sein | Der Agent jedes Projekts erreicht dann deine Shager-Workspaces |

Für Entwicklerinnen und Entwickler in Agenturen, die mehrere Kundenwebsites betreuen, passt die Projektdatei meist besser. Im Repo von Kunde A sollte kein Agent sitzen, der nebenbei Entwürfe im Workspace von Kunde B anlegen kann. Kombiniere die Projektdatei mit einem Schlüssel, dessen Organisation nur die Workspaces enthält, die zu diesem Repo passen, oder nenne die Workspaces in deinen Prompts zumindest ausdrücklich.

## Woher kommt der Schlüssel?

Ein Mensch legt ihn unter https://app.shager.ai/dashboard/agents an und wählt die Scopes. Für die Arbeit im Editor ist `read` plus `write` der richtige Standard: Der Agent kann Medien hochladen und Entwürfe anlegen, aber ohne den Scope `publish` verweigert Shager das Planen und Veröffentlichen. Wenn du gerade einen Prototyp baust und noch kein Konto hast, kann ein Agent über die [Selbstregistrierung](/en/blog/agent-self-signup-and-claim) eine Sandbox anlegen; die Anleitung steht unter shager.ai/auth.md.

## Wie prüfst du, ob Cursor die Tools sieht?

Öffne die MCP-Einstellungen von Cursor und such nach `shager` mit dem Status verbunden und seiner Tool-Liste: `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` und `get_analytics`. Zeigt der Server einen Fehler, sind die drei üblichen Ursachen: eine fehlende Umgebungsvariable, ein fehlendes `Bearer` im Header-Wert oder ein Syntaxfehler im JSON.

Dann im Agent-Chat:

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

## Der Workflow: aus dem Changelog werden Entwürfe pro Konto

Hier ein konkreter Job, der gut zu Cursor passt. Angenommen, du betreust die Website eines Software-Händlers mit zwölf regionalen Partnerseiten auf Facebook und Instagram. Bei jedem Release schreibt jemand das Changelog von Hand in Social-Media-Beiträge um. Mit verbundenem Shager kann der Agent den ersten Durchgang übernehmen.

```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.
```

Einige Entscheidungen in diesem Prompt sind bewusst getroffen.

Die Fakten bleiben gleich, die Formulierungen variieren. `per_channel` überschreibt den Text für jedes einzelne Konto, und genau das ist das empfohlene Muster. Zwölf Kopien desselben Textes auf verwandten Seiten sind die Art von Wiederholung, vor der unser Beitrag über [Spam-Sperren beim Posten im großen Stil](/en/blog/avoid-spam-blocks-when-posting-at-scale) warnt. Und für alle, die zwei dieser Seiten folgen, liest sich das schlecht.

Der Link wird pro Konto getrackt. Mit `cta_url` erzeugt Shager für jedes Konto einen eigenen Kurzlink und eigene UTM-Parameter, wobei `utm_content` das Konto kennzeichnet. Später liefert `get_analytics` die Klicks pro Konto und pro Beitrag, und der Partner in jeder Region sieht, was seine Seite gebracht hat.

Das Ergebnis ist ein Entwurf. Bevor er rausgeht, liest ihn noch jemand in Shager, entweder intern oder der Kunde über einen Freigabelink.

## Und wenn du die API lieber aus dem Code aufrufen willst?

Manchmal soll das ein Skript im Repo sein statt eines Chats. Ein Release-Workflow in der CI zum Beispiel sollte nicht davon abhängen, dass jemand Cursor öffnet. Dieselben Operationen gibt es per REST, beschrieben im [OpenAPI-Dokument](https://app.shager.ai/api/v1/openapi.json). Das Gegenstück zu Schritt 4 oben in 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
```

Antworten stecken in `{ "data": ... }`, Fehler in `{ "error": { "code", "message" } }`. Die Fehlerbehandlung ist also überall dieselbe. Der [REST-Quickstart](/en/blog/shager-rest-api-quickstart) geht die komplette Abfolge durch.

## Regeln, die sich fürs Projekt lohnen

Cursor unterstützt Projektregeln, und eine kurze Regel erspart dir, dieselben Vorgaben in jedem Prompt zu wiederholen. Etwa so:

```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.
```

Regeln sind Hinweise an das Modell, keine Durchsetzung. Durchgesetzt wird über den Scope des Schlüssels. Lass `publish` beim Editor-Schlüssel weg, dann kann die erste Regel nicht gebrochen werden, selbst wenn das Modell sie ignoriert.

## FAQ

### Funktioniert Shager in Cursor ohne OAuth?

Ja. Cursor schickt die Header mit, die du konfigurierst, der Bearer-API-Schlüssel funktioniert also direkt. Der MCP-Server von Shager unterstützt auch die Anmeldung per OAuth für Clients, die das bevorzugen, aber in Cursor reicht der Schlüssel.

### Kann ich denselben Schlüssel in Cursor und Claude Code verwenden?

Kannst du, getrennte Schlüssel sind aber besser. Jeder Aufruf landet im Audit-Log von Shager unter dem Schlüssel, der ihn ausgelöst hat, und mit getrennten Schlüsseln kannst du einem Tool den Zugriff entziehen, ohne das andere lahmzulegen. Für das Setup von Claude Code gibt es in dieser Reihe eine eigene Anleitung.

### Postet der Agent sofort, wenn ich „veröffentliche das“ sage?

Nur wenn der Schlüssel den Scope `publish` hat, das Konto von einem Menschen übernommen wurde und der Workspace nicht vorher eine Kundenfreigabe verlangt. Mit einem read/write-Schlüssel scheitert die Anfrage mit einem eindeutigen 403, und nichts geht raus.

## Nächster Schritt

Sobald die Verbindung steht, bringt eine wiederholbare Vorgehensweise mehr als clevere Prompts. Lies, [wie du einen Claude-Skill für Shager baust](/en/blog/build-a-claude-skill-for-shager), um die Struktur zu verstehen; dieselben Anweisungen lassen sich gut in Cursor-Regeln übertragen. Und halte die [Seite für Agenten](/en/agents) als Referenz für jedes Tool und jedes Feld offen.

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