Skip to main content
Glama
deenesjakoruzh
AceDataCloud

VeoMCP

by AceDataCloud
OverviewSchemaSourceRelated ServersDiscussionsAdmin
Python
Hybrid

VeoMCP

PyPI version PyPI downloads Python 3.10+ License: MIT MCP

一个用于 AI 视频生成的 Model Context Protocol (MCP) 服务器，通过 AceDataCloud API 使用 Veo。

直接从 Claude、VS Code 或任何兼容 MCP 的客户端，根据文本提示词或图像生成 AI 视频。

功能特性

  • 文生视频 - 根据文本描述创建 AI 生成的视频

  • 图生视频 - 为图像添加动画或创建图像间的过渡效果

  • 多图融合 - 融合来自多张图像的元素

  • 1080p 超分 - 获取生成视频的高分辨率版本

  • 任务追踪 - 监控生成进度并获取结果

  • 多种模型 - 在多种 Veo 模型中选择质量与速度的平衡

Related MCP server: Veo 3.1 MCP Server

工具参考

工具

描述

veo_text_to_video

使用 Veo 根据文本提示词生成 AI 视频。

veo_image_to_video

使用 Veo 根据一张或多张参考图像生成 AI 视频。

veo_get_1080p

获取生成视频的 1080p 高分辨率版本。

veo_get_task

查询视频生成任务的状态和结果。

veo_get_tasks_batch

同时查询多个视频生成任务。

veo_list_models

列出所有可用的 Veo 模型及其功能。

veo_list_actions

列出所有可用的 Veo API 操作及对应的工具。

veo_get_prompt_guide

获取关于编写高效 Veo 视频生成提示词的指南。

快速入门

1. 获取您的 API Token

  1. 在 AceDataCloud 平台 注册

  2. 前往 API 文档页面

  3. 点击 "Acquire" 获取您的 API token

  4. 复制该 token 以供下方使用

2. 使用托管服务器（推荐）

AceDataCloud 托管了一个受管理的 MCP 服务器 —— 无需本地安装。

端点： https://veo.mcp.acedata.cloud/mcp

所有请求都需要 Bearer token。请使用第 1 步中获取的 API token。

Claude.ai

通过 OAuth 直接在 Claude.ai 上连接 —— 无需 API token：

  1. 前往 Claude.ai 设置 → 集成 → 添加更多

  2. 输入服务器 URL：https://veo.mcp.acedata.cloud/mcp

  3. 完成 OAuth 登录流程

  4. 开始在对话中使用这些工具

Claude Desktop

添加到您的配置文件（macOS 上为 ~/Library/Application Support/Claude/claude_desktop_config.json）：

