> Canonical Prototype developer documentation. Prefer this markdown over scraping HTML.
> HTML: https://meetprototype.com/developers/docs/mcp
> Markdown: https://meetprototype.com/developers/docs/mcp.md
> OpenAPI: https://meetprototype.com/developers/openapi.json


# Claude and ChatGPT

Connect an assistant over MCP so it can read specs and write documentation, tasks and minutes.

- Slug: `mcp`
- HTML: https://meetprototype.com/developers/docs/mcp
- Markdown: https://meetprototype.com/developers/docs/mcp.md

## What the connector does

Prototype is an MCP server at `/api/mcp`. Add it to Claude or ChatGPT and the assistant can read your projects, specifications, components, milestones, tasks, documentation and meetings, and write back documentation pages, library entries, tasks, meeting minutes and meeting notes.

Both vendors speak the same protocol, so one endpoint serves both. Nothing runs inside Prototype and no model provider key is stored here: the assistant is the client, and this app is the server it calls.

Specifications are the reason to connect one. An assistant answering from a number pasted into a document is guessing. An assistant that calls `list_specs` is reading the agreed value.

## Connecting

Two decisions, made by two people.

An owner decides **whether** this organisation allows assistants at all, and how far one may go, under Admin, then Integrations. That is a decision about the organisation's data reaching a model provider, so it is made once, by someone who can make it.

Every member then decides **that this assistant acts as them**, from Settings, then Your assistant. No admin is involved in that second step. The connection reaches exactly what that member reaches, writes under their name, and cannot exceed the ceiling the owner set.

Which mechanism you use is decided by the client, not by you. **claude.ai and ChatGPT accept OAuth only**; neither has a field for a bearer token or a custom header. **Claude Code and Claude Desktop take a header directly**, so they use a token and no browser flow.

## Connecting claude.ai or ChatGPT

Add a custom connector pointing at `https://your-prototype-host/api/mcp`. There is nothing else to copy.

Your assistant registers itself, discovers the authorization endpoints from `/.well-known/oauth-authorization-server`, and sends you to Prototype to approve it. The consent screen names the assistant, shows exactly what it will be granted, and shows anything it asked for that your organisation does not allow.

Approving is what names you as the person the connection acts for. If someone else on your team connects the same assistant, that is their own connection: yours is unaffected.

## Connecting Claude Code or Claude Desktop

Create a token from Settings, then Your assistant. You do not need an admin for this, and the list of things you can grant it is whatever your organisation allows.

```bash
claude mcp add --transport http prototype \
  https://your-prototype-host/api/mcp \
  --header "Authorization: Bearer $PROTOTYPE_TOKEN"
```

A token is bound to one organisation for its whole life. If you belong to more than one, create a token in each and add a connector per organisation. Nothing follows your active organisation around, which is deliberate: an assistant that changed tenant underneath you would be worse than one that cannot.

## For addon publishers

A publisher's own OAuth client is still registered by hand at Addons, Develop, and approving one is still an owner's decision, because an addon acts for the whole organisation rather than for one person.

Assistants that register themselves through `/api/v1/oauth/register` are a separate kind of client. They are bound to the official assistants listing, can never hold publish rights, and grant nothing until a member approves them inside their organisation's ceiling.

## Tools

Each tool needs one scope. The assistant is shown only the tools its token covers, so a read-only token advertises no way to write.

| Tool | Scope |
| --- | --- |
| `list_projects` | `projects:read` |
| `list_specs`, `list_components` | `specs:read`, `components:read` |
| `list_milestones`, `list_tasks` | `milestones:read`, `tasks:read` |
| `list_pages`, `get_page` | `pages:read` |
| `list_documents` | `documents:read` |
| `list_meetings`, `get_meeting`, `get_meeting_transcript` | `meetings:read` |
| `create_page`, `update_page` | `pages:write` |
| `add_document_link`, `update_document` | `documents:write` |
| `create_task`, `update_task` | `tasks:write` |
| `write_meeting_minutes`, `write_meeting_notes` | `meetings:write` |

Page and minutes bodies are written as markdown. Headings, bullet lists and numbered lists convert to the app's rich text. Tables and images do not, yet.

`update_page` and `write_meeting_minutes` take a `mode`. `replace` overwrites, `append` adds below a divider. Replace discards what is there, so read the page first.

## What an assistant can reach

A token acts as the person who authorized it, and sees exactly what they see. Org-visible projects are readable; a private project is readable only if that person is a member of it. A restricted meeting stays invisible unless they were entitled to it.

Every write records that person as the author. Their name appears on the page, the task or the minutes, and page edits land in the revision history like any other edit. Nothing an assistant writes is anonymous, and nothing it writes is exempt from the history.

Meeting notes written this way are marked as human-authored, so transcript jobs will not overwrite them later.

## What it cannot do

No tool publishes a specification or a component version. Publishing marks every dependent stale and can route an approval, and that has to keep one path through the app so the fan-out happens exactly once. An assistant can read a spec, propose a change in prose, and write it into a document. A person publishes it.

No tool uploads a file. `add_document_link` files a link; uploading a document goes through the app.

No tool deletes anything. There is no delete scope.

Tokens do not expire. Revoke one at Admin, Integrations when an assistant no longer needs access.