---
title: "MCP server"
description: "Connect AI agents and MCP-compatible clients to QuiverAI."
icon: "plug-zap"
sidebar:
  badge: "Beta"
---

The QuiverAI MCP server lets compatible AI agents create SVGs, vectorize images,
animate existing SVGs, inspect your Gallery, and fetch completed SVG content through a
secure hosted connection.

Connect your MCP client to:

```text
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.

:::info
MCP access is in beta. Model and operation availability follows your QuiverAI plan, account
limits, and credit balance.
:::

## What agents can do

Once connected, agents can:

- List the QuiverAI models available to your account with `list_models`.
- Browse Gallery metadata with `list_creations` and fetch selected creation metadata or SVG content
  with `get_creation` and `get_creation_content`.
- Filter `list_creations` with `cursor`, `limit` (1–100), `method` (`generate`, `vectorize`, or `animate`), and
  `status`, and set `includeContent` when inline SVG is needed for multiple items.
- Request a PNG preview alongside SVG content when they need to show a creation in chat.
- Create text-to-SVG generation tasks with `create_generation`; set `n` from 1 to 16 when you need
  multiple outputs (the default is 1).
- Pass image and SVG sources directly to create tools as public URLs, base64 payloads, or completed
  QuiverAI upload IDs. QuiverAI fetches or decodes non-upload sources, validates them, stores them, and
  persists upload IDs in the task. URL and base64 sources may include an optional `filename`.
- Vectorize raster image sources with `create_vectorization`.
- Animate an existing SVG creation or SVG source with `create_animation` when animation is enabled
  for the account.
- Successful `create_*` calls return `status: "completed"` with `creationIds`. Consume those
  directly. Use `get_task` later only to inspect an existing request.

## Setup

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

<InstallButtons
  items={[
    {
      ariaLabel: "Install QuiverAI MCP Server in Cursor",
      href: "https://cursor.com/en-US/install-mcp?name=quiverai&config=eyJ1cmwiOiJodHRwczovL2FwcC5xdWl2ZXIuYWkvbWNwIn0%3D",
      icon: "/images/agents/cursor.svg",
      invertIconInDark: true,
      label: "Install in Cursor",
    },
    {
      ariaLabel: "Install QuiverAI MCP Server in Visual Studio Code",
      href: "vscode:mcp/install?%7B%22name%22%3A%22quiverai%22%2C%22type%22%3A%22http%22%2C%22url%22%3A%22https%3A%2F%2Fapp.quiver.ai%2Fmcp%22%7D",
      icon: "/images/agents/visual-studio-code.svg",
      label: "Install in VS Code",
    },
  ]}
/>

:::tip
Codex and Cursor users can also install the public [agent plugins](/app/plugins), which package
the MCP configuration together with QuiverAI agent instructions.
:::

### Manual setup

**Codex**

Add QuiverAI from the CLI:

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

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

```bash
codex mcp login quiverai
```

**Claude Code**

Add QuiverAI as an HTTP MCP server:

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

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

**Cursor**

Add QuiverAI to your Cursor MCP configuration:

```json
{
  "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.

**VS Code**

Add QuiverAI to your user or workspace MCP configuration:

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

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

**Other clients**

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`:

```json
{
  "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, inspect Gallery items, read creation content, and
  inspect existing tasks.
- Write access lets agents start text-to-SVG generations, vectorizations, and animations. The MCP
  server does not expose a separate upload-slot tool; sources are supplied inline to create tools or
  referenced by an existing completed upload ID.

MCP is a Platform product surface. MCP task creation follows Platform billing: eligible weekly app
credits are used first, and prepaid on-demand credits can cover additional work. Public API calls
use API prepaid balance; see [API Pricing](/api/pricing).

## Animations (coming soon)

Use `create_animation` to animate an existing QuiverAI creation or SVG source. Supply exactly one
`source`:

- `{ "creationId": "..." }` for an existing SVG creation in your Gallery.
- `{ "url": "https://..." }` for a public SVG URL.
- `{ "base64": "...", "mediaType": "image/svg+xml" }` for an inline SVG payload.
- `{ "uploadId": "..." }` for an existing completed QuiverAI upload.
- `prompt` is an optional direction for the animation.
- `n` is optional and must be `1` when present. OpenResponses animation returns one output.

A successful `create_animation` returns `status: "completed"` with `creationIds` and `taskId`.
Consume `creationIds` directly, then read each resulting creation with `get_creation_content`.
Use `get_task` later only to inspect that existing request.

Animation tools and animation creations are visible only when the rollout and an animate-capable
model are available for the account. Plan or credit access can still restrict creation.

## Reading creation previews

Use `get_creation_content` when your client needs the SVG for a specific creation. By
default the tool returns SVG content only.

When the client should render the creation 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](https://quiver.ai/contact).
