v0 MCP connector

1. Install the SDK

   Node.js

   npm install @scalekit-sdk/node

   Python

   pip install scalekit

   Full SDK reference: Node.js | Python

2. Set your credentials

   Add your Scalekit credentials to your .env file. Find values in app.scalekit.com > Developers > API Credentials.

   .env

   SCALEKIT_ENVIRONMENT_URL=<your-environment-url>
   SCALEKIT_CLIENT_ID=<your-client-id>
   SCALEKIT_CLIENT_SECRET=<your-client-secret>

3. Set up the connector

   Register your v0 MCP credentials with Scalekit so it can authenticate requests on your behalf. You do this once per environment.

   Dashboard setup steps

   Register your v0 API key with Scalekit so it can authenticate and proxy requests to the v0 MCP server on behalf of your users. v0 MCP uses bearer token authentication — there is no redirect URI or OAuth flow.

   1. Get a v0 API key

      • Go to v0.app/chat/settings/keys and sign in with your Vercel account.
      • Click Create new key. Give it a name (e.g., Agent Auth) and confirm.
      • Copy the key immediately — it will not be shown again.

   2. Create a connection in Scalekit

      • In the Scalekit dashboard, go to AgentKit > Connections. Find v0 MCP and click Create.
      • Note the Connection name — you will 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 them via the dashboard for testing, or via the Scalekit API in production.

      Via dashboard (for testing)

      • Open the connection you created and click the Connected Accounts tab → Add account.

      • Fill in:

        • Your User’s ID — a unique identifier for this user in your system (e.g., user_123)
        • Bearer Token — the v0 API key you copied in step 1

      • Click Save.

      Via API (for production)

      Node.js

      await scalekit.actions.upsertConnectedAccount({
        connectionName: 'v0mcp',
        identifier: 'user_123',       // your user's unique ID
        credentials: { token: 'v0_api_...' },
      });

      Python

      scalekit_client.actions.upsert_connected_account(
          connection_name="v0mcp",
          identifier="user_123",
          credentials={"token": "v0_api_..."}
      )

4. Make your first call

   Node.js

   quickstart.ts

   import { ScalekitClient } from '@scalekit-sdk/node'
   import 'dotenv/config'
   
   const scalekit = new ScalekitClient(
     process.env.SCALEKIT_ENV_URL,
     process.env.SCALEKIT_CLIENT_ID,
     process.env.SCALEKIT_CLIENT_SECRET,
   )
   const actions = scalekit.actions
   
   const connector = 'v0mcp'
   const identifier = 'user_123'
   
   // Make your first call
   const result = await actions.executeTool({
     connector,
     identifier,
     toolName: 'v0mcp_findchats',
     toolInput: {},
   })
   console.log(result)

   Python

   quickstart.py

   import os
   from scalekit.client import ScalekitClient
   from dotenv import load_dotenv
   load_dotenv()
   
   scalekit_client = ScalekitClient(
       env_url=os.getenv("SCALEKIT_ENV_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"
   
   # Make your first call
   result = actions.execute_tool(
       tool_input={},
       tool_name="v0mcp_findchats",
       connection_name=connection_name,
       identifier=identifier,
   )
   print(result)

What you can do

Connect this agent connector to let your agent:

• Create a new chat — Start a fresh v0 conversation from an initial message and get back a chat ID with generated UI
• Send follow-up messages — Continue an existing v0 chat with a new message and retrieve the updated result
• List all chats — Retrieve all chats owned by the authenticated user, including IDs and metadata
• Get a specific chat — Fetch the full content of a chat by ID, including messages and generated UI
• Get user info — Retrieve authenticated user details such as plan and billing context

Common workflows

Tool calling

• Use v0mcp_search_actors to discover Actors for a specific platform or use case before deciding which to run.
• Use v0mcp_fetch_actor_details to retrieve an Actor’s input schema before calling it — always pass output: { inputSchema: true } to keep the response concise.
• Use v0mcp_call_actor to run an Actor synchronously, or with async: true for long-running tasks.
• Use v0mcp_get_actor_run to poll the status of an async run, and v0mcp_get_actor_output to retrieve results once complete.
• Use v0mcp_rag_web_browser when you need real-time web content for LLM grounding — it returns clean Markdown from the top search result pages.

Node.js

const toolResponse = await actions.executeTool({
  connector: 'v0mcp',
  identifier: 'user_123',
  toolName: 'v0mcp_fetch_actor_details',
  toolInput: {
    actor: 'apify/web-scraper',
  },
});
console.log('Actor details:', toolResponse.data);

Python

tool_response = actions.execute_tool(
    connection_name='v0mcp',
    identifier='user_123',
    tool_name='v0mcp_fetch_actor_details',
    tool_input={
        "actor": "apify/web-scraper",
    },
)
print("Actor details:", tool_response)

Tool list

Use the exact tool names from the Tool list below when you call execute_tool. If you’re not sure which name to use, list the tools available for the current user first.

v0mcp_createchat#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.8 params▾

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.

NameTypeRequiredDescription

messagestringrequiredThe initial message to start the chat with.

attachmentsarrayoptionalAttachments to include with the initial message.

chatPrivacystringoptionalPrivacy level for the chat.

designSystemIdstringoptionalThe ID of a design system to apply to this chat.

modelConfigurationobjectoptionalModel configuration for the chat.

projectIdstringoptionalAssociates the chat with a specific project.

responseModestringoptionalControls how the response is delivered.

systemstringoptionalSystem-level context or background for the chat.

v0mcp_findchats#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.0 params▾

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.

v0mcp_getchat#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.1 param▾

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.

NameTypeRequiredDescription

chatIdstringrequiredThe ID of the chat to retrieve.

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

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

NameTypeRequiredDescription

scopestringoptionalOptional scope parameter.

v0mcp_sendchatmessage#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.4 params▾

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.

NameTypeRequiredDescription

chatIdstringrequiredThe ID of the chat to add the message to.

messagestringrequiredThe message content to send.

attachmentsarrayoptionalAttachments to include with the message.

modelConfigurationobjectoptionalModel configuration for processing the message.