{
  "mcpServers": {
    "veo": {
      "type": "streamable-http",
      "url": "https://veo.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Cursor / Windsurf

添加到您的 MCP 配置文件（.cursor/mcp.json 或 .windsurf/mcp.json）：

{
  "mcpServers": {
    "veo": {
      "type": "streamable-http",
      "url": "https://veo.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

VS Code (Copilot)

添加到您的 VS Code MCP 配置文件（.vscode/mcp.json）：

{
  "servers": {
    "veo": {
      "type": "streamable-http",
      "url": "https://veo.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

或者为 VS Code 安装 Ace Data Cloud MCP 扩展，该扩展集成了所有 15 个 MCP 服务器，支持一键设置。

JetBrains IDEs

  1. 前往 设置 → 工具 → AI Assistant → Model Context Protocol (MCP)

  2. 点击 添加 → HTTP

  3. 粘贴：

{
  "mcpServers": {
    "veo": {
      "url": "https://veo.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Claude Code

Claude Code 原生支持 MCP 服务器：

claude mcp add veo --transport http https://veo.mcp.acedata.cloud/mcp \
  -h "Authorization: Bearer YOUR_API_TOKEN"

或者添加到项目的 .mcp.json 中：

{
  "mcpServers": {
    "veo": {
      "type": "streamable-http",
      "url": "https://veo.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Cline

添加到 Cline 的 MCP 设置（.cline/mcp_settings.json）：

{
  "mcpServers": {
    "veo": {
      "type": "streamable-http",
      "url": "https://veo.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Amazon Q Developer

添加到您的 MCP 配置中：

{
  "mcpServers": {
    "veo": {
      "type": "streamable-http",
      "url": "https://veo.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Roo Code

添加到 Roo Code 的 MCP 设置中：

{
  "mcpServers": {
    "veo": {
      "type": "streamable-http",
      "url": "https://veo.mcp.acedata.cloud/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_API_TOKEN"
      }
    }
  }
}

Continue.dev

添加到 .continue/config.yaml：

mcpServers:
  - name: veo
    type: streamable-http
    url: https://veo.mcp.acedata.cloud/mcp
    headers:
      Authorization: "Bearer YOUR_API_TOKEN"

Zed

添加到 Zed 的设置（~/.config/zed/settings.json）：

{
  "language_models": {
    "mcp_servers": {
      "veo": {
        "url": "https://veo.mcp.acedata.cloud/mcp",
        "headers": {
          "Authorization": "Bearer YOUR_API_TOKEN"
        }
      }
    }
  }
}

cURL 测试

# Health check (no auth required)
curl https://veo.mcp.acedata.cloud/health

# MCP initialize
curl -X POST https://veo.mcp.acedata.cloud/mcp \
  -H "Content-Type: application/json" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer YOUR_API_TOKEN" \
  -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2025-03-26","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}'

3. 或者本地运行（替代方案）

如果您更喜欢在自己的机器上运行服务器：

# Install from PyPI
pip install mcp-veo
# or
uvx mcp-veo

# Set your API token
export ACEDATACLOUD_API_TOKEN="your_token_here"

# Run (stdio mode for Claude Desktop / local clients)
mcp-veo

# Run (HTTP mode for remote access)
mcp-veo --transport http --port 8000

Claude Desktop (本地)

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

Docker (自托管)

docker pull ghcr.io/acedatacloud/mcp-veo:latest
docker run -p 8000:8000 ghcr.io/acedatacloud/mcp-veo:latest

客户端使用各自的 Bearer token 进行连接 —— 服务器会从每个请求的 Authorization 头中提取 token。

可用工具

视频生成

工具

描述

veo_text_to_video

根据文本提示词生成视频

veo_image_to_video

根据参考图像生成视频

veo_get_1080p

获取 1080p 高分辨率版本

任务

工具

描述

veo_get_task

查询单个任务状态

veo_get_tasks_batch

同时查询多个任务

信息

工具

描述

veo_list_models

列出可用的 Veo 模型

veo_list_actions

列出可用的 API 操作

veo_get_prompt_guide

获取视频提示词编写指南

使用示例

根据文本生成视频

User: Create a video of a sunset over the ocean

Claude: I'll generate a sunset video for you.
[Calls veo_text_to_video with prompt="Cinematic shot of a golden sunset over the ocean, waves gently rolling, warm colors reflecting on the water"]

为图像添加动画

User: Animate this product image to make it rotate slowly

Claude: I'll create a video from your image.
[Calls veo_image_to_video with image_urls=["product_image.jpg"], prompt="Product slowly rotates 360 degrees, studio lighting"]

创建图像过渡效果

User: Create a video that transitions between these two landscape photos

Claude: I'll create a transition video between your images.
[Calls veo_image_to_video with image_urls=["img1.jpg", "img2.jpg"], prompt="Smooth cinematic transition between scenes"]

可用模型

模型

文生视频

图生视频

图像输入

veo2

✅

✅

1 张图像（第一帧）

veo2-fast

✅

✅

1 张图像（第一帧）

veo3

✅

✅

1-3 张图像

veo3-fast

✅

✅

1-3 张图像

veo31

✅

✅

1-3 张图像

veo31-fast

✅

✅

1-3 张图像

veo31-fast-ingredients

❌

✅

1-3 张图像（融合）

宽高比：

  • 16:9 - 横屏/宽屏（默认）

  • 9:16 - 竖屏（社交媒体）

  • 4:3 - 标准

  • 3:4 - 标准竖屏

  • 1:1 - 正方形

配置

环境变量

变量

描述

默认值

ACEDATACLOUD_API_TOKEN

来自 AceDataCloud 的 API token

必填

ACEDATACLOUD_API_BASE_URL

API 基础 URL

https://api.acedata.cloud

ACEDATACLOUD_OAUTH_CLIENT_ID

OAuth 客户端 ID（托管模式）

—

ACEDATACLOUD_PLATFORM_BASE_URL

平台基础 URL

https://platform.acedata.cloud

VEO_DEFAULT_MODEL

生成默认模型

veo2

VEO_REQUEST_TIMEOUT

请求超时时间（秒）

180

LOG_LEVEL

日志级别

INFO

命令行选项

mcp-veo --help

Options:
  --version          Show version
  --transport        Transport mode: stdio (default) or http
  --port             Port for HTTP transport (default: 8000)

开发

设置开发环境

# Clone repository
git clone https://github.com/AceDataCloud/VeoMCP.git
cd VeoMCP

# Create virtual environment
python -m venv .venv
source .venv/bin/activate  # or `.venv\Scripts\activate` on Windows

# Install with dev dependencies
pip install -e ".[dev,test]"

运行测试

# Run unit tests
pytest

# Run with coverage
pytest --cov=core --cov=tools

# Run integration tests (requires API token)
pytest tests/test_integration.py -m integration

代码质量

# Format code
ruff format .

# Lint code
ruff check .

# Type check
mypy core tools

构建与发布

# Install build dependencies
pip install -e ".[release]"

# Build package
python -m build

# Upload to PyPI
twine upload dist/*

项目结构

VeoMCP/
├── core/                   # Core modules
│   ├── __init__.py
│   ├── client.py          # HTTP client for Veo API
│   ├── config.py          # Configuration management
│   ├── exceptions.py      # Custom exceptions
│   ├── server.py          # MCP server initialization
│   ├── types.py           # Type definitions
│   └── utils.py           # Utility functions
├── tools/                  # MCP tool definitions
│   ├── __init__.py
│   ├── video_tools.py     # Video generation tools
│   ├── info_tools.py      # Information tools
│   └── task_tools.py      # Task query tools
├── prompts/                # MCP prompts
│   └── __init__.py
├── tests/                  # Test suite
│   ├── conftest.py
│   ├── test_client.py
│   ├── test_config.py
│   ├── test_integration.py
│   └── test_utils.py
├── deploy/                 # Deployment configs
│   └── production/
│       ├── deployment.yaml
│       ├── ingress.yaml
│       └── service.yaml
├── .env.example           # Environment template
├── .gitignore
├── Dockerfile             # Docker image for HTTP mode
├── docker-compose.yaml    # Docker Compose config
├── LICENSE
├── main.py                # Entry point
├── pyproject.toml         # Project configuration
└── README.md

API 参考

此服务器封装了 AceDataCloud Veo API：

贡献

欢迎贡献代码！请：

  1. Fork 本仓库

  2. 创建功能分支 (git checkout -b feature/amazing)

  3. 提交更改 (git commit -m 'Add amazing feature')

  4. 推送到分支 (git push origin feature/amazing)

  5. 开启 Pull Request

许可证

MIT 许可证 - 详情请参阅 LICENSE。

链接

由 AceDataCloud 用心制作

Available Tools

8 tools
veo_get_1080pAInspect

Get the 1080p high-resolution version of a generated video.

By default, Veo generates videos at a lower resolution for faster processing.
Use this tool to get the full 1080p version of a completed video.

Use this when:
- You need a higher resolution version for production use
- The initial video generation is complete and you want to upscale
- You need a clearer, more detailed video output

Note: The video must be in 'succeeded' state before requesting 1080p version.

Returns:
    Task ID and the 1080p video information including the new video URL.
ParametersJSON Schema
NameRequiredDescriptionDefault
modelNoThe model used to generate the source video. Required by the API; pass the same model you used for the original generation.veo31-fast
video_idYesThe video ID from a previous generation result. This is the 'id' field from the video data, not the task_id.
callback_urlNoOptional URL to receive a POST callback when upscaling completes.

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.2/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden. It discloses the succeeded-state requirement, the return payload (task ID and new video URL), and the lower-resolution default. It does not mention asynchronous behavior beyond the callback_url hint or potential costs, but it covers the most critical operational constraint.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is front-loaded with the core purpose, followed by compact context, a clearly formatted 'Use this when' list, a single note, and a return summary. Every sentence adds distinct value with no filler or redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a tool with three parameters, a rich schema, and an output schema, the description adequately covers the main precondition and result. It could be more complete by explicitly contrasting with veo_get_task or noting any asynchronous/cost implications, but the information provided is sufficient for correct use in most cases.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, and each parameter is already well documented in the schema, including the distinction between video_id and task_id, the need to pass the same model, and callback_url's optionality. The description adds no parameter-level detail beyond what the schema provides.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource: 'Get the 1080p high-resolution version of a generated video.' This clearly differentiates from sibling tools like veo_text_to_video or veo_get_task by focusing on upscaling an already generated video. The added context about Veo's default lower resolution further clarifies the tool's role.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description includes an explicit 'Use this when' list covering production needs, completed generation, and clearer output, plus a key precondition (video must be in 'succeeded' state). It does not name alternative tools or explicitly state when not to use it, so it stops short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

veo_get_prompt_guideAInspect

Get guidance on writing effective prompts for Veo video generation.

Shows how to structure prompts for best video generation results.
Following these tips helps Veo understand your vision and generate
more accurate and higher quality videos.

Returns:
    Complete guide with prompt structure, examples, and tips.
ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.7/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description fully discloses that the tool is read-only and returns a guide with prompt structure, examples, and tips, with no side effects or hidden behaviors.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and well-structured, with a clear first sentence and brief elaboration, earning its place without waste.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's simplicity (no parameters, output schema provided), the description fully covers what the tool does and returns, making it complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With no parameters and 100% schema coverage, the description does not need to add parameter semantics; baseline 4 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool provides guidance on writing effective prompts for Veo video generation, distinguishing it from sibling tools that handle actual video generation or task management.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the tool should be used before generating videos to improve prompt quality, but does not explicitly state when not to use it or mention alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

veo_get_taskAInspect

Query the status and result of a video generation task.

Use this to check if a generation is complete and retrieve the resulting
video URLs and metadata.

Use this when:
- You want to check if a generation has completed
- You need to retrieve video URLs from a previous generation
- You want to get the full details of a generated video

Task states:
- 'processing': Generation is still in progress
- 'succeeded': Generation finished successfully
- 'failed': Generation failed (check error message)

Returns:
    Task status and generated video information including URLs and state.
ParametersJSON Schema
NameRequiredDescriptionDefault
task_idNoThe task ID returned from a generation request. This is the 'task_id' field from any veo_text_to_video, veo_image_to_video, or veo_get_1080p tool response.
trace_idNoOptional trace identifier of the task to retrieve.

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.1/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden and does well by documenting the three task states ('processing', 'succeeded', 'failed'), noting that failures include an error message, and stating that results contain URLs and metadata. It stops short of explaining data retention or polling implications, but the core behavior is transparent.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well organized with a short summary, usage bullets, task-state list, and return-value note. There is minor redundancy between the opening paragraph and the use-when bullets, but it is compact and scannable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a simple task-status tool with an output schema, the description is mostly complete: it covers when to use it, expected states, and return content. The main gap is that both parameters are marked optional while the description implies a task ID is needed, but this is minor given the schema and output schema.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100% and already explains task_id and trace_id. The description adds task-level context but does not provide additional param-specific semantics beyond what the schema already states.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb and resource: 'Query the status and result of a video generation task.' It clearly distinguishes this single-task query tool from generation tools like veo_text_to_video and batch tool veo_get_tasks_batch.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit 'Use this when' bullets covering completion checks and URL retrieval. It does not explicitly name alternatives or state when not to use this tool, but the context is clear and sufficient.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

veo_get_tasks_batchAInspect

Query multiple video generation tasks at once.

Efficiently check the status of multiple tasks in a single request.
More efficient than calling veo_get_task multiple times.

Use this when:
- You have multiple pending generations to check
- You want to get status of several videos at once
- You're tracking a batch of generations

Returns:
    Status and video information for all queried tasks.
ParametersJSON Schema
NameRequiredDescriptionDefault
typeNoOptional task type filter.
limitNoMaximum number of tasks to return.
offsetNoNumber of matching tasks to skip for list retrieval.
task_idsNoOptional list of task IDs to query. Maximum recommended batch size is 50 tasks.
trace_idsNoOptional list of trace identifiers to query.
created_at_maxNoReturn tasks created before this Unix timestamp.
created_at_minNoReturn tasks created after this Unix timestamp.

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.3/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must carry the burden. It clearly frames the tool as a non-destructive 'query' operation, states that it returns status and video information, and emphasizes batch efficiency. It does not discuss auth, rate limits, or failure behavior, but the read-only intent is clear.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise and front-loaded, with a clear opening statement and structured 'Use this when' bullets. It is slightly repetitive ('efficiently' appears in two sentences), but every section earns its place and supports quick scanning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool has seven optional parameters and an output schema, the description supplies the necessary overall behavior: batch status checking and returned video information. Parameter details are left to the schema, which is acceptable here because the schema descriptions are complete and meaningful.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description adds general context about querying multiple tasks, but it does not elaborate on each parameter. Schema description coverage is 100%, so every parameter already has a meaningful description; the tool text simply reinforces the batch-facing purpose.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb (query) and clearly identifies the resource (multiple video generation tasks), immediately distinguishing it from the single-task sibling veo_get_task. The phrase 'More efficient than calling veo_get_task multiple times' further clarifies its unique role.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It provides explicit 'Use this when' scenarios, such as checking multiple pending generations or tracking a batch. It also names the alternative veo_get_task and explains when this batch variant is preferable, giving clear usage boundaries.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

veo_image_to_videoAInspect

Generate AI video from one or more reference images using Veo.

This creates a video using your image(s) as reference frames. The video
will animate from/between your provided images according to the prompt.

Image modes:
- 1 image: First-frame mode - the video starts from your image
- 2-3 images: First-last frame mode - video interpolates between images
- veo31-fast-ingredients model: Multi-image fusion - blends elements from all images

Use this when:
- You have a specific image you want to animate
- You want consistent visual style from a reference
- You need to create a video transition between two images

For video generation from text only, use veo_text_to_video instead.

Returns:
    Task ID and generated video information including URLs and state.
ParametersJSON Schema
NameRequiredDescriptionDefault
modelNoVeo model version. Note: 'veo31-fast-ingredients' is for multi-image fusion mode only. Other models support 1 image (first frame) or 2-3 images (first/last frame).veo31-fast
promptYesDescription of the video motion and action. Describe what should happen to the subject in the image. Examples: 'The coffee steam rises gently', 'The person turns and smiles at the camera', 'Camera slowly zooms out revealing the landscape'
image_urlsYesList of image URLs to use as reference. For first-frame mode, provide 1 image. For first-last frame mode, provide 2-3 images. The first image is the starting frame, the last image is the ending frame. Maximum 3 images.
resolutionNoVideo resolution. Options: '4k' for highest quality, '1080p' for standard HD, 'gif' for animated GIF format.
translationNoIf true, automatically translate the prompt to English for better generation quality.
aspect_ratioNoVideo aspect ratio. Should typically match your input image aspect ratio for best results.16:9
callback_urlNoOptional URL to receive a POST callback when generation completes.

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, and the description does not disclose any side effects, costs, rate limits, or asynchronous behavior beyond vague mention of returning a task ID. It lacks transparency about operational implications.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness2/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is verbose, redundantly repeating schema details in narrative form. Although structured with sections, it could be much more concise without losing information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the schema's richness, the description covers purpose, usage, and return values adequately. However, it omits potential error scenarios, limitations, or additional operational context, making it only moderately complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema covers all parameters with descriptions, achieving 100% coverage. The description adds minimal new meaning—it repeats schema info but does not clarify undefined aspects. Baseline of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool generates AI video from reference images and explicitly distinguishes it from text-to-video by mentioning the alternative veo_text_to_video. The purpose is unambiguous.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit 'Use this when' conditions and contrasts with text-only generation. Clearly guides when to choose this tool over alternatives.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

veo_list_actionsAInspect

List all available Veo API actions and corresponding tools.

Reference guide for what each action does and which tool to use.
Helpful for understanding the full capabilities of the Veo MCP.

Returns:
    Categorized list of all actions and their corresponding tools.
ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.3/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavior. It implies a read-only operation by stating it lists and categorizes, but it does not explicitly confirm safety, idempotency, or any side effects. With no annotations, the agent lacks explicit behavioral guarantees.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is three concise sentences, front-loaded with the core purpose, and every sentence adds value. No redundancy or wasted words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given zero parameters, a clear purpose, and the existence of an output schema (indicated by 'Returns: ...'), the description sufficiently explains what the tool does and its output. No critical information is missing for a listing operation.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

There are no parameters, so schema coverage is 100% by default. The description adds no parameter-specific info (not needed), but explains the return structure, which is adequate. Baseline for 0 parameters is 4.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it 'List all available Veo API actions and corresponding tools', establishing a specific verb and resource. It distinguishes from sibling tools by being a meta-reference rather than an action tool.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description indicates it is 'Helpful for understanding the full capabilities of the Veo MCP', providing clear context for when to use it. However, it does not explicitly exclude inappropriate uses or mention alternatives, which is acceptable for a listing tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

veo_list_modelsAInspect

List all available Veo models and their capabilities.

Shows all available model versions with their features, supported actions,
and image input rules. Use this to understand which model to choose
for your video generation.

Model comparison:
- veo3/veo3-fast: Improved quality, 1-3 images supported
- veo31/veo31-fast: Latest models, 1-3 images supported
- veo31-fast-ingredients: Multi-image fusion mode (ingredients2video action)

Returns:
    Table of all models with their capabilities and image rules.
ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.3/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Describes the return as a table and includes model specifics, but does not explicitly mention side effects or confirm read-only behavior; no annotations are available to cover this.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Structured with a purpose statement, model comparison list, and return description; concise and well-organized without unnecessary details.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The description covers the purpose, output format, and model capabilities, sufficient for a simple list operation; no error cases are mentioned but not needed for this clarity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has no parameters, so the description does not need to explain them; it adds clarity about the output, meeting the baseline for zero parameters.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it lists all available Veo models and their capabilities, with a specific verb and resource, distinguishing it from sibling tools like veo_get_task.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Explicitly instructs 'Use this to understand which model to choose for your video generation', providing a clear use case for when to call this tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

veo_text_to_videoAInspect

Generate AI video from a text prompt using Veo.

This creates a video from scratch based on your text description. Veo
will interpret your prompt and generate a matching video clip.

Use this when:
- You want to create a video from a text description
- You don't have a reference image to use
- You want maximum creative freedom for Veo

For video generation starting from an image, use veo_image_to_video instead.

Returns:
    Task ID and generated video information including URLs and state.
ParametersJSON Schema
NameRequiredDescriptionDefault
modelNoVeo model version. 'veo31'/'veo31-fast' are the latest; 'veo3'/'veo3-fast' remain available. Models with '-fast' suffix are faster but slightly lower quality.veo31-fast
promptYesDescription of the video to generate. Be descriptive about scene, subject, action, camera movement, lighting, and style. Examples: 'A white ceramic coffee mug on a glossy marble countertop, steam rising, soft morning light', 'Cinematic drone shot over a forest at sunset, golden hour lighting'
resolutionNoVideo resolution. Options: '4k' for highest quality, '1080p' for standard HD, 'gif' for animated GIF format. If not specified, uses the model's default resolution.
translationNoIf true, automatically translate the prompt to English for better generation quality. Useful for non-English prompts.
aspect_ratioNoVideo aspect ratio: '16:9' for landscape/widescreen or '9:16' for portrait/vertical.16:9
callback_urlNoOptional URL to receive a POST callback when generation completes. The callback will include the task_id and video results.

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries full responsibility for behavioral transparency. It mentions that the tool 'creates a video from scratch' and returns a 'Task ID and generated video information including URLs and state,' which implies asynchronous behavior, but it does not explicitly state that generation is non-blocking or that polling is required. It also fails to mention authentication, rate limits, or costs. The description gives some context but misses key behavioral traits for a generation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a clear opening, a 'Use this when' bullet list, and a 'Returns' section. It is concise—two paragraphs plus bullets—and front-loaded with the main purpose. The only minor inefficiency is that the first sentence is somewhat redundant with the tool name, but overall it earns its place without excessive verbosity.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity (6 parameters, video generation, potential async), the description covers the usage context and alternatives well, but it lacks explicit details on asynchronous workflow (polling vs. callback), any limitations, and does not describe the output schema beyond a one-line mention of 'Task ID and generated video information including URLs and state.' Since there is no output schema provided and no annotations, the description should compensate more by explaining the async nature and return structure in detail.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the baseline is 3. The description does not add any parameter-specific semantics beyond the schema's already detailed field descriptions (e.g., examples for prompt, model variant differences, resolution options). While the description mentions 'maximum creative freedom' which relates to prompt usage, it doesn't elaborate on any parameter behavior that the schema doesn't already cover. Thus, it adds minimal value beyond the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Generate AI video from a text prompt using Veo.' It uses a specific verb ('generate') and resource (text prompt → video), and distinguishes itself from the sibling tool veo_image_to_video by explicitly noting the alternative for image-based generation. The use-case bullets further clarify the intended scope.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Provides explicit usage guidance with a 'Use this when' list that details appropriate scenarios (creating video from text, no reference image, maximum creative freedom). It also gives a direct exclusion and alternative: 'For video generation starting from an image, use veo_image_to_video instead.' This clearly differentiates from the sibling tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 1 tool updatev0.1.10
    • Changedveo_get_1080p1 field changed
      • addedInput schema / properties / callback_url
        Added value: +{
+  "default": "",
+  "description": "Optional URL to receive a POST callback when upscaling completes.",
+  "title": "Callback Url",
+  "type": "string"
+}
  2. 9 tool updatesv0.1.8
    • Removedveo_extend_video
    • Changedveo_get_1080p2 fields changed
      • changedInput schema / properties / model / default
        Previous value: -"veo2"New value: +"veo31-fast"
      • changedInput schema / properties / model / enum
        Previous value: -[
-  "veo2",
-  "veo2-fast",
-  "veo3",
-  "veo3-fast",
-  "veo31",
-  "veo31-fast",
-  "veo31-fast-ingredients"
-]New value: +[
+  "veo3",
+  "veo3-fast",
+  "veo31",
+  "veo31-fast",
+  "veo31-fast-ingredients"
+]
    • Changedveo_get_task3 fields changed
      • addedInput schema / properties / task_id / default
        Added value: +""
      • addedInput schema / properties / trace_id
        Added value: +{
+  "default": "",
+  "description": "Optional trace identifier of the task to retrieve.",
+  "title": "Trace Id",
+  "type": "string"
+}
      • removedInput schema / required
        Removed value: -[
-  "task_id"
-]
    • Changedveo_get_tasks_batch12 fields changed
      • addedInput schema / properties / created_at_max
        Added value: +{
+  "anyOf": [
+    {
+      "type": "number"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "description": "Return tasks created before this Unix timestamp.",
+  "title": "Created At Max"
+}
      • addedInput schema / properties / created_at_min
        Added value: +{
+  "anyOf": [
+    {
+      "type": "number"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "description": "Return tasks created after this Unix timestamp.",
+  "title": "Created At Min"
+}
      • addedInput schema / properties / limit
        Added value: +{
+  "default": 12,
+  "description": "Maximum number of tasks to return.",
+  "title": "Limit",
+  "type": "integer"
+}
      • addedInput schema / properties / offset
        Added value: +{
+  "default": 0,
+  "description": "Number of matching tasks to skip for list retrieval.",
+  "title": "Offset",
+  "type": "integer"
+}
      • addedInput schema / properties / task_ids / anyOf
        Added value: +[
+  {
+    "items": {
+      "type": "string"
+    },
+    "type": "array"
+  },
+  {
+    "type": "null"
+  }
+]
      • addedInput schema / properties / task_ids / default
        Added value: +null
      • changedInput schema / properties / task_ids / description
        Previous value: -"List of task IDs to query. Maximum recommended batch size is 50 tasks."New value: +"Optional list of task IDs to query. Maximum recommended batch size is 50 tasks."
      • removedInput schema / properties / task_ids / items
        Removed value: -{
-  "type": "string"
-}
      • removedInput schema / properties / task_ids / type
        Removed value: -"array"
      • addedInput schema / properties / trace_ids
        Added value: +{
+  "anyOf": [
+    {
+      "items": {
+        "type": "string"
+      },
+      "type": "array"
+    },
+    {
+      "type": "null"
+    }
+  ],
+  "default": null,
+  "description": "Optional list of trace identifiers to query.",
+  "title": "Trace Ids"
+}
      • addedInput schema / properties / type
        Added value: +{
+  "default": "",
+  "description": "Optional task type filter.",
+  "title": "Type",
+  "type": "string"
+}
      • removedInput schema / required
        Removed value: -[
-  "task_ids"
-]
    • Changedveo_image_to_video3 fields changed
      • changedInput schema / properties / aspect_ratio / enum
        Previous value: -[
-  "16:9",
-  "9:16",
-  "3:4",
-  "4:3",
-  "1:1"
-]New value: +[
+  "16:9",
+  "9:16"
+]
      • changedInput schema / properties / model / default
        Previous value: -"veo2"New value: +"veo31-fast"
      • changedInput schema / properties / model / enum
        Previous value: -[
-  "veo2",
-  "veo2-fast",
-  "veo3",
-  "veo3-fast",
-  "veo31",
-  "veo31-fast",
-  "veo31-fast-ingredients"
-]New value: +[
+  "veo3",
+  "veo3-fast",
+  "veo31",
+  "veo31-fast",
+  "veo31-fast-ingredients"
+]
    • Removedveo_reshoot
    • Changedveo_text_to_video5 fields changed
      • changedInput schema / properties / aspect_ratio / description
        Previous value: -"Video aspect ratio. '16:9' for landscape/widescreen, '9:16' for portrait/vertical, '1:1' for square, '4:3' for standard, '3:4' for portrait standard."New value: +"Video aspect ratio: '16:9' for landscape/widescreen or '9:16' for portrait/vertical."
      • changedInput schema / properties / aspect_ratio / enum
        Previous value: -[
-  "16:9",
-  "9:16",
-  "3:4",
-  "4:3",
-  "1:1"
-]New value: +[
+  "16:9",
+  "9:16"
+]
      • changedInput schema / properties / model / default
        Previous value: -"veo2"New value: +"veo31-fast"
      • changedInput schema / properties / model / description
        Previous value: -"Veo model version. 'veo2' for quality mode, 'veo2-fast' for faster generation. 'veo3'/'veo31' offer improved quality. Models with '-fast' suffix are faster but slightly lower quality."New value: +"Veo model version. 'veo31'/'veo31-fast' are the latest; 'veo3'/'veo3-fast' remain available. Models with '-fast' suffix are faster but slightly lower quality."
      • changedInput schema / properties / model / enum
        Previous value: -[
-  "veo2",
-  "veo2-fast",
-  "veo3",
-  "veo3-fast",
-  "veo31",
-  "veo31-fast",
-  "veo31-fast-ingredients"
-]New value: +[
+  "veo3",
+  "veo3-fast",
+  "veo31",
+  "veo31-fast",
+  "veo31-fast-ingredients"
+]
    • Removedveo_upsample
    • Removedveo_video_objects
  3. 1 tool updatev0.1.7
    • Changedveo_get_1080p1 field changed
      • addedInput schema / properties / model
        Added value: +{
+  "default": "veo2",
+  "description": "The model used to generate the source video. Required by the API; pass the same model you used for the original generation.",
+  "enum": [
+    "veo2",
+    "veo2-fast",
+    "veo3",
+    "veo3-fast",
+    "veo31",
+    "veo31-fast",
+    "veo31-fast-ingredients"
+  ],
+  "title": "Model",
+  "type": "string"
+}
  4. 12 tool updatesv0.1.4
    • Addedveo_extend_video
    • Addedveo_get_1080p
    • Addedveo_get_prompt_guide
    • Addedveo_get_task
    • Addedveo_get_tasks_batch
    • Addedveo_image_to_video
    • Addedveo_list_actions
    • Addedveo_list_models
    • Addedveo_reshoot
    • Addedveo_text_to_video
    • Addedveo_upsample
    • Addedveo_video_objects
  5. 12 tool updatesv0.1.3
    • Removedveo_extend_video
    • Removedveo_get_1080p
    • Removedveo_get_prompt_guide
    • Removedveo_get_task
    • Removedveo_get_tasks_batch
    • Removedveo_image_to_video
    • Removedveo_list_actions
    • Removedveo_list_models
    • Removedveo_reshoot
    • Removedveo_text_to_video
    • Removedveo_upsample
    • Removedveo_video_objects
  6. 4 tool updatesv0.1.2
    • Addedveo_extend_video
    • Addedveo_reshoot
    • Addedveo_upsample
    • Addedveo_video_objects
  7. 8 tool updatesv0.1.0
    • First observedveo_get_1080p
    • First observedveo_get_prompt_guide
    • First observedveo_get_task
    • First observedveo_get_tasks_batch
    • First observedveo_image_to_video
    • First observedveo_list_actions
    • First observedveo_list_models
    • First observedveo_text_to_video
Deploy Server
One endpoint for every MCP toolRayrun runs every MCP server behind one URL and holds the credentials. Each call is decided per client, tool, and argument, then recorded.ray.runAd

TDQS

A4.1/5.0

Scored across 8 tools

Disambiguation4/5

Most tools have distinct purposes (text-to-video, image-to-video, status checking), but veo_get_task and veo_get_tasks_batch overlap slightly in that both retrieve task status, just for different counts. Descriptions clarify the difference, so ambiguity is minimal.

Naming Consistency5/5

All tools follow a consistent 'veo_<verb>_<noun>' pattern (e.g., veo_get_task, veo_list_models, veo_text_to_video). The verbs are descriptive and the pattern is uniform across all 8 tools.

Tool Count5/5

With 8 tools, the server is well-scoped for a video generation MCP. Each tool addresses a core need: generation (text/image), task management (single/batch), model/prompt guidance, and resolution upgrade. No bloat or sparseness.

Completeness4/5

The tool set covers the core lifecycle: create (text/image), poll status (single/batch), and retrieve high-res output. A minor gap is no explicit cancellation or deletion tool for tasks, but that may not be critical for the domain.

Maintenance

ActivityMaintained
ResponsivenessResponsive

Resources

Related MCP Connectors

Related MCP Servers