Skip to content
Esc
↑↓navigate↵open⌘Jpreview
On this page

MCP server

Connect AI agents and MCP-compatible clients to QuiverAI.

The QuiverAI MCP server lets compatible AI agents make SVGs, icons, logos, illustrations and animations, vectorize images, search your Library, and fetch completed SVG content through a secure hosted connection. The work happens in QuiverAI Chats, so everything an agent makes continues in the QuiverAI app.

Connect your MCP client to:

https://app.quiver.ai/mcp

QuiverAI uses the remote Model Context Protocol over Streamable HTTP with OAuth. Your client starts the sign-in flow, you authorize access with your QuiverAI account, and the client receives a token scoped to your account.

What agents can do

Once connected, agents can:

  • List the QuiverAI models available to your account with list_models.
  • Send a prompt with send_prompt to make, vectorize, edit or animate SVG artwork. Pass images (public URLs, base64 payloads, or completed QuiverAI upload IDs; up to 4) as sources or references, outputCount from 1 to 4 (the default is 1), an optional model and reasoningEffort, and an optional chatId to continue a Chat you own. Omit chatId to start a new Chat that you also see in the QuiverAI app.
  • Read a Chat with get_chat: its title, app link, the status of its latest turn (queued, running, completed, failed or cancelled) and the Artifacts that turn wrote, with app links and never SVG. Set waitSeconds (up to 25) to wait for a running turn.
  • Stop a running turn with cancel_turn.
  • Search your Library with search_library, read one Artifact’s prompt and versions with get_artifact, and fetch the SVG of a version with get_artifact_svg. Request a PNG preview alongside SVG content when they need to show an Artifact in chat.

Turns, idempotency and waiting

Every send_prompt call requires an idempotencyKey (1 to 200 characters) that is new for each user request. Repeating a call with the same key and Chat returns the same turn and is not billed twice, so a client can safely retry after a timeout. Repeating a key returns that turn as it ended, failed or cancelled included; to try again, send the prompt with a new idempotencyKey. A new key is a new request.

send_prompt waits up to 40 seconds for the result. If the turn is still running it returns status running with the chatId; call get_chat with waitSeconds until the status is completed, failed or cancelled. A client that disconnects or gives up does not stop the turn: it keeps running and is visible in the QuiverAI app. Use cancel_turn to stop it.

A Chat runs one turn at a time: a prompt sent while the Chat is busy is refused with a turn-in-progress error. Each user can have at most three connected-app turns running at once; a fourth is refused until one finishes or is stopped.

Prompts consume your available usage and never purchase more. When usage is insufficient the prompt is refused and you manage usage in your account.

Models

Call list_models before choosing a model. The response is the source of truth for the models and operations available to the connected App account, with the default marked; omit model to use that default. Inspect each model’s account-level access and operation-level availability before a paid prompt. Do not substitute a model from the API Platform catalog.

Setup

Choose an installer below. Cursor and Visual Studio Code open an install confirmation.

Install in CursorInstall in VS Code

Manual setup

Add QuiverAI from the CLI:

codex mcp add quiverai --url https://app.quiver.ai/mcp

Then run the login flow when Codex prompts you, or start it manually:

codex mcp login quiverai

Add QuiverAI as an HTTP MCP server:

claude mcp add --transport http quiverai https://app.quiver.ai/mcp

Open a Claude Code session and run /mcp to complete authentication.

Add QuiverAI to your Cursor MCP configuration:

{
  "mcpServers": {
    "quiverai": {
      "url": "https://app.quiver.ai/mcp"
    }
  }
}

After saving the config, use Cursor’s MCP tools UI or command palette to connect and complete the OAuth flow.

Add QuiverAI to your user or workspace MCP configuration:

{
  "servers": {
    "quiverai": {
      "type": "http",
      "url": "https://app.quiver.ai/mcp"
    }
  }
}

Start the server from the MCP configuration editor and complete the OAuth flow.

For clients with native remote MCP support, add https://app.quiver.ai/mcp as a Streamable HTTP server.

For clients that only support stdio MCP servers, use mcp-remote:

{
  "mcpServers": {
    "quiverai": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://app.quiver.ai/mcp"]
    }
  }
}

Permissions

The MCP server uses scoped OAuth access:

  • Read access lets agents list models, search your Library, read Artifacts and their SVG, and read the status of a Chat.
  • Write access lets agents send prompts and stop running turns. The MCP server does not expose a separate upload-slot tool; sources are supplied inline to send_prompt or referenced by an existing completed upload ID.

MCP is an App product surface. MCP prompts count toward the eligible weekly App usage allowance first, then toward prepaid App usage. Public API calls use the API Platform prepaid balance; see API Pricing.

Reading Artifact previews

Use get_artifact_svg when your client needs the SVG for a specific Artifact. By default the tool returns SVG content only.

When the client should render the Artifact visually in chat, set includePng: true. QuiverAI returns the SVG together with a PNG preview and a render instruction so the client can display the image directly to the user without rasterizing the SVG itself.

Troubleshooting

If connection fails, verify that your client supports remote MCP over Streamable HTTP or use the mcp-remote fallback shown above. If authentication opens in the browser but does not return to the client, remove the saved MCP connection from your client and add it again.

For account issues, contact us.

Was this page helpful?