Ciência e Dados
Menu
  • Home
  • Sobre
  • Contato
Menu
AI Home Lab – Testando os Limites da IA Local em Um Gaming Laptop MSI Titan Dragon com 96 GB de RAM eGPU RTX 5090

AI Home Lab – Testando os Limites da IA Local no Gaming Laptop MSI Titan Dragon com 96 GB de RAM + eGPU RTX 5090

Posted on 19 de novembro de 202619 de novembro de 2026 by David Matos

AI Home Lab – Testando os Limites da IA Local

Episódio 2: Quais os Limites da IA Local no Gaming Laptop MSI Titan Dragon com 96 GB de RAM + eGPU RTX 5090?

Caso queira pular direto para a conclusão, acesse a seção “O Que Podemos Concluir?” ao final do artigo.

Proposta do Experimento

A proposta do AI Home Lab é descobrir quais tarefas com modelos de linguagem locais são úteis em cada computador. Neste experimento, usei meu Gaming Laptop, o Titan, identificado no inventário abaixo, e testei desde responder a uma pergunta até ler uma entrada extensa e corrigir código com ferramentas reais. O objetivo é descrever o alcance desta configuração, com memória, espera e correção observadas separadamente.

O Titan tem 96 GB de memória RAM e uma GPU Nvidia 5090 interna com 24 GB de VRAM. Adicionei também uma Nvidia 5090 externa com 32 GB de VRAM, ligada por eGPU e cabo Thunderbolt.

Essa configuração apresentou um dos melhores resultados entre todas as máquinas que testei no AI Home Lab.

Configuração do Computador Neste Experimento

CPU é o processador principal do computador e GPU é o processador da placa gráfica. RAM é a memória principal e VRAM é a memória própria de cada GPU. O Titan deste experimento tem duas GPUs, uma interna e outra externa (ambas 5090), e cada uma tem a sua VRAM.

Componente Configuração
Computador Titan 18 HX Dragon Edition Draco Epic
Processador Intel(R) Core(TM) Ultra 9 290HX Plus
RAM instalada nos módulos 96,00 GiB
Sistema Microsoft Windows 11 Home 26H2 / build 26300.9711
GPU interna NVIDIA GeForce RTX 5090 Laptop GPU 23,89 GiB de VRAM própria (aproximadamente 24 GiB)
GPU externa NVIDIA GeForce RTX 5090 31,84 GiB de VRAM própria (aproximadamente 32 GiB)
Roteador externo USB4 Router (2.0), Razer – Core X V2
Conexão PCI Express de quinta geração PCIe 5.0 x16 da GPU interna
Conexão PCI Express de quarta geração PCIe 4.0 x4 da pela GPU externa

A RAM do computador e a VRAM de cada GPU são espaços separados, então as três capacidades não se somam em um bloco único que qualquer operação possa usar. Para dividir os pesos de um modelo entre a CPU, a GPU interna e a GPU externa, o programa precisa copiar dados e coordenar os cálculos entre elas. Os tamanhos de arquivo e de memória aparecem em GiB, uma unidade de 1.073.741.824 bytes, um pouco maior que o GB decimal.

No software, o motor foi o llama.cpp b12180 com as bibliotecas CUDA 13.5 e o driver NVIDIA 617.42, no Windows 11 Home 26H2. O Python 3.14.10 organizou as tarefas, a telemetria e os testes, e o Microsoft MXC 1.0.1 isolou a execução do pequeno projeto de programação.

Conceitos Antes dos Resultados

Os pesos são os números que o modelo aprendeu durante o treinamento e que ficam guardados nos seus arquivos. O B no nome de um modelo significa bilhões de parâmetros, e não diz o tamanho do arquivo nem a qualidade das respostas. Tokens são os pedaços de texto que o modelo lê ou escreve, e a janela de contexto é o espaço onde tudo precisa caber: instruções, conversa, código, respostas de ferramentas e a resposta que será gerada.

