Amazon Nova Reel 1.1

Um servidor MCP para gerar vídeos usando Amazon Nova Reel 1.1 via AWS Bedrock.

GitHub
1
Experimente este MCPPatrocinado

Documentação

Servidor MCP Amazon Nova Reel 1.1

Um servidor Model Context Protocol (MCP) para geração de vídeos Amazon Nova Reel 1.1 usando AWS Bedrock. Este servidor fornece ferramentas para geração assíncrona de vídeos com diretrizes abrangentes de prompts e suporte a transporte stdio e SSE.

"Buy Me A Coffee" "PayPal.me"

Recursos

  • Geração Assíncrona de Vídeos: Inicie, monitore e recupere trabalhos de geração de vídeos
  • Múltiplos Métodos de Transporte: Suporte para stdio, Server-Sent Events (SSE) e HTTP Streaming
  • Guia Abrangente de Prompts: Diretrizes integradas baseadas na documentação da AWS
  • Suporte a Docker: Contêineres Docker prontos para uso em todos os métodos de transporte
  • Integração com AWS: Integração completa com AWS Bedrock e S3

Ferramentas Disponíveis

1. start_async_invoke

Inicie um novo trabalho de geração de vídeo.

Parâmetros:

  • prompt (obrigatório): Descrição em texto para geração de vídeo
  • duration_seconds (opcional): Duração do vídeo (12-120 segundos, múltiplos de 6, padrão: 12)
  • fps (opcional): Quadros por segundo (padrão: 24)
  • dimension (opcional): Dimensões do vídeo (padrão: "1280x720")
  • seed (opcional): Semente aleatória para resultados reproduzíveis
  • task_type (opcional): Tipo de tarefa (padrão: "MULTI_SHOT_AUTOMATED")

Retorna: Detalhes do trabalho incluindo job_id, invocation_arn e URL estimada do vídeo.

2. list_async_invokes

Liste todos os trabalhos de geração de vídeo rastreados com seu status atual.

Retorna: Resumo de todos os trabalhos com contagens de status e detalhes individuais dos trabalhos.

3. get_async_invoke

Obtenha informações detalhadas sobre um trabalho específico de geração de vídeo.

Parâmetros:

  • identifier (obrigatório): Ou job_id ou invocation_arn

Retorna: Informações detalhadas do trabalho incluindo URL do vídeo quando concluído.

4. get_prompting_guide

Obtenha diretrizes abrangentes de prompts para geração eficaz de vídeos.

Retorna: Práticas recomendadas detalhadas de prompts, exemplos e modelos.

Instalação

Pré-requisitos

  • Python 3.8+
  • Conta AWS com acesso ao Bedrock
  • Bucket S3 para saída de vídeo
  • Credenciais AWS com permissões apropriadas

Instalação Local

  1. Clone ou baixe os arquivos do servidor
  2. Instale as dependências:
pip install -e .

Instalação com Docker

Usando Imagens Pré-construídas (Recomendado)

Baixe imagens multi-arquitetura do 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

Construindo Localmente

  1. Construa os contêineres usando os scripts fornecidos:
# 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
  1. Ou use docker-compose:
docker-compose up -d
  1. Ou use o script de início rápido:
# Build all images
./start.sh build

# Build specific version
./start.sh build-stdio
./start.sh build-sse
./start.sh build-http

Configuração

Variáveis de Ambiente

  • AWS_ACCESS_KEY_ID: Seu ID da chave de acesso AWS
  • AWS_SECRET_ACCESS_KEY: Sua chave de acesso secreta AWS
  • AWS_REGION: Região AWS (padrão: us-east-1)
  • S3_BUCKET: Nome do bucket S3 para saída de vídeo

Exemplo de Arquivo .env

Crie um arquivo .env para 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

Uso

Integração com Cliente MCP (Cline/Claude Desktop)

Adicione o servidor à configuração do seu cliente MCP:

Configuração do Cline

Adicione às configurações MCP do seu Cline:

{
  "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"
      ]
    }
  }
}

Configuração do Claude Desktop

Adicione ao seu claude_desktop_config.json do Claude Desktop:

{
  "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"
      ]
    }
  }
}

Alternativa: Instalação Python Local

Se preferir executar sem 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"
      ]
    }
  }
}

Importante: Substitua os valores de exemplo pelas suas credenciais AWS reais e nome do bucket S3.

Executando com uvx (Recomendado)

# 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

Versão Stdio (Cliente MCP Direto)

# 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

Versão SSE (Interface Web)

# 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

Em seguida, acesse http://localhost:8000/sse/ para o endpoint SSE.

Versão HTTP Streaming (Transporte Bidirecional)

# 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

Em seguida, acesse http://localhost:8001 para o transporte HTTP streaming.

Build do Pacote

Para criar um pacote de distribuição:

# Install build tools
pip install build

# Create package
python3 -m build

# Output files will be in dist/

Exemplo de Uso

Geração Básica de Vídeo

# 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']}")

Listar Todos os Trabalhos

# Get overview of all jobs
jobs = list_async_invokes()
print(f"Total jobs: {jobs['total_invocations']}")
print(f"Completed: {jobs['summary']['completed']}")
print(f"In progress: {jobs['summary']['in_progress']}")

Diretrizes de Prompts

