IA local com 64 GB de VRAM em 2 GPUs: até onde esse setup consegue ir?

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: Portuguese

Original video: IA local com 64 GB de VRAM em 2 GPUs: até onde esse setup consegue ir? · Channel: AI ProgBr · 24:34 · Watch on YouTube

Topics: AI agents, AI developer tools, AI content generation, AI infrastructure and hardware, Local and open-source models

Summary

O vídeo apresenta um computador com duas GPUs Intel Arc e 64 GB de VRAM, usado para testar modelos locais, geração de imagens e vídeo. O apresentador compara o desempenho de versões Q4 e FP8 do Qwen 3.8 27B, incluindo velocidade de geração e processamento de prompt com uma ou duas GPUs. Em seguida, demonstra um fluxo com Open Code e ComfyUI para organizar workflows e gerar imagens por meio de MCP. O teste de geração de vídeo mostra que o setup também consegue executar essa tarefa, embora ela leve vários minutos e se beneficie de mais memória no computador.

Key points

A máquina tem duas GPUs Intel Arc, com 64 GB de VRAM combinada, e 32 GB de RAM no momento da gravação.
O modelo Qwen 3.8 27B em formato Q4 alcança altas velocidades de geração, especialmente ao usar duas GPUs.
A versão Q4 perde velocidade de processamento de prompt quando executada em duas GPUs, devido à falta de otimização da engine.
A versão FP8 do Qwen 3.8 27B oferece geração mais lenta que a Q4 em alguns testes, mas mantém maior precisão.
Com uma GPU dedicada ao modelo e outra ao ComfyUI, o apresentador gera imagens em lote usando MCP.
O vídeo de quatro segundos gerado com Minimax H3 levou 291 segundos para ser produzido.
O apresentador destaca que contexto maior com duas GPUs exigiria testes para verificar a recuperação de informações ao longo do contexto.

Chapters

Start	Chapter	Summary
00:00	Apresentação do setup e do modelo Q4	O apresentador mostra o computador com duas GPUs e introduz os modelos locais que pretende testar.
02:07	Testes de velocidade em uma GPU	O modelo Q4 é testado em geração de texto, código e processamento de prompt.
04:46	Adaptação para duas GPUs	O apresentador explica a modificação da engine e mede o desempenho do modelo usando as duas placas.
08:36	Contexto maior e limitações de desempenho	São discutidos os ganhos de velocidade, a possibilidade de ampliar o contexto e a queda no processamento de prompt.
12:20	Comparação entre Q4 e FP8	O vídeo compara velocidade de geração e processamento de prompt entre as versões quantizada e FP8 do Qwen 3.8 27B.
14:33	ComfyUI e organização de workflows	Uma GPU fica dedicada ao ComfyUI enquanto o apresentador usa um modelo para categorizar e reorganizar workflows.
18:08	Geração de imagens por MCP	O modelo se conecta ao ComfyUI e gera uma série de imagens de animais com o mesmo estilo.
21:25	Geração de vídeo e próximos testes	O apresentador gera um vídeo com Minimax H3, comenta o tempo de execução e cita testes que ficaram para outro vídeo.

Quotes

Isso daqui é absurdo para um modelo local, pelo menos na minha experiência. — 04:13

Essa é uma das coisas que a gente pode destacar de ganho quando usa duas placas. — 08:36

Tem tarefas e tarefas; para algumas tarefas eu vou preferir esse aqui, para outras, o de 4 bits. — 13:59

Hoje a gente consegue gerar 10 imagens em menos de 2 minutos de graça. — 21:25

Vídeo ainda é complicado, por isso que é caro ainda fazer vídeo. — 22:27

Concepts and entities

Intel Arc A770, Qwen3.8 27B, vLLM, SXL3, ZimaOS, ComfyUI, OpenCode, MCP, MiniMax H3, tensor parallelism, Liquid

Full transcript (original language)

00:00 Na última semana eu passei boa parte do meu tempo configurando a minha nova máquina aqui, que é um computador com duas Arc A70. Cada Arc A70 tem 32 GB de VRAM, então no total a gente tem 64 GB de VRAM. Eu ainda estou longe de acabar, mas eu já preparei vários workflows para funcionar dentro dessa máquina, que nesse momento está com 32 GB de RAM, né? Em breve vai ter um pouco mais. Mas com 32 a gente já consegue fazer bastante coisa e eu quero compartilhar com vocês o que é que dá para fazer aqui nesse vídeo. Vamos lá para tela. Bem, estou aqui no meu ZimaOS, está? Eu estou falando do ZimaOS, está uma bagunça

