MCP Content Workflow

How to connect your own AI client to Papera and use it to create content. Papera exposes a Model Context Protocol (MCP) server so you can drive content creation with your own LLM — Papera never uses server-side model keys for this path; your client's model does the generation, guided by prompts Papera returns.

The result of the workflow is a normal, editable local project in your Papera account. You choose how to render it (e.g. as a presentation) later, in the app.

1. Connect the MCP server

Server URL: <your Papera origin>/api/mcp (for a local dev server, http://localhost:3000/api/mcp).

Authentication: the server is OAuth-protected. You do not paste a token by hand — an MCP-capable client discovers how to authenticate automatically:

• On the first unauthenticated request the server replies with a WWW-Authenticate challenge pointing at Papera's protected-resource metadata (/.well-known/oauth-protected-resource).
• Your client follows that to Papera's authorization server, opens a browser sign-in, and you log in with the same Papera account you use in the app.
• The client stores the resulting token and attaches it to every MCP call.

So the only thing you provide is the server URL; sign-in happens in your browser through your account.

Adding it to a client (high level)

Most MCP clients take a name and a URL for a remote (HTTP) MCP server. Point the URL at <your Papera origin>/api/mcp and let the client run the OAuth sign-in flow. For example, a client's config typically looks like:

{
  "mcpServers": {
    "papera": {
      "url": "https://<your-papera-origin>/api/mcp"
    }
  }
}

Exact steps differ per client (some use a config file, some a settings UI), but the shared contract is always: remote HTTP MCP server + OAuth sign-in. Refer to your client's docs for where it registers remote MCP servers.

2. Start here: generate_outline

generate_outline is the normal first tool for creating content. Everything else in the workflow is reached from it. Calling it with no arguments asks you to pick one of two input paths:

• AI (mode: "ai") — you give a topic and Papera researches and drafts from it.
• Paste (mode: "paste") — you give source_text (text you already have) and Papera turns it into structured content.

You can also pass an optional mood and theme hint.

3. The full workflow

Each generation step is prompt-return: Papera hands your client a prompt, your client's model runs it, and you submit the raw JSON result back with the next tool. Papera tells you exactly which tool to call next at every step.

AI path

1. generate_outline { mode: "ai", topic } → returns a research prompt.
2. content_research { research } → submit the research JSON your model produced; returns the outline prompt. (AI path only.)
3. generate_content_outline { outline } → submit the outline JSON; returns the outline for your approval.
4. approve_outline { decision } → you review the outline (see §4). Once approved, returns the content prompt.
5. generate_content { content } → submit the content JSON; returns the content for your approval.
6. approve_content { decision } → you review the content. Once approved, Papera tells you to save.
7. create_local_project {} → saves the approved content as a local Papera project and returns a link to open it.

Paste path

Identical, but you skip research: generate_outline { mode: "paste", source_text } goes straight to the outline prompt. From step 3 onward the two paths are the same.

generate_outline ──(ai)──► content_research ─┐
        │                                    ▼
        └──(paste)──────────────► generate_content_outline
                                             │
                                     approve_outline  ◄── your approval (loop)
                                             │
                                     generate_content
                                             │
                                     approve_content  ◄── your approval (loop)
                                             │
                                   create_local_project ──► link

4. Approval & revision loops

At both approval steps (approve_outline, approve_content) you are shown the draft and asked what to do. The decision you pass can be:

• Approve — accept the draft as-is and move on.
• Edit directly — pass edited JSON to change the draft yourself.
• Request revisions — pass free-text feedback (e.g. "make it shorter, add a section on pricing"). Papera returns a fresh prompt so your model can redo that stage. You can repeat this as many times as you like until you're happy.

Nothing advances until you approve — the outline is settled before any content is generated, and the content is settled before anything is saved.

5. After saving

create_local_project returns a link like .../project/_upload_<id>. Open it in your browser while signed in to the same Papera account and the project imports automatically as an editable local project.

At that point you're in the normal app: nothing has been published, and you pick a renderer (for example, generate a presentation) from the editor. Rendering and publishing are separate, later choices — the MCP workflow's job is done once your content unit exists and is open for editing.