MCP

Let your agent set it up

Using Claude Code, Codex, Cursor, or another coding agent? Copy this and send it to the agent, and it adds the server for you.

Server

The server runs on our side over Streamable HTTP, so there’s nothing to install. Give your assistant its URL, and it sends you to Qualifical to sign in and approve the connection. You can disconnect an assistant at any time under Settings → Connected apps.

URL        https://qualifical.com/api/mcp
Transport  Streamable HTTP
Sign-in    OAuth, or an API key as "Authorization: Bearer qk_…"

Setup

Menus in these apps change often. If a step below doesn’t match what you see, look for “custom connector” or “MCP server” in the app’s settings and use the URL above.

Claude

On claude.ai, Claude Desktop, or the mobile app, add a custom connector and paste the URL above. Then select Connect and approve it on Qualifical. On Team and Enterprise plans, an owner adds the connector for the organization, and each member connects their own account.

ChatGPT

Turn on developer mode in ChatGPT’s settings (under Apps or Connectors, then Advanced), create an app with the URL above, and choose OAuth for authentication. Which plans offer developer mode is up to OpenAI.

Grok

On grok.com/connectors, choose New connector, then Custom, and paste the URL above. Allow pop-ups from grok.com so the sign-in window can open.

Claude Code

claude mcp add --transport http qualifical https://qualifical.com/api/mcp

Then run /mcp in Claude Code, choose qualifical, and sign in in the browser.

Gemini CLI

gemini mcp add --transport http qualifical https://qualifical.com/api/mcp

Then run /mcp auth qualifical in Gemini CLI and sign in in the browser.

Codex CLI

codex mcp add qualifical --url https://qualifical.com/api/mcp
codex mcp login qualifical

The second command opens the browser to sign in.

OpenCode

In opencode.json in a project, or ~/.config/opencode/opencode.json. OpenCode asks you to sign in the first time it uses the server, or you can run opencode mcp auth qualifical first:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "qualifical": { "type": "remote", "url": "https://qualifical.com/api/mcp" }
  }
}

Pi

Pi reaches MCP servers through the pi-mcp-adapter extension. Install it with pi install npm:pi-mcp-adapter, restart Pi, and add the server to .mcp.json in a project or ~/.config/mcp/mcp.json. Then run /mcp-auth qualifical to sign in:

{
  "mcpServers": {
    "qualifical": { "url": "https://qualifical.com/api/mcp", "auth": "oauth" }
  }
}

Cursor

In ~/.cursor/mcp.json, or .cursor/mcp.json in a project, then select Connect next to the server in Cursor’s MCP settings:

{
  "mcpServers": {
    "qualifical": { "url": "https://qualifical.com/api/mcp" }
  }
}

VS Code

In .vscode/mcp.json. VS Code asks you to sign in when it first starts the server:

{
  "servers": {
    "qualifical": { "type": "http", "url": "https://qualifical.com/api/mcp" }
  }
}

Using an API key instead

Clients that can send headers can skip the sign-in and use the same keys as the REST API. Create one under Settings → API keys and send it as a bearer token. A key is shown only once, so paste it straight into your client’s settings. If it leaks, revoke it in Settings.

claude mcp add --transport http qualifical https://qualifical.com/api/mcp \
  --header "Authorization: Bearer qk_…"

In Cursor and VS Code, add the header to the server’s entry:

"headers": { "Authorization": "Bearer qk_…" }

In OpenCode, add the same headers and "oauth": false. In Pi, add the same headers and "auth": "bearer". In Codex, put the key in an environment variable and name it in ~/.codex/config.toml:

[mcp_servers.qualifical]
url = "https://qualifical.com/api/mcp"
bearer_token_env_var = "QUALIFICAL_API_KEY"

Clients that only start servers as local commands can reach this one through mcp-remote, which needs Node.js:

{
  "mcpServers": {
    "qualifical": {
      "command": "npx",
      "args": ["mcp-remote", "https://qualifical.com/api/mcp", "--header", "Authorization:${AUTH_HEADER}"],
      "env": { "AUTH_HEADER": "Bearer qk_…" }
    }
  }
}

Tools

Ask the assistant in plain words, for example “check this essay for AI writing and rewrite the passages over 30%”, and it picks the tools to call: check the text, rewrite the passages scoring 0.3 or more, put the rewrites in place, and check again. Scores run from 0 to 1: under 0.3 reads as human, 0.3 to 0.7 is mixed, and over 0.7 is likely AI. They measure how much the wording reads as written by a language model, so text a model wrote scores high whatever its layout, and rewording is what lowers it. Texts are split into passages of about a paragraph, as in the REST API.

check_text

Scores the whole text and each passage. Needs at least 300 characters, and costs 1 credit per word.

It returns aiScore and verdict for the whole text, words, creditsCharged, attackDetected (hidden characters or look-alike letters that can skew detection), and each passage with its index, aiScore, words, character offsets, and its first words as opening.

rewrite_text

Rewrites the passages it’s sent so they read as written by a person. Only those passages are sent, as text, not the whole document. It tries to keep the meaning, but a rewrite can shift the emphasis, change a term, or drop a detail, so read the result before you use it. Prose works best: tables, lists, and other markdown may not survive. Costs 7 credits per word sent for rewriting.

It returns one entry per passage sent, by its index in the list, with the rewritten text to put in its place, or null if it came back unchanged (its credits are still spent), and creditsCharged.

get_credits

Takes no arguments and returns your plan and the credits you have left, as GET /api/v1/credits does, including how many free credits you’ve used today.

Credits and limits

The tools spend the same credits as the app and the REST API, with the same limits on free credits per day and on document length. When a tool can’t run, for example because the text is too short or you’re out of credits, it answers with a message the assistant can pass on, and nothing is charged. Each request to the server counts toward a limit of 60 requests per minute, per key or per connected account, including the handshake a client makes when it connects. Send one message per request: the server refuses batches.

Texts aren’t saved as documents, but on a free account (no plan or bought credits) they’re kept to train and improve our models, as described in the privacy policy.