MCP server

Klype MCP server for Claude, ChatGPT, Cursor and VS Code

Klype is a GTM and content intelligence platform with an API and an MCP server. Connect it to your assistant and it can read your saved product, buyer and voice context, draft LinkedIn and other social posts in your measured voice, check any draft before it goes out and record your approval. It never publishes: a person approves and posts every post.

Endpoint: https://api.klype.ai/api/v1/mcp (streamable HTTP, JSON-RPC answered in the same response; protocol versions 2025-06-18, 2025-03-26 and 2024-11-05)
Registry name: ai.klype/klype

What it does

  • Context. Your assistant reads the workspace Klype keeps for each business: product, audience, positioning and voice notes.
  • Drafts. draft_post writes in the owner's measured voice for LinkedIn, X, Instagram, Facebook or Reddit and returns a draft with published: false.
  • Check. review_draft scores any text, including text the assistant wrote itself, against voice, saved facts, machine-writing patterns and publishing rules, and lists the fixes.
  • Approval record. approve_draft records the owner's approval; list_approvals reads the record back.
  • Results. get_performance_insights reports what has performed, from the owner's imported post results.

The server tells clients the intended order: list_workspaces, then get_workspace_context, then draft_post; run review_draft before the owner posts; call approve_draft only when the owner says they approve.

The 7 tools

ToolWhat it doesScopeRead or write
list_workspaces
List Klype workspaces
Lists the business workspaces saved in Klype. Each holds one company's product, buyer and voice context.
Inputs: none
context:readRead
get_workspace_context
Get workspace context
Returns the saved product, audience, positioning and voice notes for one workspace. Use it before writing anything for that business.
Inputs: workspaceId (required)
context:readRead
draft_post
Draft a post in the owner's voice
Writes a social post draft in the account owner's measured writing voice, grounded in the workspace context. Returns a draft only; nothing is published.
Inputs: brief (required); platform: linkedin (default), twitter, instagram, facebook, reddit; workspaceId; tone: professional, conversational, inspiring, educational, storytelling, humorous; context
drafts:writeWrite (creates a draft, publishes nothing)
list_approvals
List approval record
Returns the owner's approval record: what they scheduled, published or copied, when, and how much of each Klype draft they edited.
Inputs: limit: 1 to 500, default 50
approvals:readRead
review_draft
Check a draft before it goes out
Checks any text against the owner's measured writing voice, the facts saved for their business, machine-writing patterns and their company's publishing rules. Returns a 0-100 score, a verdict (ready, needs_changes, blocked), specific fixes and a reviewId for approve_draft.
Inputs: text (required); workspaceId (defaults to the first); platform: linkedin, twitter, instagram, facebook, reddit, email, blog, other; sourceText
context:readWrite (stores the check)
approve_draft
Record the owner's approval
Records in the owner's approval record that they approved a checked draft. Call only when the owner has explicitly said they approve it. Does not publish anything.
Inputs: reviewId (required); finalText
drafts:writeWrite (adds an approval entry, publishes nothing)
get_performance_insights
What has worked for this owner
Returns what has performed for the owner from their imported post results: engagement by format, length, day and how much they edited Klype drafts, plus their top posts.
Inputs: workspaceId
context:readRead

A connection only sees the tools its scopes allow: tools/list is filtered by scope, and a call without the scope returns an error. The full schemas are public in the server card.

Sign-in options

OAuth 2.1 (recommended for Claude and ChatGPT)

  • Your client discovers Klype's authorization server from https://api.klype.ai/.well-known/oauth-protected-resource and https://api.klype.ai/.well-known/oauth-authorization-server.
  • Dynamic client registration: the client registers itself, so there is no client ID to copy.
  • PKCE with S256 is required. Plain PKCE and requests without PKCE are refused.
  • You sign in to Klype and approve the connection on a consent screen that shows the permissions asked for.
  • Access tokens last 1 hour. Refresh tokens last 90 days and rotate on every use; if an old refresh token is ever reused, the whole connection is revoked.
  • A client that requests no recognised scope gets context:read only.

API key (Bearer)

  • Create a key on the Connections page of the Klype app. Keys start with klp_live_, are shown once and stored only as a SHA-256 hash.
  • Choose scopes when you create it; with none chosen it gets all three. Up to 10 active keys per account.
  • Send it as Authorization: Bearer klp_live_.... Keys only work on the Klype API and MCP endpoint, never on billing, account or admin routes.

Connect it

Claude (claude.ai and Claude Desktop)

  1. Open Settings > Connectors > Add custom connector.
  2. Name: Klype. URL: https://api.klype.ai/api/v1/mcp.
  3. Click Add, then Connect. Sign in to Klype and approve the permissions.
  4. In a chat, enable the Klype connector from the tools menu.

