Vídeo com IA: Claude Code, Codex e ElevenLabs · Capítulo 9 de 25 · 27 min
Conectar fal, Replicate e ElevenLabs por MCP com permissões mínimas
Registre fal, Replicate e ElevenLabs por MCP com login no navegador, grave o .mcp.json e libere só as ferramentas de consulta antes de qualquer geração paga.
Este capítulo faz parte do curso gratuito Vídeo com IA: Claude Code, Codex e ElevenLabs.
Cada serviço de mídia tem painel, chave e formato de resposta próprios. Copiar esses detalhes para o chat expõe credenciais e convida o agente a inventar parâmetros: o resultado típico é uma chave colada na conversa, uma geração disparada sem preço conhecido e um modelo escolhido pelo nome parecido.
O MCP, protocolo que liga o agente a ferramentas externas como uma tomada padronizada, resolve a conexão: o Claude Code passa a enxergar as ferramentas de cada serviço com nome, esquema e descrição. Conectar, porém, não é autorizar. Um servidor de geração expõe na mesma lista a consulta de preço, que é gratuita, e a execução do modelo, que é cobrada por execução.
Nesta aula o primeiro resultado é um inventário, e não um vídeo. Você registra fal, Replicate e ElevenLabs hospedados, autentica cada um pelo navegador, grava o .mcp.json do projeto, libera só as ferramentas de consulta e deixa geração e alteração sob pergunta ou negadas.
Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
Diferencie conexão, autenticação e permissão
Conexão é o registro do servidor. Servidor remoto entra com claude mcp add --transport http <nome> <url>. Servidor local, um processo na sua máquina que conversa pelo stdio (a entrada e a saída padrão do terminal), entra com claude mcp add --transport stdio <nome> -- <comando>, e variáveis vão em --env CHAVE=valor. O escopo decide onde o registro mora: local, o padrão, vale só para você neste projeto; project grava o .mcp.json na raiz, que vai para o Git e aceita variáveis no formato ${VAR}; user vale para todos os seus projetos.
Autenticação é provar ao serviço quem você é. Na fal e na ElevenLabs, o OAuth abre o navegador, você entra na conta e o Claude Code guarda o token. Na Replicate, a página que o /mcp abre pede um API token, que você cria em replicate.com/account/api-tokens e cola nessa página do navegador. Nos três casos, nenhuma chave passa pelo chat nem pelo .mcp.json. Permissão é o que o agente pode chamar sem perguntar, e ela mora no settings.json, com a mesma lógica de allow, ask e deny da aula 07. A aula sobre o grau de poder de cada servidor aprofunda essa separação para empresas, e a de MCP no curso de agentes explica o protocolo por dentro.
Servidores do laboratório em 12/10/2026
| Servidor | Origem e transporte | Uso nesta aula |
|---|---|---|
| fal | Oficial, hospedado; HTTP em mcp.fal.ai/mcp-relay com OAuth | Buscar modelo, esquema e preço |
| Replicate | Oficial, hospedado; HTTP em mcp.replicate.com/sse, com recuo automático para SSE | Inspecionar catálogo e ferramentas |
| ElevenLabs | Oficial, hospedado; HTTP em api.elevenlabs.io/v1/mcp com OAuth | Inspecionar ElevenAgents |
| Kinocut | Comunitário, Apache 2.0; stdio local via uvx | Ler metadados de uma cópia de teste |
O Kinocut, antigo mcp-video, chegou à versão 1.16.1 em 06/10/2026 com 203 ferramentas tipadas.
Fonte: fal, Replicate, ElevenLabs e KyaniteLabs, documentação de MCP, 09/10/2026; Claude Code Docs, MCP, 12/10/2026
Registre os servidores no projeto
O bloco abaixo registra os quatro servidores pela linha de comando. Na ElevenLabs, use só o hospedado: o servidor local antigo saiu de linha, como a aula 01 registra. A documentação de operação do hospedado cobre ElevenAgents, os agentes de voz da empresa, e fala; o anúncio de 14/09/2026 promete também transcrição, música e efeitos, então conte só com o que aparecer no /mcp do seu workspace. No curso, a narração segue pela API, como na aula de Eleven v4. Alterações em agentes feitas pelo MCP são publicadas na hora, sem rascunho, na branch que o assistente indicar ou na main quando nenhuma for indicada; por isso o exercício nunca aponta para um agente em produção.
#!/usr/bin/env bash
# Registra os servidores MCP. Nenhuma chave passa por aqui: os hospedados autenticam pelo navegador, no /mcp.
set -euo pipefail
# fal oficial: relay com OAuth, conforme o guia de 02/10/2026. Escopo user.
claude mcp add --transport http --scope user fal https://mcp.fal.ai/mcp-relay
# Replicate oficial, hospedado. O SSE está obsoleto: desde a 2.1.265 (08/09/2026), um servidor http
# tenta HTTP primeiro e cai para SSE sozinho. No /mcp, a Replicate pede um API token colado na página do navegador.
claude mcp add --transport http --scope user replicate https://mcp.replicate.com/sse
# ElevenLabs hospedado. Escopo local (o padrão): vale só para você, neste projeto.
claude mcp add --transport http elevenlabs https://api.elevenlabs.io/v1/mcp
# Kinocut é comunitário: confira a interface da versão instalada antes de registrar.
command -v uvx >/dev/null || { echo "uvx ausente: instale o uv antes de seguir."; exit 1; }
uvx --from kinocut kino --help | head -20
read -r -p "Revisou o pacote kinocut e quer registrar? Digite SIM: " RESPOSTA
if [ "$RESPOSTA" = "SIM" ]; then
# Processo local por stdio. Recusa caminhos com .., symlinks e pastas de sistema, mas aceita
# qualquer saída absoluta e não se limita ao projeto: use só com cópias de teste.
claude mcp add --transport stdio kinocut -- uvx --from kinocut kino --mcp
fi
claude mcp list
# Dentro do Claude Code: /mcp, escolha o servidor e Authenticate, um de cada vez.

Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
Para a equipe inteira usar os mesmos servidores, registre-os com --scope project ou grave direto o .mcp.json abaixo na raiz video-ia. Ele vai para o Git, então nunca leva chave: os três hospedados autenticam pelo navegador, e um servidor que precise de credencial lê a variável do ambiente com ${VAR}.
{
"mcpServers": {
"fal": {
"type": "http",
"url": "https://mcp.fal.ai/mcp-relay"
},
"replicate": {
"type": "http",
"url": "https://mcp.replicate.com/sse"
},
"elevenlabs": {
"type": "http",
"url": "https://api.elevenlabs.io/v1/mcp"
},
"kinocut": {
"type": "stdio",
"command": "uvx",
"args": ["--from", "kinocut", "kino", "--mcp"],
"alwaysLoad": false
}
}
}
Libere só a consulta e deixe a geração sob pergunta
O MCP da fal expõe 11 ferramentas. Cinco só consultam: search_models, get_model_schema, get_pricing, search_docs e recommend_model. As outras seis executam, acompanham ou enviam arquivos: run_model, submit_job, check_job, get_job_result, cancel_job e upload_file. A geração é cobrada pela tabela da fal por execução, e não pela cota do seu plano Claude.
No settings.json, cada ferramenta MCP tem um nome no formato mcp__<servidor>__<ferramenta>, e a regra mcp__<servidor> sozinha cobre todas as ferramentas daquele servidor. Antes de gravar as regras, abra o /mcp e copie os nomes exatos que aparecem no seu workspace: a lista muda entre versões, e uma regra com nome errado não casa com nada. Nunca marque "sempre permitir" num servidor inteiro por conveniência.
O que cada tipo de ferramenta MCP recebe no settings.json
Eixo horizontal: Custo da chamadaEixo vertical: Efeito fora da sua máquina
Consulta gratuita e sem efeito: allow
- search_models, get_model_schema, get_pricing e search_docs da fal
- Listar o catálogo do Replicate
- Ler metadados de uma cópia com o Kinocut
Geração paga: ask
- run_model e submit_job da fal
- Rodar um modelo de vídeo no Replicate
- Sempre com fornecedor, ID, parâmetros e preço antes do sim
Alteração remota: deny
- Criar ou editar ElevenAgents, que publica na hora, sem rascunho
- upload_file e cancel_job enquanto não houver necessidade
- Qualquer escrita numa conta em produção
Escrita local: ask, só em cópia
- Cortes e conversões do Kinocut
- Nunca sobre midia/raw/
- O hook da aula 07 continua valendo
Mescle as regras abaixo no .claude/settings.json da aula 07, sem apagar o hook nem as permissões que já estão lá. A lista enabledMcpjsonServers aprova os servidores do .mcp.json que você quer ativos; o Kinocut fica de fora até você revisar o pacote. Depois, o script Python cria o inventário que registra o que cada servidor realmente mostrou.
{
"enabledMcpjsonServers": ["fal", "replicate", "elevenlabs"],
"permissions": {
"allow": [
"mcp__fal__search_models",
"mcp__fal__get_model_schema",
"mcp__fal__get_pricing",
"mcp__fal__search_docs",
"mcp__fal__recommend_model"
],
"ask": [
"mcp__fal__run_model",
"mcp__fal__submit_job",
"mcp__fal__check_job",
"mcp__fal__get_job_result",
"mcp__replicate",
"mcp__kinocut"
],
"deny": [
"mcp__fal__upload_file",
"mcp__fal__cancel_job",
"mcp__elevenlabs"
]
}
}
"""Cria logs/mcp-inventario.json, o registro do que cada servidor expõe.
É documentação de operação: não aplica permissão nenhuma. Quem impõe limite é
o settings.json. Salve em scripts/criar_inventario_mcp.py e rode na raiz video-ia com:
python3 scripts/criar_inventario_mcp.py
"""
import json
from pathlib import Path
arquivo = Path("logs") / "mcp-inventario.json"
arquivo.parent.mkdir(exist_ok=True)
if arquivo.exists():
raise SystemExit("O inventário já existe: atualize-o depois de revisar, sem sobrescrever.")
inventario = {
"data_referencia": "2026-10-12",
"natureza": "Registro didático; as permissões ficam em .claude/settings.json.",
"servidores": [
{
"nome": "fal",
"transporte": "http, OAuth",
"autenticado": False,
"ferramentas_observadas": [], # copie do /mcp, como aparecem
"liberadas": ["search_models", "get_model_schema", "get_pricing", "search_docs", "recommend_model"],
"geracao_paga_aprovada": False,
},
{
"nome": "replicate",
"transporte": "http, com recuo para SSE",
"autenticado": False,
"ferramentas_observadas": [],
"geracao_paga_aprovada": False,
},
{
"nome": "elevenlabs",
"transporte": "http, OAuth",
"autenticado": False,
"ferramentas_observadas": [],
"uso_no_curso": "Inspeção de ElevenAgents; narração e Scribe pela API.",
"alteracao_de_agentes_aprovada": False,
},
{
"nome": "kinocut",
"transporte": "stdio, local",
"origem": "comunitária, Apache 2.0",
"ferramentas_observadas": [],
"restricao_tecnica_de_pastas": "sem pasta permitida configurável; aceita saída absoluta: usar só cópias de teste",
"escrita_aprovada": False,
},
],
}
arquivo.write_text(json.dumps(inventario, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
print(f"Criado: {arquivo}")
Conectar os servidores e validar sem iniciar uma geração
Faça na ordem, um servidor de cada vez, na raiz video-ia.
Passo 1: Registre só os servidores que vai usar
Rode o bloco de registro; o Kinocut exige confirmação.
Deu certo quando: O claude mcp list mostra fal, replicate e elevenlabs.
Erro comum: Instalar um MCP comunitário achando que é oficial.
Passo 2: Autentique fal e Replicate pelo /mcp
Escolha o servidor e Authenticate; o navegador abre. Na Replicate, cole ali o API token da conta.
Deu certo quando: Cada servidor aparece autenticado e com ferramentas listadas.
Erro comum: Colar um token no prompt para contornar uma falha de login.
Passo 3: Inspecione o ElevenLabs hospedado
Leia a lista de ferramentas que o seu workspace recebeu.
Deu certo quando: Você sabe quais ferramentas de ElevenAgents e de fala estão presentes.
Erro comum: Pedir uma ferramenta que o servidor não oferece no seu workspace.
Passo 4: Grave as permissões mínimas
Mescle as regras no settings.json da aula 07.
Deu certo quando: As ferramentas de consulta rodam sem pergunta e run_model pede confirmação.
Erro comum: Liberar o servidor inteiro com mcp__fal em allow.
Passo 5: Crie e preencha o inventário
Rode o script e cole o prompt da aula.
Deu certo quando: O inventário lista as ferramentas observadas e o estado de autenticação.
Erro comum: Tratar o inventário como se ele aplicasse restrições.
Passo 6: Aprove só a consulta de descoberta
O agente propõe a busca antes de chamar.
Deu certo quando: Você recebe modelo, esquema e preço, e nenhum job foi criado.
Erro comum: Aprovar run_model junto com a consulta de preço.
Passo 7: Revise as aprovações concedidas
Abra /permissions e confira as regras ativas.
Deu certo quando: Nenhuma regra allow cobre geração ou alteração.
Erro comum: Marcar "sempre permitir" sem entender o efeito da ferramenta.
No fim você tem: Servidores autenticados, permissões mínimas gravadas, inventário preenchido e nenhuma geração disparada.
Servidores grandes e servidores que caem
Deixe o Kinocut entrar pela busca de ferramentas
Com 203 ferramentas, o Kinocut encheria o contexto de descrições em todo turno. O campo "alwaysLoad": false no .mcp.json da seção de registro, aceito desde a versão 2.1.287, de 01/10/2026, adia todas as ferramentas do servidor para a busca de ferramentas: o Claude carrega a descrição de uma só quando precisa dela. Desde a 2.1.296, de 09/10/2026, cada descrição de ferramenta MCP vai até 4.096 caracteres, e o que passa disso é cortado. Depois da mudança, confira no /mcp que o Kinocut continua conectado; se ele sumir, revise a vírgula antes do campo novo.
Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
Reconecte e reautentique sem perder o lote
Num lote longo, um servidor pode cair ou pedir mais permissão no meio do caminho. Desde 15/09/2026, na versão 2.1.273, o Claude Code avisa quando a reconexão automática desiste e aponta para o /mcp; desde a 2.1.284, de 28/09/2026, /mcp reconnect all reconecta fal, Replicate e ElevenLabs de uma vez. Desde 02/10/2026, na versão 2.1.288, quando um servidor pede escopo OAuth a mais no meio de uma chamada, o Claude Code interrompe e pede que você autentique de novo: nada é gerado sem isso, e o login continua no navegador, nunca no chat.
Depois de reconectar, rode /mcp e confira que cada servidor voltou autenticado antes da próxima consulta. Se o Kinocut, que roda por stdio, quebrar depois da versão 2.1.292, que passou a negociar o protocolo MCP 2026-07-28 por padrão, abra a sessão com MCP_PROTOCOL_NEGOTIATION=legacy e anote o caso no inventário. Erro comum: autenticar de novo com outra conta, que não é a da cota; confira o e-mail na página de login antes de aprovar.
Se a figura ultrapassar a área visível, deslize para os lados. Pelo teclado, foque a figura e use as setas.
# Dentro do Claude Code, quando um servidor cai no meio do lote:
# /mcp mostra o estado e a autenticação de cada servidor
# /mcp reconnect all reconecta todos de uma vez (desde a 2.1.284)
# Kinocut quebrou com o protocolo 2026-07-28 (padrão desde a 2.1.292)?
# Abra a sessão com a negociação antiga e anote o caso no inventário.
MCP_PROTOCOL_NEGOTIATION=legacy claude
# Em claude -p e no SDK, o primeiro turno espera os servidores MCP subirem.
# Desde a 2.1.274, a espera tem teto em milissegundos (15 s aqui, escolha do exercício).
CLAUDE_CODE_MCP_STARTUP_WAIT_MS=15000 claude -p "Liste os servidores MCP conectados e pare."
Decida quais operações podem avançar
Se a tarefa é narração ou transcrição, use a API da ElevenLabs com eleven_v4 ou scribe_v2, e não o MCP. Quando não houver preço ou esquema que dê para conferir, não autorize a geração. Se um servidor comunitário pedir acesso amplo, rode-o num ambiente separado, só com cópias de teste. E se o modelo devolvido for um preview com data de saída anunciada, escolha antes uma alternativa estável, pelos critérios da aula de escolha do modelo de vídeo.
Para os três vídeos semanais da Cozinha da Rafa, o agente consulta na fal opções de b-roll gerado, as imagens de apoio como a cartola dourando na frigideira, sem gerar nada. A resposta é uma tabela com fornecedor, ID, duração e preço por segundo; só depois do sim da Rafa a primeira cena é gerada, na aula de geração por API com polling.
Guia prático: consulta de preço sem tela e registro de toda tentativa de geração
Com os servidores conectados e as permissões mínimas da aula, dois usos aparecem na rotina: conferir preços toda semana sem abrir sessão e saber depois quem tentou gerar o quê. Aqui você roda a consulta da fal em claude -p, o modo sem interface que responde e sai, só com o servidor que ela precisa, e grava num arquivo de custos/ cada chamada de geração antes mesmo da pergunta de permissão.
Funções, casos de uso e aplicações
Funções
Recursos de MCP para rotina e auditoria no projeto video-ia
| Função ou recurso | O que faz | Quando usar | Desde |
|---|---|---|---|
| Servidor de documentação da fal (fal.ai/docs/mcp) | Busca só a documentação pública; não acessa a conta nem roda modelo | Explorar a fal com alguém da equipe que ainda não tem conta | Em vigor em 12/10/2026 |
| get_pricing com vários modelos | Até 50 IDs separados por vírgula numa chamada; a resposta pode ficar em cache por cinco minutos e, se vier limitada, traz retry_after_seconds | Comparar o preço de todos os candidatos a b-roll de uma vez | Em vigor em 12/10/2026 |
| --mcp-config com --strict-mcp-config | A sessão usa só os servidores do arquivo indicado e ignora os do projeto | Rotina em claude -p que precisa só da fal, sem Kinocut nem ElevenLabs | Em vigor; desde a v2.1.246 não espera aprovação dos servidores ignorados |
| Hook PreToolUse com matcher mcp__fal__(run_model|submit_job) | Roda antes de cada chamada de geração da fal, mesmo as que depois serão negadas | Trilha de auditoria em custos/ com hora, ferramenta e parâmetros | Em vigor em 12/10/2026 |
| MAX_MCP_OUTPUT_TOKENS | Teto de tokens da resposta de uma ferramenta MCP: aviso acima de 10 mil e corte em 25 mil por padrão | Catálogos longos do search_models que estouram a resposta | Em vigor em 12/10/2026 |
| Imagem de ferramenta MCP salva em arquivo | Além de mostrar a imagem, o Claude Code grava o original na pasta tool-results da sessão | Abrir a prévia gerada com Read ou ffmpeg e passar pela rubrica da aula 11 | 25/09/2026 (v2.1.283) |
| Pedido de URL que espera "I'm done, continue" | Quando o servidor pede um passo no navegador, a chamada aguarda você terminar lá | Login ou autorização da ElevenLabs no meio de uma tarefa | 02/10/2026 (v2.1.288) |
No MCP hospedado da ElevenLabs, a fala sai como link de download de curta duração e cada ferramenta pode ser ligada, desligada ou posta sob confirmação no cliente; há endereços próprios para as regiões com residência de dados, como a UE.
Fonte: fal, MCP server; Claude Code Docs, MCP e hooks; changelog v2.1.283 e v2.1.288; 12/10/2026
Casos de uso
Analista de mídia de uma escola de inglês em Fortaleza que usa b-roll gerado nos anúncios
Marketing digital, criativos para mídia paga
Dor
Os preços dos modelos de vídeo mudavam entre uma campanha e outra, e ela só descobria na fatura. Ela esquecia de abrir uma sessão toda semana para perguntar.
Solução
Ela agendou às segundas a consulta em claude -p com o arquivo config/mcp-consulta.json, só com a fal, liberando search_models e get_pricing e negando run_model e submit_job na linha de comando.
Resultado
O que observar: a cada segunda, se o arquivo logs/precos-<data>.json aparece e se algum modelo da lista mudou de preço ou de unidade de cobrança antes da próxima campanha.
Cenário construído para fins didáticos. Números não correspondem a cliente específico.
Coordenadora de produção de uma edtech de São Paulo com quatro editores usando a mesma conta da fal
Educação, vídeos de cursos
Dor
A conta de créditos subiu num mês e ninguém sabia que vídeo tinha gerado as cenas, porque o aceite da permissão acontecia em sessões de pessoas diferentes.
Solução
No projeto, ela incluiu o hook que grava cada chamada de geração em custos/mcp-tentativas.jsonl, com hora, ferramenta e nomes de parâmetros, e passou a cruzar o arquivo com o extrato da fal.
Resultado
O que observar: no fechamento do mês, se cada cobrança do extrato tem uma linha correspondente no registro e quantas tentativas foram negadas na pergunta.
Cenário construído para fins didáticos. Números não correspondem a cliente específico.
Na prática
Três peças, todas na raiz video-ia. O arquivo config/mcp-consulta.json traz só a fal. O hook registra a tentativa e libera a chamada com saída 0: quem decide continua sendo a regra ask do settings.json. Por fim, a consulta em claude -p usa a lista de liberação e a de negação na própria linha de comando, então nenhuma geração roda nem que o pedido peça.
"""Hook PreToolUse do MCP da fal. Só registra; a decisão é da regra ask do settings.json."""
import datetime
import json
import os
import sys
from pathlib import Path
try:
dados = json.load(sys.stdin)
except (ValueError, TypeError):
sys.exit(0) # registro não pode impedir o trabalho: entrada estranha passa sem linha
entrada = dados.get("tool_input") or {}
linha = {
"hora": datetime.datetime.now().isoformat(timespec="seconds"),
"ferramenta": dados.get("tool_name"),
# Os nomes exatos dos campos mudam entre versões do servidor: guarda todos os nomes.
"parametros": sorted(entrada.keys()),
"sessao": dados.get("session_id"),
}
destino = Path(os.environ.get("CLAUDE_PROJECT_DIR", ".")) / "custos" / "mcp-tentativas.jsonl"
destino.parent.mkdir(exist_ok=True)
with destino.open("a", encoding="utf-8") as arquivo:
arquivo.write(json.dumps(linha, ensure_ascii=False) + "\n")
sys.exit(0){
"hooks": {
"PreToolUse": [
{
"matcher": "mcp__fal__(run_model|submit_job)",
"hooks": [
{
"type": "command",
"command": "python3 \"$CLAUDE_PROJECT_DIR/.claude/hooks/registrar_mcp.py\"",
"timeout": 5
}
]
}
]
}
}#!/usr/bin/env bash
# Rode na raiz video-ia. Autentique a fal antes, numa sessão interativa, pelo /mcp.
set -euo pipefail
mkdir -p config logs
test -e config/mcp-consulta.json || cat > config/mcp-consulta.json <<'EOF'
{ "mcpServers": { "fal": { "type": "http", "url": "https://mcp.fal.ai/mcp-relay" } } }
EOF
# Troque a lista pelos IDs que você está avaliando (até 50 numa chamada de get_pricing).
MODELOS="$(cat config/modelos-candidatos.txt)"
claude -p "Chame get_pricing da fal uma vez com estes IDs: $MODELOS. Devolva só JSON:
lista de {id, preco, unidade}. Onde faltar dado, escreva [conferir]. Não gere nada." \
--mcp-config config/mcp-consulta.json --strict-mcp-config \
--allowedTools "mcp__fal__get_pricing,mcp__fal__search_models" \
--disallowedTools "mcp__fal__run_model,mcp__fal__submit_job,mcp__fal__upload_file" \
--output-format json > "logs/precos-$(date +%F).json"
echo "Preços em logs/precos-$(date +%F).json"Ligar a consulta sem tela e a trilha de tentativas
Passo 1: Grave o hook e mescle o trecho no settings.json
O hook fica em .claude/hooks/registrar_mcp.py, ao lado do guarda.py.
Deu certo quando: O /hooks mostra dois PreToolUse: o da aula e o do MCP da fal.
Erro comum: Escrever o matcher como mcp__fal, que sem regex casa só com um nome exato e não pega nada.
Passo 2: Teste o registro numa sessão interativa
Peça uma geração de teste e responda não na pergunta de permissão.
Deu certo quando: custos/mcp-tentativas.jsonl ganha uma linha mesmo com a chamada negada.
Erro comum: Pôr onFailure: block neste hook e impedir o trabalho porque o registro falhou.
Passo 3: Crie config/modelos-candidatos.txt e rode a consulta
Uma linha com os IDs separados por vírgula, tirados do search_models.
Deu certo quando: logs/precos-<data>.json tem preço e unidade por modelo e nenhum job foi criado.
Erro comum: Rodar sem --strict-mcp-config e carregar todos os servidores do projeto na rotina.
Passo 4: Ajuste o teto se o catálogo vier cortado
MAX_MCP_OUTPUT_TOKENS=50000 antes do claude -p, só se o aviso de 10 mil tokens aparecer.
Deu certo quando: A resposta do search_models chega inteira.
Erro comum: Subir o teto por padrão e pagar contexto em toda consulta.
No fim você tem: Preços da semana em logs/ sem abrir sessão e toda tentativa de geração registrada em custos/.
Armadilhas
Rotina de MCP que abre a carteira contra rotina que só consulta
Evite
Coluna a evitar
- claude -p com --dangerously-skip-permissions para a rotina não parar
- Repetir get_pricing em seguida quando a resposta vem limitada
- Tratar o aceite no agente como bloqueio do servidor: a fal avisa que é só instrução do cliente
- Copiar para a rotina o .mcp.json inteiro do projeto
- Pedir narração pelo MCP da ElevenLabs e guardar o link, que expira
Prefira
Coluna recomendada
- Lista de liberação e de negação na própria linha de comando
- Esperar o retry_after_seconds e consultar os 50 IDs numa chamada só
- Regra ask para gerar e registro da tentativa no hook
- Arquivo de configuração com um servidor e --strict-mcp-config
- Narração pela API, como na aula de Eleven v4, com o arquivo salvo em audio/
Glossário rápido
MCP
Model Context Protocol, protocolo que liga o agente a ferramentas externas como uma tomada padronizada: cada serviço expõe ferramentas com nome, esquema e descrição.
servidor MCP hospedado
Servidor que roda na nuvem do fornecedor e se conecta por URL, por HTTP, sem instalar nada na sua máquina; o SSE está obsoleto e só entra como recuo automático.
stdio
Entrada e saída padrão do terminal; é por ela que um servidor MCP local, rodando como processo na sua máquina, conversa com o agente.
escopo do MCP
Onde o registro mora: local (padrão, só você neste projeto), project (grava o .mcp.json, vai para o Git) ou user (todos os seus projetos).
.mcp.json
Arquivo na raiz do projeto com os servidores MCP da equipe; aceita ${VAR} para ler do ambiente e nunca deve conter chave.
OAuth no MCP
Login pelo navegador que entrega ao Claude Code um token do serviço, sem chave colada no chat.
regra mcp__servidor__ferramenta
Nome de uma ferramenta MCP nas permissões do settings.json; mcp__servidor sozinho cobre todas as ferramentas daquele servidor.
ferramenta de descoberta
Ferramenta MCP que só consulta, como busca de modelo, esquema e preço; não gera mídia nem cobra execução.
Registre os servidores, grave as permissões mínimas e faça uma consulta de descoberta. Está pronto quando fal, Replicate e ElevenLabs aparecem autenticados no /mcp, a Replicate está registrada como http, o .mcp.json está na raiz sem segredo, logs/mcp-inventario.json lista as ferramentas que realmente apareceram, a consulta da fal devolveu modelo, esquema e preço sem nenhum job criado e nenhuma regra allow cobre geração ou alteração. Com isso, a aula de subagentes pode dividir o trabalho sem abrir a carteira.
Seu caderno neste capítulo
Abrir o caderno completoSelecione um trecho do capítulo para destacar ou anotar. Nos vídeos e áudios, use Anotar este momento. No teclado, selecione com Shift e as setas e use Alt+Shift+D para destacar ou Alt+Shift+N para anotar.
Salvo neste navegador. Entre na sua conta para levar o caderno a outros aparelhos.
Entre na sua conta para compartilhar o que aprendeu e convidar alguém para estudar com você.
Conexões deste capítulo
Veja o que estudar antes e para onde seguir depois, explore os conceitos e compare abordagens em outros cursos. Sugestões marcadas como “sugerido pelo grafo” vêm dos assuntos em comum, não do índice do curso.
Estude antes
- CursoClaude Code CLI: Programação com IA
- Usar o mapa do curso e o glossário mínimosugerido pelo grafoApresenta o conceito “MCP”, usado em “Conectar fal, Replicate e ElevenLabs por MCP com permissões mínimas”.
- Veja o que o Claude Code faz antes de instalarsugerido pelo grafoApresenta o conceito “Claude Code”, usado em “Conectar fal, Replicate e ElevenLabs por MCP com permissões mínimas”.
- CursoAstra profundosugerido pelo grafoA quinta parte do Astra planeja o vídeo e edita o material bruto com o modelo dirigindo a ferramenta. O curso de vídeo com IA aprofunda esse trabalho com Claude Code, Codex e ElevenLabs, do roteiro à publicação. O grafo já sugeria esta ordem pela regra de entrada da trilha; com a ordem anterior curada, ela passa a ser declarada (Etapa 4, wave 3).
Depois, siga para
- CursoFrontends com Vibecodingsugerido pelo grafo21 capítulos de “Frontends com Vibecoding” usam conceitos apresentados em “Vídeo com IA: Claude Code, Codex e ElevenLabs”.
- CursoDo Agile ao Agentic Operating Modelsugerido pelo grafo5 capítulos de “Do Agile ao Agentic Operating Model” usam conceitos apresentados em “Vídeo com IA: Claude Code, Codex e ElevenLabs”.
- CursoAgentes de IA Autônomos: Do Conceito à Produçãosugerido pelo grafo7 capítulos de “Agentes de IA Autônomos: Do Conceito à Produção” usam conceitos apresentados em “Vídeo com IA: Claude Code, Codex e ElevenLabs”.
- CursoLLM FinOps: o custo da IA para quem assina o orçamentosugerido pelo grafo4 capítulos de “LLM FinOps: o custo da IA para quem assina o orçamento” usam conceitos apresentados em “Vídeo com IA: Claude Code, Codex e ElevenLabs”.
Conceitos deste capítulo
O mesmo assunto em outros cursos
- Agentes de IA Autônomos: Do Conceito à ProduçãoMCP (Model Context Protocol)Examinar conexões de MCP (Model Context Protocol)
- MCP para quem decideInventariar o que já roda nas máquinas do timeExaminar conexões de Inventariar o que já roda nas máquinas do time
- Software e IA para executivosConferir quem publicou cada plugue que liga o agente aos sistemasExaminar conexões de Conferir quem publicou cada plugue que liga o agente aos sistemas
- Skills de IA com Vibecoding e TerminalModel Context Protocol: o USB-C da IAExaminar conexões de Model Context Protocol: o USB-C da IA
Voltar ao capítulo anterior: Instalar e invocar skills de vídeo no Claude Code
Leve uma ideia para a prática
Escolha uma atividade no painel e volte a este curso quando quiser.
Atividades e evolução ficam reunidas no painel da sua conta.
Laboratórios ao vivo deste curso
Cada laboratório monta a biblioteca real dentro da aula, com controles para você mexer e o código do exemplo para copiar. O texto de reserva descreve a demonstração para quem lê sem JavaScript. O link abre o capítulo já no ponto do laboratório.
MediaRecorder, Canvas 2D e Long Animation Frames (plataforma)
Grave a cena em tempo real e veja os quadros que se perdem
Suba as partículas, force um bloqueio de 300 ms e grave seis segundos; compare com o render quadro a quadro desta aula.
Pacote
Abrir no capítuloMontar vídeo em HTML com HyperFrames e escolher entre ele e o Remotionsem pacoteMotion
Ver agentes em paralelo trocando mensagens numa linha do tempo
Reproduza a cena, percorra o tempo pelo controle e compare o tempo de parede com a soma das barras de cada agente.
Pacote
Abrir no capítuloParalelizar cenas com subagentes sem estourar o limite das APIsmotionReact (sem dependência extra), com as APIs do Veo e do fal.ai
Prompt de vídeo em cinco camadas, pronto para a API
Escolha plano, câmera, luz, ação e áudio e copie o prompt e o JSON para o Veo ou para o fal.ai.
Pacote
Abrir no capítuloEscrever prompt de vídeo em cinco camadas e manter o personagem consistentereactReact (sem dependência extra), com o comando para o FFmpeg
Corte o vídeo apagando palavras da transcrição
Aperte as palavras para removê-las, ligue a remoção de pausas e copie o comando FFmpeg e a legenda SRT gerados.
Pacote
Abrir no capítuloRemover pausas e reenquadrar o vídeo de 16:9 para 9:16 com legenda por palavrareactReact (sem dependência extra)
Quanto custa cada etapa do seu pipeline de vídeo
Troque a ferramenta de cada etapa e o percentual de b-roll e veja qual etapa pesa no custo por minuto e por vídeo.
Pacote
Abrir no capítuloOrquestrar o pipeline com etapas idempotentes e teto de gastoreact
Capítulos vizinhos em Vídeo com IA: Claude Code, Codex e ElevenLabs
- 07Estruturar o projeto de vídeo para o Claude Code operar sem improvisar
- 08Instalar e invocar skills de vídeo no Claude Code
- 09Conectar fal, Replicate e ElevenLabs por MCP com permissões mínimas
- 10Paralelizar cenas com subagentes sem estourar o limite das APIs
- 11Revisar quadros com a visão do Claude e uma rubrica escrita