Um modelo denso usa o conjunto principal das suas camadas a cada token. Em uma mistura de especialistas, ou MoE, um roteador escolhe só uma parte dos especialistas a cada passo. Isso pode reduzir os cálculos, mas os pesos dos outros especialistas precisam continuar disponíveis.

Quantizar é guardar os pesos em representações menores. Q4_K_M é uma receita baseada em códigos de quatro bits, em que K identifica uma família de formatos e M significa Medium, a variante intermediária. Apesar das letras, K e M não indicam milhares ou milhões de tokens, nem quilobytes ou megabytes. Q8_0, IQ4_NL, IQ4_XS e MXFP4 são outras receitas, cada uma com a sua forma de representar os pesos. Já f16 e q8_0 se referem ao cache KV, a memória temporária da atenção: f16 usa números de 16 bits e q8_0 uma versão quantizada em oito bits.

Tokens por segundo é a taxa de geração que o motor informa depois de processar a entrada. Essa contagem pode incluir raciocínio interno, então uma taxa alta não garante que a resposta final correta chegou cedo. Os números são medianas, e n é a quantidade de observações válidas: com n igual a 1, o valor descreve uma única tentativa.

Modelos Selecionados e Finalidade

Modelo Receita Arquivos Arquitetura registrada
Qwen3.5 4B Q4 Q4_K_M 2,55 GiB Denso; Estado recorrente e atenção
Qwen3.8 27B Q4 Q4_K_M 18,07 GiB Denso; Estado recorrente e atenção
Qwen3.8 27B Q8 Q8_0 26,63 GiB Denso; Estado recorrente e atenção
Nemotron Nano 30B Q4 Q4_K_M 20,88 GiB Mistura de especialistas; Estados recorrentes e atenção
Coder Next 80B Q4 Q4_K_M 45,09 GiB Mistura de especialistas; Estado recorrente e atenção
GPT OSS 120B MXFP4 MXFP4 59,03 GiB Mistura de especialistas; Atenção local e atenção completa
Flash Next IQ4 IQ4_NL 95,04 GiB Mistura de especialistas; Estado recorrente atenção esparsa e tabelas para padrões de tokens
Qwen3 235B IQ4 XS IQ4_XS 117,24 GiB Mistura de especialistas; Atenção completa

Os planos incluem 8 conjuntos de pesos de 7 modelos-base, porque o Qwen de 27B aparece com duas receitas. O 4B entrou para verificar a instalação e a instrumentação, então o resultado dele não mostra o limite da máquina. O 235B é um conjunto condicional, que só entra no relatório quando há uma tentativa registrada, como aconteceu aqui.

Como os Testes Foram Feitos?

O roteiro tem quatro tipos de tarefa. A pergunta curta mede a espera e a velocidade de geração. A leitura longa coloca fatos no início, no meio e no fim de um texto que ocupa até 75% da janela e pede ao modelo que os encontre. A conta em JSON pede um cálculo de desconto e frete em geração livre, sem ferramenta de cálculo e sem uma gramática que force o formato. No microagente, o modelo recebe duas funções com defeito, uma de desconto e outra de frete, e precisa corrigir o arquivo com ferramentas reais até passar em doze testes Python.

A tarefa de programação é pequena. O enunciado já traz a fórmula do desconto e as regras de frete, e a versão inicial passa em quatro dos doze testes de propósito. Cada tentativa aprovada conta como uma tarefa concluída, e por isso estes acertos dizem pouco sobre projetos maiores ou sobre encontrar erros sem uma especificação pronta.

Três reservas protegeram o computador durante os testes: 8 GiB de RAM disponível, 1 GiB de VRAM livre em cada GPU e no máximo 2 GiB de crescimento do arquivo de paginação. Antes de carregar um modelo, um estimador calcula a memória necessária e recusa a condição que ultrapassaria as reservas de RAM ou de VRAM. Só entram na síntese prática as condições concluídas, com encerramento do servidor comprovado e telemetria válida. Na janela principal de cada modelo o plano previa três repetições, e as janelas maiores e o 235B tiveram uma só.