00:31 porque eu ainda estou brincando um pouco, testando alguns formatos de modelos, algumas engines. Eu ainda não bati o martelo em muita coisa. Mas o que eu bati o martelo nesse momento foi o seguinte: um dos modelos que eu queria rodar nesse setup era o Qwen 3.8 27B, que é um modelo que eu considero um dos melhores modelos para rodar em hardwares que não tem tanta VRAM assim. Inicialmente eu estava rodando via vLLM, uma versão feita para Intel, e essa versão do modelo aqui ó, do Sergio Bi, Qwen 3.8 27B, GPTQ 4 sim G128 MTP BF16.

01:05 Difícil falar esse nome, tá? Mas era esse aqui o modelo que eu estava rodando e ele roda muito bem. Só que ele tinha dois problemas. O primeiro é que em uma placa só a gente conseguia no máximo ali 160, 170, abaixo um pouco de 200.000 tokens. Esse modelo ele tem a capacidade até 262.000 tokens de janela de contexto. A gente conseguia ficar abaixo disso, mas se eu tivesse usando as duas placas, a gente conseguia chegar no contexto inteiro. O problema é que conforme eu ia avançando, tentando usar ele, eu comecei a perceber que ele se

01:35 perdia um pouco. Ele tinha um pouco de dificuldade de chegar no resultado. Então eu estou achando que esse modelo ele está com algum probleminha. E aí eu fui buscar alguma outra versão, outro formato, né? E cheguei ao SXL3. Assim como o do Sergio, esse daqui também é uma versão de 4 bits, está? É uma versão quantizada, mas a diferença é que ele cabe em uma placa só com contexto inteiro. Então a gente consegue carregar os só. E para rodar esse modelo, a gente roda numa versão modificada do vLLM, também preparada para Intel, só que o desenvolvimento dela foi feito por um

02:07 usuário, acho que é OX0, OX0, algo assim. Ele ainda não adaptou essa engine para rodar em duas placas Intel. Deixa eu dar um spoiler aqui. Eu fiz isso e a gente vai ver já já. Mas, nesse momento, o nosso Coinzito tá aqui carregado, ó, ele tá em uma placa só, consumindo quase toda a VRAM dessa placa e, inclusive, esse painel aqui foi ele que fez. Eu já tô com ele carregado e conectado aqui. Vamos testar um pouquinho a velocidade dele, ó, vou dar aqui um oi. Ó, a gente conseguiu aqui em torno de 67 tokens por segundo. Não é nada mal, né? Mas, vamos dar um prompt que ele consiga responder um pouquinho mais. Conte uma história.

02:39 Então, aqui a gente consegue ver a velocidade dele em tempo real. E ignora isso daqui, tá? Esse token instantâneo não tá muito certo, esse daqui tá certo. 55 tokens por segundo é a velocidade que a gente tá conseguindo com esse modelo. Deixa eu atualizar aqui que eu vou pedir para ele criar um código. Vou pedir para ele criar aqui um código para que ele receba o endereço de uma pasta, leia todas as imagens dessa pasta e gere uma versão de cada imagem com metade do tamanho. Eu vou fazer o seguinte, vou adicionar mais um detalhe aqui, ó, todas as imagens são JPEG, JPG. Se não, ele pode ter que considerar alfa e etc. e aí

03:10 ele vai pensar demais. Mas, aqui, ó, a gente consegue ter uma ideia da velocidade que ele tá atingindo. Eu acho que tá um pouco mais rápido, vamos ver. No final, a gente vai saber. Ó, tá gerando aqui para a gente o código e aqui a gente conseguiu uma velocidade quase 70 tokens por segundo. Agora, tem uma coisa que é muito interessante desse modelo e eu vou te mostrar agora. Ó, eu tô aqui no site da Liquid e eles acabaram de lançar um modelo que eu acho que pode ser bem interessante, o LFM 2.5 24B. Deixa eu copiar esse texto aqui. Eu vou pedir para ele aqui, ó, resuma em um parágrafo. Olha, ele resumiu aqui