ChatGPT (developer mode connector)

  1. Open Settings > Apps & Connectors > Advanced settings and turn on Developer mode.
  2. Back in Apps & Connectors, choose Create. Name: Klype. MCP server URL: https://api.klype.ai/api/v1/mcp. Authentication: OAuth.
  3. Create, sign in to Klype and approve. Then add Klype to a chat from the developer mode tools.

Claude Code

claude mcp add --transport http klype https://api.klype.ai/api/v1/mcp

Then run /mcp in Claude Code and authenticate. To use an API key instead:

claude mcp add --transport http klype https://api.klype.ai/api/v1/mcp --header "Authorization: Bearer klp_live_YOUR_KEY"

Cursor

Add to ~/.cursor/mcp.json (or .cursor/mcp.json in a project):

{
  "mcpServers": {
    "klype": {
      "url": "https://api.klype.ai/api/v1/mcp"
    }
  }
}

With an API key instead of OAuth:

{
  "mcpServers": {
    "klype": {
      "url": "https://api.klype.ai/api/v1/mcp",
      "headers": { "Authorization": "Bearer klp_live_YOUR_KEY" }
    }
  }
}

VS Code (GitHub Copilot agent mode)

Add to .vscode/mcp.json, or run MCP: Add Server and choose HTTP:

{
  "servers": {
    "klype": {
      "type": "http",
      "url": "https://api.klype.ai/api/v1/mcp"
    }
  }
}

Start the server from the file and sign in when VS Code asks.

Example prompts

Write a post

  • "Using Klype, list my workspaces and draft a LinkedIn post for the first one about why we dropped our free plan."
  • "Turn this voice-memo transcript into a LinkedIn post in my voice with Klype: ..."
  • "Draft three LinkedIn post options with Klype on our new onboarding flow, one educational, one storytelling, one conversational."

Check before posting

  • "Run this draft through Klype's review_draft and apply every fix it lists: ..."
  • "I wrote this with ChatGPT. Check it against my Klype voice and saved facts and tell me what would get flagged."
  • "Check this post for LinkedIn. The figures come from this note: ... (pass it as sourceText)."

Plan from what worked

  • "Get my Klype performance insights and suggest next week's three posts based on what has worked."
  • "Which days and lengths have performed best for me according to Klype?"
  • "Read my Klype workspace context and list five post topics my buyer would care about."

Approval record

  • "I approve this version. Record the approval in Klype with the final text."
  • "Show my last 20 Klype approvals and how much I edited each draft."
  • "How many drafts did I approve in Klype this month?"

Limits

  • 360 requests per hour to the MCP endpoint (about 120 drafts, since a draft usually takes three protocol calls).
  • At most 10 messages in one JSON-RPC batch; batched messages run in order.
  • General limits on every request: 10 a second, 120 a minute, 1,000 an hour.
  • draft_post brief up to 4,000 characters; review_draft text from about a sentence up to 12,000 characters; list_approvals up to 500 entries.
  • No server-initiated streams: GET on the endpoint returns 405.
  • Drafting uses the same plan allowance as the Klype app.

Security

  • Scopes. context:read, drafts:write, approvals:read. Grant only what the assistant needs.
  • Revocation. Revoke an API key or disconnect an app on the Connections page and it stops working immediately. Clients can also revoke tokens at https://api.klype.ai/api/v1/oauth/revoke.
  • Approval step. No tool publishes. approve_draft records an approval the owner gave; it does not post.
  • Keys stay narrow. API keys and OAuth tokens cannot reach billing, account or admin endpoints.
  • Usage visible. The Connections page shows how connected apps and keys used Klype over the last 30 days.

Listings

Questions

What is the Klype MCP server?

It is a remote Model Context Protocol server at https://api.klype.ai/api/v1/mcp that gives Claude, ChatGPT, Cursor, VS Code and other MCP clients access to a Klype workspace: the saved product, buyer and voice context, drafting in the owner's measured voice, a pre-publish check and the approval record.

Can Klype post to LinkedIn through MCP?

No. None of the seven tools publishes anything. draft_post returns a draft, review_draft checks text, and approve_draft only records that the owner approved it. A person posts it themselves.

How do I sign in?

Either with OAuth 2.1, where your client opens a Klype sign-in and approval screen, or with a Klype API key (klp_live_...) sent as a Bearer token in the Authorization header.

Which permissions can a connection have?

Three scopes: context:read, drafts:write and approvals:read. An OAuth client that asks for no recognised scope gets context:read only. A connection only sees the tools its scopes allow.

How do I disconnect an assistant?

Disconnect it on the Connections page in the Klype app, or revoke the API key. Revoking an OAuth connection ends all of its tokens at once.

What are the limits?

The MCP endpoint accepts 360 requests per hour per caller and at most 10 messages in one JSON-RPC batch, on top of Klype's general limits of 10 requests a second, 120 a minute and 1,000 an hour.

Every plan starts with a 7-day free trial with no card. Start the trial, then connect Klype to your assistant. More about the company: About Klype.