Pegasus 1.5 da TwelveLabs já está disponível no Amazon Bedrock

O que é o Pegasus 1.5 e por que ele importa

Em 9 de outubro de 2026, a AWS anunciou a disponibilidade do Pegasus 1.5 da TwelveLabs no Amazon Bedrock. Trata-se de um modelo de linguagem de vídeo projetado para transformar conteúdo de longa duração em metadados estruturados e com timestamps — ou seja, você descreve os momentos que importam para o seu fluxo de trabalho, e o modelo retorna cada trecho correspondente em formato JSON.

Vídeo é uma das categorias mais volumosas e complexas de dados não estruturados que existem, e a grande maioria desse conteúdo permanece impossível de pesquisar e subutilizado. Extrair insights acionáveis de vídeos sempre exigiu revisão manual trabalhosa ou cadeias de ferramentas fragmentadas. O Pegasus 1.5 foi desenvolvido para mudar esse cenário.

O que há de novo no Pegasus 1.5

Em relação às versões anteriores, o Pegasus 1.5 traz quatro avanços principais:

• Geração de metadados baseada em tempo: você define os segmentos, eventos ou marcadores específicos do seu domínio — como cortes editoriais, jogadas esportivas, mudanças de apresentador ou aparições de marca — e o modelo retorna cada ocorrência em JSON com horários de início e fim.
• Prompts multimodais: uma definição de segmento pode combinar uma descrição em texto com uma imagem de referência visual, permitindo localizar um produto específico, logotipo ou pessoa, junto com o que estão fazendo na tela.
• Processamento sob demanda (on-the-fly): não há necessidade de pipeline de ingestão ou etapa de pré-indexação. Os vídeos são enviados diretamente do Amazon S3 e os resultados são retornados na própria resposta.
• Capacidade de processamento ampliada: o Pegasus 1.5 analisa vídeos de até duas horas em uma única requisição, ante uma hora no Pegasus 1.2.

O modelo também mantém e aprimora as capacidades centrais da versão anterior: geração de texto a partir de vídeo, compreensão visual granular (objetos, texto na tela, conteúdo numérico), ancoragem temporal de eventos, compreensão multimodal (visual, áudio e texto) e suporte multilíngue — com inglês completo e suporte parcial para árabe, chinês, francês, alemão, italiano, japonês, coreano, português, russo, espanhol, tailandês e vietnamita.

Como o Pegasus 1.5 funciona no Amazon Bedrock

O modelo recebe um vídeo e um prompt de texto ou um conjunto de definições de segmento, e retorna texto ou JSON. A chamada é feita no endpoint bedrock-runtime com a API InvokeModel, ou com InvokeModelWithResponseStream para respostas em streaming.

• ID do modelo: twelvelabs.pegasus-1-5-v1:0
• Região AWS: US West (Oregon) — us-west-2
• APIs de inferência: InvokeModel, InvokeModelWithResponseStream

Cada requisição opera em um de dois modos, definido pelo campo analysisMode:

• Modo geral (general): você envia um prompt em texto via inputPrompt e recebe uma resposta em texto — ou em JSON, quando fornece um schema.
• Metadados baseados em tempo (time_based_metadata): você envia definições de segmento em responseFormat e recebe uma lista de segmentos com horários de início e fim e os campos solicitados.

O vídeo pode ser fornecido de duas formas: via URI do Amazon S3 (Serviço de Armazenamento Simples) — indicado para vídeos longos — ou como string base64 embutida na requisição, com limite de 25 MB, indicado para clipes curtos.

Primeiros passos com o Pegasus 1.5

Pré-requisitos

• Conta AWS ativa com acesso ao Amazon Bedrock.
• Python 3.10 ou superior, com o SDK AWS para Python (Boto3) instalado.
• Permissões do IAM (Gerenciamento de Identidade e Acesso) para bedrock:InvokeModel e bedrock:InvokeModelWithResponseStream.
• Acesso ao modelo TwelveLabs Pegasus 1.5 habilitado no console do Amazon Bedrock.
• Vídeos armazenados em um bucket do Amazon S3, ou clipes curtos para envio inline.

A política IAM abaixo concede as duas ações de invocação no Pegasus 1.5:

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Effect": "Allow",
      "Action": [
        "bedrock:InvokeModel",
        "bedrock:InvokeModelWithResponseStream"
      ],
      "Resource": [
        "arn:aws:bedrock:us-west-2::foundation-model/twelvelabs.pegasus-1-5-v1:0"
      ]
    }
  ]
}

Sua primeira requisição

Instale o Boto3:

pip install boto3

O exemplo a seguir analisa um vídeo armazenado no Amazon S3 no modo geral, usando o endpoint global de Inferência entre Regiões (CRIS). Para usar o endpoint geográfico dos EUA, substitua "global." por "us." na URL do endpoint.

import boto3
import json
from botocore.config import Config