03:42 para a gente em um parágrafo e entregou para a gente a 60 tokens por segundo. Mas, olha a parte interessante disso. Ele processou o prompt a 2.610 tokens por segundo. O prompt, né, esse texto aqui tinha 3.000 tokens, então levou um pouco mais de 1 segundo para ele processar tudo. E aqui que eu tô vendo a grande vantagem, tá? Se a gente tivesse rodando esse mesmo modelo quantizado a 4 bits aqui no meu Mac M3 Ultra, a gente teria em torno de 400 tokens por segundo de processamento de prompt. Pois é, um salto gigantesco

04:13 aqui. Vamos pegar um texto um pouco maior, vou pegar um livro aqui, a mesma coisa, resuma em um parágrafo. E esse texto um pouco maior vai levar um pouquinho mais de tempo, né? Ó, esse texto tinha 10.000 tokens e ele processou em 4 segundos, a 2.700 tokens por segundo. Isso daqui é absurdo, absurdo para um modelo local, pelo menos na minha experiência aqui. É papo de conseguir isso daqui na 5090, que é uma placa que custa quatro vezes essa placa daqui. E aqui começa a grande vantagem das duas placas. Primeira coisa, vamos rodar esse mesmo modelo agora em duas placas. Mas antes disso, deixa eu só te

04:46 mostrar um detalhe para a gente ficar de olho. Criei um site, não importa, não quero nem que ele termine aqui, mas o que a gente pode ver aqui, enquanto ele tá processando aqui, ó, a nossa taxa de potência tá lá quase no limite de 280 W, tá? Eu vou parar ele aqui agora, ela instantaneamente cai aqui e aí vou carregar o mesmo modelo em duas placas. Para eu conseguir carregar esse modelo em duas placas, eu tive que modificar a engine, porque a engine, até então, e eu preciso falar até então, porque as coisas mudam tão rápido que pode ser que nesse segundo que eu tô gravando já dê suporte a duas placas, mas até ontem não dava suporte e eu fiz a modificação

05:20 dessa engine usando esse modelo, inclusive, tá? Usando esse modelo para fazer o planejamento. Então, pedi para ele varrer o projeto, me ajudar com o plano para modificar o que fosse necessário para a gente conseguir carregar em duas placas e, spoiler, funcionou. Eu só não consegui executar o plano com o modelo porque eu precisava das duas placas livres para poder testar. Então, a gente executou com o DeepSeek V4.1, mas foi ele que fez o o Então, isso demonstra a qualidade do que que a gente tem em mãos aqui. Uma coisa que ajudou bastante também a gente conseguir fazer isso funcionar foi uma

05:52 metodologia, né? De ter especificações, de criar um plano detalhado e separado por tarefas, de criar testes e gateways para ele só poder ir para a próxima fase depois que terminar a fase anterior. Sabe onde é que você pode aprender tudo isso? No meu curso de IA para Devs, que eu vou dar até um espaço aqui para o banner aparecer aqui embaixo, né? Vai estar aparecendo aqui embaixo nesse momento. Você pode clicar no link aqui na descrição ou escanear o QR code que está aparecendo para você agora, se inscrever lá no nosso curso para você aprender também tudo sobre ferramentas como Pen Code, conceitos de inteligência artificial e muito em breve a gente vai ter esse módulo de specs no ar com

06:24 alguns projetos incríveis. Nesse momento ainda estou produzindo essas aulas, não está disponível, mas já se inscreve lá e já vai assistindo todas as aulas até a gente chegar nesse módulo. Prontinho, modelo carregado, eu vou dar um oi agora para ele e olha isso, 84 tokens por segundo. Mas às vezes a gente tem um golpe de sorte. Vamos pedir um pouco mais. Crie uma história. Aqui a gente pode ver ele criando a nossa história, ó. Parece rápido mesmo, hein? Mas lembra que eu falei para a gente olhar para cá, ó. Uma coisa importante é que aqui agora

06:55 a gente não bateu mais o topo da potência. E a gente conseguiu aqui em torno de 65 tokens por segundo. Agora eu vou pedir para ele criar um código Python para inverter as cores de uma imagem e a gente pode ver que, olha só, quando eu aperto aqui o enter, as duas placas começam a trabalhar, mas nenhuma delas atinge aquele topo, né? Aqui, ó, para código a gente conseguiu 91 tokens por segundo. Isso é bizarro, né? 91 tokens por segundo, cara. Vamos pedir para ele criar uma página web, então? Deixa eu zerar aqui para ele não pegar o contexto. Eu olhei aqui para o lado e vi que eu tenho aqui uma lupa que eu

