Nova Reel Video Mcp

by mirecekd

283 downloads
Not rated
GitHub

About

A Model Context Protocol (MCP) server for Amazon Nova Reel 1.1 video generation using AWS Bedrock. This server provides tools for asynchronous video generation with comprehensive prompting guidelines and both stdio and SSE transport support.

Details

Author
mirecekd
Downloads
283
Categories
Cloud Service, Other, AI, Media

Jump to

- Asynchronous video generation with job monitoring
- Multiple transport methods: stdio, SSE, and HTTP Streaming
- Built‑in prompting guide based on AWS documentation
- Docker support for all transport variants
- Full integration with AWS Bedrock and S3

Setting up with Highlight

This MCP is not yet compatible with Highlight’s one-click setup. However, you can still use it with Highlight by following these steps:

  1. Download and install Highlight from highlightai.com/download
  2. Navigate to the plugins tab and select "Add Custom Plugin"
  3. Configure the plugin with the settings below
    Plugin Name Nova Reel Video Mcp
    Command (node, npx, python, etc.)

    Please refer to the README for specific instructions on how to obtain API keys or other required environment variables.

  4. Enable "Start Automatically" if you want the plugin to start when Highlight launches

From the repository

Install via Docker (pre‑built images) or locally with pip install -e . or uvx. Configure AWS credentials and an S3 bucket as environment variables or CLI arguments. Add the server to your MCP client configuration (e.g., Cline or Claude Desktop) or run the SSE/HTTP Streaming version as a standalone web server. Use the four tools: start_async_invoke, list_async_invokes, get_async_invoke, and get_prompting_guide.

Claude Desktop / Cursor

Paste into your MCP client config file to install this server.

{
    "mcpServers": {
        "nova reel video mcp": {
            "Nova Reel Video MCP": {
                "disabled": false,
                "timeout": 60,
                "type": "stdio",
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "ghcr.io/mirecekd/novareel-mcp:latest-stdio",
                    "--aws-access-key-id",
                    "YOUR_AWS_ACCESS_KEY_ID",
                    "--aws-secret-access-key",
                    "YOUR_AWS_SECRET_ACCESS_KEY",
                    "--s3-bucket",
                    "YOUR_S3_BUCKET_NAME"
                ]
            }
        }
    }
}

McpServers

{
    "Nova Reel Video MCP": {
        "disabled": false,
        "timeout": 60,
        "type": "stdio",
        "command": "docker",
        "args": [
            "run",
            "-i",
            "--rm",
            "ghcr.io/mirecekd/novareel-mcp:latest-stdio",
            "--aws-access-key-id",
            "YOUR_AWS_ACCESS_KEY_ID",
            "--aws-secret-access-key",
            "YOUR_AWS_SECRET_ACCESS_KEY",
            "--s3-bucket",
            "YOUR_S3_BUCKET_NAME"
        ]
    }
}

Amazon Nova Reel 1.1 MCP Server

A Model Context Protocol (MCP) server for Amazon Nova Reel 1.1 video generation using AWS Bedrock. This server provides tools for asynchronous video generation with comprehensive prompting guidelines and both stdio and SSE transport support.

<div align="center">

"Buy Me A Coffee"

</div>

Features

- Asynchronous Video Generation: Start, monitor, and retrieve video generation jobs
- Multiple Transport Methods: Support for stdio, Server-Sent Events (SSE), and HTTP Streaming
- Comprehensive Prompting Guide: Built-in guidelines based on AWS documentation
- Docker Support: Ready-to-use Docker containers for all transport methods
- AWS Integration: Full integration with AWS Bedrock and S3

Available Tools

1. start_async_invoke

Start a new video generation job.

Parameters:
- prompt (required): Text description for video generation
- duration_seconds (optional): Video duration (12-120 seconds, multiples of 6, default: 12)
- fps (optional): Frames per second (default: 24)
- dimension (optional): Video dimensions (default: "1280x720")
- seed (optional): Random seed for reproducible results
- task_type (optional): Task type (default: "MULTI_SHOT_AUTOMATED")

Returns: Job details including job_id, invocation_arn, and estimated video URL.

2. list_async_invokes

List all tracked video generation jobs with their current status.

