Write Your Web Novel Inside Claude, ChatGPT, and Cursor (MCP Guide)

For most of the AI-writing era, using a writing tool meant going to that tool's website. You opened a tab, worked inside its editor, and when you wanted help from a general assistant like ChatGPT or Claude, you copied text back and forth between windows. MCP changes that shape. With a Model Context Protocol connection, the writing tool comes to your assistant — its features appear as tools the AI can call directly inside the conversation you are already having.

Disclosure up front: Seosa is the AI web novel pipeline built and operated by this article's authors, and it runs a remote MCP server, so it is the concrete example used throughout. We have tried to keep the explanation general enough to be useful even if you connect a different MCP tool. Claude, ChatGPT, and Cursor are products of their respective companies and have no affiliation with Seosa.

What MCP Actually Is, in Plain Terms

MCP (Model Context Protocol) is an open standard for connecting AI assistants to external services. Think of it as a universal adapter: instead of every tool building a custom plugin for every assistant, a tool exposes a standard MCP server, and any MCP-capable assistant can use it. When you connect one, your assistant gains a set of named tools — for a web novel pipeline, things like 'create a series,' 'generate an outline,' 'generate an episode,' 'evaluate this chapter,' 'read my bible.' The AI decides when to call them based on what you ask in plain language.

The reason this matters for fiction specifically is context management. A general assistant has no memory of your world between sessions. Ask ChatGPT to write chapter 40 and it knows nothing about the magic system you defined in chapter 3 unless you paste it back in. A connected pipeline solves this at the tool layer: when the assistant calls the generate-episode tool, the pipeline assembles your registered bible, a rolling summary of recent episodes, and genre tone instructions automatically — then generates. You direct; the plumbing is handled.

The Copy-Paste Workflow vs. the Connected Workflow

It is worth being concrete about what the connection replaces. Here is the manual loop most authors run when writing a serial with a general assistant alone, versus the connected version.

• Manual loop: Open your notes. Copy the relevant character sheets, world rules, and a summary of the last few chapters. Paste them into the assistant with a generation prompt. Read the draft. Re-paste context for a revision. Manually check the result against your bible for continuity errors. Repeat next chapter — re-assembling the same context from scratch, because the session forgot.
• Connected loop: Tell the assistant what happens in the chapter. The pipeline injects the bible, the prior-episode summary, and tone rules behind the scenes, generates the draft, and can run a quality and continuity pass on request. Your bible lives in one place and is referenced automatically, so it does not drift just because you opened a new session.
• Where the difference compounds: At chapter 5 the manual overhead is annoying but survivable. At chapter 50 it is the dominant time cost — and the most common source of continuity errors, because re-pasting context by hand is exactly where details get dropped.

How to Connect Seosa to Your Assistant

The setup is a one-time step. The exact snippet differs per client, but the shape is the same: point the client at Seosa's MCP endpoint and authenticate. The current quick-connect cards for each client live in the app under Settings → API Keys, and they give you copy-paste-ready commands.

• Claude and Claude.ai: Connect over OAuth. You authorize Seosa the way you would authorize any connected app — no configuration file, no pasted key. Once authorized, Seosa's tools appear in the conversation.
• Claude Code: Add the server with a single CLI command and your API key as an environment variable. After that, the tools are available in every Claude Code session in that project.
• ChatGPT: Add Seosa's MCP URL and an Authorization header in the connector settings. The tools then appear for the assistant to call.
• Cursor: Drop a short JSON block into your Cursor MCP settings with the endpoint and your API key. The tools become available in Cursor's assistant.

To generate an API key for the non-OAuth clients, open the web app, go to Settings → API Keys, and create one. Keep it private — it authenticates as you and spends your credits. If a key is ever exposed, revoke it from the same screen and generate a new one.

What You Can Do Once Connected

After connecting, your assistant can run the full serial workflow conversationally. A typical first session looks like this: ask it to create a new series with your genre and premise, run the setup wizard to draft the world, characters, relationships, and bible, generate an outline for the first arc, then generate and evaluate episode one. You stay in the chat the entire time, approving and redirecting as it goes.

• Free read tools: list your series, read any episode, inspect your bible, characters, and relationships, check your credit balance, and view episode version history. These cost nothing and are useful even on their own — for example, asking your assistant to summarize where a subplot stands across the last ten chapters.
• Free edit tools: update an episode's text, roll back to a previous version, edit bible components, update relationships, and add or revise characters. Edits are free because they are not generation — they are changes to data you already own.
• Paid generation and evaluation: outline generation, episode generation, the setup wizard, passage rewrites, and quality evaluation use credits, at the same rates as the web app. Episode generation is the heaviest call and runs asynchronously — the tool returns immediately and you poll for the finished draft, so a long generation never times out your assistant.

What the AI Decides vs. What You Decide

This is the part tool marketing tends to blur, so it is worth stating plainly. Connecting a pipeline over MCP changes where the work happens, not who is the author. The AI handles mechanical assembly: pulling the right bible entries, summarizing prior episodes, formatting the prompt, generating within that context, and scoring the result. You handle everything that makes the story yours — what each scene is emotionally for, which foreshadowing thread to pull this episode, when to turn an arc, and what the book is actually about.

An MCP connection does not give the AI new creative judgment. It removes the friction between your judgment and the page. If you find yourself spending more time managing context than making story decisions, that friction is the problem worth solving — and it is the specific problem this kind of integration is built for.

Limitations and Honest Caveats

MCP client support evolves quickly. The exact connection steps for each assistant can change as those products update their MCP interfaces, which is why the canonical setup snippets live in the app's Settings → API Keys rather than being hard-coded here. Verify the current quick-connect card for your client before troubleshooting from memory.

The connection is also only as good as the underlying model your assistant uses and the bible you maintain. Automatic context injection cannot rescue a thin or contradictory bible — it will faithfully inject whatever you have registered. The pipeline reduces overhead and catches consistency drift; it does not invent the world for you. For the craft side of keeping a long serial coherent, see our deeper guides on the [AI writing assistant episode workflow](/en/blog/ai-writing-assistant-web-serial-workflow-2026), [voice consistency across long serials](/en/blog/ai-voice-consistency-long-form-web-novel), and [building an AI-assisted series bible](/en/blog/ai-assisted-worldbuilding-series-bible-guide).