07:28 precisei usar, né? Por por causa do meu acidente com o computador. Se você não sabe do que que eu estou falando, depois você dá uma olhada no vídeo que vai estar aqui no card que eu falo sobre a montagem desse computador e o que que deu ruim. Então, vou pedir para ele criar uma página web sobre lupas. Vamos ver aqui o planejamento dele, como é que tá indo, ó. A gente tá conseguindo uma boa velocidade aqui também, pelo visto. E mais uma vez destacando que com as duas placas a gente não atinge, ou pelo menos não atinge tão rápido, o máximo de potência, né? A gente não quer ficar rodando a placa no máximo de potência o tempo todo. Inclusive, eu ainda não capeei elas, mas eu acho que vou dar uma

08:00 diminuída aqui, principalmente nessa daqui, que ela é ela vai um pouco além, né? Essa daqui é a ASRock, essa daqui é a da Intel. Vamos deixar ele pensar aqui um pouco e vamos olhar no final quando ele criar a página quantos tokens a gente tem no contexto e qual foi a velocidade que ele conseguiu. Olha essa velocidade, hein? Tá criando aqui a página. Eu acho que a gente vai ter ali uns 70, 80 tokens por segundo. Se bem que também vai depender do tamanho disso aqui, né? Porque se a gente tiver um contexto muito grande, conforme vai aumentando, a velocidade ela vai caindo um pouco. Mas eu acho que ainda tá muito boa aqui. Olha só, no total ele gerou 25.000 tokens a uma média de 90 tokens

08:36 por segundo. 25.000 tokens não é tão pouco assim, não. Com esse nível aqui, 25.000 tokens, achei que ia ser bem menos, ia ser 70 tokens por segundo, que já seria excelente. E essa é uma das coisas que a gente pode destacar de ganho quando a gente usa duas placas. Então a gente tem um aumento da velocidade. No meu caso, eu queria mesmo tentar diminuir aqui o consumo de potência em cada placa para ela não ficar no limite. No final das contas, isso aqui só vai valer a pena se a gente for aumentar o contexto também, porque essa seria uma segunda vantagem. A gente poderia ter um contexto maior. Se a gente consegue ali 260.000 tokens em uma placa, a gente conseguiria em torno de

09:10 500.000 tokens nas duas. Mas para isso a gente precisa usar Rope e aí a gente precisaria testar bastante para ver se os dados não tão se perdendo. É o teste da agulha no palheiro. Quando você aumenta o contexto, você precisa ver se você tá conseguindo recuperar informações, principalmente ali do meio, que é onde o modelo se perde um pouco. Eu não fiz esse teste ainda e não ajustei a engine para isso. Inclusive, já vou te falar de uma desvantagem que a gente acabou tendo aqui, muito por conta dessa otimização que ainda não foi feita nessa engine. O meu objetivo era conseguir rodar nas duas placas, tá? Nem

09:41 era conseguir rodar bem, era só conseguir rodar. Por acaso, a gente conseguiu um ganho de velocidade, mas a gente perdeu em outro lugar. Já já eu te explico. Primeiro, deixa eu ver esse site aqui, como é que ficou. Então, esse aqui é o nosso site, ó. Nosso site sobre lupas. Tudo ampliado. Ó lá. Maneiro demais. Vamos rolando aqui embaixo, ó. Seis instrumentos, um ofício. Ah, a gente não tem as imagens,

10:11 infelizmente. Quero imagens. Mas a gente tem aqui, ó, cada cada elemento, né? Aqui, ó, a lente, parte um, a lente, armação, o cabo e aí vai mudando aqui com uma animação, ó. Legal a animação, hein? Foco. Aqui, ó, a gente vê a escala, ó, e vai aumentando ali, ó. Legal, legal demais, cara. Aqui tem um pequeno guia numa tabela, né? Temos aqui a história, né? Sete séculos

