> One SupWriter MCP connector for Cursor, VS Code, Claude Code, Codex, and OpenCode. Exact config for each — humanize READMEs and grammar-check docs in your editor.
- **Published**: 2026-05-26
- **Category**: Integrations
- **URL**: https://supwriter.com/blog/humanize-ai-text-in-cursor-vscode-mcp

---
# SupWriter in Cursor, VS Code, Claude Code, Codex & OpenCode: One MCP, Every Dev Tool

Writing isn't only something that happens in a chat app. You write READMEs in VS Code, documentation in Cursor, release notes in Claude Code. The same SupWriter connector that works in Claude and ChatGPT works in your editor and terminal too — so you can humanize a generated README or check the grammar on docs without leaving the file you're in.

Every tool below points at the same endpoint:

```
https://supwriter.com/api/mcp
```

The difference is how each one authenticates. **Cursor, VS Code, Claude Code, and OpenCode** can sign in with **OAuth** (a one-time browser approval). **Codex** uses a **bearer token** instead. Where a tool takes a token, create one under **Settings → API & MCP** in SupWriter (Pro or Ultra).

## Claude Code

From your terminal, add the remote server. The simplest path for a terminal agent is a Direct API key:

```bash
claude mcp add --transport http supwriter https://supwriter.com/api/mcp \
  --header "Authorization: Bearer sw_live_your_key"
```

Prefer OAuth? Add it without the header, then run `/mcp` inside Claude Code to sign in:

```bash
claude mcp add --transport http supwriter https://supwriter.com/api/mcp
```

Either way, the `humanize`, `paraphrase`, `grammar_check`, and `detect_ai` tools become available in your sessions. Confirm with `claude mcp list`.

## Cursor

Open Cursor's MCP settings (**Settings → Tools & Integrations**, then **New MCP Server**) — that opens your `mcp.json`. Use `~/.cursor/mcp.json` for every project, or `.cursor/mcp.json` for one. The URL on its own is enough; Cursor handles the OAuth sign-in:

```json
{
  "mcpServers": {
    "supwriter": {
      "url": "https://supwriter.com/api/mcp"
    }
  }
}
```

Save, then toggle SupWriter **on** in the MCP panel. Cursor opens your browser to authenticate with SupWriter; after you approve, the tools appear in the Agent (Composer).

Prefer a static key over the sign-in screen? Add a header instead:

```json
{
  "mcpServers": {
    "supwriter": {
      "url": "https://supwriter.com/api/mcp",
      "headers": { "Authorization": "Bearer ${env:SUPWRITER_TOKEN}" }
    }
  }
}
```

## VS Code

MCP is built into VS Code's **Copilot agent mode** (1.102+). Run **"MCP: Add Server"** from the Command Palette, or create a `.vscode/mcp.json`. Note the top-level key is `servers` and the remote type is `http`:

```json
{
  "servers": {
    "supwriter": {
      "type": "http",
      "url": "https://supwriter.com/api/mcp"
    }
  }
}
```

Approve the trust prompt to start the server. On first use VS Code runs the OAuth flow automatically — click **Allow** and sign in. Then open Chat, switch the dropdown to **Agent** mode (MCP tools only show there), and ask away.

## Codex

OpenAI's Codex CLI connects to remote MCP servers through `~/.codex/config.toml`. Codex sends the **value of an environment variable** as the bearer token — so it stores the variable's *name*, not the secret. Export your key first:

```bash
```

Then add the server (either the CLI or the config file works):

```bash
codex mcp add supwriter --url https://supwriter.com/api/mcp \
  --bearer-token-env-var SUPWRITER_TOKEN
```

```toml
# ~/.codex/config.toml
[mcp_servers.supwriter]
url = "https://supwriter.com/api/mcp"
bearer_token_env_var = "SUPWRITER_TOKEN"
```

Restart Codex and the tools are available. (On older Codex builds that don't load remote servers, add `experimental_use_rmcp_client = true` to your config and update Codex.)

## OpenCode

OpenCode reads MCP servers from `opencode.json`. Add a `remote` server and pass your key as a header — `{env:…}` keeps the token out of the file:

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "supwriter": {
      "type": "remote",
      "url": "https://supwriter.com/api/mcp",
      "enabled": true,
      "headers": {
        "Authorization": "Bearer {env:SUPWRITER_TOKEN}"
      }
    }
  }
}
```

Restart OpenCode to load the server. (OpenCode can also do the OAuth flow automatically; set `"oauth": false` when you're using a static header to skip it.)

## Using it in an editor

Once connected, the tools work on selections and generated content. Ask your editor's agent to *"humanize the draft README"* or *"grammar-check the docstring I just wrote, style mode."* The agent calls the tool and edits in place.

## Troubleshooting

- **Loopback redirect.** OAuth-based tools (Cursor, VS Code, Claude Code) complete sign-in via a `localhost` redirect — that's expected. If a browser window doesn't open, check the tool's logs for the authorization URL and open it manually.
- **Token not picked up (Codex/OpenCode).** Make sure `SUPWRITER_TOKEN` is exported in the same shell that launches the tool; these read the env var at startup.
- **Reconnect prompts.** OAuth access tokens are short-lived and refresh automatically; if asked, re-approve. Your account stays linked.
- **`INSUFFICIENT_CREDITS` / `PLAN_LIMIT`.** Out of word credits, or text over your plan's per-request cap (500 free/basic, 1,500 Pro, 3,000 Ultra).
- **`LANGUAGE_NOT_AVAILABLE`.** That language requires a higher plan; English is available everywhere.

## What's next

Every tool is documented on its own: the [humanizer](/blog/humanize-ai-text-mcp-server), [grammar checker](/blog/grammar-checker-mcp-server), [paraphraser](/blog/paraphraser-mcp-server), and [AI detector](/blog/ai-detection-mcp-server). Prefer a chat app? See [Claude](/blog/humanize-ai-text-in-claude-mcp) and [ChatGPT](/blog/humanize-ai-text-in-chatgpt-mcp).


---

Source: https://supwriter.com/blog/humanize-ai-text-in-cursor-vscode-mcp