Foram nove rodadas no dia 10 de novembro de 2026, entre 03:10 pm e 08:06 pm, com uma reinicialização do computador entre a quinta e a sexta. Os planos abrangem 92 condições distintas. Foram iniciadas 49 tentativas e 36 condições ficaram aptas para a síntese prática.

Resultados Explicados

A tabela resume o que cada modelo entregou nas condições aptas para a síntese prática.

Modelo Camadas nas GPUs Geração tokens por s Maior leitura aprovada Conta em JSON Correção de código
Qwen3.5 4B Q4 33/33 na interna 133,47 (n=3) 3.082 tokens em 0,93 s 0/3 3/3
Qwen3.8 27B Q4, GPU interna 65/65 na interna 25,37 (n=1) 12.299 tokens em 11,87 s 0/2 2/2
Qwen3.8 27B Q4, GPU externa 65/65 na externa 65,01 (n=3) 196.619 tokens em 142,57 s 0/4 4/4
Qwen3.8 27B Q8 65/65 na externa 49,20 (n=3) 49.164 tokens em 18,81 s 0/4 4/4
Nemotron Nano 30B Q4 53/53 na externa 273,28 (n=3) 196.622 tokens em 31,17 s 0/4 4/4
Coder Next 80B Q4 49/49 nas duas 159,23 (n=3) 196.615 tokens em 121,10 s 0/4 4/4
GPT OSS 120B MXFP4 30/37 nas duas 65,89 (n=1) 98.371 tokens em 128,55 s 4/4 4/4
Flash Next IQ4 35/49 nas duas 24,48 e 26,61 (n=3) 196.620 tokens em 209,64 s 1/8 8/8
Qwen3 235B IQ4 XS 39/95 nas duas 9,22 (n=1) 49.160 tokens em 150,47 s 1/1 1/1

A segunda coluna mostra quantas camadas foram para as GPUs na janela de 4.096 tokens, e as que faltam para o total ficaram na CPU. A geração é a mediana da pergunta curta nessa mesma janela, e o Flash Next tem dois valores porque teve duas condições válidas. A leitura é a maior entrada com recuperação aprovada, com o tempo total. Usaram cache q8_0 as leituras do Qwen 27B Q4 na GPU externa, do Qwen 27B Q8, do Flash Next e do 235B. As medições do Nemotron, do GPT OSS e do 235B tiveram prefixo reutilizado, o que pode reduzir o texto processado de novo. As tabelas completas, condição por condição, estão no relatorio-completo.md e nos CSVs.

O que foi possível fazer no Titan?

O maior conjunto de pesos que concluiu as tarefas avaliadas foi o Qwen3 235B em IQ4_XS, com 117,24 GiB em arquivos. Outros modelos, menores, chegaram a janelas de 262.144 tokens e recuperaram corretamente fatos de entradas com cerca de 196 mil tokens. O maior modelo e a maior janela vieram de condições diferentes, então não existe uma configuração única que tenha entregado os dois números ao mesmo tempo.

O papel do modelo pequeno

O Qwen de 4B serviu para conferir a instalação e o uso das ferramentas, e já trouxe a primeira lição do experimento. Na janela de 2.048 tokens, uma chamada do agente acumulou 2.538 tokens e foi recusada por falta de espaço para a conversa, mesmo com memória disponível. Com a janela de 4.096, as três tentativas de programação terminaram com os doze testes aprovados.

O que o GPT OSS demonstrou?

Na janela de 16.384 tokens, o GPT OSS 120B acertou as três respostas de cálculo em JSON e concluiu as três correções de código. Ele rodou com raciocínio ativado em esforço low, enquanto todos os outros modelos rodaram com o raciocínio desativado. O resultado ajuda a escolher uma configuração de uso, mas mistura duas escolhas, a do modelo e a do raciocínio.

O que as janelas maiores demonstraram?

