How to Generate Videos from Claude Desktop, VS Code, and Cursor with Veo MCP

A common problem with AI video tools is not the prompt itself. It is the context switch: you plan a scene in an assistant, write copy in your editor, maybe attach a reference image, and then jump to a separate interface just to create or check the video.

This guide shows how to keep that workflow inside your AI client by wiring the Veo MCP Server into Claude Desktop, VS Code, or Cursor. The goal is simple: make video generation and task tracking available where you are already working.

What you can do

The Veo MCP Server from Ace Data Cloud exposes Google Veo video capabilities through the Model Context Protocol. According to the public guide, the server supports:

• Text-to-video generation from prompts
• Image-to-video generation from input images
• Multiple models, including veo3, veo2, and veo31-fast-ingredients
• Output formats and resolutions such as 4K, 1080p, and GIF
• Aspect ratios such as 16:9 and 9:16
• 1080p upgrade for already generated videos
• Task querying so you can monitor progress and retrieve results

That combination is especially useful for developer workflows around demo videos, landing page concepts, documentation previews, social clips, and product storytelling drafts.

The tools listed in the guide are:

Tool	Purpose
veo_text_to_video	Generate video from text prompts
veo_image_to_video	Generate video based on images
veo_get_1080p	Upgrade video to 1080p
veo_get_task	Query one task status
veo_get_tasks_batch	Query multiple task statuses

Instead of leaving your editor to start every experiment manually, you can ask your assistant to call the appropriate MCP tool, then query the task status until the result is ready.

How it works

This setup does not start with a raw REST call in your application code. It starts by registering a local MCP server command with the client you use.

The documented command is:

mcp-veo

The server authenticates with an environment variable:

ACEDATACLOUD_API_TOKEN

Once configured, the AI client can discover Veo-related tools and call them during a conversation. That is the important MCP shift: the assistant is not merely writing instructions for you to follow later; it can use a standardized tool interface from inside the client.

Install the Veo MCP server

The recommended installation path in the guide is pip:

pip install mcp-veo

If you prefer working from source, the documented option is:

git clone https://github.com/AceDataCloud/VeoMCP.git
cd VeoMCP
pip install -e .

After installation, the server can be started with mcp-veo.

For a local setup, keep your API token out of source control. Treat the token like any other secret: put it in the MCP client configuration for your own machine, or use your normal secret-management workflow when applicable.

Configure Claude Desktop

In Claude Desktop, edit the configuration file for your operating system.

On macOS:

~/Library/Application Support/Claude/claude_desktop_config.json

On Windows:

%APPDATA%\Claude\claude_desktop_config.json

Add a server entry like this:

{
  "mcpServers": {
    "veo": {
      "command": "mcp-veo",
      "env": {
        "ACEDATACLOUD_API_TOKEN": "your API Token"
      }
    }
  }
}

Restart Claude Desktop after saving the file. The restart matters because the client needs to reload the MCP server definition.

If you prefer not to install the package in advance, the guide also documents a uvx configuration:

{
  "mcpServers": {
    "veo": {
      "command": "uvx",
      "args": ["mcp-veo"],
      "env": {
        "ACEDATACLOUD_API_TOKEN": "your API Token"
      }
    }
  }
}

That can be a good fit if you experiment with multiple MCP servers and want less global package state on your machine.

Configure VS Code or Cursor

For VS Code or Cursor, create this file in your project root:

.vscode/mcp.json

Then add the Veo server under servers:

{
  "servers": {
    "veo": {
      "command": "mcp-veo",
      "env": {
        "ACEDATACLOUD_API_TOKEN": "your API Token"
      }
    }
  }
}

The uvx variant uses the same structure:

{
  "servers": {
    "veo": {
      "command": "uvx",
      "args": ["mcp-veo"],
      "env": {
        "ACEDATACLOUD_API_TOKEN": "your API Token"
      }
    }
  }
}

This project-level config is useful when the video workflow belongs to a specific repo, for example a docs site, a product launch page, or a prototype with embedded demo assets.

A practical workflow to try

Start with a constrained prompt and a clear output shape. For a horizontal demo background, you might ask:

Use the Veo MCP server to generate a 16:9 video from text. Scene: a calm starry sky time-lapse over a minimal developer workspace. Keep the motion slow and cinematic.

For a short-form clip, make the aspect ratio explicit:

Create a vertical 9:16 short video concept from this product description. Focus on a clean product reveal, subtle camera movement, and readable visual hierarchy.

If you have a reference image, use the image-to-video path:

Use veo_image_to_video with this landscape image and generate a 4K-style cinematic motion clip. Preserve the composition, add gentle camera movement, and avoid changing the core subject.

And because video generation is usually asynchronous, make task lookup part of the workflow:

Check the task with veo_get_task and summarize whether it is still running or ready to retrieve.

For several experiments, use veo_get_tasks_batch so the assistant can track multiple results without losing context.

Final notes

The practical value of MCP is not that it adds another configuration file. It is that your assistant can move from planning to execution without making you leave the environment where the work started.

For video generation, that means text-to-video, image-to-video, 1080p upgrade, and task querying can sit beside your code, docs, or product notes. If you want the exact reference configuration, the public guide is here: https://platform.acedata.cloud/documents/veo-mcp