10:44 de vidro. A história das lupas. Temos aqui uns depoimentos. Legal esse estilo de depoimento, né? Parece que pendurou um papel ali na parede. E aqui o footer. Cara, digno, site digno. Né? Só faltou as imagens aqui mesmo. Provavelmente a gente até a lupa aqui nas imagens também, que tem um uma coisinha ali, um glow no meu mouse, ó. Não sei exatamente o que é, mas aqui a imagem vê, a gente consegue ver. Ah, muito legal. E é muito importante que tudo tenha funcionado direitinho, porque não não adianta a gente ganhar velocidade, né, e perder qualidade.

11:16 Inclusive, como eu falei, a gente tem um pequeno problema. Vou pegar lá o nosso texto que a gente já experimentou aqui e vou pedir, ó, “Resuma em um parágrafo”. E lembra que da outra vez a gente teve em torno de 2.700 tokens por segundo de processamento de prompt. A gente pode ver que já levou um pouquinho mais de tempo aqui, né? Olha, ele respondeu aqui pra gente, a gente teve 80 tokens por segundo, que é excelente, mas o nosso processamento de prompt caiu de 2.700 tokens por segundo pra 886, em torno de 900 tokens por

11:47 segundo. Então, é uma perda considerável. Isso não é um problema de modelo, isso é uma falta de otimização da minha conversão ali. Então, eu modifiquei a engine pra poder rodar em duas placas, mas eu ainda não otimizei e não sei se eu vou otimizar também pra rodar em duas placas. Por que que eu provavelmente não vou otimizar? Porque a grande vantagem dessa versão desse modelo aqui é rodar numa placa só, né? Se eu for rodar em duas placas, eu vou fazer um pouco diferente. A propósito, a gente tá rodando em duas placas com tensor paralelismo. E então, se for pra rodar mesmo, eu vou rodar esse container

12:20 aqui, ó, porque nesse container a gente tem o brabo Qwen 3.8 27B FP8. Que que isso significa? Significa que ele tem pouquíssima quantização. Ele é quase igual à versão sem quantização nenhuma, a versão 16 bits. Esse daqui é o modelo que vem direto do Qwen. E esse modelo, ele vai ter em torno de 30 GB. O problema é que 30 GB, você até consegue colocar na placa, mas não sobra espaço pra mais nada. Então, por isso, a gente normalmente não roda esse modelo nem numa 5090, precisaria de duas. Mas hoje em dia é impossível ter duas 5090, é

12:54 difícil ter uma. E a questão é: será que duas Arc A770 então fazem esse trabalho? É isso que a gente vai ver agora. Modelo carregado, vamos começar a brincadeira. Vamos começar com o nosso clássico oi, pra gente ter uma ideia da velocidade. E olha só, a gente conseguiu aqui 18 tokens por segundo. Acho que dá pra ser um pouquinho melhor. Acho que essa primeira mensagem, ele foi um pouquinho lento. Então, conte uma piada. E aqui a gente conseguiu mais, 45 tokens por segundo, o modelo FP8, tá? Isso aqui é muito bom, muito, muito bom. Pedi pra escrever um código agora, ó, “Crie um script Python pra aplicar um filtro

13:26 blur, né, aquele borrado numa imagem. Ó, aqui, essa é a velocidade dele, né, a olho nu. E ó, aqui a gente conseguiu 50 tokens por segundo. Passa para Sep agora. Nós vamos usar uma biblioteca aqui, ó. Ó, 59 tokens por segundo. 59 tokens por segundo o modelo FP8 contra 90 tokens por segundo o modelo Q4, modelo quantização 4 bits. E aí eu te pergunto, qual que você prefere? Deixa aqui embaixo nos comentários. FP8 60 tokens por segundo ou Q4 90 tokens por segundo? Pois é, eu fico dividido aí, hein. Tem tarefas e tarefas, né? Para

13:59 algumas tarefas eu vou preferir esse aqui, para outras eu vou preferir o de 4 bits. Agora, uma outra coisa que a gente vai ver é exatamente o nosso livro lá. Resuma em um parágrafo. Olha, levou 8 segundos. 8 segundos, nada mal. Nada mal. Ó, 41 tokens por segundo e a gente conseguiu então processamento de prompt de 1.315 tokens por segundo, mais do que a gente conseguiu na versão Q4 rodando em duas placas. Mais uma vez, porque não tá otimi- -zado para isso. Dá para otimizar. Talvez eu faça, não sei. Se você quiser ver isso aqui no canal, deixa aqui embaixo nos comentários. Agora, uma outra coisa interessante que

