keepp.

What We Learned Letting Claude and ChatGPT Edit Live Websites Over MCP

How we built Keepp's MCP server so Claude and ChatGPT can edit public web pages: whole-document writes with a version check, schemas in resources, owned images, structured results and OAuth for every client.

By Vasanth Sriram

Keepp’s MCP server lets Claude and ChatGPT build and edit real, public web pages. The things that made it work were: one tool that writes the whole page with a version check so stale writes fail, the block catalogue kept in an MCP resource instead of every tool listing, every image the model sends copied to our own storage, structured results on every tool, OAuth that accepts native clients on any loopback port, and a tool list shaped to each client.

Keepp is a link in bio and website builder for creators and small businesses: one page that holds a website, a shop, bookings, forms and chat. A person says “add my new class times and a booking button” in a chat, and the assistant changes their live page. That is a different job from most MCP servers, which read data or run a search. Ours writes to something strangers will see. Here is what that taught us.

1. Let the model write the whole document, but make stale writes fail

Our first instinct was a dozen small tools: add a block, move a block, change a colour. Models were bad at it. They lost track of order, half-applied changes, and left the page inconsistent.

What worked was one tool, put_page, that replaces the whole page document. The model calls get_page, edits what it got back, and sends the complete list of blocks. Anything left out is deleted, and the tool description says so plainly.

The risk is clear: the owner edits the page in the editor while the assistant is mid-change, and the assistant overwrites it. So every get_page returns a version, put_page requires it, and a write against an old version fails with a clear error instead of silently winning. Optimistic concurrency turned out to be the most important guard on the whole server.

2. Keep the schema out of every tool listing

A page has many block types, each with its own fields. Putting all of that in the put_page input schema bloated every tool listing the host sent to the model, on every turn.

We moved the full block catalogue into an MCP resource. The tool description points at it, so the model reads it once when it needs it rather than carrying it in every request. Tool listings stayed small, and the model still had every field when it built a page.

The catalogue is generated from the product’s own block definitions, so it can’t drift from what the editor accepts. Each block lists only the fields and values it takes, and the server treats that as a closed list.

3. Never trust a URL the model gives you

Models like to put image URLs straight into a page, often from wherever they found them. That makes the public page depend on someone else’s server, and some of those images vanish a day later.

Every image URL in a write is now downloaded and stored on our side as part of the write. If one can’t be fetched, the whole write fails and names the block. The model is told exactly what went wrong and usually fixes it on the next try.

4. Return structured results on every path

Hosts handle tool results differently. Some only show the model the text content, some read structuredContent. We declare an outputSchema on every tool and return structured content on every success path, with a readable sentence in the text as well. A test fails the build if any tool is missing either.

The same goes for safety hints. Each tool declares whether it is read-only, destructive, or reaches outside Keepp, from one table in the codebase, so hosts can decide when to ask the user first.

5. OAuth for native clients needs loopback on any port

Remote MCP over OAuth worked first time in browser hosts. It broke for native clients like Claude Code, which sign in through a callback on localhost with a random port. Our redirect check wanted an exact match.

The OAuth rules for native apps already cover this: loopback redirect URIs are allowed on any port. Once we accepted that, sign-in worked everywhere. Client ID Metadata Documents also meant we didn’t need dynamic client registration for the hosts we cared about. A client identifies itself by a URL it controls, and the user approves it on Keepp’s own consent screen.

6. Different hosts need different tool sets

Not every host wants every tool. Some app directories don’t allow selling subscriptions inside the assistant, so for those clients we hide the plan tools entirely rather than letting them fail. Filtering by client when the tools are listed is cleaner than refusing when they are called.

The same rule now covers previews. Keepp has a preview_page tool that shows a draft of the page inside the chat before anything is published. ChatGPT renders widgets its own way, so it isn’t offered that tool or its widget at all, and it edits the page the normal way instead.

What it looks like in practice

A creator opens Claude or ChatGPT, connects Keepp once, and says what they want: a shop with three products, a booking page for sessions, a contact form and a chat. The assistant reads the catalogue, writes the page, and gets back the live URL plus a link for each part that opens as its own page.

If you’re building an MCP server that writes to anything public, the short version is: give the model whole documents with a version check, keep big schemas in resources, own every asset it hands you, and return structured results everywhere.

Our developer docs explain how to connect the MCP server. For the bigger picture of why we think MCP changes how products connect, read The End of the Developer Portal.

An earlier version of this post appeared on DEV.

Like what you read? Add Keepp as a preferred source on Google to see more of our posts in your search results.