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

Video generation becomes much easier to prototype when it sits inside the tools where builders already write prompts, inspect assets, and iterate on ideas. The Veo MCP Server from Ace Data Cloud lets an MCP-capable client such as Claude Desktop, VS Code, or Cursor call Veo video tools through a standard interface, so you can move from a written brief to a generated video task without leaving your working environment.

What you can do

The documented Veo MCP setup exposes a small, practical tool surface for video workflows:

• veo_text_to_video for generating video from text prompts.
• veo_image_to_video for generating video based on images.
• veo_get_1080p for upgrading an already generated video to 1080p.
• veo_get_task for checking a single task status.
• veo_get_tasks_batch for checking multiple task statuses.

The same document also describes support for multiple Veo models, including veo3, veo2, and veo31-fast-ingredients, plus output options such as 4K, 1080p, GIF, and aspect ratios including 16:9 and 9:16. That is enough to cover many builder scenarios: cinematic landscape clips, vertical short-video drafts, motion tests from reference images, and post-generation status checks.

How it works

MCP, or Model Context Protocol, gives AI clients a standardized way to call external tools. In this case, the local MCP server is installed as mcp-veo. Your client starts that command and passes an ACEDATACLOUD_API_TOKEN environment variable. Once the client restarts, the Veo tools become available in conversation.

The important design detail is that the AI client does not need to know every implementation detail of the Veo API. It only needs to call the MCP tools exposed by the server. As a builder, you still keep control over prompts, source images, task checks, and output format requests from the client interface.

Install the MCP server

The recommended installation path in the documentation is a simple pip install:

pip install mcp-veo

If you prefer source installation, the documented repository flow is:

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

After installation, the command you wire into your MCP client is mcp-veo. If your team uses ephemeral tool execution or you do not want to pre-install a Python package globally, the docs also show a uvx configuration.

Configure Claude Desktop

For Claude Desktop, edit the configuration file for your operating system:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
• 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"
      }
    }
  }
}

Or use uvx instead of a pre-installed command:

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

Save the file and restart Claude Desktop. After that, you can ask for tasks such as generating a starry sky time-lapse, creating a vertical 9:16 short video, or upgrading a generated clip to 1080p.

Configure VS Code or Cursor

For project-based workflows, create .vscode/mcp.json in the project root. The documented configuration is similar, but the top-level key is servers:

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

And the uvx version is:

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

This is a good fit when video generation is part of a larger workflow: a landing page repo, a product demo script, a storyboard folder, or a content automation project. Your editor can hold the prompt notes, reference images, and generated task IDs in the same place.

A practical workflow for builders

1. Write a concise scene brief in your client or editor.
2. Call veo_text_to_video for a prompt-only draft, or veo_image_to_video when you have a reference image.
3. Use veo_get_task to monitor a single generation task, or veo_get_tasks_batch when you are comparing several variants.
4. If the generated asset needs a higher-resolution delivery version, use veo_get_1080p.

A useful habit is to make aspect ratio part of the brief. Ask for 16:9 when you are designing a website hero or presentation clip, and 9:16 when you are testing a short-form mobile format. For teams, keep the MCP configuration checked into the project only if it does not include secrets; the token value belongs in the local environment or private client config.

Where to go next

The main value of this setup is not that it hides video generation behind chat. It is that it puts generation, iteration, task tracking, and editor context in one loop. If you are already using Claude Desktop, VS Code, or Cursor for planning and implementation, Veo through MCP can become another tool in the builder workflow rather than a separate destination.

For the complete setup reference, see the Veo MCP Integration Guide.