Google Veo

Reviewed 2026-10-13mediaMCP Server# media # video # mcp # google-veo # gemini

Unofficial Python MCP server by Andrew Lo (alohc) that lets an AI assistant generate, animate and extend short Google Veo video clips with your Gemini API key and save them as local MP4 files.

Security Reviewed

Local stdio MCP server that sends your prompts, and any local image or video you name, to Google Veo with your GOOGLE_API_KEY and saves MP4 files to VEO_OUTPUT_DIR; no other network calls, shell commands or telemetry.

Install Google Veo in Google Antigravity

Antigravity reads MCP servers from ~/.gemini/config/mcp_config.json (all projects) or .agents/mcp_config.json (one project) (official docs).

EasiestOption 1: paste this to your Antigravity agent

Install the "Google Veo" MCP server for Google Antigravity.
Follow the steps at https://www.antigravityskills.org/install/veo-video.md (source: https://github.com/alohc/veo-mcp-server).
Before running anything, show me what you will download and whether it includes scripts, and wait for my OK.
Ask me for any keys or paths it needs. When done, check that it is listed under Installed MCP Servers.

The agent reads the install file, shows you what it will download and waits for your OK.

Option 2: install it yourself

1. Clone and install the server
```
git clone https://github.com/alohc/veo-mcp-server.git && cd veo-mcp-server && uv pip install -e .
```
From the README Installation section (with the real repository URL). Needs Python 3.10+ and uv.
2. Get a Gemini API key
The README uses GOOGLE_API_KEY for the Gemini Developer API (create one in Google AI Studio). Veo generation is billed by Google on that key. Without the variable, the server falls back to the google-genai SDK's default authentication.

3. Add it to Antigravity's mcp_config.json

{
  "mcpServers": {
    "veo": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/veo-mcp-server",
        "run",
        "veo-mcp-server"
      ],
      "env": {
        "GOOGLE_API_KEY": "your-api-key-here",
        "VEO_OUTPUT_DIR": "/absolute/path/to/videos"
      }
    }
  }
}

Global: ~/.gemini/config/mcp_config.json. One project: .agents/mcp_config.json. This is the README's Claude Desktop block; Antigravity uses the same "mcpServers" format. Use absolute paths.

4. Check that it loaded
Open Settings, Customizations, Installed MCP Servers: "veo" should be listed and switched on. Then ask "List the available Veo models".

The README does not mention Antigravity; these steps reuse its documented config. Set VEO_OUTPUT_DIR to an absolute path, because the default ./generated_videos is relative to whatever folder Antigravity starts the server in. MCP servers are not skills: they do not go in .agents/skills/. Antigravity reads them from ~/.gemini/config/mcp_config.json (all projects) or .agents/mcp_config.json (one project).

Using Claude Code, Cursor or Codex? See other assistants below.

What is Google Veo?

Veo MCP Server is a small, unofficial Python MCP server by Andrew Lo (GitHub: alohc) for people who want their AI assistant to make short video clips with Google's Veo models without leaving the chat. It wraps the google-genai SDK in five tools (generate_video, animate_image, extend_video_clip, generate_video_with_style and list_veo_models), waits while Google renders the clip, downloads it and saves it as an MP4 on your disk. We counted the repository at the reviewed commit: it has a single commit and 14 tracked files, 744 lines of Python in server.py, core.py, models.py and __init__.py, 17 unit tests, and a 13.6 MB demo video (assets/video_0.mp4) that makes up most of the download. Five model IDs are hard-coded in models.py: veo-3.1-generate-preview (the default), veo-3.1-fast-generate-preview, veo-3.0-generate-001, veo-3.0-fast-generate-001 and veo-2.0-generate-001.

How to use Google Veo?

Once the server is registered in your client, ask for a clip in plain language. The agent picks the tool; the server starts a Veo job, checks it every 10 seconds, reports progress to the client, then writes the MP4 to VEO_OUTPUT_DIR (default ./generated_videos, relative to the folder the server was started in) and returns the file path. Unless you ask otherwise, every call uses Veo 3.1 Preview, 16:9, 8 seconds and 720p. You can ask for 4 or 6 seconds, 9:16, 1080p, a negative prompt, up to 4 clips per text-to-video call, or a different model by name. For image-to-video, extension and reference images you give local file paths; the server reads those files and sends them to Google with your prompt.

Key features of Google Veo

