New Semantics

Deutsch

English

Deutsch

English

Theme

LLM mit dem CMS verbinden (MCP-Server) ​

Du verbindest einen LLM-Client — Claude Code, Cursor oder Claude Desktop — mit deinem CMS, damit er deine Website lesen und pflegen kann: Design, Seiten, Menues, Medien, SEO und mehr. Am Ende listet dein Client die newmeta-Tools, beantwortet ein ping und kann deine Design-Tokens lesen.

Der MCP-Server spricht das Model Context Protocol ueber HTTP. Der Client authentifiziert sich mit einem Bearer-Token, das du im Backend anlegst, und jeder Tool-Aufruf ist scope-begrenzt und wird auditiert.

Was du brauchst ​

  • Ein Backend-Zugang mit Admin-Rechten (du legst MCP-Tokens an und verwaltest sie).
  • Einen MCP-faehigen Client: Claude Code (CLI), Cursor oder Claude Desktop.
  • Deine CMS-URL, z. B. https://example.com.

Wo was passiert

Der MCP-Endpoint ist https://{deine-domain}/api/backend/mcp. Das Token-Panel liegt im Backend unter MCP Server (/admin/mcp). Der Client spricht mit dem Endpoint; den Zugriff verwaltest du im Backend.

1. Das MCP-Server-Panel oeffnen ​

Klick in der Backend-Seitenleiste auf MCP Server. Das Panel oeffnet sich mit drei Bereichen: MCP-Token erstellen, MCP-Tokens und Client verbinden.

MCP-Server-Panel mit Token-Erstellung, Token-Liste und Verbinden-Bereich
Das MCP-Server-Panel verwaltet Tokens und zeigt den Verbinden-Befehl.

Screenshot ausstehend

Diese Seite verweist auf Screenshots, die noch gegen die Demo-Seite aufgenommen werden muessen. Sie brechen den Build nicht — die <Screenshot>-Komponente zeigt einen Platzhalter, bis das PNG existiert.

2. Token mit den richtigen Scopes anlegen ​

Gib unter MCP-Token erstellen einen Namen ein (z. B. Cursor — Designer), hake die benoetigten Scopes an, setze optional Ablauf (optional) und klick auf Token erstellen.

Token-Formular mit Name, Scope-Checkboxen und Ablaufdatum
Vergib nur die Scopes, die der Client wirklich braucht.

Scopes folgen dem Least-Privilege-Prinzip — vergib das Minimum und nichts darueber hinaus:

ScopeWas er freischaltet
readNur-Lesen: Seiten, Struktur, Design-Tokens, Stammdaten, Menues, Media-Suche, SEO-Einstellungen, Versionen.
designSpeichert das Custom LESS / die Design-Tokens der Seite (schreibt live).
contentSeiten im Pagebuilder bauen und bearbeiten (Entwurf), SEO-Meta, Stammdaten, Weiterleitungen, Versionen, Vibecode.
menuNavigations-Menueeintraege anlegen und bearbeiten (schreibt live).
mediaMedia-Ordner anlegen, Medien hochladen und umbenennen (schreibt live).
publishEinen Seiten-Entwurf live schalten. Separat und explizit — ohne diesen Scope kann der Client gar nicht publizieren.

publish bewusst vergeben

publish ist niemals von einem anderen Scope abgedeckt, auch nicht von einem Wildcard. Lass ihn weg, ausser du willst, dass der Client Seiten live schalten darf. Das Publish-Tool laeuft nur, wenn du den Client ausdruecklich bittest, eine bestimmte Seite zu publizieren — nie als Teil eines Bau- oder Edit-Flows.

Draft-First per Design

Pagebuilder-Aenderungen, Seiteninhalte und Seiten-SEO werden in den Entwurf geschrieben, nicht auf die Live-Seite. Sie werden erst sichtbar, wenn ein Operator publiziert. Live schreibende Tools — Design/LESS, Stammdaten, Menue, SEO-Site-Einstellungen, Medien, Weiterleitungen — aendern die Seite sofort. Die Tool-Referenz kennzeichnet jedes Tool mit Entwurf oder Live.

3. Token kopieren — nur einmal ​

Nach dem Klick auf Token erstellen erscheint das vollstaendige Token genau einmal. Es beginnt mit nscms_mcp_. Klick auf Kopieren und leg es jetzt im Secret-Store deines Clients ab — du kannst es nicht erneut abrufen.

Einmalige Token-Anzeige mit Kopier-Button
Das vollstaendige Token wird nur einmal angezeigt. Kopiere es sofort.

Das vollstaendige Token wird nur einmal angezeigt

Das Backend speichert nur einen Hash. Wenn du das Token verlierst, kannst du es nicht wiederherstellen — widerrufe es in der Liste MCP-Tokens und lege ein neues an. Die Liste zeigt nur den Prefix (nscms_mcp_…), die vergebenen Scopes und den letzten Nutzungszeitpunkt.

4. Client konfigurieren ​

Jeder MCP-Client braucht dieselben drei Angaben. Der Rest dieses Schritts ist nur, wo der jeweilige Client sie erwartet:

  • Transport: Streamable HTTP.
  • Endpoint: https://{your-domain}/api/backend/mcp.
  • Header: Authorization: Bearer <token> — das nscms_mcp_…-Token aus Schritt 3.

Jeder Spec-konforme MCP-Client verbindet sich, indem du ihn auf diese URL mit diesem Header zeigst. Der Bereich Client verbinden im Backend zeigt den fertigen Befehl fuer deine eigene CMS-URL.

Nur HTTPS

