Connect Palate

Palate is a hosted MCP server. Once connected, your AI coding agent can search 2,169 deeply-analysed real websites and build with their craft instead of defaulting to generic. Three steps: get a token, connect your tool, verify.

Curious what the build itself is made of? The stack, and why walks through every framework, hosting and quality choice with the honest trade-off for each.

You need an account first

The MCP is token-gated. Without a valid token every request returns 401 unauthorised, so there is no anonymous access. Creating a token is free and takes a minute.

Step 1

Get your token

  1. 01

    Go to app.palatemcp.com and sign in with Google, GitHub, or a one-time email code. Palate is passwordless: there is no password to create, remember, or reset.

  2. 02

    You land straight on the dashboard. (Free tier: 50 deep reference reads a month, search is unlimited, no card required.)

  3. 03

    In the dashboard, open TokensCreate token, give it a name (e.g. "Claude Code"), and copy the key. It starts with plt_live_ and is shown once, so save it somewhere safe.

Step 2

Connect your tool

Pick your platform below. Everywhere you see YOUR_TOKEN, paste the plt_live_ key from step 1.

Claude Code

Recommended: install the plugin. It adds the website-builder skill and the build-quality hooks, and /plugin marketplace update palate keeps it current (restart Claude Code after an update so the new version loads).

In Claude Code, run these as two separate commands (slash commands run one at a time, so paste the first, press enter, then the second):

/plugin marketplace add jake-jiffi/palate-marketplace
/plugin install palate-website-builder@palate

Install failed with "Host key verification failed"?

A known Claude Code installer issue clones plugins over SSH with strict host checking, which fails on machines that have never connected to GitHub over SSH. Fix it once, then rerun the install:

mkdir -p ~/.ssh && ssh-keyscan -t ed25519 github.com >> ~/.ssh/known_hosts

A freshly installed plugin is not active until you reload it. Run /reload-plugins (or restart Claude Code) so the website-builder skill loads.

Then connect the Palate MCP. There are two paths, both work, pick whichever you prefer.

With your token (deterministic). One header, no browser round-trip, and it works the same in every client (terminal, IDE extension, desktop, CI). It connects straight away, with no sign-in step:

claude mcp add --scope user --transport http palate https://mcp.palatemcp.com/api/mcp --header "Authorization: Bearer YOUR_TOKEN"

Or sign in with your browser (no token to copy). The same command without the header:

claude mcp add --scope user --transport http palate https://mcp.palatemcp.com/api/mcp

Adding the server does not sign you in by itself, you'll see ! Needs authentication. To finish: start Claude Code, run /mcp, select palate, choose Authenticate, and click Allow in the browser. After you allow, the browser finishes on a localhost page saying authorization successful, that page is your own Claude Code confirming the connection (not an error). Return to your terminal, palate then shows connected. No token, no environment variables.

--scope user is required. Without it, claude mcp add defaults to the current project, so Palate only exists in this directory. A build runs in a fresh directory and would silently lose the refs_* tools.

Run /mcp to confirm palate is connected. Either command on its own (without the plugin) also gives you the refs_* tools.

Cursor, Windsurf, VS Code and Claude Desktop use the token path below.

Claude Desktop

Claude Desktop connects to a bearer-auth server through the mcp-remote bridge (it needs Node.js 18+, which covers the bridge only; running a build needs Node 22+). Open Settings → Developer → Edit Config, or edit the file directly:

  • macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Windows: %APPDATA%\\Claude\\claude_desktop_config.json
{
  "mcpServers": {
    "palate": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "https://mcp.palatemcp.com/api/mcp",
        "--header",
        "Authorization: Bearer YOUR_TOKEN"
      ]
    }
  }
}

Save the file and fully restart Claude Desktop. Palate appears under the tools menu.

Cursor

Create .cursor/mcp.json in your project root (or ~/.cursor/mcp.json for all projects).

{
  "mcpServers": {
    "palate": {
      "url": "https://mcp.palatemcp.com/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_TOKEN"
      }
    }
  }
}

Windsurf

Edit ~/.codeium/windsurf/mcp_config.json (note Windsurf uses serverUrl).

{
  "mcpServers": {
    "palate": {
      "serverUrl": "https://mcp.palatemcp.com/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_TOKEN"
      }
    }
  }
}

VS Code (Copilot agent mode)

Create .vscode/mcp.json in your workspace (VS Code uses servers with a type).