Quatro modelos recuperaram corretamente os três fatos em entradas de cerca de 196 mil tokens, dentro de janelas de 262.144: Qwen3.8 27B Q4, Nemotron Nano 30B Q4, Coder Next 80B Q4 e Flash Next IQ4, com uma tentativa cada. A maior entrada aprovada foi a do Nemotron, com 196.622 tokens contados pelo motor, cerca de 75% da janela. No Flash Next, uma leitura do mesmo tamanho levou 209,64 segundos, e 203,13 deles se passaram antes de aparecer o primeiro texto visível. Uma janela grande permite a leitura, mas pode cobrar vários minutos de espera.

O Flash Next resolveu tarefas diferentes de formas diferentes

Na janela de 4.096 tokens, o Flash Next concluiu as três correções de código em cada uma das duas condições principais válidas. Na conta em JSON o resultado foi outro: nenhum acerto em três tentativas em uma condição e um acerto em três na outra. O formato das respostas estava válido e o erro estava nos valores: em uma delas, o subtotal correto era 4.6 centavos e a resposta informou 4.75. Nas janelas maiores, o cache f16 esbarrou na reserva de RAM em 16 mil tokens, e com o cache q8_0 o modelo avançou até 262 mil. Como o número de camadas nas GPUs e o modo de leitura dos arquivos também mudaram no caminho, os dados não permitem separar o efeito de cada mudança.

Até onde chegou o modelo de 235B?

As primeiras tentativas com o 235B pararam antes das tarefas, quando a RAM disponível caiu abaixo da reserva de 8 GiB, e uma rodada inteira ficou sem execução porque o Windows ainda registrava cerca de 3 GiB ocupados no arquivo de paginação. Depois da reinicialização, com a divisão 2 para 3 entre a GPU interna e a externa, o modelo completou as janelas de 4.096, 16.384 e 32.768 tokens com cache f16. Em 4 mil, a única tentativa de cálculo em JSON acertou os valores, e o microagente corrigiu o arquivo com 12 de 12 testes aprovados em 68,80 segundos. Na pergunta curta, a geração ficou em 9,22 tokens por segundo.

A janela de 65.536 tokens foi recusada pela previsão de memória com cache f16 e coube com cache q8_0: o modelo recuperou corretamente os fatos de uma entrada de 49.160 tokens em 150,47 segundos. Foi por pouco, porque a menor RAM disponível observada foi de 9,01 GiB. Com esse mesmo cache, a previsão recusou 131.072 tokens. Quem parasse nas primeiras falhas concluiria que o modelo não roda neste computador, e as execuções seguintes, com os mesmos pesos e o mesmo motor, mostraram o contrário.

O Que Podemos Concluir?

A pergunta deste episódio era até onde a IA local chega em um gaming laptop com 96 GB de RAM e uma eGPU. O Titan carregou os oito conjuntos de pesos selecionados, leu entradas de quase 200 mil tokens e corrigiu código em arquivos reais, tudo rodando localmente. O maior deles, o Qwen3 235B, tem 117,24 GiB de arquivos, mais do que toda a RAM do laptop: cerca de 70 GiB de pesos ficaram na memória do lado da CPU e quase 48 GiB foram para as duas GPUs. Nesta máquina ele gera cerca de 9 tokens por segundo.

Na outra ponta está o Nemotron Nano 30B, com todas as camadas na GPU externa. Ele gerou cerca de 270 tokens por segundo e, com prefixo reutilizado, leu 196.622 tokens em 31,17 segundos. Em leituras do mesmo tamanho, sem reuso de prefixo, o Coder Next 80B levou 121,10 segundos, o Qwen 27B Q4 levou 142,57 e o Flash Next, 209,64.

A tarefa que parecia mais simples foi a que mais derrubou os modelos. Nas condições aptas, as 34 tentativas de correção de código foram aprovadas, nos oito conjuntos de pesos, do 4B ao 235B. Já a conta em JSON, feita sem ferramenta de cálculo, só saiu certa em 6 de 34 tentativas: quatro do GPT OSS 120B, que rodou com raciocínio ativado, uma do 235B e uma do Flash Next. Em todos os erros o JSON estava bem formado e os números estavam errados. A lição que tiro daqui é dar ao modelo uma ferramenta de cálculo sempre que a resposta depender de uma conta.

