> **Building with AI coding agents?** Install the authstack plugin with one command. This equips your agent with accurate Scalekit implementation patterns.
>
> **Recommended** (the `-y` flags skip prompts, so the command runs without an interactive terminal):
> ```bash
> npx -y @scalekit-inc/cli setup -y
> ```
>
> Global:
> ```bash
> npm install -g @scalekit-inc/cli
> scalekit setup -y
> ```
>
> Supports Claude Code, Cursor, GitHub Copilot, Codex + skills for other Agent Skills-compatible agents in `~/.agents/skills`.
> Skills: integrate-agentkit, implement-saaskit, add-mcp-oauth, implement-sso, implement-scim.
> [Full setup guide](https://docs.scalekit.com/dev-kit/build-with-ai/)

---

# Connect AI agents to the v0 MCP server

The v0 MCP connector routes your AI agent's tool calls to v0's own MCP server through Scalekit. Each user connects their own v0 access token once, and Scalekit sends it with every call, so your agent never handles credentials. It comes with 5 tools.

**Authentication:** Bearer Token
**Categories:** AI, Developer Tools, Design
**Tools:** 5: 3 read, 2 write, 0 destructive
**Users sign in with:** Access token
**Built by:** Vendor MCP
**Try it:** [Playground in the Scalekit dashboard](https://app.scalekit.com/ws/signup?sk_intent=playground&provider=V0MCP)

## Setup

1. ### Install the SDK

   **Node.js**

   ```bash
   npm install @scalekit-sdk/node dotenv
   ```

   **Python**

   ```bash
   pip install scalekit-sdk-python python-dotenv
   ```

2. ### Set your credentials

   Add your Scalekit credentials to your `.env` file. Find values in **[app.scalekit.com](https://app.scalekit.com)** > **Developers** > **API Credentials**.

   ```sh title=".env"
   SCALEKIT_ENVIRONMENT_URL=<your-environment-url>
   SCALEKIT_CLIENT_ID=<your-client-id>
   SCALEKIT_CLIENT_SECRET=<your-client-secret>
   ```

3. ### Create the v0 MCP connection

   In **AgentKit > Connections**, create a v0 MCP connection. The name you give it is the `connection_name` your code passes. See [Configure connections](/agentkit/connections/).

   **Console steps with screenshots:**

   Register your v0 API key with Scalekit so it can authenticate and proxy requests on behalf of your users. v0 MCP uses Bearer Token authentication.

   1. ### Get a v0 API key

      - Go to [v0.dev](https://v0.dev) and sign in to your account.
      - Click your workspace name in the top-left corner and select **Settings**.
      - In the left sidebar, click **API Keys**.
      - Click **New Key**, give it a name (e.g. `Agent Auth`), and copy the generated key.

      > Image: v0 Settings page showing the API Keys section with an existing key and the New Key button

   2. ### Create a connection in Scalekit

      - In the [Scalekit dashboard](https://app.scalekit.com), go to **AgentKit** → **Connections** → **Create Connection**.
      - Search for **v0 MCP** and click **Create**.
      - Note the **Connection name** — use this as `connection_name` in your code (e.g., `v0mcp`).

   3. ### Add a connected account

      Connected accounts link a specific user identifier in your system to a v0 API key. Add one in the dashboard to test. In production, each user adds their own through the authorization link: they enter their credentials on the page it opens.

      **In the dashboard, to test**

      - Open the connection and click the **Connected Accounts** tab → **Add account**.
      - Fill in **Your User's ID** and **API Key**, then click **Save**.

      **From your backend, if your app already has the credentials**

      For example, when users enter them on a settings page in your app:

        **Node.js**

        ```ts
        import { ConnectorStatus } from '@scalekit-sdk/node'

        const authorizationDetails = {
          details: {
            case: 'staticAuth',
            value: { details: { token: 'your-v0-api-key' } },
          },
        }

        let { connectedAccount } = await scalekit.actions.upsertConnectedAccount({
          connectionName: 'v0mcp',
          identifier: 'user_123',
          authorizationDetails,
        })

        // Make sure the account is ACTIVE before the first tool call.
        if (connectedAccount?.status !== ConnectorStatus.ACTIVE) {
          ;({ connectedAccount } = await scalekit.actions.upsertConnectedAccount({
            connectionName: 'v0mcp',
            identifier: 'user_123',
            authorizationDetails,
          }))
        }
        ```

        **Python**

        ```python
        authorization_details = {"static_auth": {"token": "your-v0-api-key"}}

        response = scalekit_client.actions.upsert_connected_account(
            connection_name="v0mcp",
            identifier="user_123",
            authorization_details=authorization_details,
        )

        # Make sure the account is ACTIVE before the first tool call.
        if response.connected_account.status != "ACTIVE":
            response = scalekit_client.actions.upsert_connected_account(
                connection_name="v0mcp",
                identifier="user_123",
                authorization_details=authorization_details,
            )
        ```

4. ### Authorize a user and make your first call

   **Node.js** (`quickstart.mts`)

   ```typescript
   import { ScalekitClient } from '@scalekit-sdk/node'
   import 'dotenv/config'
   import { createInterface } from 'node:readline/promises'

   const scalekit = new ScalekitClient(
     process.env.SCALEKIT_ENVIRONMENT_URL,
     process.env.SCALEKIT_CLIENT_ID,
     process.env.SCALEKIT_CLIENT_SECRET,
   )
   const actions = scalekit.actions

   const connector = 'v0mcp'
   const identifier = 'user_123'

   // Generate an authorization link for the user
   const { link } = await actions.getAuthorizationLink({ connectionName: connector, identifier })
   console.log('Authorize v0 MCP:', link)
   const rl = createInterface({ input: process.stdin, output: process.stdout })
   await rl.question('Press Enter after authorizing...')
   rl.close()

   // Make your first call
   const result = await actions.executeTool({
     connector,
     identifier,
     toolName: 'v0mcp_findchats',
     toolInput: {},
   })
   console.log(result)
   ```

   ```bash
   npx tsx quickstart.mts
   ```

   **Python** (`quickstart.py`)

   ```python
   import os
   from scalekit import ScalekitClient
   from dotenv import load_dotenv
   load_dotenv()

   scalekit_client = ScalekitClient(
       env_url=os.getenv("SCALEKIT_ENVIRONMENT_URL"),
       client_id=os.getenv("SCALEKIT_CLIENT_ID"),
       client_secret=os.getenv("SCALEKIT_CLIENT_SECRET"),
   )
   actions = scalekit_client.actions

   connection_name = "v0mcp"
   identifier = "user_123"

   # Generate an authorization link for the user
   link_response = actions.get_authorization_link(
       connection_name=connection_name,
       identifier=identifier,
   )
   print("Authorize v0 MCP:", link_response.link)
   input("Press Enter after authorizing...")

   # Make your first call
   result = actions.execute_tool(
       tool_input={},
       tool_name="v0mcp_findchats",
       connection_name=connection_name,
       identifier=identifier,
   )
   print(result)
   ```

   ```bash
   python quickstart.py
   ```

   Each user opens the link once and enters their v0 MCP server credentials there. If your app already has a user's credentials, add the account from your backend instead, as the console steps above show. See [Authorize a user](/agentkit/tools/authorize/) for the full flow and statuses.

## Tools

Pass the exact name to `execute_tool`, with an input like each tool's example. To ask for a tool that's missing, use the [request form](https://scalekitsupport.portal.usepylon.com/forms/request-a-connector-tool).

**Node.js**

```typescript
const result = await actions.executeTool({
  toolName: 'v0mcp_findchats',
  toolInput: {},
  connector: 'v0mcp',
  identifier: 'user_123',
})
```

**Python**

```python
result = actions.execute_tool(
    tool_name="v0mcp_findchats",
    tool_input={},
    connection_name="v0mcp",
    identifier="user_123",
)
```

`result.data` is the app's response as JSON, and `result.execution_id` (`executionId` in Node.js) is the ID of the call.

### `v0mcp_findchats`

Find v0 Chats · Read-only

Find all chats using the v0 Platform API. Returns the list of chats owned by the authenticated user, including each chat's ID and metadata. Use this to discover chat IDs for v0mcp_getchat or v0mcp_sendchatmessage.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs: none.

Example input: `{}`

### `v0mcp_getchat`

Get v0 Chat · Read-only

Get a specific chat by ID using the v0 Platform API. Returns the full chat, including its messages and generated UI. Obtain a chat ID from v0mcp_findchats or v0mcp_createchat.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `chatId` (`string`, required): The ID of the chat to retrieve.

Example input: `{"chatId":"<chatId>"}`

### `v0mcp_getuser`

Get User Info · Read-only

Get user information using the v0 Platform API. Returns details about the authenticated v0 account, such as plan and billing context.

Read only: yes. Destructive: no. Idempotent (safe to retry): yes.

Inputs:

- `scope` (`string`, optional): Optional scope parameter.

Example input: `{}`

### `v0mcp_createchat`

Create v0 Chat · Write

Create a new chat using the v0 Platform API. Starts a fresh v0 conversation from an initial message and returns the created chat, including generated UI and a chat ID you can use with v0mcp_getchat or v0mcp_sendchatmessage.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `message` (`string`, required): The initial message to start the chat with.
- `attachments` (`array`, optional): Attachments to include with the initial message.
- `chatPrivacy` (`string`, optional): Privacy level for the chat. One of: `public`, `private`, `team-edit`, `team`, `unlisted`. Default: `private`.
- `designSystemId` (`string`, optional): The ID of a design system to apply to this chat.
- `modelConfiguration` (`object`, optional): Model configuration for the chat.
- `projectId` (`string`, optional): Associates the chat with a specific project.
- `responseMode` (`string`, optional): Controls how the response is delivered. One of: `sync`, `async`. Default: `sync`.
- `system` (`string`, optional): System-level context or background for the chat.

Example input: `{"message":"<message>"}`

### `v0mcp_sendchatmessage`

Send Chat Message · Write

Send a new message to an existing chat using the v0 Platform API. Continues an existing v0 conversation with a follow-up message and returns the updated chat. Obtain a chat ID from v0mcp_findchats or v0mcp_createchat.

Read only: no. Destructive: no. Idempotent (safe to retry): no.

Inputs:

- `chatId` (`string`, required): The ID of the chat to add the message to.
- `message` (`string`, required): The message content to send.
- `attachments` (`array`, optional): Attachments to include with the message.
- `modelConfiguration` (`object`, optional): Model configuration for processing the message.

Example input: `{"chatId":"<chatId>","message":"<message>"}`

## Related

Other AI connectors ([all 116](/agentkit/connectors/?category=ai)):

- [Chorus](/agentkit/connectors/chorus/): Scalekit connector, Username and password, 9 tools
- [Gong](/agentkit/connectors/gong/): Scalekit connector, OAuth, 49 tools
- [Jiminny](/agentkit/connectors/jiminny/): Scalekit connector, Access token, 27 tools


---

## More Scalekit documentation

| Resource | What it contains | When to use it |
|----------|-----------------|----------------|
| [/llms.txt](/llms.txt) | Structured index with routing hints per product area | Start here — find which documentation set covers your topic before loading full content |
| [/llms-full.txt](/llms-full.txt) | Complete documentation for all Scalekit products in one file | Use when you need exhaustive context across multiple products or when the topic spans several areas |
| [sitemap-0.xml](https://docs.scalekit.com/sitemap-0.xml) | Full URL list of every documentation page | Use to discover specific page URLs you can fetch for targeted, page-level answers |