{
  "servers": {
    "palate": {
      "type": "http",
      "url": "https://mcp.palatemcp.com/api/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_TOKEN"
      }
    }
  }
}

Cline, Zed, Codex, Gemini CLI, ChatGPT, and any other MCP client

Any client that speaks streamable-HTTP MCP connects with your token in an Authorization: Bearer header. The dashboard token page hands you each block with your real token already baked in. The generic shape is:

URL:     https://mcp.palatemcp.com/api/mcp
Header:  Authorization: Bearer YOUR_TOKEN

Cline

Edit the Cline MCP settings JSON. macOS path: ~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json (open it via the MCP Servers icon in Cline's top toolbar -> Configure tab -> "Configure MCP Servers" button). CLI users edit ~/.cline/mcp.json instead.

{
  "mcpServers": {
    "palate": {
      "type": "streamableHttp",
      "url": "https://mcp.palatemcp.com/api/mcp",
      "headers": {
        "Authorization": "Bearer plt_live_YOUR_TOKEN"
      },
      "disabled": false,
      "autoApprove": []
    }
  }
}

Official docs: https://docs.cline.bot/mcp/mcp-transport-mechanisms

Zed

Config file: ~/.config/zed/settings.json (global, macOS/Linux) or .zed/settings.json (per-project). No CLI; add the entry under the top-level "context_servers" key.

{
  "context_servers": {
    "palate": {
      "url": "https://mcp.palatemcp.com/api/mcp",
      "headers": {
        "Authorization": "Bearer plt_live_YOUR_TOKEN"
      }
    }
  }
}

Official docs: https://zed.dev/docs/ai/mcp

OpenAI Codex CLI

Edit ~/.codex/config.toml (global) or .codex/config.toml (project-scoped). Equivalent CLI: codex mcp add palate --url https://mcp.palatemcp.com/api/mcp --bearer-token-env-var PALATE_MCP_TOKEN

# ~/.codex/config.toml
[mcp_servers.palate]
url = "https://mcp.palatemcp.com/api/mcp"
bearer_token_env_var = "PALATE_MCP_TOKEN"

# Then export the token in your shell profile (~/.zshrc or ~/.bashrc),
# NOT inside config.toml:
#   export PALATE_MCP_TOKEN="plt_live_YOUR_TOKEN"

Official docs: https://developers.openai.com/codex/mcp

Google Gemini CLI

CLI: `gemini mcp add` (recommended) OR edit the settings.json file directly. User scope file: ~/.gemini/settings.json. Project scope file: .gemini/settings.json (this is the CLI default scope).

Option A — one-shot CLI (recommended; -s user writes it globally):

gemini mcp add --transport http -s user -H "Authorization: Bearer plt_live_YOUR_TOKEN" palate https://mcp.palatemcp.com/api/mcp

Option B — hand-edit ~/.gemini/settings.json (note the key is httpUrl, not url):

{
  "mcpServers": {
    "palate": {
      "httpUrl": "https://mcp.palatemcp.com/api/mcp",
      "headers": {
        "Authorization": "Bearer plt_live_YOUR_TOKEN"
      }
    }
  }
}

Official docs: https://github.com/google-gemini/gemini-cli/blob/main/docs/tools/mcp-server.md

ChatGPT (Developer Mode connectors) (OAuth, no static token)

ChatGPT web UI (no CLI / no config file): Settings -> Apps & Connectors -> Advanced settings -> Developer mode, then the "Create" button on Apps & Connectors.

ChatGPT -> Settings -> Apps & Connectors -> Create

Name:            palate
Description:     Palate MCP - the taste layer for AI website builders
MCP Server URL:  https://mcp.palatemcp.com/api/mcp
Authentication:  OAuth

# There is NO header / API-key field in ChatGPT's connector UI.
# The static bearer (Authorization: Bearer PLT_LIVE_TOKEN) is NOT used by ChatGPT.
# Connect via the OAuth browser flow (sign in to your Palate account at the consent screen).

Official docs: https://developers.openai.com/api/docs/guides/developer-mode

Step 3

Verify it works

Ask your agent to call a tool. A simple first call lists every vertical in the library:

Ask your agent: "Use Palate's refs_list_verticals tool and show me the verticals."

You should get back a list of verticals with counts. If you instead see 401 unauthorised, jump to troubleshooting.

Step 4

Build a website

Connecting the MCP gives your agent the refs_* tools (look-ups). The Claude Code plugin adds the website-builder skill on top, so you can ask Claude to build a whole production site grounded by the library, not just query it. If you installed the plugin during setup you already have it; if you only ran claude mcp add, add it now (two separate commands):

/plugin marketplace add jake-jiffi/palate-marketplace
/plugin install palate-website-builder@palate

Run /reload-plugins (or restart Claude Code) so the newly installed skill loads.

Then just ask Claude, in plain language:

Build a site for {client}, {domain}. Brand assets at {path}.

The skill surveys the library for real design taste, then scaffolds a production Astro project (Sanity CMS, SEO, forms, the client's brand package) and can deploy a shareable preview. There's also a brand-package mode, "Build a brand package for {client}, assets at {path}." The bundled build-quality hooks make sure it actually draws on the library before it writes any code.

Building with Cursor, Codex, Gemini or Copilot

The website-builder skill is a Claude Code plugin, but the build doctrine, the Astro stack and the quality gate are portable. One command scaffolds a real Astro project (Astro 6, Tailwind, Vercel) with the doctrine in your tool's rules file and the gate wired in as a git pre-push hook and CI:

curl -fsSL https://raw.githubusercontent.com/jake-jiffi/palate-website-builder/main/scripts/create-palate.sh | bash -s -- my-site codex

Swap codex for cursor, gemini or copilot. Your agent then surveys the library, works the concept-first build spine, and builds in src/pages. Before you ship, the gate runs both floors the Claude plugin runs, a real Astro build (no freestyle HTML) and the anti-slop lint:

curl -fsSL https://raw.githubusercontent.com/jake-jiffi/palate-website-builder/main/scripts/palate-verify.sh | bash -s -- ./

What stays Claude-only: the in-editor auto-gates and the visual self-review loop. The taste, the stack and the deterministic floor run anywhere.

Tools reference

Palate exposes ten refs_* tools. Your agent calls them automatically once connected.

Tool What it does
refs_search Search the library by facet (vertical, page type, UX pattern, style, and more).
refs_match_brief Match a free-text brief to the best references and get a binding playbook.
refs_for_business Find references for a specific business type, with honest coverage notes.
refs_get Read one reference in full: tokens, do/don't, component prompts, inner pages.
refs_get_tokens Get the extracted design tokens (palette, type scale, radii, easings).
refs_get_screenshot Get screenshots of a reference (homepage and captured inner pages).
refs_get_astro_recipe Get the Astro rebuild recipe: islands, motion mapping, token bridge.
refs_similar Find references similar to a given one, by meaning across the library.
refs_list_verticals List every vertical with counts, subtypes, and example slugs.
refs_insights Corpus-level insights: trends, clusters, mechanics, emotional registers.

Troubleshooting

401 unauthorised (token path)
The token is missing, mistyped, or revoked. Check the header is exactly Authorization: Bearer plt_live_… (the word "Bearer", a space, then the key). If it was revoked, create a new one in the dashboard.

The browser ended on a localhost page

That is the success step: after you approve, your own Claude Code (listening on your machine) receives the sign-in and shows "authorization successful". Return to your terminal. If that page says connection refused instead, the usual cause is running Claude Code on a different machine (SSH, a devbox) from your browser, the loopback cannot cross machines. Connect with a token instead (the deterministic path above), it has no browser step at all.

401 unauthorised (OAuth path)
Connected after the browser sign-in, but every call still returns 401? Your account needs to be provisioned once. Open the dashboard at app.palatemcp.com once to provision it, or run claude mcp remove palate and re-Authorise.
"MCP server palate skipped" after an update
An older bundled version is cached. Restart Claude Code (or run /mcp and reconnect) and the warning clears.
The sign-in code did not arrive
Codes come from send.palatemcp.com and usually land in seconds; check spam once, then use Resend code (a fresh code invalidates the old one). Google or GitHub sign-in also works immediately. Codes expire after 10 minutes.
Claude Desktop: "npx" or "mcp-remote" not found
Install Node.js 18+ (which includes npx), then fully restart Claude Desktop. That 18+ floor is for the Claude Desktop bridge only; running a build needs Node 22+.
Hitting the daily limit
The free tier allows 50 deep reference reads a month (search is unlimited). Upgrade to Pro for unlimited deep reads in the dashboard.