As duas placas se chamam 5090, mas não são iguais: a do laptop tem 24 GiB de VRAM e a externa tem 32. Com o mesmo Qwen 27B Q4 carregado inteiro em uma placa só, a externa gerou cerca de 65 tokens por segundo e a interna ficou perto de 25, mesmo com a externa ligada por uma conexão PCIe 4.0 x4 e a interna por um PCIe 5.0 x16. A interna teve só uma tentativa por janela, mas as duas janelas testadas deram praticamente o mesmo número.

O ponto negativo continuou sendo o Windows. Uma rodada inteira deixou de ser executada por causa do arquivo de paginação, e o cache de arquivos do sistema ficou sem controle, o que impede separar o efeito de algumas mudanças entre uma fase e outra.

Cada resultado vale para a condição em que foi medido. O projeto de programação era pequeno e vinha com a especificação pronta, várias das medições maiores têm uma tentativa só, e não testei requisições simultâneas nem sessões longas. Dentro desses limites, o Nemotron na GPU externa foi o mais rápido tanto na pergunta curta quanto nas leituras longas, o GPT OSS 120B com raciocínio acertou as quatro contas que recebeu, e o 235B mostrou que um modelo maior que a RAM do laptop roda nele, para quem aceita esperar.

Ranking

Não dá para comparar as máquinas entre si, pois elas são diferentes em vários aspectos. Considerando capacidade demonstrada, velocidade, contexto e utilidade para programação, este é meu ranking geral. É uma avaliação qualitativa dos experimentos, cujos modelos e configurações variaram.

1º – Titan com 96 GB + duas RTX 5090 – Executou o LLM 235B IQ4_XS; combina GPU interna de 24 GB e externa de 32 GB.

2º – Mac Mini M6 com 32 GB – Forte opção compacta: Coder 30B Q4 gerou cerca de 63 tokens/s e concluiu o exercício em aproximadamente 12-13 segundos.

É claro que essa comparação chega a ser injusta. O Titan tem que ser comparado com alguém do seu tamanho….kkkk. Farei isso em um dos próximos episódios ao compará-lo com minha máquina principal de trabalho, o Macbook Pro M5 Max com 128 GB de RAM. Seguirei atualizando o ranking nos próximos episódios.

Fontes dos Modelos e dos Conceitos

[1] llama.cpp b12180 servidor e ferramentas

[2] llama.cpp b12180 modos de leitura e lazy

[3] llama.cpp b12180 tipos e receitas de quantização

[4] NVIDIA NVML consulta de memória e particularidades do WDDM

[5] NVIDIA CUDA Runtime API 13.5 códigos de erro

[6] Microsoft MXC 1.0.1

[7] Qwen3.5 4B Q4 documentação de origem

[8] Qwen3.8 27B Q4 documentação de origem

[9] Nemotron Nano 30B Q4 documentação de origem

[10] Coder Next 80B Q4 documentação de origem

[11] GPT OSS 120B MXFP4 documentação de origem

[12] Flash Next IQ4 documentação de origem

[13] Qwen3 235B IQ4 XS documentação de origem

[14] Curso Gratuito de Programação Python

Compartilhar

  • Compartilhar no X(abre em nova janela) X
  • Compartilhar no Facebook(abre em nova janela) Facebook
  • Compartilhar no LinkedIn(abre em nova janela) LinkedIn
  • Compartilhar no WhatsApp(abre em nova janela) WhatsApp
  • Compartilhar no Telegram(abre em nova janela) Telegram
  • Compartilhar no Tumblr(abre em nova janela) Tumblr
  • Compartilhar no Pinterest(abre em nova janela) Pinterest

Relacionado

Deixe um comentário Cancelar resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *

Assinar blog por e-mail

Digite seu endereço de e-mail para assinar este blog e receber notificações de novas publicações por e-mail.

Buscar

Tags Mais Comuns nos Posts