✓generate_video: text to video, 4, 6 or 8 seconds, 16:9 or 9:16, 720p or 1080p, optional negative prompt, 1 to 4 clips per call
✓animate_image: animate a local image, with an optional last-frame image for first-to-last-frame interpolation
✓extend_video_clip: continue a local MP4 (the tool description says Veo 3.1 only); always requests an 8-second, 16:9 extension
✓generate_video_with_style: 1 to 3 local reference images, each typed "asset" (characters, objects) or "style" (the description says Veo 3.1 only)
✓list_veo_models: returns the 5 hard-coded models and their features without calling Google
✓Progress updates through MCP while the render job runs; files are never overwritten (a counter is added to the timestamped name)

When to use Google Veo

1README example: "Generate a video of a sunset over the ocean with birds flying". The agent calls generate_video with the defaults (Veo 3.1 Preview, 8 s, 16:9, 720p) and gets back the path of one video_<timestamp>.mp4 in your output folder.
2README example: "Animate /path/to/image.jpg with the prompt 'The character waves and smiles'". animate_image reads the local JPEG, sends it to Google with the prompt and saves video_from_image_<timestamp>.mp4.
3Our example: "Make two 4-second 9:16 clips at 1080p of rain on a neon street, no people." The agent should call generate_video with duration_seconds "4", aspect_ratio "9:16", resolution "1080p", number_of_videos 2 and a negative prompt; both clips count against your Google API usage.

Installation & Setup Guide

MCP Server Integration

Follow these steps (taken from the project's own docs) to configure Google Veo in your development environment.

Step 1: Clone and installAll

git clone https://github.com/alohc/veo-mcp-server.git && cd veo-mcp-server && uv pip install -e .

README, Installation. The README's clone command still shows a <repository-url> placeholder; this is the real URL. Needs Python 3.10+ (pyproject.toml) and uv. There is no PyPI package documented.

Step 2: Claude Desktop configClaude Desktop

{
  "mcpServers": {
    "veo": {
      "command": "uv",
      "args": [
        "--directory",
        "/path/to/veo-mcp-server",
        "run",
        "veo-mcp-server"
      ],
      "env": {
        "GOOGLE_API_KEY": "your-api-key-here",
        "VEO_OUTPUT_DIR": "/path/to/output/directory"
      }
    }
  }
}

README, Claude Desktop Configuration: add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows). This is the only client the README documents.

Step 3: Claude Code (not in the README)Claude Code

claude mcp add --env GOOGLE_API_KEY=your-api-key-here --env VEO_OUTPUT_DIR=/absolute/path/to/videos --transport stdio veo -- uv --directory /path/to/veo-mcp-server run veo-mcp-server

The README does not cover Claude Code. This is the README's command and env vars in the claude mcp add format from Anthropic's Claude Code MCP docs (code.claude.com/docs/en/mcp).

Step 4: Cursor (not in the README)Cursor

The README does not cover Cursor. Cursor reads the same "mcpServers" JSON from ~/.cursor/mcp.json or .cursor/mcp.json (Cursor MCP docs), so paste the block from step 2 there.

Step 5: Codex CLI (not in the README)Codex

codex mcp add veo --env GOOGLE_API_KEY=your-api-key-here --env VEO_OUTPUT_DIR=/absolute/path/to/videos -- uv --directory /path/to/veo-mcp-server run veo-mcp-server

The README does not cover Codex. Syntax from the Codex CLI itself (openai/codex, codex mcp add <NAME> --env KEY=VALUE -- <COMMAND>).

Usage Example & Verification

Prompt / Request Example

"Generate a video of a sunset over the ocean with birds flying" (README example for generate_video).

Expected Output / Response

From the code: the agent calls generate_video(prompt=..., model="veo-3.1-generate-preview", aspect_ratio="16:9", duration_seconds="8", resolution="720p"), the server polls Google every 10 seconds, and the tool returns {"status": "success", "videos": [{"path": "<VEO_OUTPUT_DIR>/video_<timestamp>.mp4", "duration_seconds": 8.0, "model": "veo-3.1-generate-preview"}]}.

Installation Confirmation Method

Ask: "List the available Veo models." The agent should call list_veo_models and return the five model IDs from models.py. That tool does not contact Google, so it proves the server is connected, not that your API key works; a first short generate_video call does that.

Security Review

Static review

Reviewed Date

2026-10-13

Audited Ref / Commit

v0.1.0 (commit 423233c06a764d32b65d57dfbfac75c080dd5e77)

Reviewer

antigravityskills.org (static code review)

Full review: scope, findings, risks

Audit Scope:All 14 tracked files at commit 423233c (also the current HEAD on 2026-10-13): README.md, pyproject.toml, .python-version, uv.lock (dependency pins only), src/veo_mcp_server/server.py, core.py, models.py, __init__.py, tests/test_core.py and tests/test_models.py. assets/video_0.mp4 is a demo video and was only checked for size.