14:33 dá para fazer com esse setup também é usar um modelo numa única placa, né, e deixar outra placa livre para modelos de imagem e vídeo rodando com ComfyUI. E é isso que a gente vai fazer. Deixa eu tirar aqui o meu ComfyUI 8, vou colocar de volta aqui o meu ComfyUI de 4 bits. Eu peço mil desculpas. Se você tem toque, eu sei que você deve tá desesperado com essa loucura aqui, com essa bagunça. Depois eu vou organizar. Pode ficar tranquilo. Daqui a uns seis ou sete vídeos que a gente fale disso aqui, vai tá bom. Vai demorar um pouquinho, mas vai vou chegar lá. O que que a gente tem aqui agora? Então eu tô

15:03 aqui na minha Asrock com o ComfyUI 1.8.27b no formato XL 3, que é a versão Q4 dele. E como ele tá ocupando só uma placa, essa daqui tá livre para a gente rodar o ComfyUI. Então já estou com meu ComfyUI aqui. A gente pode até fazer um pequeno teste rapidamente. Só que primeiro, minha pasta aqui de workflows tá muito pior do que minha tela inicial lá do nosso Zima. Já vamos resolver isso. Antes vamos fazer um teste rapidamente. Deixa eu criar uma pequena imagem aqui e aí a gente pode ver, ó, aqui a V Runner aqui já tá começando a encher, né? Porque a gente tá carregando os modelos que a gente vai precisar para

15:36 gerar essa imagem. Beleza, a gente gerou aqui a nossa vaquinha. Inclusive, gerei uma vaquinha aqui inspirado no novo lançamento do Baby Learning, que é um app que eu tinha na App Store e agora a gente fez uma repaginada nele. Eu fiz até um vídeo aqui no canal sobre isso. o card aqui em cima para você dar uma olhada depois. Mas basicamente, ó, esse aqui é o nosso Baby Learning e ele é um app para criança aprender palavras, né? Animais. A criança arrasta a cartinha aqui, ó, coloca aqui dentro. >> Vaca. >> E aí fala o nome do animal, né? Tem três línguas: inglês, português, espanhol e

16:07 mais de 300 cartas para criança aprender diversas palavras. Esse app tá disponível para iPhone e iPad. Se você por acaso tiver um filho, dá uma olhada porque pode ser interessante. O link vai tá aqui embaixo. Mas beleza, eu criei aqui a nossa vaquinha. Só que, como eu falei, não tô gostando disso aqui. Tá muito bagunçado. Vamos resolver isso agora. Tô aqui no nosso Open Code com o nosso modelo 512.827B, que agora eu vi que eu chamei de LX em vez de AXL. Tô achando que eu tô ficando com dislexia, cara. Não sei se eu sempre tive e nunca percebi ou se é algo novo. Dá para ficar depois de velho? Eu não

16:38 sei. Mas eu tô fazendo uns negócios desses toda hora. De qualquer forma, eu já tô aqui na pasta do ComfyUI, onde a gente tem os workflows. O que que eu vou pedir para o meu modelo? Fazer o seguinte: vou mudar aqui para o modo plano e vou pedir: “Leia os workflows dessa pasta e me entregue uma tabela com eles categorizados e com nomes mais descritivos”. Só não deixa eu dar um mole aqui de não mudar o modelo, né? Porque mudei para o modo plano e não tinha mudado o modelo.

17:08 Outra coisa que eu vou fazer aqui, ó, é tirar esse MCP que tá ligado aqui do Context Server e show de bola. Agora, ó, a A já vê aqui a potência no lá para cima, quer dizer que o modelo tá trabalhando e ó, tá numa excelente velocidade aqui, hein? Olha eu também chegando aqui a tabela, então, ó, imagem, então tem todos esses templates aqui de imagem e olha só, realmente aqui era um pouco mais difícil de entender o que que era, ele tá sugerindo um novo nome que é interessante, só que ele tá sugerindo todos os nomes em português. Não era meu plano, mas pode ser também. Ó, a gente teve aqui uma média de 53