AWS_REGION = "us-west-2"
MODEL_ID = "global.twelvelabs.pegasus-1-5-v1:0"

bedrock_runtime = boto3.client(
    service_name="bedrock-runtime",
    region_name=AWS_REGION,
    config=Config(
        # keep a longer read_timeout for lengthier invocations such as video segmentation
        read_timeout=900,
        retries={"max_attempts": 0},
        connect_timeout=10,
    ),
)

# Analyze a video stored in Amazon S3
payload = {
    "inputPrompt": "Summarize this video and identify the key topics discussed.",
    "mediaSource": {
        "s3Location": {
            "uri": "s3://amzn-s3-demo-pegasus-15/your-video.mp4",
            "bucketOwner": "your-account-id"
        }
    },
    "temperature": 0.2,
    "maxOutputTokens": 4096,
    "includeMetering": True
}

response = bedrock_runtime.invoke_model(
    modelId=MODEL_ID,
    body=json.dumps(payload)
)

result = json.loads(response["body"].read())
print(result["message"])

A resposta traz a resposta em message, a contagem de tokens em input_tokens e output_tokens, e o motivo do encerramento em stopReason. Um stopReason igual a length indica que a resposta foi cortada antes de terminar — aumente o maxOutputTokens e tente novamente:

if result["stopReason"] == "length":
    print("The answer was cut off. Raise maxOutputTokens and try again.")
print("Tokens in:", result["input_tokens"], "out:", result["output_tokens"])

Para clipes curtos, é possível enviar o vídeo inline em vez de via S3:

import base64

with open("your-video.mp4", "rb") as f:
    video_b64 = base64.b64encode(f.read()).decode("utf-8")

payload["mediaSource"] = {"base64String": video_b64}
response = bedrock_runtime.invoke_model(modelId=MODEL_ID, body=json.dumps(payload))
print(json.loads(response["body"].read())["message"])

Resposta em streaming

Para aplicações interativas, o InvokeModelWithResponseStream retorna a resposta em pedaços conforme ela é gerada:

response = bedrock_runtime.invoke_model_with_response_stream(
    modelId=MODEL_ID,
    body=json.dumps(payload)
)

for event in response["body"]:
    chunk = json.loads(event["chunk"]["bytes"])
    print(chunk.get("message", ""), end="", flush=True)
print()

Retornando JSON estruturado

No modo geral, é possível restringir a resposta a um JSON Schema para que o código downstream possa fazer o parse diretamente. Defina responseFormat.type como json_schema e coloque o schema em jsonSchema:

payload = {
    "inputPrompt": "Analyze this video and return a structured summary.",
    "mediaSource": {
        "s3Location": {
            "uri": "s3://amzn-s3-demo-pegasus-15/your-video.mp4",
            "bucketOwner": "your-account-id"
        }
    },
    "temperature": 0,
    "maxOutputTokens": 2048,
    "includeMetering": True,
    "responseFormat": {
        "type": "json_schema",
        "jsonSchema": {
            "type": "object",
            "properties": {
                "summary": {"type": "string"},
                "key_scenes": {"type": "array", "items": {"type": "string"}},
                "setting": {"type": "string"}
            },
            "required": ["summary", "key_scenes", "setting"]
        }
    }
}

response = bedrock_runtime.invoke_model(modelId=MODEL_ID, body=json.dumps(payload))
summary = json.loads(json.loads(response["body"].read())["message"])
print(summary["summary"])
for scene in summary["key_scenes"]:
    print(" -", scene)

Segmentação de vídeo: transformando vídeo em dados estruturados

A geração de metadados baseada em tempo é onde o Pegasus 1.5 mais se diferencia das versões anteriores. Em vez de um prompt, você envia uma ou mais definições de segmento, e o modelo retorna cada trecho do vídeo que corresponde a cada definição.

Para isso, defina analysisMode como time_based_metadata e responseFormat.type como segment_definitions. Cada definição possui:

• id: nome da definição, retornado em cada segmento correspondente.
• description: como é um segmento correspondente.
• fields: os valores a extrair para cada segmento, cada um com nome, tipo e descrição.

O exemplo abaixo identifica cada seção editorial em uma transmissão de notícias e retorna título, resumo e tópicos principais:

payload = {
    "analysisMode": "time_based_metadata",
    "mediaSource": {
        "s3Location": {
            "uri": "s3://amzn-s3-demo-pegasus-15/news-broadcast.mp4",
            "bucketOwner": "your-account-id"
        }
    },
    "responseFormat": {
        "type": "segment_definitions",
        "segmentTimeFormat": "hh:mm:ss",
        "segmentDefinitions": [
            {
                "id": "editorial_section",
                "description": "A distinct editorial section of the broadcast, "
                               "such as a new story, topic, or segment of the program.",
                "fields": [
                    {"name": "segment_title", "type": "string", "description": "A descriptive title"},
                    {"name": "summary", "type": "string", "description": "A brief summary of the segment content"},
                    {"name": "key_topics", "type": "array", "items": {"type": "string"}, "description": "Main topics discussed"}
                ]
            }
        ]
    },
    "temperature": 0,
    "maxOutputTokens": 32768,
    "includeMetering": True
}

