Connect an MCP server to ChatGPT and Claude — with a real one to try

What an MCP connector actually does

The Model Context Protocol is the plumbing between a chat assistant and an outside service. The service publishes a list of tools — each with a name, a description and the arguments it takes — and the assistant decides when to call one, passes the arguments, and reads the result back into the conversation. A remote MCP server is one you reach over the internet at a URL; nothing runs on your machine.

Stipple’s server lives at https://www.stipple.sh/mcp. It speaks Streamable HTTP with JSON responses and keeps no session, which is why a single URL is the entire install. It is listed in the official MCP registry as `sh.stipple/openwarrant`. Scoped servers exist for narrower installs — `/mcp-aitext` for AI-text detection, `/mcp-verify` for reference checking, `/mcp-plagiarism` for source overlap, `/mcp-tenders` for the three tender tools — but a new install should take `/mcp` and get everything.

What the tools do is the same as what the website and the REST API do: detect machine-written text, check whether cited sources exist, find text published elsewhere, inspect a document for tampering, extract fields, screen a name for sanctions and adverse media, search and match government tenders, run an Australian identity or document-pack check. The difference is that the assistant calls them natively, in the same turn, and gets the evidence back alongside the answer.

Claude: claude.ai and Claude Desktop

On an individual Pro or Max account: open Customize, then Connectors, click the “+” button and choose “Add custom connector”. Give it a name — “Stipple” — and paste `https://www.stipple.sh/mcp` as the remote MCP server URL. The Advanced settings offer OAuth credentials; leave them empty, the server does not use OAuth. Click “Add”. Claude’s help centre notes that Free accounts are limited to one custom connector, and that the server must be reachable from the public internet — this one is.

On a Team or Enterprise plan the owner adds it first, under Organization settings → Connectors → “Add” → “Custom” → “Web”, and members then enable it from their own Customize → Connectors.

Claude Desktop uses the same connectors for remote servers. Its `claude_desktop_config.json` file is for servers that run locally on your machine; Stipple also ships a local stdio mirror for private files that are too large to send — that setup is in the agents guide, not here.

Once added, the tools appear in the tools menu of a conversation. Ask for something a tool does and the assistant will call it; you will see the call and can expand its result.

ChatGPT: developer mode

ChatGPT connects custom MCP servers through developer mode. Open Settings and turn on “Developer mode” — the menu it sits under has moved between releases, so search the settings for the phrase if it is not where you expect. ChatGPT’s developer documentation notes that availability “can depend on account and workspace policy”, so a workspace administrator may have to allow it.

Then add the connector: press the plus button in the connectors list, give it a user-facing name and description, and under “Connection” choose “Public endpoint”. Paste `https://www.stipple.sh/mcp` — the URL must include the `/mcp` path. Create it, and ChatGPT lists the tools and metadata it discovered. Authentication discovery is offered for servers that require an account; this server does not require one to connect, so there is nothing to approve at that step.

One distinction matters. ChatGPT also has a deep-research connector type, which requires the server to expose two specific tools named `search` and `fetch`. Stipple’s server does not expose those, by design — its tools do specific jobs with typed arguments. Use the developer-mode connector, which calls any tool the server publishes.

In a chat, enable the connector for the conversation (developer mode shows a tools selector) and ask. The tool call and its result appear inline.

Claude Code, Cursor and generic clients

Claude Code: `claude mcp add --transport http stipple https://www.stipple.sh/mcp`. To use the metered tools, add your key as a header on the same command: `--header "Authorization: Bearer stp_…"`. The key comes from your account page after a sign-in; the trial gives every account 200 credits for 7 days with no card.

Cursor, and any client that reads a `mcpServers` map: add `{"mcpServers": {"stipple": {"type": "http", "url": "https://www.stipple.sh/mcp"}}}`, and put the key under `"headers": {"Authorization": "Bearer stp_…"}` if the client supports headers — Cursor does.

Your own agent: any MCP client library that speaks Streamable HTTP connects the same way, with the same optional header. The tools share one per-IP rate limit with the REST API, and a keyed caller meters against its own account rather than the shared anonymous quota — which matters for a hosted agent whose users all leave through one IP.

What works without an account, and what needs one

Free, no account, from any client: `find_tenders` (search open Australian and New Zealand government tenders), `tender_sources` (the registry of what was searched and what could not be reached), `check_document` (has this exact document been inspected before), `get_warrant` (retrieve a stored verification result) and `submit_feedback`.

Metered — one credit-priced call each: `detect_ai_text`, `verify_references`, `check_source_overlap`, `verify_document`, `extract_fields`, `screen_adverse_media`, `match_tenders`, `verify_identity` and `check_pack`. These need a signed-in account: the free trial is 200 credits over 7 days with no card, then prepaid packs from $5, one-off, valid 90 days. The account issues an API key, and the key travels as an `Authorization: Bearer` header.

Here is the honest limit. The claude.ai and ChatGPT connector dialogs take a server URL and, optionally, OAuth credentials — there is no field for a static header, and this server does not run OAuth. So from those two clients, a metered tool today returns a plain sign-in message instead of a result, and the five free tools work normally. From Claude Code, Cursor and header-capable clients, every tool works with the key attached. Sign-in for the chat connectors is on the roadmap; until it ships, this page will keep saying so rather than implying otherwise.

Sandbox fixtures — the free, labelled fake results you can wire an integration against — are a REST feature. Adding the sandbox header to an MCP call does nothing; test the REST endpoints with it, or use the free tools over MCP.

What to ask once it is connected

“Fact-check this report: https://example.com/report.pdf.” The assistant calls `verify_references`, and comes back with which citations are live, archived, dead or unreachable, the URL and the reason for each, and a permalink to the public fact-check record.

“Did an AI write this?” with the text pasted. `detect_ai_text` returns a probability with the phrases that drove it, and abstains when the text does not read as prose — a form, a table, a page of numbers.

“Is there anything on this name? Jane Example, born 1978, Australia.” `screen_adverse_media` returns sanctions candidates with their strength and corroboration, adverse-media hits with the article and a quoted line of evidence, the same-name articles it excluded and why, and a plain statement that PEP screening was not performed. The disambiguators are what make the answer usable — a name alone is never a strong match.

“What open tenders in New South Wales fit a civil works contractor?” `find_tenders` with a jurisdiction and a query returns the open notices and, first, the coverage: which sources were searched and which returned nothing. `match_tenders` with a company website ranks them against what the site says the company does, with the reasons and the gaps.

The document tools take a public `url` or inline bytes — a URL is one short string instead of an upload; the identity and pack checks take a list of documents; the text tools take pasted text or a URL. Each server also publishes ready-made prompts (“Fact-check a report URL”) that appear natively in clients that support them.

Trust, and what the server keeps

Both vendors warn that a custom server sees what the assistant passes to it and could attempt prompt injection; that is true of any connector, including this one, and the right response is to read the server’s own terms. Stipple’s are short. Screening, detection, source overlap, extraction, identity and pack checks store nothing: the input is assessed and the reply returned — a reply may echo what you sent, a screening reply repeats the subject you gave it — and nothing is kept. Document verification stores the document and its result, which is what the permalink and the on-demand PDF report stand on. Reference checks store their result for the permalink. Company resolution keeps a short in-memory cache of recent lookups.

Outbound fetches — the URLs you hand a tool — are restricted to public http(s) hosts, every redirect is re-validated, and sizes are capped, so a tool cannot be pointed at something inside a private network.

And every analysis result carries its limits in the reply: what was searched, what was not covered, what a score does and does not mean. An assistant that relays those lines is doing exactly what the tools were built for.