Skip to main content
Glama

sanzaru

PyPI version Python versions License CI PyPI downloads

A stateless, lightweight MCP server and agent CLI that wraps Higgsfield video generation (Seedance 2.5, Kling 3.0) and OpenAI's image, transcription, audio and TTS APIs, plus ElevenLabs for podcasts.

0.14.0: the base install is the agent CLI only. Anything that launches the MCP server (.mcp.json, Claude Desktop, sanzaru serve) must install sanzaru[mcp] or sanzaru[all]. HIGGSFIELD_BASE_URL can point video at a credential proxy.

0.13.0: OpenAI removed the Sora Videos API and every Sora model on 2026-09-24. sanzaru now generates video through the Higgsfield API — set HF_KEY. Old video_… ids and the list_videos / delete_video / remix_video tools are gone.

Features

Video Generation (Higgsfield)

  • Text-to-video and image-to-video with Seedance 2.5 (default; 4–30 s, native audio) or Kling 3.0 (std / pro / 4K / turbo), or any Higgsfield catalog model by id

  • Edit and extend existing clips (Seedance 2.5) — including a job you just rendered, by its hf_… id

  • Every job is priced before it is submitted: the cost comes back with the job, max_cost_usd refuses anything over budget (nothing uploaded or charged), dry_run prices for free

  • One wait_for(download=true) call waits server-side and saves the file into your media directory

Image Generation

  • Generate images with gpt-image-2.5 (sunburst/flare, recommended), gpt-image-2, gpt-image-1.5, or GPT-5

  • Edit and compose images with up to 16 inputs

  • Iterative refinement via Responses API

  • Crop a reference image to a video aspect ratio (image-to-video framing follows the image)

Audio Processing

  • Transcription: gpt-transcribe (default), GPT-4o models, whisper-1 (deprecated) and ElevenLabs scribe_v2 with word times

  • Word timing: audio align, and --timestamps on audio speak and podcast generate, via ElevenLabs forced alignment

  • Audio Chat: Interactive analysis with GPT-4o

  • Text-to-Speech: Multi-voice TTS generation

  • Processing: Format conversion, compression, file management

Podcast Generation

  • Multi-voice podcasts with up to 4 speakers and 10 TTS voices

  • Parallel segment generation with configurable pacing

  • MP3/WAV output with loudness normalization

  • The recommended way to make a podcast — from a script, or from a topic (the model writes the script first): ElevenLabs eleven_v4 (the ElevenLabs default) in dialogue render mode with --verify. OpenAI is the zero-setup fallback

  • ElevenLabs dialogue render mode: consecutive turns go out together so the model paces them

  • --verify transcribes the rendered audio and re-renders segments the TTS silently dropped

Simulated Podcasts (experimental)

  • Experimental, and the most expensive tool in sanzaru — for when you explicitly want an unscripted conversation. For a podcast, prefer the scripted ElevenLabs path above

  • The conversation is generated, not read — N gpt-realtime agents actually talk to each other

  • Each host hears the others' audio, so they respond to delivery and timing, not to a transcript

  • Pre-production plans acts that record in parallel: a 30-minute episode in ~1 minute

  • Checkpointed per act and resumable; cost ceiling, dry-run projection, per-host stems

  • QC transcribes the rendered audio and judges it against the plan

  • See docs/audio/simulated-podcasts.md

Agent CLI

  • Every capability as a shell command: sanzaru video create, sanzaru image generate, ...

  • One-shot async workflows: create ... -o out.mp4 submits, polls, downloads in one command

  • JSON envelopes on stdout, progress on stderr, deterministic exit codes, resumable waits

  • Concurrent fan-out (multi-prompt image batches, multi-job wait) and arbitrary -o output paths

  • See docs/cli.md — bare sanzaru still runs the MCP server (nothing breaks)

Note: Content guardrails are enforced by OpenAI. This server does not run local moderation.

Related MCP server: imagine-mcp

Requirements

  • Python 3.11+ (tested through 3.15 and 3.15t)

  • OPENAI_API_KEY for images, audio and podcasts

  • HF_KEY for video — a Higgsfield API key (key_id:key_secret) from the API console. The API is prepaid and billed separately from a Higgsfield app/CLI subscription; the video tools register only when it is set

Media storage (choose one):

