New Semantics

English

Deutsch

English

Deutsch

Theme

Connect your LLM to the CMS (MCP Server) ​

You will connect an LLM client — Claude Code, Cursor, or Claude Desktop — to your CMS so it can read and maintain your site: design, pages, menus, media, SEO, and more. When you finish, your client lists the newmeta tools, answers a ping, and can read your design tokens.

The MCP Server speaks the Model Context Protocol over HTTP. The client authenticates with a Bearer token you create in the Backend, and every tool call is scoped and audited.

What you'll need ​

  • A Backend account with admin permission (you create and manage MCP tokens).
  • An MCP-capable client: Claude Code (CLI), Cursor, or Claude Desktop.
  • Your CMS URL, e.g. https://example.com.

Where things happen

The MCP endpoint is https://{your-domain}/api/backend/mcp. The token panel is in the Backend under MCP Server (/admin/mcp). The client talks to the endpoint; you manage access in the Backend.

1. Open the MCP Server panel ​

Click MCP Server in the Backend sidebar. The panel opens with three sections: Create MCP token, MCP tokens, and Connect a client.

MCP Server panel with token creation, token list, and connect sections
The MCP Server panel manages tokens and shows the connect command.

Screenshot pending

This page references screenshots that still need to be captured against the demo site. They do not block the build — the <Screenshot> component renders a placeholder until the PNG exists.

2. Create a token with the right scopes ​

In Create MCP token, enter a Name (e.g. Cursor — Designer), tick the Scopes the client needs, optionally set Expires (optional), and click Create token.

Token creation form with name, scope checkboxes, and expiry date
Grant only the scopes the client needs.

Scopes follow least-privilege — grant the minimum and nothing more:

ScopeWhat it unlocks
readRead-only inspection: pages, structure, design tokens, settings, menus, media search, SEO settings, versions.
designSave the site Custom LESS / design tokens (writes live).
contentBuild and edit pages in the Pagebuilder (draft), SEO meta, settings, redirects, versions, vibecode.
menuCreate and edit navigation menu items (writes live).
mediaCreate media folders, upload, and rename media (writes live).
publishPromote a page Draft to live. Separate and explicit — without it, the client cannot publish at all.

Grant publish deliberately

publish is never covered by any other scope, not even a wildcard. Leave it off unless you want the client to be able to take pages live. The publish tool only runs when you explicitly ask the client to publish a specific page — never as part of a build or edit flow.

Draft-first by design

Pagebuilder edits, page content, and page SEO are written to the Draft, not to the live site. They become visible only when an operator publishes. Live-writing tools — design/LESS, master data, menu, SEO site settings, media, redirects — change the site immediately. The Tool Reference marks each tool Draft or Live.

3. Copy the token — once ​

After you click Create token, the full token appears once. It starts with nscms_mcp_. Click Copy and store it in your client's secret store now — you cannot retrieve it again.

One-time token reveal with a copy button
The full token is shown only once. Copy it immediately.

The full token is shown only once

The Backend stores only a hash. If you lose the token, you cannot recover it — revoke it in the MCP tokens list and create a new one. The list shows only the prefix (nscms_mcp_…), the granted scopes, and the last-used time.

4. Configure your client ​

Every MCP client needs the same three facts. The rest of this step is just where each client wants them:

  • Transport: Streamable HTTP.
  • Endpoint: https://{your-domain}/api/backend/mcp.
  • Header: Authorization: Bearer <token> — the nscms_mcp_… token from step 3.

Any spec-compliant MCP client connects by pointing it at that URL with that header. The Connect a client section in the Backend shows the ready-to-paste command for your own CMS URL.

HTTPS only

The endpoint must be reachable over HTTPS at your real domain. The server validates the Bearer token on every request and rejects anything without a valid nscms_mcp_… token with a 401.

Pick your client below. Replace {your-domain} with your CMS host and nscms_mcp_… with the token you copied in step 3.

Claude Code (CLI) ​

Run this in a terminal:

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

This registers a server named newmeta. Use claude mcp list to confirm it is connected.

Claude Desktop ​

Open Settings → Connectors, click Add custom connector, and enter the remote URL https://{your-domain}/api/backend/mcp plus the Authorization: Bearer nscms_mcp_… header.

Needs a recent Claude Desktop

Custom/remote connectors require a recent Claude Desktop build. Older builds have no remote-connector UI and no per-server header field — on those, bridge the connection with mcp-remote, which forwards the header for you:

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

Cursor ​

Add a server to ~/.cursor/mcp.json (global, all projects) or .cursor/mcp.json (this project only):

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

VS Code (GitHub Copilot agent mode) ​

Add a server to .vscode/mcp.json in your workspace:

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

The tools become available to Copilot Chat in Agent mode.

ChatGPT ​

There are two routes, depending on what you have access to:

  • ChatGPT app — Developer mode → Connectors: add a remote MCP server by URL (https://{your-domain}/api/backend/mcp) and supply the Authorization: Bearer nscms_mcp_… header. This is available on eligible paid plans and is currently in beta.
  • OpenAI Responses API: pass the server as an mcp tool:
json
{
  "tools": [
    {
      "type": "mcp",
      "server_label": "newmeta",
      "server_url": "https://{your-domain}/api/backend/mcp",
      "headers": {
        "Authorization": "Bearer nscms_mcp_…"
      }
    }
  ]
}

ChatGPT MCP support is evolving

ChatGPT's connector / MCP availability depends on your plan and is changing fast (parts are beta or limited to specific tiers). If the Developer mode connector option is missing, fall back to the Responses API route, or use a different MCP client. Check the current OpenAI docs for what your plan supports.

Any other MCP client (generic fallback) ​

Windsurf, Cline, Zed, and other spec-compliant MCP clients work the same way: point them at the Streamable HTTP endpoint https://{your-domain}/api/backend/mcp and send the header Authorization: Bearer <token>. The exact config file or UI differs per client, but the three facts at the top of this step are all any of them need.

5. Verify the connection with ping ​

Restart the client so it reloads its MCP servers, then ask it to call the ping tool. A healthy server returns pong plus the authenticated tenant and the scopes your token carries.

text
Use the newmeta ping tool.
→ pong — tenant: example.com, scopes: read, content

If the scopes in the ping response do not match what you granted, you are using the wrong token — check the header in your client config.

6. Run your first read call ​

Ask the client to read your design tokens. With the read scope, this calls get_design_tokens and returns the site's live Custom LESS variables.

text
Read the current design tokens of the site.

From here, the client can list pages (list_pages), inspect a page's structure (get_page_structure), and — with the matching scopes — build and edit content. See the MCP Tool Reference for the full catalog.

What you've learned ​

  • How to create a scoped MCP token in the Backend.
  • What each scope unlocks, and why publish is separate.
  • How to configure Claude Code, Claude Desktop, Cursor, VS Code, ChatGPT, or any other MCP client with HTTP + Bearer.
  • How to verify the connection with ping and run a first read call.
  • The Draft-first model: most edits stay in the Draft until an operator publishes.

See also ​