Key Findings:The server runs locally over stdio (mcp.run(transport="stdio")) and its only network traffic goes to Google through google-genai (generate_videos, operations.get, files.download). No other HTTP calls, no subprocess, eval or exec, no telemetry. It reads two environment variables: GOOGLE_API_KEY, passed to genai.Client (if unset, the SDK default credentials are used), and VEO_OUTPUT_DIR. It creates the output folder if needed and writes video_, video_from_image_, extended_video_ or video_with_style_<timestamp>.mp4, adding a counter instead of overwriting. Paths passed as image_path, last_frame_path, video_path or reference images are opened without any folder restriction.

Identified Operational Risks & Permissions:Any local file the agent names is read and uploaded to Google with the request, so keep the agent away from private images and videos you do not want sent. Each call is billed Veo usage, up to 4 clips per text-to-video call. A slow job times out after 600 seconds. No LICENSE file. Dependencies (pyproject.toml): mcp[cli]>=1.25.0, google-genai>=0.5.0, pydantic>=2.0.0. Static review only; nothing was run.

Static review of alohc/veo-mcp-server at commit 423233c06a764d32b65d57dfbfac75c080dd5e77 (v0.1.0, the only commit), done on 2026-10-13. server.py defines five FastMCP tools and starts the server with stdio transport. core.py builds a google-genai Client from GOOGLE_API_KEY (or the SDK default credentials when the variable is not set), calls models.generate_videos, polls operations.get every 10 seconds for at most 60 attempts, then calls files.download and saves the video under VEO_OUTPUT_DIR (default ./generated_videos) with a timestamped, non-overwriting name. Image and video inputs are loaded with types.Image.from_file and types.Video.from_file from whatever path is given, with no folder restriction, and sent to Google. models.py validates prompts (1 to 5,000 characters), the 5 model IDs, durations 4/6/8, 16:9 or 9:16, 720p or 1080p, and 1 to 4 videos. We found no other network endpoints, no subprocess, eval or exec, and no telemetry. There is no LICENSE file. Static inspection only: we did not install or run the server.

Operational Notes & Known Limitations

Known Limitations

•Costs money on your Google account: every successful call is a Veo generation billed to the key in GOOGLE_API_KEY, and one generate_video call can ask for up to 4 clips. The repository says nothing about pricing.
•README says a render takes 11 seconds to 6 minutes; the code gives up after 600 seconds (we counted: 60 polls at 10-second intervals in core.py) and reports a timeout even if Google finishes later.
•README says Google keeps generated videos for 2 days; the server downloads each one immediately, so the local MP4 is the copy to keep.
•Inputs must be local file paths (types.Image.from_file / types.Video.from_file in core.py); image or video URLs are not accepted.
•person_generation is fixed in code (allow_all for text-to-video and extension, allow_adult for image and reference generation) and is not a tool option (we read core.py and models.py).
•The model list is hard-coded; an ID that is not one of the 5 enum values fails validation until the code is updated, and the default is a preview model ID.
•Small, unofficial project: one commit, no releases, no PyPI package, and no LICENSE file at the reviewed commit although the README says MIT; the README's project tree lists docs/implementation-plan.md, which is not in the repository (we checked).
•The README documents only Claude Desktop; Antigravity, Claude Code, Cursor and Codex setups above are our adaptations of its config.

Frequently Asked Questions

Is the Veo MCP server safe?

In our static review of commit 423233c it only talks to Google through the official google-genai SDK, runs no shell commands and has no telemetry. It does read any local file path you or the agent pass to it and sends that file to Google, and it writes MP4 files to VEO_OUTPUT_DIR.

How do I add Veo to Antigravity?

Clone the repo, run uv pip install -e ., then add the README's "mcpServers" block (command uv, args --directory <path> run veo-mcp-server, env GOOGLE_API_KEY and VEO_OUTPUT_DIR) to ~/.gemini/config/mcp_config.json and check Installed MCP Servers.

Does it render video on my GPU?

No. The server is a local Python process; Veo runs on Google's servers and the server only downloads the finished clip.

Can I animate an image from a URL?

No. animate_image, extend_video_clip and generate_video_with_style take local file paths only.

Which Veo models does it support?

Five hard-coded IDs: Veo 3.1 Preview (default), Veo 3.1 Fast Preview, Veo 3.0, Veo 3.0 Fast and Veo 2.0. Extension and reference images are described as Veo 3.1 features.