Der Endpoint muss ueber HTTPS unter deiner echten Domain erreichbar sein. Der Server prueft das Bearer-Token bei jedem Request und weist alles ohne gueltiges nscms_mcp_…-Token mit einem 401 ab.

Waehle unten deinen Client. Ersetze {your-domain} durch deinen CMS-Host und nscms_mcp_… durch das in Schritt 3 kopierte Token.

Claude Code (CLI) ​

Fuehre das in einem Terminal aus:

bash
claude mcp add --transport http newmeta https://{your-domain}/api/backend/mcp --header "Authorization: Bearer nscms_mcp_…"

Das registriert einen Server namens newmeta. Mit claude mcp list pruefst du, ob er verbunden ist.

Claude Desktop ​

Oeffne Settings → Connectors, klick auf Add custom connector und gib die Remote-URL https://{your-domain}/api/backend/mcp plus den Header Authorization: Bearer nscms_mcp_… ein.

Braucht ein aktuelles Claude Desktop

Custom-/Remote-Connectors erfordern ein aktuelles Claude-Desktop-Build. Aeltere Builds haben keine Remote-Connector-UI und kein Header-Feld pro Server — dort ueberbrueckst du die Verbindung mit mcp-remote, das den Header fuer dich weiterreicht:

json
{
  "mcpServers": {
    "newmeta": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://{your-domain}/api/backend/mcp",
        "--header",
        "Authorization: Bearer nscms_mcp_…"
      ]
    }
  }
}

Cursor ​

Fuege einen Server in ~/.cursor/mcp.json (global, alle Projekte) oder .cursor/mcp.json (nur dieses Projekt) hinzu:

json
{
  "mcpServers": {
    "newmeta": {
      "url": "https://{your-domain}/api/backend/mcp",
      "headers": {
        "Authorization": "Bearer nscms_mcp_…"
      }
    }
  }
}

VS Code (GitHub Copilot Agent-Modus) ​

Fuege einen Server in .vscode/mcp.json in deinem Workspace hinzu:

json
{
  "servers": {
    "newmeta": {
      "type": "http",
      "url": "https://{your-domain}/api/backend/mcp",
      "headers": {
        "Authorization": "Bearer nscms_mcp_…"
      }
    }
  }
}

Die Tools stehen dann im Copilot-Chat im Agent-Modus zur Verfuegung.

ChatGPT ​

Es gibt zwei Wege, je nachdem, worauf du Zugriff hast:

  • ChatGPT-App — Developer mode → Connectors: fuege einen Remote-MCP-Server per URL (https://{your-domain}/api/backend/mcp) hinzu und gib den Header Authorization: Bearer nscms_mcp_… an. Das ist auf berechtigten Bezahl-Plaenen verfuegbar und derzeit Beta.
  • OpenAI Responses API: uebergib den Server als mcp-Tool:
json
{
  "tools": [
    {
      "type": "mcp",
      "server_label": "newmeta",
      "server_url": "https://{your-domain}/api/backend/mcp",
      "headers": {
        "Authorization": "Bearer nscms_mcp_…"
      }
    }
  ]
}

ChatGPTs MCP-Unterstuetzung entwickelt sich

ChatGPTs Connector-/MCP-Verfuegbarkeit haengt von deinem Plan ab und aendert sich schnell (Teile sind Beta oder auf bestimmte Stufen begrenzt). Fehlt die Connector-Option im Developer mode, weiche auf den Responses-API-Weg aus oder nutze einen anderen MCP-Client. Pruefe die aktuelle OpenAI-Doku fuer das, was dein Plan unterstuetzt.

Jeder andere MCP-Client (generischer Fallback) ​

Windsurf, Cline, Zed und andere Spec-konforme MCP-Clients funktionieren gleich: zeige sie auf den Streamable-HTTP-Endpoint https://{your-domain}/api/backend/mcp und sende den Header Authorization: Bearer <token>. Die genaue Konfigurationsdatei oder UI unterscheidet sich je Client, aber die drei Angaben oben in diesem Schritt sind alles, was jeder von ihnen braucht.

5. Verbindung mit ping pruefen ​

Starte den Client neu, damit er seine MCP-Server neu laedt, und bitte ihn dann, das Tool ping aufzurufen. Ein gesunder Server gibt pong plus den authentifizierten Tenant und die Scopes deines Tokens zurueck.

text
Nutze das newmeta-Tool ping.
→ pong — tenant: example.com, scopes: read, content

Wenn die Scopes in der ping-Antwort nicht zu dem passen, was du vergeben hast, nutzt du das falsche Token — pruefe den Header in deiner Client-Konfiguration.

6. Ersten Read-Call ausfuehren ​

Bitte den Client, deine Design-Tokens zu lesen. Mit dem Scope read ruft das get_design_tokens auf und gibt die Live-Custom-LESS-Variablen der Seite zurueck.

text
Lies die aktuellen Design-Tokens der Seite.

Von hier aus kann der Client Seiten listen (list_pages), die Struktur einer Seite inspizieren (get_page_structure) und — mit den passenden Scopes — Inhalte bauen und bearbeiten. Die vollstaendige Liste steht in der MCP-Tool-Referenz.

Was du gelernt hast ​

  • Wie du ein scope-begrenztes MCP-Token im Backend anlegst.
  • Was jeder Scope freischaltet und warum publish separat ist.
  • Wie du Claude Code, Claude Desktop, Cursor, VS Code, ChatGPT oder jeden anderen MCP-Client mit HTTP + Bearer konfigurierst.
  • Wie du die Verbindung mit ping pruefst und einen ersten Read-Call ausfuehrst.
  • Das Draft-First-Modell: die meisten Aenderungen bleiben im Entwurf, bis ein Operator publiziert.

Siehe auch ​