Agentes de IA Analytics Análise de Negócios Apache Spark AWS Banco de Dados Vetorial Big Data Business Intelligence Carreira ChatGPT Cientista de Dados Ciência de Dados Claude Code Cloud Computing Data Lake Data Mesh Data Science Data Scientist Data Warehouse Deep Learning Engenharia de Dados Engenharia de Software Estatística GPU GraphRAG Hadoop IA Generativa Inteligência Artificial Internet of Things Linguagem Python Linguagem R LLM LLMs Machine Learning MCP (Model Context Protocol) Metadados Microsoft Ollama Oracle Predictive Analytics Probabilidade PySpark Python RAG Storytelling

Histórico de Posts

  • novembro 2026 (7)
  • outubro 2026 (6)
  • setembro 2026 (8)
  • agosto 2026 (9)
  • julho 2026 (2)
  • junho 2026 (3)
  • maio 2026 (5)
  • abril 2026 (8)
  • março 2026 (2)
  • fevereiro 2026 (9)
  • janeiro 2026 (8)
  • dezembro 2025 (3)
  • novembro 2025 (6)
  • outubro 2025 (7)
  • setembro 2025 (4)
  • agosto 2025 (4)
  • julho 2025 (4)
  • junho 2025 (2)
  • maio 2025 (6)
  • abril 2025 (3)
  • março 2025 (5)
  • fevereiro 2025 (8)
  • janeiro 2025 (5)
  • dezembro 2024 (4)
  • novembro 2024 (1)
  • outubro 2024 (1)
  • setembro 2024 (1)
  • agosto 2024 (1)
  • julho 2024 (2)
  • junho 2024 (1)
  • maio 2024 (1)
  • abril 2024 (2)
  • março 2024 (1)
  • janeiro 2024 (1)
  • dezembro 2023 (1)
  • outubro 2023 (2)
  • setembro 2023 (1)
  • agosto 2023 (4)
  • julho 2023 (2)
  • junho 2023 (4)
  • maio 2023 (2)
  • abril 2023 (1)
  • março 2023 (3)
  • fevereiro 2023 (2)
  • janeiro 2023 (3)
  • dezembro 2022 (6)
  • novembro 2022 (5)
  • outubro 2022 (2)
  • setembro 2022 (2)
  • agosto 2022 (2)
  • julho 2022 (1)
  • junho 2022 (3)
  • maio 2022 (1)
  • abril 2022 (3)
  • março 2022 (1)
  • fevereiro 2022 (3)
  • janeiro 2022 (2)
  • dezembro 2021 (1)
  • novembro 2021 (4)
  • outubro 2021 (2)
  • setembro 2021 (2)
  • agosto 2021 (1)
  • junho 2021 (1)
  • fevereiro 2021 (2)
  • janeiro 2021 (1)
  • dezembro 2020 (1)
  • novembro 2020 (1)
  • outubro 2020 (2)
  • agosto 2020 (1)
  • abril 2020 (1)
  • março 2020 (1)
  • fevereiro 2020 (2)
  • agosto 2019 (1)
  • abril 2019 (1)
  • setembro 2018 (2)
  • julho 2018 (1)
  • junho 2018 (3)
  • abril 2018 (1)
  • março 2018 (1)
  • fevereiro 2018 (2)
  • janeiro 2018 (1)
  • dezembro 2017 (1)
  • novembro 2017 (1)
  • outubro 2017 (1)
  • setembro 2017 (1)
  • julho 2017 (1)
  • junho 2017 (1)
  • maio 2017 (2)
  • abril 2017 (1)
  • janeiro 2017 (1)
  • novembro 2016 (1)
  • outubro 2016 (1)
  • setembro 2016 (1)
  • julho 2016 (1)
  • junho 2016 (1)
  • maio 2016 (1)
  • abril 2016 (1)
  • fevereiro 2016 (1)
  • janeiro 2016 (3)
  • dezembro 2015 (4)
  • novembro 2015 (6)
  • outubro 2015 (9)
  • setembro 2015 (9)
  • agosto 2015 (9)
©2026 Ciência e Dados