# Recommended: unified path (auto-creates videos/, images/, audio/ subdirs)
SANZARU_MEDIA_PATH="/path/to/media"

# Or individual paths (legacy, still supported)
VIDEO_PATH="/path/to/videos"
IMAGE_PATH="/path/to/images"
AUDIO_PATH="/path/to/audio"

Features are auto-detected based on configured paths. Set only what you need.

Quick Start

  1. Clone the repository:

    git clone https://github.com/TJC-LP/sanzaru.git
    cd sanzaru
  2. Run the setup script:

    ./setup.sh

    The script will:

    • Prompt for your OpenAI API key

    • Create directories and .env configuration

    • Install dependencies with uv sync --all-extras --dev

  3. Start using:

    claude

That's it! Claude Code will automatically connect and you can start generating videos, images, and processing audio.

Or skip MCP entirely — the agent CLI

uv tool install sanzaru && export OPENAI_API_KEY=sk-...

# One command: price → submit → wait → download → print the file path
sanzaru video create "a tabby cat stretches on a windowsill" --duration 4 --resolution 480p --max-cost 1 -o ./cat.mp4 | jq -r .result.file.path

# Synchronous image generation (gpt-image-2.5), batch fan-out, JSONL output
sanzaru image generate "app icon" "hero banner" --quality high -o ./art/

sanzaru capabilities   # machine-readable: what's enabled here

JSON envelopes on stdout, progress on stderr, exit 4 = still-running-and-resumable. Full reference: docs/cli.md.

Installation

Install as a plugin — auto-configures the MCP server and ships three skills: sanzaru-mcp (the tool surface, incl. wait_for), sanzaru-cli (the shell surface), prompt-guidance (how to write video/image prompts):

/plugin marketplace add TJC-LP/sanzaru

Requires OPENAI_API_KEY and SANZARU_MEDIA_PATH environment variables to be set (and HF_KEY for video).

Quick Install

# All features
uv add "sanzaru[all]"

# Specific features
uv add "sanzaru[audio]"       # With audio support
uv add "sanzaru[elevenlabs]"  # ElevenLabs as a second TTS provider
uv add sanzaru                # Base: the agent CLI only (video via HF_KEY; no MCP dependencies)
uv add "sanzaru[mcp]"         # + the MCP server (bare `sanzaru` / `sanzaru serve`)

The base install is the CLI and carries nothing from the MCP stack (mcp, starlette, uvicorn). Anything that launches the server — a .mcp.json, Claude Desktop, codex mcp add — must install the mcp extra; sanzaru[all] includes it. Running bare sanzaru without it exits 3 with the install command.

From Source

git clone https://github.com/TJC-LP/sanzaru.git
cd sanzaru
uv sync --all-extras

Claude Desktop

Add to your claude_desktop_config.json:

{
  "mcpServers": {
    "sanzaru": {
      "command": "uvx",
      "args": ["sanzaru[all]"],
      "env": {
        "OPENAI_API_KEY": "your-api-key-here",
        "HF_KEY": "your-higgsfield-key-id:secret",
        "SANZARU_MEDIA_PATH": "/absolute/path/to/media"
      }
    }
  }
}

Or from source:

{
  "mcpServers": {
    "sanzaru": {
      "command": "uv",
      "args": ["run", "--directory", "/path/to/sanzaru", "sanzaru"]
    }
  }
}

Codex MCP

# Using uvx (from PyPI)
codex mcp add sanzaru \
  --env OPENAI_API_KEY="sk-..." \
  --env SANZARU_MEDIA_PATH="$HOME/sanzaru-media" \
  -- uvx "sanzaru[all]"

Manual Setup

uv venv
uv sync

# Set required environment variables
export OPENAI_API_KEY=sk-...
export SANZARU_MEDIA_PATH=~/sanzaru-media

# Run server (stdio for MCP clients)
uv run sanzaru

# Or HTTP mode (for remote access)
uv run sanzaru --transport http --port 8000

Available Tools

Category

Tools

Description

Video

create_video, edit_video, extend_video, get_video_status, download_video, cancel_video, list_local_videos, inspect_video_frame

Generate, edit and extend video on Higgsfield (priced before submit, optional cost cap); inspect framess with optional reference images

Jobs

wait_for

Block server-side on any mix of hf_*/resp_* ids until they finish (progress on every poll, optional download); replaces model-driven polling

Image