Returns: Summary of all jobs with status counts and individual job details.

3. get_async_invoke

Get detailed information about a specific video generation job.

Parameters:
- identifier (required): Either job_id or invocation_arn

Returns: Detailed job information including video URL when completed.

4. get_prompting_guide

Get comprehensive prompting guidelines for effective video generation.

Returns: Detailed prompting best practices, examples, and templates.

Installation

Prerequisites

- Python 3.8+
- AWS Account with Bedrock access
- S3 bucket for video output
- AWS credentials with appropriate permissions

Local Installation

1. Clone or download the server files
2. Install dependencies:

pip install -e .

Docker Installation

Using Pre-built Images (Recommended)

Pull multi-architecture images from GitHub Container Registry:

# STDIO version
docker pull ghcr.io/mirecekd/novareel-mcp:latest-stdio

SSE version  

docker pull ghcr.io/mirecekd/novareel-mcp:latest-sse

HTTP Streaming version

docker pull ghcr.io/mirecekd/novareel-mcp:latest-http

Building Locally

1. Build containers using provided scripts:

# Build all versions

./build-all.sh


Or build individual versions

./build-stdio.sh    # STDIO version
./build-sse.sh      # SSE version
./build-http.sh     # HTTP Streaming version

2. Or use docker-compose:

docker-compose up -d

3. Or use the quick start script:

# Build all images

./start.sh build


Build specific version

./start.sh build-stdio
./start.sh build-sse
./start.sh build-http

Configuration

Environment Variables

- AWS_ACCESS_KEY_ID: Your AWS access key ID
- AWS_SECRET_ACCESS_KEY: Your AWS secret access key
- AWS_REGION: AWS region (default: us-east-1)
- S3_BUCKET: S3 bucket name for video output

.env File Example

Create a .env file for docker-compose:

AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
AWS_REGION=us-east-1
S3_BUCKET=my-video-generation-bucket

Usage

MCP Client Integration (Cline/Claude Desktop)

Add the server to your MCP client configuration:

Cline Configuration

Add to your Cline MCP settings: 
{
  "mcpServers": {
    "Nova Reel Video MCP": {
      "disabled": false,
      "timeout": 60,
      "type": "stdio",
      "command": "docker",
      "args": [
        "run",
        "-i",
        "--rm",
        "ghcr.io/mirecekd/novareel-mcp:latest-stdio",
        "--aws-access-key-id",
        "YOUR_AWS_ACCESS_KEY_ID",
        "--aws-secret-access-key",
        "YOUR_AWS_SECRET_ACCESS_KEY",
        "--s3-bucket",
        "YOUR_S3_BUCKET_NAME"
      ]
    }
  }
}

Claude Desktop Configuration

Add to your Claude Desktop claude_desktop_config.json: 
{
  "mcpServers": {
    "novareel-mcp": {
      "command": "docker",
      "args": [
        "run",
        "-i", 
        "--rm",
        "ghcr.io/mirecekd/novareel-mcp:latest-stdio",
        "--aws-access-key-id",
        "YOUR_AWS_ACCESS_KEY_ID",
        "--aws-secret-access-key",
        "YOUR_AWS_SECRET_ACCESS_KEY",
        "--s3-bucket",
        "YOUR_S3_BUCKET_NAME"
      ]
    }
  }
}

Alternative: Local Python Installation

If you prefer running without Docker: 
{
  "mcpServers": {
    "novareel-mcp": {
      "command": "uvx",
      "args": [
        "--from", "git+https://github.com/mirecekd/novareel-mcp.git",
        "novareel-mcp-server",
        "--aws-access-key-id", "YOUR_AWS_ACCESS_KEY_ID",
        "--aws-secret-access-key", "YOUR_AWS_SECRET_ACCESS_KEY",
        "--s3-bucket", "YOUR_S3_BUCKET_NAME"
      ]
    }
  }
}

Important: Replace the placeholder values with your actual AWS credentials and S3 bucket name.

Running with uvx (Recommended)

# First build the package
./build.sh

Then run from wheel file

uvx --from ./dist/novareel_mcp-1.0.0-py3-none-any.whl novareel-mcp-server --aws-access-key-id YOUR_KEY --aws-secret-access-key YOUR_SECRET --s3-bucket YOUR_BUCKET

