Version: 2.0

Agents & MCP

The Prezent Platform API ships with a first-class Model Context Protocol (MCP) server, so AI agents can create and convert presentations as a tool call instead of writing custom HTTP code. Two ways to use it:

Hosted remote MCP at https://mcp.myprezent.com/mcp — no install needed. Authenticate either with OAuth 2.1 (works with Claude.ai Custom Connectors) or with your API key as a Bearer token.
Local stdio server via pip install prezent-mcp-server — drop a config snippet into Claude Desktop, Cursor, Cline, Continue, or Zed and the tools appear in your agent's tool list.

The same tools (presentation and poster creation and editing, status, download, template conversion, theme discovery, feedback) are exposed in both modes. The MCP server wraps the documented REST API — anything you can do through the API, an agent can do through MCP.

Distributed as the prezent-mcp-server package (see SDKs & Client Libraries for install).

Quick start — hosted MCP (Claude.ai)

The fastest path. Zero install.

In Claude.ai, open Settings → Custom Connectors → Add custom connector.
MCP server URL: https://mcp.myprezent.com/mcp
Click Connect. Claude.ai redirects through Prezent's OAuth login — sign in with your Prezent account.
The Prezent tools (create_presentation_v2, edit_presentation_v2, etc.) are now available in any Claude.ai chat.

That's it — your Prezent API key is fetched server-side from your Prezent account, so you don't paste it into Claude.

Quick start — hosted MCP with an API key

OAuth needs a browser. When there isn't one — a CLI, a CI job, a scripted integration, a server-side agent — send your Prezent API key as the Bearer token instead. Same endpoint, same tools, no OAuth handshake and no discovery round-trip.

POST https://mcp.myprezent.com/mcp
Authorization: Bearer YOUR_API_KEY
Content-Type: application/json
Accept: application/json, text/event-stream

Point any MCP client that supports a static header at the endpoint:

{
  "mcpServers": {
    "prezent": {
      "url": "https://mcp.myprezent.com/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_KEY"
      }
    }
  }
}

The server tells the two credentials apart by shape, so nothing extra is needed to select a mode — an API key takes this path, anything else is treated as an OAuth token.

Quick start — local stdio (Claude Desktop / Cursor / Cline / Continue / Zed)

For locally-running agents and IDE integrations.

1. Install the server

pip install prezent-mcp-server

Requires Python 3.10+.

2. Get a Prezent API key

Contact your Customer Success Manager. The key is a Bearer token of the form pzbk_.... Set it as an environment variable.

3. Add the server to your agent's MCP config

Claude Desktop
Cursor
Cline / Continue
Zed

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "prezent": {
      "command": "prezent-mcp-server",
      "env": {
        "PRESENTATION_API_TOKEN": "pzbk_your_key_here"
      }
    }
  }
}

Restart Claude Desktop. The Prezent tools appear under the 🔌 plug icon in the chat input.

In Cursor, open Settings → Features → Model Context Protocol → Add new MCP server:

{
  "mcpServers": {
    "prezent": {
      "command": "prezent-mcp-server",
      "env": {
        "PRESENTATION_API_TOKEN": "pzbk_your_key_here"
      }
    }
  }
}