17:38 tokens por segundo, perfeito. O que que eu vou pedir para ele agora? Vou sair aqui do modo plano, então vou pedir para ele aqui, ó, “Crie uma pasta para cada categoria e coloque o workflow correspondente dentro, ou os workflows, né? Faça um update dos nomes para os nomes sugeridos”. Show de bola, tá me dando aqui o resumão do que que ele fez, né? Então ele moveu tudo, agora eu vou voltar aqui no ComfyUI e vou apertar o R, atualizar aqui a nossa pasta e agora quando eu vou em workflows, olha só, muito mais organizado. Se eu quiser um workflow de imagem, vai tá aqui, ó, e eu consigo ver o que que é. Não gosto tanto

18:08 desses nomes aqui, achei que não ficou muito bom, mas isso aqui eu vou ajustar depois. Pelo menos já tá bem mais organizado, né? Então o nosso Coenzito já ajudou a gente aqui. Passou no teste aqui de uso agente, que dá para facilitar nossa vida. Dessa vez ele conseguiu 60 tokens por segundo, inclusive. Só que até aqui a gente nem precisava tá com ComfyUI aberto para fazer isso. Agora a coisa vai começar a ficar legal. Tô aqui com meu Open Code aberto e o meu ComfyUI aberto e eu vou fazer o seguinte, eu vou ativar o MCP que eu tenho do ComfyUI, vou desativar aqui o do Context Server e eu vou

18:39 perguntar para ele, ó, “Testa o MCP do ComfyUI”. Ó, ele conseguiu encontrar lá, tá? Show de bola, OK. Ele tá falando que o ComfyUI local não tá rodando, mas esse daqui, o remote, que é o que eu queria usar mesmo, tá configurado. Então conexão remota OK, show de bola, acho que ele pode parar, né? Eu já vou te falar o que que você tem que fazer. Eu vou pegar essa vaquinha aqui que a gente criou e eu vou falar com ele, ó, “Com esse mesmo estilo, crie 10 outros animais”. E aqui eu vou fazer o seguinte, eu sei que eu tenho um workflow de imagem aqui que ele é turbo, Esse daqui, ó, Queen Imagem de 2.1

19:14 turbo. Eu vou copiar o nome dele e vou falar, ó, “Use o Imagem de 2.1 turbo para gerar as imagens através do MCP do Comfy”. OK, ele achou aqui os modelos e agora ele vai se preparar para começar a fazer as chamadas. Ele tá preparando a lista de animais. Ó, ele identificou novamente aqui a imagem, ele vai começar a preparar aqui os prompts. Ó, mandou aqui a primeira imagem, tá? Já temos aqui um ativo, né? Então a gente já vai ver aqui carregando e rodando. Vamos ver se vai funcionar. Ó, gerou aqui já. Vamos olhar aqui, ó. Tá bem no mesmo estilo, tá? Tá bem no mesmo estilo e todos tem uma gravatinha

19:48 borboleta. Cachorro foi gerado, ó, ele já conseguiu identificar aqui e agora ele vai mandar todos os outros nove animais. Então esse daqui foi a geração de teste. Ele vai mandar todos os outros nove animais agora, ó, e a gente vai ver que a fila vai começar a crescer. Aqui então a gente tem a primeira placa agora gerando as imagens e a segunda placa com o nosso modelo fazendo todo esse gerenciamento. Ó, o gato foi gerado ali. Pô, mas todos vão ter gravata vermelha? Esse daqui tava meio tava marrom, né? Um vermelho mais desbotado, talvez. Aqui, ó, panda. Aqui a gente consegue ver quanto tempo levou para gerar uma

20:20 imagem. Então essa imagem aqui, ó, que ela é 1024 por 1024, levou 14 segundos. Panda levou 12, o elefante levou 12, 12.27, né? Todas elas estão sendo geradas nesse momento com 1024 por 1024. A raposinha ficou muito maneiro. Ó, o ursinho. Ainda faltam três. Pinguim, hipopótamo. Cara, o hipopótamo ficou maneirasso. Cara, olha esse leão. Pronto, gerou as 10 imagens e aqui ele vai baixar aqui para o nosso projeto, ó, fazendo o download de tudo. Então se eu abrir aqui minha pasta, ó, o download dele falhou. Vamos ver o que que ele vai

20:53 fazer aqui para buscar esses arquivos. Ah, conseguiu, conseguiu. Se virou, deu o jeito dele, baixou, ó. Aqui tão os nossos animais. Urso, raposa, pinguim, panda, leão. Cara, o leão ficou muito maneiro. Hipopótamo, também gostei. Gato, elefante, coelho, cachorrinho. Ficou muito bom. Pronto, a gente acabou de usar então as duas placas ao mesmo tempo, uma rodando modelo, outra rodando ComfyUI. Antigamente, para tu fazer qualquer tipo de imagem dessa aqui, para colocar num app ou em alguma coisa,