Or from current directory during development (without build)

uvx --from . novareel-mcp-server --aws-access-key-id YOUR_KEY --aws-secret-access-key YOUR_SECRET --s3-bucket YOUR_BUCKET

Or using start script

./start.sh build-package  # Build wheel

Stdio Version (Direct MCP Client)

# Local execution
python main.py --aws-access-key-id YOUR_KEY --aws-secret-access-key YOUR_SECRET --s3-bucket YOUR_BUCKET

Docker execution

docker run --rm -i mirecekd/novareel-mcp-server:stdio --aws-access-key-id YOUR_KEY --aws-secret-access-key YOUR_SECRET --s3-bucket YOUR_BUCKET

SSE Version (Web Interface)

# Local execution
python -m novareel_mcp_server.server_sse --aws-access-key-id YOUR_KEY --aws-secret-access-key YOUR_SECRET --s3-bucket YOUR_BUCKET --host 0.0.0.0 --port 8000

Docker execution

docker run -p 8000:8000 -e AWS_ACCESS_KEY_ID=YOUR_KEY -e AWS_SECRET_ACCESS_KEY=YOUR_SECRET -e S3_BUCKET=YOUR_BUCKET mirecekd/novareel-mcp-server:sse

Then access http://localhost:8000/sse/ for the SSE endpoint.

HTTP Streaming Version (Bidirectional Transport)

# Local execution
python -m novareel_mcp_server.server_http --aws-access-key-id YOUR_KEY --aws-secret-access-key YOUR_SECRET --s3-bucket YOUR_BUCKET --host 0.0.0.0 --port 8001

Docker execution

docker run -p 8001:8001 -e AWS_ACCESS_KEY_ID=YOUR_KEY -e AWS_SECRET_ACCESS_KEY=YOUR_SECRET -e S3_BUCKET=YOUR_BUCKET ghcr.io/mirecekd/novareel-mcp:latest-http

Then access http://localhost:8001 for the HTTP streaming transport.

Package Build

To create a distribution package:

# Install build tools
pip install build

Create package

python3 -m build

Output files will be in dist/

Example Usage

Basic Video Generation

# Start a video generation job
result = start_async_invoke(
    prompt="A majestic eagle soars over a mountain valley, camera tracking its flight as it circles above a pristine lake",
    duration_seconds=24,
    fps=24,
    dimension="1920x1080"
)

job_id = result["job_id"]

print(f"Started job: {job_id}")


Check job status

status = get_async_invoke(job_id)
print(f"Status: {status['status']}")

When completed, get video URL

if status["status"] == "Completed":
    print(f"Video URL: {status['video_url']}")

List All Jobs

…

No reviews yet — be the first

Sign in to leave a review

Use Google, GitHub, or an email account so ratings stay tied to real people.

Email sign in

No reviews posted yet.

Install

Add to Claude Desktop or Cursor

{
    "mcpServers": {
        "nova reel video mcp": {
            "Nova Reel Video MCP": {
                "disabled": false,
                "timeout": 60,
                "type": "stdio",
                "command": "docker",
                "args": [
                    "run",
                    "-i",
                    "--rm",
                    "ghcr.io/mirecekd/novareel-mcp:latest-stdio",
                    "--aws-access-key-id",
                    "YOUR_AWS_ACCESS_KEY_ID",
                    "--aws-secret-access-key",
                    "YOUR_AWS_SECRET_ACCESS_KEY",
                    "--s3-bucket",
                    "YOUR_S3_BUCKET_NAME"
                ]
            }
        }
    }
}

More like this

Similar MCP servers you might find useful

Browse category

Sequential Thinking

Sequential Thinking is an MCP server that provides a tool for dynamic and reflective problem-solving through a structured, step-by-step thinking process. It is…

88.2k
Other

Filesystem

Filesystem is a Node.js server that implements the Model Context Protocol (MCP) for filesystem operations. It enables AI assistants to read, write, and manage…

88.1k
Other

Context 7

Official Context7 MCP server that brings up-to-date, version-specific library documentation and code examples into AI coding prompts.

58.7k
Developer Tools