response = bedrock_runtime.invoke_model(
    modelId=MODEL_ID,
    contentType="application/json",
    accept="application/json",
    body=json.dumps(payload)
)

result = json.loads(response["body"].read())
for segment in result["segments"]:
    print(segment["start_sec"], "-", segment["end_sec"], segment["segment_title"])
    print("  ", segment["summary"])
    print("  topics:", ", ".join(segment["key_topics"]))

O campo segmentTimeFormat controla como os horários são escritos: seconds retorna números para operações aritméticas, enquanto hh:mm:ss e hh:mm:ss.fff retornam timestamps legíveis como strings. Uma única requisição pode incluir múltiplas definições de segmento — por exemplo, uma para seções editoriais e outra para aparições de marca — e o modelo retorna os resultados de todas em uma única lista de segmentos, identificando cada um com _definition_id.

Prompts multimodais: adicionando contexto visual às consultas

O Pegasus 1.5 introduz prompts multimodais, permitindo incluir imagens de referência junto com os prompts de texto. Isso é útil quando você quer perguntar ao modelo sobre objetos, pessoas ou cenas que são mais fáceis de mostrar do que descrever — por exemplo, fornecer a imagem de um produto e pedir ao modelo que identifique cada momento em que ele aparece no vídeo.

As imagens de referência são anexadas de forma diferente dependendo do modo:

• No modo geral, elas ficam em promptV2.mediaSources, ao lado da pergunta em promptV2.inputText.
• No modo de segmentação (time_based_metadata), elas são anexadas ao campo mediaSources de cada definição de segmento dentro de responseFormat.segmentDefinitions.

Cada imagem precisa de um nome, um media_type igual a image, e exatamente uma fonte: base64String inline ou s3Location com uri e bucketOwner. Uma única requisição pode carregar até 30 imagens de referência.

Monitoramento de uso

O Pegasus 1.5 publica métricas no Amazon CloudWatch no namespace AWS/Bedrock sob o ID do modelo, incluindo Invocations, OutputTokenCount, InvocationLatency e InvocationClientErrors. Para rastrear custos por aplicação, crie um perfil de inferência de aplicação a partir do modelo Pegasus 1.5, adicione tags e chame-o pelo seu ARN (Nome de Recurso da Amazon) no lugar do ID do modelo.

Casos de uso

O Pegasus 1.5 foi projetado para organizações que gerenciam grandes volumes de vídeos de longa duração:

• Arquivos de notícias e transmissão: equipes podem definir segmentos editoriais, tópicos e mudanças de apresentador uma vez, e catalogar anos de gravações que antes só eram pesquisáveis por palavras-chave de transcrição.
• Transmissoras esportivas e ligas: detecção de jogadas, eventos de pontuação e momentos-chave em partidas completas, acelerando a produção de highlights.
• Aplicações de streaming: metadados em nível de cena viabilizam recomendações baseadas em momentos, inserção contextual de anúncios e revisão de segurança de marca por segmento.

Em todos os casos, as pessoas permanecem parte do fluxo de trabalho — o trabalho muda de encontrar e rotular cada momento manualmente para revisar e refinar os metadados gerados pelo modelo.

Requisitos de entrada

• Duração: até 2 horas.
• Tamanho do arquivo: até 2 GB via Amazon S3, ou até 25 MB como string base64.
• Resolução: de 360×360 a 5184×2160.
• Proporção de tela: entre 1:1 e 2.4:1, ou seus inversos.
• Formatos: formatos suportados pelo FFmpeg.

Disponibilidade e cobrança

O TwelveLabs Pegasus 1.5 está disponível no Amazon Bedrock na região AWS US West (Oregon). Consulte a lista completa de regiões para atualizações futuras, e acesse a página de preços do Amazon Bedrock para informações de valores. O Pegasus 1.5 é cobrado via AWS Marketplace, portanto seus encargos aparecem na fatura AWS e no AWS Cost Explorer sob TwelveLabs, e não sob Amazon Bedrock.

Para começar, acesse a página de modelos TwelveLabs no Amazon Bedrock e consulte o model card do Pegasus 1.5 para suporte a recursos, disponibilidade por região e exemplos de código. Dúvidas e feedbacks podem ser enviados pelo AWS re:Post para Amazon Bedrock.

Fonte

Pegasus 1.5 from TwelveLabs is now available in Amazon Bedrock (https://aws.amazon.com/blogs/machine-learning/pegasus-1-5-from-twelvelabs-is-now-available-in-amazon-bedrock/)