21:25 seria impossível se você não fosse um ilustrador ou contratasse um, e seria caro, né? Hoje a gente consegue gerar 10 imagens em menos de 2 minutos de graça. Quer dizer, depois de pagar algumas milhares de dólares em equipamento, a geração de uma imagem se torna praticamente de graça. É claro que você não precisa ter um equipamento, existem várias outras alternativas. Eu mesmo faço vários vídeos aqui falando da Rig Skill, por exemplo, né? Que é uma alternativa para você gerar imagens. Agora eles têm a API também. Então se você for gerar algo esporadicamente, essa é uma saída. Mas se você for gerar

21:57 muito, principalmente vídeo, vídeo é complexo. Falando em vídeo, e vídeo ser complexo, vamos gerar um vídeo? Falar para ele: “Gere uma animação de 4 segundos do meu leão com Minimax H3”. Ó, ele bateu um pouco de cabeça aqui, tá? Isso daqui seria facilmente resolvível com uma skill. Ele bateu um pouquinho de cabeça, mas conseguiu mandar aqui nossa chamada aqui para gerar o vídeo, e a gente pode ver aqui que a VRAM ela deu uma baixada, e ela está subindo de novo, porque ele descarregou o Qwen que estava carregado, e ele está carregando agora os pesos do Minimax. A gente está usando bastante da memória do computador

22:27 também, e aqui no caso, ter mais memória seria melhor, né? Mas tudo bem. Eu acho que está acabando aqui. Temos aqui o nosso vídeo já, tá? Levou 291 segundos para a gente poder gerar, e a gente consegue assistir ele aqui, ó. Vou botar aqui grande, ó. Muito legal, muito legal. São 4 segundos de vídeo, levou bastante tempo, né? Pois é, vídeo ainda é complicado, por isso que é caro ainda fazer vídeo, mesmo

22:59 quando a gente usa a API. A 5090 consegue fazer muito mais rápido isso aqui. E eu também não estou usando Lora, dá para usar Lora, diminuir os passos e ser um pouco mais rápido. Mas, nesse setup aqui é possível usar. Se tiver tudo planejadinho, dá para deixar rodando de madrugada ali, né? Um agente vai gerando, ele pode ele mesmo ir checando, regenerando, se for necessário. No outro dia de manhã você vem, confere, se precisar você ajusta um ou outro que seja necessário, mas dá para fazer. E tem tanta coisa mais para falar sobre esse setup, mas esse vídeo já está longo demais. Eu não consegui te

23:30 mostrar, por exemplo, rodando com o fine nas duas placas, que a gente poderia gerar duas imagens ao mesmo tempo, dois vídeos ao mesmo tempo. No caso, dois vídeos acho que não, porque precisaria de mais memória no computador, que a gente vai resolver em breve, talvez a gente traga esse vídeo aí. Uma outra coisa que não deu para a gente ver nesse vídeo que eu queria ter colocado é o Nico Strata rodando com 13.8 Flash Next, modelo de mais de 100 bilhões de parâmetros, e eu vou dar um spoiler, está rodando muito bem nessa máquina. Mas isso vai ficar para um outro vídeo, talvez eu faça um vídeo só sobre isso. Então, se você não quiser perder, se inscreve aqui no canal, clica no sininho

24:03 para receber todas as notificações. E se você quiser aprender mais sobre desenvolvimento com inteligência artificial, dá uma olhada aqui no meu curso, que vai ter um QR Code aqui, um link também. Pode clicar aqui ou escanear o QR Code, você vai para a página do curso, dá uma olhada lá, se for interessante, se inscreve. Se você quiser ver o primeiro vídeo dessa série rodando modelos locais nessa máquina de 64 GB de VRAM, dá uma olhada nesse vídeo aqui. Agora, se você quiser ver o Quantas 8 Flash Next rodando no Mac Studio, aí você clica aqui para conferir. Se você curtiu esse vídeo, deixa um hype aqui no canal, ajuda a mostrar para mais gente. Um like também,

24:34 pô, não custa nada, deixa aqui o like e estamos juntos. Te vejo no próximo vídeo.