Skip to main content
Glama

WanMCP

PyPI version PyPI downloads Python 3.10+ License: MIT MCP

A Model Context Protocol (MCP) server for AI video generation using Wan through the AceDataCloud API.

Generate AI videos from text or images directly from Claude, VS Code, or any MCP-compatible client.

Features

  • Text to Video - Create AI-generated videos from text prompts

  • Image to Video - Generate videos using reference images

  • Multiple Models - Support for 5 Wan models (wan2.6-t2v, wan2.6-i2v, wan2.6-r2v, wan2.6-i2v-flash, wan3.0-video)

  • Multiple Resolutions - 480P (draft), 720P (default), 1080P (high quality)

  • Audio Support - Generate videos with sound

  • Character Transfer - Extract character appearance via reference videos (wan2.6-r2v)

  • Task Tracking - Monitor generation progress and retrieve results

Related MCP server: HailuoMCP

Tool Reference

Tool

Description

wan_generate_video

Generate AI video from a text prompt using Wan.

wan_generate_video_from_image

Generate AI video using a reference image as the starting frame.

wan_get_task

Query the status and result of a video generation task.

wan_get_tasks_batch

Query multiple video generation tasks at once.

wan_list_models

List all available Wan models for video generation.

wan_list_resolutions

List all available resolution options.

wan_list_actions

List all available Wan API actions and corresponding tools.

Quick Start

1. Get Your API Token

  1. Sign up at AceDataCloud Platform

  2. Go to the API documentation page

  3. Click "Acquire" to get your API token

  4. Copy the token for use below

AceDataCloud hosts a managed MCP server — no local installation required.

Endpoint: https://wan.mcp.acedata.cloud/mcp

All requests require a Bearer token. Use the API token from Step 1.

Claude.ai

Connect directly on Claude.ai with OAuth — no API token needed:

  1. Go to Claude.ai Settings → Integrations → Add More

  2. Enter the server URL: https://wan.mcp.acedata.cloud/mcp

  3. Complete the OAuth login flow

  4. Start using the tools in your conversation

Claude Desktop