generate_image, edit_image, create_image, get_image_status, download_image, inspect_image

generate_image is synchronous — one call, finished file (the default). create_image starts a background job for batches and refinement chains; collect with wait_for. edit_image edits; inspect_image shows the model what it rendered

Reference

list_reference_images, prepare_reference_image

Manage reference images; crop to a video aspect ratio or exact size

Audio

transcribe_audio, chat_with_audio, create_audio, convert_audio, compress_audio, list_audio_files, get_latest_audio, transcribe_with_enhancement

Transcription, analysis, TTS (OpenAI or ElevenLabs), and file management

Podcast

generate_podcast

The recommended podcast tool: multi-voice episodes with parallel TTS and stitching (ElevenLabs v4 + dialogue + verify recommended); speakers may mix TTS providers

Simulated Podcast (experimental)

simulate_podcast

Unscripted: realtime agents converse from a rundown — parallel acts, checkpointing, cost ceiling, QC

Media

view_media

Interactive media player via MCP App protocol

Full API documentation: See docs/api-reference.md

Basic Workflows

Generate a Video

# Create video from text
video = create_video(
    prompt="A serene mountain landscape at sunrise, slow aerial push-in",
    duration=8,                 # Seedance 2.5 (default): 4-30 s
    aspect_ratio="16:9",
    resolution="720p",
    max_cost_usd=5,             # refused (and nothing charged) if the estimate is higher
)                               # returns id "hf_...", status, and the estimated cost

# Wait server-side and save it — one call, no polling loop
wait_for([video.id], download=True)

Generate with Reference Image

# 1. Generate reference image (gpt-image-2.5-flare, synchronous)
generate_image(
    prompt="futuristic pilot in mech cockpit",
    size="1536x1024",
    filename="pilot.png"
)

# 2. Crop to the frame shape you want (image-to-video framing follows the image)
prepare_reference_image("pilot.png", aspect_ratio="16:9", resize_mode="crop")

# 3. Animate — prompt only the motion; the image already fixes subject and style
video = create_video(
    prompt="The pilot looks up and smiles",
    reference_image="pilot_1280x720.png",
    duration=5, resolution="480p", max_cost_usd=2,
)
wait_for([video.id], download=True)

# 4. Keep going from the finished job — no download/re-upload
extend_video("He reaches for the throttle.", source_video=video.id, duration=5, max_cost_usd=3)

Audio Transcription

# List available audio files
files = list_audio_files(format="mp3")

# Transcribe — long files are auto-windowed, so nothing truncates silently
result = transcribe_audio("interview.mp3")

# Or analyze with GPT-4o
analysis = chat_with_audio(
    "meeting.mp3",
    user_prompt="Summarize key decisions and action items"
)

Generate a Podcast

generate_podcast(script={
    "title": "AI Weekly",
    "speakers": [
        {"id": "host", "name": "Alex", "voice": "nova"},
        {"id": "guest", "name": "Sam", "voice": "echo"}
    ],
    "segments": [
        {"speaker": "host", "text": "Welcome to AI Weekly!"},
        {"speaker": "guest", "text": "Thanks for having me."}
    ]
})

Simulate a Podcast (experimental — no script, the agents talk)

# 1. Plan it. Cheap, and the JSON is yours to edit.
sanzaru podcast rundown "why TTS providers drop sentence tails" \
  --acts 3 -m 6 --host "Avery" --host "Rory:cedar:You chased the bug." \
  -o rundown.json

# 2. See what it would cost. Records nothing.
sanzaru podcast simulate @rundown.json --dry-run

# 3. Record it. Acts run in parallel and each is checkpointed as it lands.
sanzaru podcast simulate @rundown.json --model gpt-realtime-2.1-mini \
  --max-cost 2.00 --stems -o ep1.mp3

# Interrupted? The run id is on stderr from the start.
sanzaru podcast simulate --resume 6f1a9c02

Documentation

Transport Modes

Mode

Command

Use Case

stdio (default)

uv run sanzaru

Claude Desktop, Claude Code, local MCP clients

HTTP

uv run sanzaru --transport http

Remote access, Databricks Apps, web clients

Authenticating HTTP mode

HTTP mode exposes the full toolset — paid generation, cancel_video, and every stored media file — to whoever can reach the port. Set a token and send it as Authorization: Bearer <token> on both /mcp and /media:

export SANZARU_HTTP_TOKEN="$(openssl rand -hex 32)"
uv run sanzaru --transport http --host 0.0.0.0

Binding to anything other than loopback requires the token: sanzaru refuses to start otherwise (exit 3). Set SANZARU_ALLOW_UNAUTHENTICATED_HTTP=1 only when something in front of it already authenticates every request — and name that proxy's hostnames in SANZARU_ALLOWED_HOSTS (comma-separated, host or host:*), which the hatch requires: it keeps the SDK's DNS-rebinding check on, Origin included, so the unauthenticated path is never also the least-protected one. With a token and no allowlist the Host/Origin check is switched off and the token is the control. On a loopback bind the token is optional but still recommended.

Databricks Apps authenticates in front of the app, so run it with SANZARU_ALLOW_UNAUTHENTICATED_HTTP=1 and SANZARU_ALLOWED_HOSTS set to the Host value the platform proxy forwards (include whatever its health probe sends). Include the loopback names too if the probe uses them, e.g. SANZARU_ALLOWED_HOSTS=myapp.example.com,localhost:*.

Upgrading from 0.10.x: sanzaru --transport http --host 0.0.0.0 used to start with no credential. It now refuses unless SANZARU_HTTP_TOKEN or the hatch above is set — deliberate, and worth a line in your deployment notes.

/media/{type}/{name} requires the same Authorization header, and every response is Content-Disposition: attachment, so it is for programmatic clients; a browser media element cannot send the header and should use the viewer's _get_media_data path (the bundled MCP App already does).

Embedding the server in your own ASGI stack? Use sanzaru.server.build_http_app() — the same authenticated app the CLI serves — never the bare mcp.streamable_http_app(), which carries none of the middleware. See CLAUDE.md, Transport Modes.

What a .env file can (and cannot) configure

The sanzaru command — every subcommand, sanzaru serve included — autoloads a .env for local development. python-dotenv is a runtime dependency, so this works in any install, not only under uv sync. Two deliberate limits apply, because a file found on disk must not be able to redirect credentials, relax transport security, or change what a run is allowed to cost:

  • Only ./.env is read — the directory you run sanzaru in. There is no search of parent directories, so a .env at your project root is not found when you run from a subdirectory.

  • Only sanzaru's documented configuration keys load (API keys, media paths, storage backend credentials, tuning knobs), matched exactly and case-sensitively. Everything else in the file is ignored with a warning naming the keys. Notably ignored on purpose: DATABRICKS_HOST and any *_BASE_URL/proxy variable (they decide where credentials are sent); every HTTP-security variable — SANZARU_HTTP_TOKEN, SANZARU_ALLOW_UNAUTHENTICATED_HTTP, SANZARU_ALLOWED_HOSTS, SANZARU_ALLOWED_ORIGINS, SANZARU_IDENTITY_HEADER, SANZARU_REQUIRE_USER_CONTEXT (a planted file must not weaken or satisfy transport auth, nor pick whose identity is trusted); SANZARU_RUN_SECRET (the signing key); SANZARU_REALTIME_PRICE_* (the price table is what --max-cost is enforced against — a planted 0,0,0,0,0,0 would make every turn free); and DATABRICKS_VIDEO_DIR/_IMAGE_DIR/_AUDIO_DIR (joined into the volume path unsanitized, so .. in one walks into another tenant's files).

Anything the allowlist skips still works exported in the real environment, or injected explicitly with npx dotenv-cli -- <command> — both are deliberate operator actions rather than a file discovered on disk.

Storage Backends

Backend

Config

Use Case

Local (default)

SANZARU_MEDIA_PATH=/path/to/media

Development, local deployments

Databricks

STORAGE_BACKEND=databricks

Databricks Apps with Unity Catalog Volumes

The Databricks backend supports per-user storage isolation via the user_context module, enabling multi-tenant deployments where each user's media is stored under their own volume prefix (<local-part>-<hash>, injective over email addresses; the prefix format changed after 0.10.0 — see CLAUDE.md for the migration note). In HTTP mode the identity comes from a proxy-injected header, and trusting one is opt-in: set SANZARU_IDENTITY_HEADER (e.g. x-forwarded-email on Databricks Apps) only when a proxy in front of sanzaru both injects that header and strips any client-supplied copy. When it is unset, no header is trusted and every request resolves to the shared volume root. A request carrying the header twice (an appending proxy forwards the client's copy first) or malformed is refused with 400 rather than binding either copy. Set SANZARU_REQUIRE_USER_CONTEXT=1 on a shared deployment so a request with no identity is refused (403 on /media) instead of silently served out of the shared root.