O servidor inclui diretrizes abrangentes de prompts baseadas na documentação da AWS. Acesse-as usando:

guide = get_prompting_guide()

Principais Dicas de Prompts

  1. Seja Específico: Use linguagem detalhada e descritiva

    • Bom: "Um cardeal vermelho empoleirado em um galho de pinheiro coberto de neve, luz da manhã filtrando pelas árvores"
    • Ruim: "Um pássaro em uma árvore"

  2. Use Terminologia de Câmera: Controle a composição da cena

    • "Close-up de mãos esculpindo madeira"
    • "Plano aberto estabelecendo a paisagem montanhosa"
    • "Câmera panorâmica para a esquerda através do vale"

  3. Inclua Detalhes de Iluminação: Especifique a atmosfera

    • "Iluminação de hora dourada projetando sombras longas"
    • "Crepúsculo suave de hora azul"
    • "Nuvens de tempestade dramáticas acima"

  4. Estruture para a Duração: Combine a complexidade com o comprimento do vídeo

    • 12-24 segundos: Ação única ou momento
    • 30-60 segundos: 2-3 ações distintas
    • 60-120 segundos: Narrativa completa com múltiplas cenas

Exemplos de Prompts por Categoria

Natureza (Curto - 12s):

Close-up of morning dew drops on a spider web, with soft sunrise lighting creating rainbow reflections

Urbano (Médio - 30s):

A street musician plays violin in a subway station, commuters pause to listen, coins drop into his case, camera slowly pulls back to reveal the bustling underground scene

Retrato (Longo - 60s):

Portrait of a chef preparing a signature dish: selecting fresh ingredients at market, returning to kitchen, methodically preparing each component, plating with artistic precision, and presenting the finished masterpiece

Permissões AWS

Suas credenciais AWS precisam das seguintes permissões:

{
    "Version": "2012-10-17",
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "bedrock:InvokeModel",
                "bedrock:StartAsyncInvoke",
                "bedrock:GetAsyncInvoke",
                "bedrock:ListFoundationModels"
            ],
            "Resource": "*"
        },
        {
            "Effect": "Allow",
            "Action": [
                "s3:PutObject",
                "s3:GetObject",
                "s3:ListBucket"
            ],
            "Resource": [
                "arn:aws:s3:::your-bucket-name",
                "arn:aws:s3:::your-bucket-name/*"
            ]
        }
    ]
}

Saída de Vídeo

Os vídeos gerados são armazenados no seu bucket S3 com a seguinte estrutura:

s3://your-bucket/
├── job-id-1/
│   └── output.mp4
├── job-id-2/
│   └── output.mp4
└── ...

Os vídeos são acessíveis via URLs HTTPS:

https://your-bucket.s3.region.amazonaws.com/job-id/output.mp4

Especificações de Vídeo Suportadas

  • Duração: 12-120 segundos (deve ser múltiplo de 6)
  • Taxa de Quadros: 24 fps (recomendado)
  • Dimensões:
    • 1280x720 (HD)
  • Formato: MP4
  • Modelo: amazon.nova-reel-v1:1

Solução de Problemas

Problemas Comuns

  1. Erro de Credenciais AWS

    • Verifique se suas credenciais AWS estão corretas
    • Garanta que sua conta tenha acesso ao Bedrock habilitado
    • Verifique as permissões IAM

  2. Acesso ao Bucket S3

    • Verifique se o bucket existe e é acessível
    • Verifique as permissões do bucket
    • Garanta que o bucket esteja na mesma região que o Bedrock

  3. Validação de Duração

    • A duração deve ser de 12-120 segundos
    • Deve ser um múltiplo de 6
    • Valores válidos: 12, 18, 24, 30, 36, 42, 48, 54, 60, 66, 72, 78, 84, 90, 96, 102, 108, 114, 120

  4. Trabalho Não Encontrado

    • Use list_async_invokes para ver todos os trabalhos rastreados
    • Os trabalhos são armazenados em memória e perdidos ao reiniciar o servidor
    • Para produção, implemente armazenamento persistente

Modo de Depuração

Habilite o registro de depuração definindo a variável de ambiente:

export PYTHONUNBUFFERED=1

Desenvolvimento

Estrutura do Projeto

novareel-mcp-server/
├── main.py              # Main MCP server (stdio)
├── main_sse.py          # SSE version of MCP server
├── main_http.py         # HTTP Streaming version of MCP server
├── prompting_guide.py   # AWS prompting guidelines
├── pyproject.toml       # Python dependencies
├── Dockerfile.stdio     # Docker for stdio version
├── Dockerfile.sse       # Docker for SSE version
├── Dockerfile.http      # Docker for HTTP streaming version
├── docker-compose.yml   # Container orchestration
└── README.md           # This documentation

Contribuindo

  1. Faça um fork do repositório
  2. Crie um branch de funcionalidade
  3. Faça suas alterações
  4. Teste com todas as versões de transporte (stdio, SSE, HTTP streaming)
  5. Envie um pull request

Licença

Este projeto é licenciado sob a Licença MIT - consulte o arquivo LICENSE para detalhes.

Suporte

Para problemas e perguntas:

  1. Consulte a seção de solução de problemas
  2. Revise a documentação do AWS Bedrock
  3. Abra um problema no repositório

Links Relacionados