Add to your config (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

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

Cursor / Windsurf

Add to your MCP config (.cursor/mcp.json or .windsurf/mcp.json):

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

VS Code (Copilot)

Add to your VS Code MCP config (.vscode/mcp.json):

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

Or install the Ace Data Cloud MCP extension for VS Code, which registers the hosted MCP servers with one-click setup.

JetBrains IDEs

  1. Go to Settings → Tools → AI Assistant → Model Context Protocol (MCP)

  2. Click AddHTTP

  3. Paste:

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

Claude Code

Claude Code supports MCP servers natively:

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

Or add to your project's .mcp.json:

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

Cline

Add to Cline's MCP settings (.cline/mcp_settings.json):

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

Amazon Q Developer

Add to your MCP configuration:

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

Roo Code

Add to Roo Code MCP settings:

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

Continue.dev

Add to .continue/config.yaml:

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

Zed

Add to Zed's settings (~/.config/zed/settings.json):

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

cURL Test

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

# MCP initialize
curl -X POST https://wan.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. Or Run Locally (Alternative)

If you prefer to run the server on your own machine:

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

# Set your API token
export ACEDATACLOUD_API_TOKEN="your_token_here"

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

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

Claude Desktop (Local)

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

Docker (Self-Hosting)

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

Clients connect with their own Bearer token — the server extracts the token from each request's Authorization header.

Available Models

Model

Description

Use Case

wan2.6-t2v

Text to video

Generate video from text prompts

wan2.6-i2v

Image to video

Standard image-to-video generation

wan2.6-r2v

Reference video-to-video

Character extraction and transfer

wan2.6-i2v-flash

Fast image to video

Quick preview, lower quality

wan3.0-video

Text to video

Video generation with optional media

Configuration

Environment Variables

Variable

Description

Default

ACEDATACLOUD_API_TOKEN

API token from AceDataCloud

Required

ACEDATACLOUD_API_BASE_URL

API base URL

https://api.acedata.cloud

WAN_DEFAULT_MODEL

Default video model

wan2.6-t2v

WAN_DEFAULT_RESOLUTION

Default resolution

720P

WAN_REQUEST_TIMEOUT

Request timeout in seconds

1800

LOG_LEVEL

Logging level

INFO

Command Line Options

mcp-wan --help

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

Development

Setup Development Environment

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

# 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 Tests

# 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

Code Quality

# Format code
ruff format .

# Lint code
ruff check .

# Type check
mypy core tools

Build & Publish

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

# Build package
python -m build

# Upload to PyPI
twine upload dist/*

Project Structure

WanMCP/
├── core/                   # Core modules
│   ├── __init__.py
│   ├── client.py          # HTTP client for Wan API
│   ├── config.py          # Configuration management
│   ├── exceptions.py      # Custom exceptions
│   ├── oauth.py           # OAuth 2.1 provider
│   ├── 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
│   ├── task_tools.py      # Task query tools
│   └── info_tools.py      # Information tools
├── prompts/                # MCP prompts
│   └── __init__.py        # Prompt templates
├── tests/                  # Test suite
│   ├── conftest.py
│   └── __init__.py
├── deploy/                 # Deployment configs
│   └── production/
│       ├── deployment.yaml
│       ├── ingress.yaml
│       └── service.yaml
├── .env.example           # Environment template
├── CHANGELOG.md
├── Dockerfile             # Docker image for HTTP mode
├── docker-compose.yaml    # Docker Compose config
├── LICENSE
├── main.py                # Entry point
├── pyproject.toml         # Project configuration
└── README.md

API Reference

This server wraps the AceDataCloud Wan API:

  • Wan Videos API - Video generation (text2video, image2video)

  • Wan Tasks API - Task queries

Contributing

Contributions are welcome! Please:

  1. Fork the repository

  2. Create a feature branch (git checkout -b feature/amazing)

  3. Commit your changes (git commit -m 'Add amazing feature')

  4. Push to the branch (git push origin feature/amazing)

  5. Open a Pull Request

Documentation

Documentation

License

MIT License - see LICENSE for details.


Made with love by AceDataCloud

Available Tools

7 tools
wan_generate_videoAInspect

Generate AI video from a text prompt using Wan text-to-video model.

This uses the wan2.6-t2v model to create video from text descriptions.
For creating video from images, use wan_generate_video_from_image instead.

Returns:
    Task ID and generated video information including URLs and state.
ParametersJSON Schema
NameRequiredDescriptionDefault
sizeNoThe size of the generated video (e.g., '1280x720').
audioNoWhether the generated video should include audio. Default is true.
promptYesDescription of the video to generate. Be descriptive about the scene, motion, style, and mood.
timeoutNoTimeout in seconds for the API to return data. Default is 1800.
durationNoVideo duration in seconds. Options: 5, 10, or 15. Default depends on model.
audio_urlNoURL of reference audio to use in the video. Only used when audio is enabled.
resolutionNoVideo resolution. Options: '480P', '720P' (default), '1080P'.720P
callback_urlNoWebhook callback URL for asynchronous notifications. When provided, the API will call this URL when the video is generated.
prompt_extendNoEnable LLM-based prompt rewriting for better results. Default is true.
negative_promptNoContent to exclude from the video. Maximum 500 characters.

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.8/5.0
Behavior2/5

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

No annotations are provided, so the description carries the full burden. It only mentions the return type (task ID and video info) but does not disclose any side effects, authentication needs, rate limits, or resource implications. For a generation tool, this is insufficient.

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 extremely concise with three sentences, each adding value. It front-loads the purpose and model, then offers alternative direction, and finally states returns. No wasted words.

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's complexity (10 parameters, output schema exists), the description is fairly complete. It specifies the model, distinguishes alternative tools, and notes the output, which is sufficient when combined with the schema. Minor gap: no mention of typical usage patterns or prompt guidance, but the schema covers prompt description.

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 input schema has 100% coverage with descriptions for all 10 parameters. The description adds little beyond the schema, only referencing the prompt implicitly. Baseline 3 is appropriate as the schema already provides adequate meaning.

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 a text prompt using the Wan text-to-video model, specifically wan2.6-t2v. It distinguishes itself from the sibling tool wan_generate_video_from_image by explicitly noting the image-based alternative.

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 clear context for when to use this tool (text-to-video generation) and directs users to the sibling tool for image-to-video. However, it does not mention when not to use it or any prerequisites, limiting full guidance.

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

wan_generate_video_from_imageAInspect

Generate AI video from a reference image using Wan image-to-video models.

This supports three models:
- wan2.6-i2v: Standard image-to-video generation
- wan2.6-r2v: Reference video-to-video with character/timbre extraction
- wan2.6-i2v-flash: Fast image-to-video generation

Returns:
    Task ID and generated video information including URLs and state.
ParametersJSON Schema
NameRequiredDescriptionDefault
sizeNoThe size of the generated video (e.g., '1280x720').
audioNoWhether the generated video should include audio. Default is true.
modelNoModel to use. Options: 'wan2.6-i2v' (standard image-to-video), 'wan2.6-r2v' (reference video-to-video), 'wan2.6-i2v-flash' (fast image-to-video). Default: 'wan2.6-i2v'.wan2.6-i2v
promptYesDescription of the video motion and content. Describe what should happen in the video.
timeoutNoTimeout in seconds. Default is 1800.
durationNoVideo duration in seconds. Options: 5, 10, or 15.
audio_urlNoURL of reference audio to use in the video.
image_urlYesURL of the reference image for video generation. The video will be generated based on this image.
shot_typeNoShot type: 'single' for continuous shot, 'multi' for multi-cut editing.
resolutionNoVideo resolution. Options: '480P', '720P' (default), '1080P'.720P
callback_urlNoWebhook callback URL for asynchronous notifications.
prompt_extendNoEnable LLM-based prompt rewriting. Default is true.
negative_promptNoContent to exclude from the video. Maximum 500 characters.
reference_video_urlsNoJSON array of reference video URLs for character/timbre extraction. Used with the wan2.6-r2v model. Pass each URL as a separate array item; never join URLs with commas and never JSON-stringify the array. Legacy comma-separated strings are still accepted for backward compatibility.

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.9/5.0
Behavior3/5

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

With no annotations, the description must carry behavioral disclosure. It does mention that the tool returns a Task ID and video information including URLs and state, and it hints at async behavior via the 'callback_url' parameter. However, it does not explain polling workflows, typical generation times, timeout implications, or failure modes—gaps for a long-running 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 front-loaded with a clear first sentence, followed by a structured list of models and a return value line. It is appropriately sized for the tool's complexity, though the model list slightly duplicates the schema's model enum, preventing a perfect score.

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 return value format and model choices, and an output schema exists to handle structured return data. It falls short on explicitly guiding the user through the asynchronous nature and when to use this versus sibling tools, but it still provides enough context for a generation task with a rich 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?

The input schema covers 100% of the 14 parameters with descriptive text, so the description does not need to repeat parameter semantics. It adds value by explaining model options, but this does not go beyond what the schema already provides for individual 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 first sentence uses a specific verb ('Generate') and resource ('AI video from a reference image'), immediately clarifying the tool's core function. It also explicitly names 'Wan image-to-video models' and lists three distinct model variants, which differentiates it from the sibling 'wan_generate_video' (likely text-to-video).

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 clear context by listing the three model options with their intended use cases (standard, reference-video, fast). However, it does not explicitly state when to choose this tool over 'wan_generate_video' or other siblings, leaving that exclusion implicit.

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

wan_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.

Task states:
- 'pending': Generation is queued
- 'processing': Generation is in progress
- 'completed': Generation finished successfully
- 'failed': Generation failed (check error message)

Returns:
    Task status and generated video information including URLs.
ParametersJSON Schema
NameRequiredDescriptionDefault
task_idYesThe task ID returned from a generation request. This is the 'task_id' field from any wan_generate_* tool response.

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.6/5.0
Behavior4/5

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

No annotations are provided, so the description carries the full burden. It describes the task states (pending, processing, completed, failed) and indicates the tool returns status and result URLs. It does not cover rate limits or polling behavior, but for a status-checking tool, this is adequate and not misleading.

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 purpose statement followed by bullet points for task states. Every sentence adds value, and there is no extraneous information.

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 output schema exists (not shown but indicated), the description appropriately summarizes the return type (status and video URLs). The sibling tools list provides sufficient context for understanding the tool's role in the broader workflow.

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

Parameters5/5

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

The single parameter 'task_id' is described in the schema, but the description adds valuable context: 'The task ID returned from a generation request. This is the 'task_id' field from any wan_generate_* tool response.' This clarifies the origin and usage beyond the schema's description.

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 that the tool queries the status and result of a video generation task. It is well differentiated from sibling tools like wan_generate_video (which creates tasks) and wan_get_tasks_batch (which retrieves multiple tasks).

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 explicitly states to use this tool to check if a generation is complete and retrieve results. It also lists task states, providing guidance on when to call it. However, it does not explicitly state when not to use or mention alternatives beyond the context.

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

wan_get_tasks_batchAInspect

Query multiple video generation tasks at once.

Efficiently check the status of multiple tasks in a single request.

Returns:
    Status and video information for all queried tasks.
ParametersJSON Schema
NameRequiredDescriptionDefault
task_idsYesList of task IDs to query. Maximum recommended batch size is 50 tasks.

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.1/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 the burden. It states the return includes status and video information, which is basic. It does not disclose rate limits, authentication needs, or any side effects. The mention of max batch size is in the schema description, not the main description.

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 sentences: purpose, benefit, and return. It is front-loaded and concise, with no unnecessary information.

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 (one parameter, output schema exists), the description sufficiently covers what the tool does and returns. The output schema handles return value details, so no further elaboration is needed.

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% for the single parameter 'task_ids', with a clear description of its purpose and constraints. The main description adds no additional semantic value beyond what the schema already provides, meeting the baseline for high coverage.

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 the specific verb 'query' and resource 'multiple video generation tasks', clearly distinguishing it from the sibling tool 'wan_get_task' which queries a single task. The phrase 'at once' and 'batch' reinforce the batching behavior.

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 usage for checking multiple tasks efficiently, and the sibling tool names provide clear contrast with 'wan_get_task' for single tasks. However, it does not explicitly state when not to use or mention alternative scenarios.

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

wan_list_actionsAInspect

List all available Wan API actions and corresponding tools.

Reference guide for what each action does and which tool to use.

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?

The description says it returns a categorized list. No annotations exist, so the description carries the burden. It's adequate but doesn't add extra behavioral traits beyond listing.

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?

Three sentences, no fluff. First sentence states purpose, second adds context, third describes output. Every sentence earns its place.

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?

For a simple listing tool with no parameters and an output schema present, the description is complete. It tells what it does and what it returns.

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?

No parameters exist in the schema. Baseline for 0 params is 4. The description adds no parameter info, but none is needed.

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 Wan API actions and corresponding tools, serving as a reference guide. This distinguishes it from sibling tools like wan_generate_video or wan_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 Guidelines4/5

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

Usage is implied as a reference to discover available actions and tools. No explicit when-not or alternatives, but the context of siblings makes it clear.

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

wan_list_modelsAInspect

List all available Wan video generation models.

Shows models with their capabilities, supported actions, and use cases.

Returns:
    Table of all models with descriptions and constraints.
ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.8/5.0
Behavior2/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 disclosure. It only states that it lists models and returns a table, without mentioning any constraints, permissions, or side effects. The read-only nature is implied but not explicit.

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 exceptionally concise with only three sentences. The first sentence front-loads the purpose, followed by additional detail. Every sentence contributes meaning without 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 simple listing tool with an output schema, the description adequately covers what the tool does and what it returns. It does not mention any error conditions or prerequisites, but given the tool's simplicity, it is mostly 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?

There are zero parameters, so the schema coverage is complete. The description adds value by explaining the return format (table with descriptions and constraints), which is not captured in the empty input schema. 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 lists all available Wan video generation models and specifies what information it shows (capabilities, supported actions, use cases). The verb-resource pair is specific, and the tool is well differentiated from sibling tools that handle generation or list other entities.

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

Usage Guidelines3/5

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

The description implies using this tool before generating videos, but it does not explicitly state when not to use it or mention alternative tools. Given the distinct sibling tools, the context is clear, but explicit guidance is missing.

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

wan_list_resolutionsAInspect

List all available resolutions for Wan video generation.

Shows resolution options with their quality and use cases.

Returns:
    Table of resolutions with descriptions.
ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

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?

The description indicates a read-only operation (list, shows) and specifies the return format (table of resolutions with descriptions). Despite no annotations, it effectively communicates behavior without contradictions.

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?

Three concise sentences front-load the purpose, followed by details on content and return format. No superfluous information.

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?

For a parameterless tool with an output schema, the description fully covers the purpose and return structure. No gaps remain.

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 zero parameters in the input schema, the description does not need to explain parameters. It adds value by clarifying scope ('all available') and the nature of returns.

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 'List all available resolutions for Wan video generation', specifying the verb (list) and resource (resolutions). It distinguishes from sibling tools like wan_generate_video by focusing on listing options rather than generation.

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

Usage Guidelines3/5

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

The description implies usage to retrieve resolution options but provides no explicit guidance on when to use this tool versus alternatives, such as before generating a video to select a resolution.

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. Dates show when Glama detected each change.

  1. 1 tool updatev0.1.18
    • Changedwan_generate_video_from_image2 fields changed
      • changedInput schema / properties / reference_video_urls / anyOf
        Previous value: -[
        -  {
        -    "type": "string"
        -  },
        -  {
        -    "type": "null"
        -  }
        -]New value: +[
        +  {
        +    "items": {
        +      "type": "string"
        +    },
        +    "minItems": 1,
        +    "type": "array"
        +  },
        +  {
        +    "type": "null"
        +  }
        +]
      • changedInput schema / properties / reference_video_urls / description
        Previous value: -"Comma-separated URLs of reference videos for character/timbre extraction. Used with wan2.6-r2v model."New value: +"JSON array of reference video URLs for character/timbre extraction. Used with the wan2.6-r2v model. Pass each URL as a separate array item; never join URLs with commas and never JSON-stringify the array. Legacy comma-separated strings are still accepted for backward compatibility."
  2. 2 tool updatesv0.1.17
    • Changedwan_generate_video4 fields changed
      • changedInput schema / properties / audio / default
        Previous value: -falseNew value: +true
      • changedInput schema / properties / audio / description
        Previous value: -"Whether the generated video should include audio. Default is false."New value: +"Whether the generated video should include audio. Default is true."
      • changedInput schema / properties / prompt_extend / default
        Previous value: -falseNew value: +true
      • changedInput schema / properties / prompt_extend / description
        Previous value: -"Enable LLM-based prompt rewriting for better results. Default is false."New value: +"Enable LLM-based prompt rewriting for better results. Default is true."
    • Changedwan_generate_video_from_image4 fields changed
      • changedInput schema / properties / audio / default
        Previous value: -falseNew value: +true
      • changedInput schema / properties / audio / description
        Previous value: -"Whether the generated video should include audio. Default is false."New value: +"Whether the generated video should include audio. Default is true."
      • changedInput schema / properties / prompt_extend / default
        Previous value: -falseNew value: +true
      • changedInput schema / properties / prompt_extend / description
        Previous value: -"Enable LLM-based prompt rewriting. Default is false."New value: +"Enable LLM-based prompt rewriting. Default is true."
  3. 7 tool updatesv0.1.0
    • First observedwan_generate_video
    • First observedwan_generate_video_from_image
    • First observedwan_get_task
    • First observedwan_get_tasks_batch
    • First observedwan_list_actions
    • First observedwan_list_models
    • First observedwan_list_resolutions

TDQS

A4.2/5.0
Disambiguation5/5

Each tool targets a distinct operation: three list endpoints for different reference data, two task-query endpoints (single vs. batch), and two generation endpoints (text-to-video vs. image-to-video). Descriptions clearly indicate when to use which tool.

Naming Consistency5/5

All tools follow a consistent wan_ prefix with a verb_noun pattern (list_*, get_*, generate_*). The naming is predictable and clearly indicates the action and subject.

Tool Count5/5

Seven tools is well-scoped for a video generation MCP server. Each tool serves a necessary purpose, and the set is not bloated or sparse.

Completeness4/5

The core workflow of listing capabilities, generating video, and querying results is fully covered. Minor gaps include no cancel-task operation and no list-all-tasks endpoint, but these do not severely impact typical usage.

Maintenance

ActivityActive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/AceDataCloud/WanMCP'

If you have feedback or need assistance with the MCP directory API, please join our Discord server