In your cline_mcp_settings.json (or Continue's ~/.continue/config.json mcpServers section):

{
  "mcpServers": {
    "prezent": {
      "command": "prezent-mcp-server",
      "env": {
        "PRESENTATION_API_TOKEN": "pzbk_your_key_here"
      }
    }
  }
}

In Zed's settings.json, under context_servers:

{
  "context_servers": {
    "prezent": {
      "command": {
        "path": "prezent-mcp-server",
        "args": [],
        "env": {
          "PRESENTATION_API_TOKEN": "pzbk_your_key_here"
        }
      },
      "settings": {}
    }
  }
}

4. Verify

In a fresh chat, ask the agent:

"Which Prezent templates can I use?"

The agent should invoke get_accessible_templates and return your company's themes.

Available tools

All tools target the Prezent Platform API. Async tools (presentation, poster, template-conversion) return a callback_id that the agent resolves via the matching check_*_status tool.

Presentation tools

The presentation tools wrap the AI Builder API and cover the whole lifecycle of a deck: create it, wait for it, revise it, download it, and rate it.

Tool	Purpose	Sync / Async
`create_presentation_v2`	Start a presentation generation job from a prompt. Accepts template, audience, agent, language, export format, voice, speaker-notes / sources / image settings, and grounding content (texts / files / web links). Returns a `callback_id`.	Async
`edit_presentation_v2`	Revise an existing presentation — either a plain-language prompt edit (content, design, one slide or the whole deck) or a precise action edit (template, audience, voice, infographic node count, sources, speaker notes). Returns a new `callback_id`.	Async
`check_presentation_status_v2`	Wait for a presentation (or edit) to finish and return the `download_url`. Streams live progress to the agent while it waits.	Sync (blocking)
`download_presentation_v2`	Get the download URL for a finished presentation, optionally re-exported to a different format (`pptx`, `pdf`) without regenerating.	Sync
`send_presentation_feedback_v2`	Like, dislike, or clear the rating on a generated or edited presentation.	Sync

The agent-facing flow is:

create_presentation_v2 ──► check_presentation_status_v2 ──► download_url
                                   ▲                             │
   edit_presentation_v2 ───────────┘     (new callback_id)       │
                                                                 ▼
                         download_presentation_v2 (different file format)

Editing a presentation

edit_presentation_v2 takes the callback_id of the most recent turn — the original generation or the last edit — and runs in one of two modes. Use exactly one per call:

Prompt edit — pass prompt with the change in plain language ("make slide 2 more concise", "add a slide on pricing"). Optionally narrow it with slide_number (counting from 1, as users do) and add context with texts, file_ids, or web_links.
Action edit — pass action_type plus that action's argument. Do not pass prompt, texts, file_ids, or web_links with an action; the API rejects them.

`action_type`	Argument(s)	Scope
`template_change`	`template` — a template code from `get_accessible_templates`.	Whole deck
`audience_change`	`audience_id` — from `search_audience`.	Whole deck
`voice_change`	`voice_type` — `brand`, `standard`, or `custom`. For `custom`, also `voice_tone` (`neutral` \| `factual` \| `implicative`) and/or `voice_emotion` (`optimistic` \| `uplifting` \| `assertive` \| `persuasive` \| `cooperative`).	Whole deck
`node_change`	`slide_number` and `node_count` (integer `1`–`10`).	One slide
`generate_sources`	`add_sources_to_footer` and/or `add_sources_to_slides_note` (booleans). `slide_number` optional.	Whole deck or one slide
`refresh_speakernotes`	None. Rewrites the speaker notes without redesigning the slides.	Whole deck

The tool maps these arguments onto the REST request body for you — see POST /api/v2/autogenerator/edit for the underlying action_type / value contract.

Three rules an agent should follow, and which the tool descriptions enforce:

Every follow-up change is an edit_presentation_v2 call. Re-running create_presentation_v2 discards the existing deck and rebuilds from scratch.
Edit only a finished deck, and chain off the newest id. An edit on a callback_id that is still generating is rejected. Each edit returns a new callback_id; pass it to check_presentation_status_v2, then use it for the next edit.
A different file format is not an edit. Use download_presentation_v2 with export_type — it re-exports the same slides and is far cheaper than regenerating.

Shared tools

Used by both the presentation and poster flows.

Tool	Purpose	Sync / Async
`upload_file_chunk_to_preprocess`	Upload one base64 chunk of a file (step 1 of the manual upload flow).	Sync
`validate_uploaded_file`	Validate the uploaded chunks and return a `file_id` to pass as `file_ids` (step 2).	Sync
`get_accessible_templates`	List the brand templates / themes the caller's company has access to.	Sync
`validate_template`	Verify that a specific template id is accessible before kicking off a generation or conversion.	Sync
`get_supported_languages`	List supported languages and their locale codes, for the `language` argument.	Sync
`get_agents`	List the Prezent agents available for `presentation` or `poster` generation, for the `agent_code` argument.	Sync
`search_audience`	Resolve an audience by name or email to an `audience_id`, for a new deck or an `audience_change` edit.	Sync
`get_integration_auth_url`	Get the login URL for an external integration (e.g. Notion) when a status tool returns `needs_auth`.	Sync
`check_integration_auth_status`	Confirm the integration is connected before retrying.	Sync

Template Converter tools

Tool	Purpose	Sync / Async
`convert_template`	Start a Template Converter job that applies a target brand template to an uploaded deck. Returns a `callback_id`.	Async
`check_template_converter_status`	Poll a Template Converter job.	Sync
`send_template_converter_reaction_feedback`	Like/dislike a conversion.	Sync
`send_template_converter_text_feedback`	Submit free-text feedback on a conversion.	Sync

Poster tools

Posters have their own create/edit/status/download tools, wrapping the Posters API. A poster is a single canvas, not a deck — so ask the agent for a poster explicitly, otherwise it will build a presentation.

Tool	Purpose	Sync / Async
`create_poster`	Start a poster generation job from a prompt. Accepts orientation, page size, template, language, export format, citation style, and grounding content (files / web links / text). Returns a `callback_id`.	Async
`edit_poster`	Revise an existing poster from a plain-language instruction — content, layout, styling, or its template. Returns a new `callback_id`.	Async
`check_poster_status`	Wait for a poster (or edit) to finish and return the `download_url`. Streams live progress to the agent while it waits.	Sync (blocking)
`download_poster`	Get the download URL for a finished poster, optionally re-exported to a different format (`pptx`, `pdf`, `png`, `jpg`) without regenerating.	Sync

The agent-facing flow is:

create_poster ──► check_poster_status ──► download_url
                        ▲                      │
   edit_poster ─────────┘   (new callback_id)  │
                                               ▼
                        download_poster (different file format)

Three rules an agent should follow, and which the tool descriptions enforce:

Every follow-up change is an edit_poster call, including switching the template ("use the corporate 2026 template"). Re-running create_poster discards the existing poster and rebuilds from scratch.
edit_poster takes no settings arguments — the entire request goes in prompt, in plain language. That is a deliberate mirror of the REST endpoint, which reuses the poster's stored configuration. See What an edit can change.
A different file format is not an edit. Use download_poster with export_type — it re-exports the same canvas and is far cheaper than regenerating.

Poster tools reuse the shared file-upload, template, language, and integration tools listed above — a file_id from validate_uploaded_file works in either flow, and get_accessible_templates is the same catalogue posters draw from.

Each tool is wired to the equivalent REST endpoint documented in the interactive API Reference — same response envelope, same error catalog, same rate limits, same annual usage quotas.

Authentication

The hosted MCP server (mcp.myprezent.com) accepts two credentials, and the local stdio server takes a third route:

Mode	Flow
Hosted — OAuth 2.1	Authorisation code + PKCE. Claude.ai redirects to Prezent's Cognito-backed login, gets an access token (Cognito id_token), and presents it as `Bearer <token>` on every `/mcp` call. The remote-server middleware exchanges that for the user's Prezent API key behind the scenes — the API key never leaves Prezent infrastructure.
Hosted — API key	Your Prezent API key sent directly as `Bearer <key>` on every `/mcp` call. No browser, no OAuth handshake. The middleware recognises the key by its shape and forwards it unchanged to the Platform API.
Local stdio	Bearer token from the `PRESENTATION_API_TOKEN` environment variable, sent directly on every API call.

All three modes ultimately hit the same Prezent Platform API endpoints described in this documentation. Auth, rate limits, error codes, and annual quotas behave identically.

Which hosted credential to use

	OAuth 2.1	API key
Needs a browser	yes	no
Acts as	the signed-in user	the key's owner
Credential in the client	none — token is issued	the key itself
Best for	Claude.ai, desktop agents	CLIs, CI, server-side agents

Prefer OAuth where a browser is available: the token is short-lived, refreshes automatically, and the API key stays inside Prezent.

Auth errors

Both hosted credentials fail the same way, per RFC 6750:

Status	`error`	Meaning
`401`	`invalid_token`	Missing, malformed, or expired credential. An OAuth client should refresh and retry.
`403`	`insufficient_scope`	The credential is genuine but the account has no API access. Contact your Customer Success Manager — retrying won't help.

A 401 carries a WWW-Authenticate header pointing at the protected-resource metadata, which is what lets an OAuth client restart discovery on its own.

An API key that is well-formed but not valid authenticates at the MCP layer and fails at the Platform API instead: initialize and tools/list succeed, then the first real tool call returns an auth error from the backend. If tools list fine but every call fails, check the key.

Rate limits & quotas

Tool calls count against the same limits as direct API calls:

Gateway throttle — 10 req/s, 5 burst, 1,000 req/day per key.
Annual quotas — slide-generation (create_presentation_v2, edit_presentation_v2) and presentation-download (download_presentation_v2) consume the per-key annual quotas (default 50,000 / 1,000,000).
Poster downloads — each download_poster call is a counted delivery against the key's poster download limit, including a re-export of a poster you already downloaded in another format.
Per-minute throttle — applied per company × category when configured.

See the Developer Guide → Usage quotas and rate limits for the full picture.

Discovery + interop

The hosted server implements the relevant MCP / OAuth interop standards:

MCP transport: Streamable HTTP at https://mcp.myprezent.com/mcp (current MCP-spec default; Server-Sent Events for streaming responses).
OAuth 2.1 authorisation server metadata: GET https://mcp.myprezent.com/.well-known/oauth-authorization-server (RFC 8414).
Protected-resource metadata: GET https://mcp.myprezent.com/.well-known/oauth-protected-resource (RFC 9728).
Dynamic client registration: POST https://mcp.myprezent.com/oauth/register (RFC 7591).
Liveness: GET https://mcp.myprezent.com/healthz.

Most agent clients (Claude.ai, Cursor, Cline) handle this discovery automatically when you give them the MCP server URL.

Discovery and the OAuth endpoints are public, so a client can reach them without a credential. API-key auth skips discovery entirely — send the key on the first initialize call.

Package, issues, and roadmap

Package: prezent-mcp-server on PyPI.
Issues / feature requests: contact your Customer Success Manager or Prezent API Support.
Versioning: the MCP server tracks the OpenAPI contract version (currently 1.0.0). New tools are additive; tool signatures don't change without a major-version bump.

Where to go next

The interactive API Reference — every underlying endpoint with try-it-out forms.
Getting Started — make your first raw HTTP call (useful for debugging what an MCP tool is doing).
AI Builder API — full request/response detail for the flow the create_presentation_v2 / edit_presentation_v2 tools wrap, including every edit action.
Posters API — full request/response detail for the flow the create_poster / edit_poster tools wrap, including the orientation and page-size catalogue.
Template Converter — full request/response detail for convert_template.

Quick start — hosted MCP (Claude.ai)​

Quick start — hosted MCP with an API key​

Quick start — local stdio (Claude Desktop / Cursor / Cline / Continue / Zed)​

1. Install the server​

2. Get a Prezent API key​

3. Add the server to your agent's MCP config​

4. Verify​

Available tools​

Presentation tools​

Editing a presentation​

Shared tools​

Template Converter tools​

Poster tools​

Authentication​

Which hosted credential to use​

Auth errors​

Rate limits & quotas​

Discovery + interop​

Package, issues, and roadmap​

Where to go next​