Multi-tenant deployments should also set SANZARU_RUN_SECRET, which signs simulated-podcast run manifests and act checkpoints so --resume refuses bookkeeping this installation did not write.

See CLAUDE.md for full configuration details.

Performance

Fully asynchronous architecture with proven scalability:

  • ✅ 32+ concurrent operations verified

  • ✅ 8-10x speedup for parallel tasks

  • ✅ Non-blocking I/O with aiofiles + anyio

  • ✅ Free-threaded Python ready (3.15t tested in CI)

See docs/async-optimizations.md for technical details.

License

MIT

Available Tools

9 tools
create_videoA

Create a new Sora video generation job. This starts an async job and returns immediately with a video_id.

The video is NOT ready immediately - use get_video_status(video_id) to poll for completion. Status will be 'queued' -> 'in_progress' -> 'completed' or 'failed'. Once status='completed', use download_video(video_id) to save the video to disk.

Parameters:

  • prompt: Text description of the video to generate (required)

  • model: "sora-2" (faster, cheaper) or "sora-2-pro" (higher quality). Default: "sora-2"

  • seconds: Duration as string "4", "8", or "12" (NOT an integer). Default: varies by model

  • size: Resolution as "720x1280" (portrait), "1280x720" (landscape), "1024x1792", or "1792x1024". Default: "720x1280"

  • input_reference_filename: Filename of reference image in IMAGE_PATH (e.g., "cat.png"). Use list_reference_images to find available images. Image must match target size. Supported: JPEG, PNG, WEBP. Optional.

Returns Video object with fields: id, status, progress, model, seconds, size.

Inputs: prompt (required), size, model, seconds, +1 more.

delete_videoA
DestructiveIdempotent

Permanently delete a video from OpenAI's cloud storage.

WARNING: This is permanent and cannot be undone! The video will be deleted from OpenAI's servers. This does NOT delete any local files you may have downloaded with download_video.

Use this to:

  • Clean up test videos

  • Remove unwanted content

  • Free up storage quota

Parameters:

  • video_id: The ID of the video to delete (required)

Returns confirmation with the deleted video_id and deleted=true.

Inputs: video_id (required).

download_videoA
Idempotent

Download a completed video to disk.

IMPORTANT: Only call this AFTER get_video_status shows status='completed'. If the video is not completed, this will fail.

The video is automatically saved to the directory configured in VIDEO_PATH. Returns the filename of the downloaded file.

Parameters:

  • video_id: The ID from create_video or remix_video (required)

  • filename: Custom filename (optional, defaults to video_id with appropriate extension)

  • variant: What to download (default: "video")

    • "video" -> MP4 video file

    • "thumbnail" -> WEBP thumbnail image

    • "spritesheet" -> JPG spritesheet of frames

Typical workflow:

  1. Create: create_video() -> video_id

  2. Poll: get_video_status(video_id) until status='completed'

  3. Download: download_video(video_id, filename="my_video.mp4") -> returns filename

Returns DownloadResult with: filename, variant

Inputs: video_id (required), variant, filename.

_get_media_dataA
Read-only

Internal tool used by the MCP App media viewer to fetch base64-encoded chunks of media data. Do not call directly — use view_media instead.

Inputs: filename (required), media_type (required), offset, chunk_size.

get_video_statusA
Read-only

Check the status and progress of a video generation job.

Use this to poll for completion after calling create_video or remix_video. Call this repeatedly (e.g. every 5-10 seconds) until status changes from 'queued'/'in_progress' to 'completed' or 'failed'.

The returned Video object contains:

  • status: "queued" | "in_progress" | "completed" | "failed"

  • progress: Integer 0-100 showing completion percentage

  • id: The video_id for use with other tools

  • Other metadata: model, seconds, size, created_at, etc.

Typical workflow:

  1. Create video with create_video() -> get video_id

  2. Poll with get_video_status(video_id) until status='completed'

  3. Download with download_video(video_id)

Inputs: video_id (required).

list_local_videosA
Read-only

List locally downloaded video files with filtering and sorting.

Use this to discover what video files have been downloaded to the VIDEO_PATH directory. These are videos previously downloaded with download_video.

Parameters:

  • pattern: Glob pattern to filter filenames (e.g., "sora*.mp4", "*.webm"). Default: all files

  • file_type: Filter by type: "mp4", "webm", "mov", or "all". Default: "all"

  • sort_by: Sort results by "name", "size", or "modified". Default: "modified"

  • order: "desc" for newest/largest/Z-A first, "asc" for oldest/smallest/A-Z. Default: "desc"

  • limit: Max results to return. Default: 50

Returns list of VideoFile objects with: filename, size_bytes, modified_timestamp, file_type.

Example workflow:

  1. list_local_videos(file_type="mp4") -> find downloaded MP4 videos

  2. view_media(media_type="video", filename="my_video.mp4") -> watch it

Inputs: limit, order, pattern, sort_by, +1 more.

list_videosA
Read-only

List all video jobs in your OpenAI account with pagination support.

Returns a paginated list of all videos (completed, in-progress, failed, etc.). Each video summary includes: id, status, progress, created_at, model, seconds, size.

Parameters:

  • limit: Max number of videos to return (default: 20, max: 100)

  • after: For pagination, pass the 'last' id from previous response (optional)

  • order: "desc" for newest first (default) or "asc" for oldest first

Returns:

  • data: Array of video summaries

  • has_more: Boolean indicating if more results exist

  • last: The ID of the last video (use this as 'after' for next page)

Pagination example:

  1. page1 = list_videos(limit=20) -> get page1.last

  2. page2 = list_videos(limit=20, after=page1.last)

  3. Continue until has_more=false

Inputs: after, limit, order.

remix_videoA

Create a NEW video by remixing an existing completed video with a different prompt.

This creates a brand new video generation job (with a new video_id) based on an existing video. The original video must have status='completed' for remix to work.

Like create_video, this returns immediately with a new video_id - the remix is NOT instant. You must poll the NEW video_id with get_video_status until it completes.

Parameters:

  • previous_video_id: ID of the completed video to use as a base (required)

  • prompt: New text prompt to guide the remix (required)

Returns a NEW Video object with a different video_id, status='queued', progress=0.

Typical workflow:

  1. Create original: create_video("a cat") -> video_id_1

  2. Wait: Poll get_video_status(video_id_1) until completed

  3. Remix: remix_video(video_id_1, "a dog") -> video_id_2 (NEW ID!)

  4. Wait: Poll get_video_status(video_id_2) until completed

  5. Download: download_video(video_id_2)

Inputs: prompt (required), previous_video_id (required).

view_mediaA
Read-only

Open a media file in the interactive media viewer.

Opens a rich media player UI for viewing videos, listening to audio, or displaying images. The viewer loads the file and renders it with native playback controls.

Parameters:

  • media_type: Type of media to view — "video", "audio", or "image" (required)

  • filename: Name of the file to open (required)

    • video files are in the videos directory

    • image files are in the images directory

    • audio files are in the audio directory

Use list_videos, list_reference_images, or list_audio_files to discover available files.

Returns metadata: filename, media_type, size_bytes, mime_type

Inputs: filename (required), media_type (required).

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 9 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: create/remix/status/download/delete/list remote/list local/view. The internal _get_media_data tool is explicitly marked as 'do not call directly,' and its relationship to view_media is clearly explained, eliminating potential confusion.

    Naming Consistency4/5

    Tool names follow a consistent verb_noun pattern (create_video, delete_video, download_video, list_videos, view_media). Minor deviations include get_video_status (three-part), list_local_videos (adjective), and the underscore-prefixed _get_media_data, but these are readable and the pattern is predictable overall.

    Tool Count5/5

    With 9 tools, the server is well-scoped for video generation and management. Each tool addresses a distinct step in the workflow (create, remix, status, download, delete, list remote/local, view), and the count feels appropriate without redundancy or bloat.

    Completeness3/5

    Core video lifecycle is covered (create, remix, status, download, delete, list). However, create_video and view_media reference list_reference_images and list_audio_files, but these tools are not provided, creating dead ends for workflows involving reference images or audio media. This is a notable gap in the tool surface.

    Maintenance

    ActivityMaintained
    ResponsivenessUsually handled

    Related MCP Connectors

    Related MCP Servers