Construir o Seu Próprio Sistema de IA: o Guia Completo de 2026 ao Hardware de GPU de Consumo para LLM Locais

Uma análise aprofundada às limitações de VRAM, ao pooling multi-GPU, aos limites do PCIe e ao desempenho em vírgula flutuante

Pela equipa técnica da Kentino.com | Janeiro de 2026

Introdução: porquê construir o seu próprio sistema de IA?

A revolução da IA já não acontece apenas nos centros de dados. Com modelos open-source como o DeepSeek R1, o Qwen 3, o Llama 4 e o Gemma a atingir capacidades sem precedentes, executar IA poderosa localmente passou a ser não só possível — mas prático.

Mas há um senão que ninguém lhe conta: A VRAM manda, e tudo o resto é um compromisso.

Este guia leva-o de comprador de GPU confuso a arquiteto informado de sistemas de IA. Abordamos tudo, desde configurações de GPU única a executar modelos de 8B parâmetros até configurações multi-GPU capazes de lidar com colossos de 70B ou mais. Quer esteja a montar um assistente de programação, uma estação de trabalho de investigação ou um servidor de IA privado, este guia dá-lhe o que precisa.

Parte 1: compreender a VRAM — a moeda da IA

Porque é que a VRAM importa mais do que tudo o resto

Ao executar Modelos de Linguagem de Grande Dimensão (LLM), a VRAM (Video Random Access Memory) da sua GPU é a especificação mais crítica. Ao contrário dos jogos, onde a VRAM guarda sobretudo texturas e buffers de imagem, as cargas de trabalho de IA precisam de VRAM para:

1. Pesos do modelo: os milhares de milhões de parâmetros que definem o conhecimento da IA
2. Cache KV: memória que cresce com o comprimento da conversa (janela de contexto)
3. Memória de ativação: cálculos temporários durante a inferência
4. Overhead do sistema: kernels CUDA, gestão de memória, buffers de runtime

A fórmula de ouro:

VRAM necessária (GB) = (Parâmetros em milhares de milhões × Precisão em bytes) × 1.2

Exemplos:
- Modelo 8B @ FP16 (2 bytes):  8 × 2 × 1.2 = ~19.2 GB
- Modelo 8B @ Q4 (0.5 bytes):  8 × 0.5 × 1.2 = ~4.8 GB
- Modelo 70B @ FP16 (2 bytes): 70 × 2 × 1.2 = ~168 GB
- Modelo 70B @ Q4 (0.5 bytes): 70 × 0.5 × 1.2 = ~42 GB

A revolução da quantização

A quantização é a técnica que torna possível executar modelos grandes em hardware de consumo. Ao reduzir a precisão dos pesos do modelo de 16 bits (FP16) para 4 bits (Q4), consegue correr modelos que de outra forma exigiriam hardware empresarial.

O ponto ideal: a quantização Q4_K_M oferece 75% de poupança de memória com apenas ~5% de perda de qualidade — o que a torna o padrão de referência para utilização de consumo em 2026.

Parte 2: o panorama das GPU em 2026

NVIDIA RTX série 50 — o novo padrão

A arquitetura Blackwell da NVIDIA traz melhorias significativas para as cargas de trabalho de IA:

RTX 5090 — a besta de topo de gama

O que 32GB de VRAM lhe permitem:

• Qwen3-32B @ Q4_K_M — com folga
• DeepSeek R1 32B @ Q4_K_M — com espaço para contexto
• Llama 4 8B @ FP16 — precisão total
• Modelos 70B @ Q4_K_M — com limites de contexto agressivos

A melhoria de 78% na largura de banda da RTX 5090 face à 4090 significa uma geração de tokens mais rápida, algo especialmente crítico nos modelos maiores, onde a largura de banda de memória se torna o estrangulamento.

RTX 5080 — a escolha prática

O que 16GB de VRAM lhe permitem:

• Qwen3-14B @ Q4_K_M — ótimo desempenho
• DeepSeek R1 14B @ Q4_K_M — excelente para programação
• Llama 4 8B @ Q8_0 — alta qualidade
• Modelos 32B @ quantização agressiva — possível, mas apertado

RTX 5070 Ti — o cavalo de batalha de IA económico

A RTX 5070 Ti oferece os mesmos 16GB de VRAM da 5080 por um custo 25% inferior — o que a torna, possivelmente, a melhor relação qualidade/preço para trabalho dedicado de IA quando a velocidade bruta de geração não é crítica.

RTX 5070 — porta de entrada

O problema dos 12GB: Embora o preço da RTX 5070 seja atrativo, 12GB de VRAM criam limitações significativas. Vai esbarrar em barreiras com modelos de 14B ou mais e com janelas de contexto longas. Encare os 4GB extra da 5070 Ti como um seguro essencial.

A geração anterior continua viável

RTX 4090 — ainda na corrida

A RTX 4090 com 24GB de VRAM continua excelente para IA. Se encontrar uma a bom preço, ela aguenta:

• Modelos 14B com quantização elevada
• Modelos 32B em Q4_K_M (apertado)
• Vários modelos 8B em simultâneo

RTX 3090 / 3090 Ti — os reis do orçamento

Com 24GB de VRAM (os mesmos da 4090), estas placas mais antigas oferecem um valor incrível para IA:

• Largura de banda mais lenta (936 GB/s)
• Núcleos Tensor mais antigos (3.ª geração)
• Mas a mesma capacidade de 24GB

Se a VRAM pura importa mais do que a velocidade (por exemplo, para processamento em lote ou desenvolvimento), uma 3090 usada a $700-900 bate uma 5070 nova a $549 em cargas de trabalho de IA.

Parte 3: compreender as limitações do PCIe

A realidade da largura de banda PCIe

O PCIe (Peripheral Component Interconnect Express) é a autoestrada entre a sua GPU e o resto do sistema. Eis o que precisa de saber:

Quando o PCIe importa (e quando não importa)

O PCIe importa para:

• Carregamento inicial do modelo (minutos poupados em modelos grandes)
• Comunicação multi-GPU (crítica para o paralelismo de tensores)
• Inferência mista CPU/GPU (quando o modelo transborda para a RAM)

O PCIe pouco importa para:

• Inferência com GPU única depois de o modelo estar carregado
• Inferência de modelos pequenos
• Sessões longas em que o tempo de carregamento é negligenciável

Orientação prática:

• GPU única: PCIe 4.0 x8 é normalmente suficiente
• GPU dupla: recomenda-se PCIe 4.0 x16/x16 ou x8/x8
• Quatro GPU: recomendam-se PCIe 5.0 ou plataformas empresariais

Limites de lanes do CPU por plataforma

O estrangulamento das plataformas de consumo: A maioria dos CPU de consumo (Intel Core, AMD Ryzen) disponibiliza apenas 16-24 lanes PCIe a partir do CPU. Isto significa:

• A primeira GPU fica com x16 completo
• Acrescentar uma segunda GPU obriga muitas vezes ambas a x8/x8
• A terceira e a quarta GPU podem funcionar a x4

Para trabalho sério de IA multi-GPU, considere plataformas Threadripper PRO ou HEDT.

Parte 4: configurações multi-GPU — juntar VRAM

O sonho vs. a realidade

O sonho: combinar 4× RTX 5090 para 128GB de VRAM unificada e executar os maiores modelos como se estivessem numa H100.

A realidade: é complicado, mas cada vez mais possível.

Como funciona o multi-GPU com LLM

Existem duas abordagens principais:

Paralelismo de tensores (TP)

Divide operações individuais (como multiplicações de matrizes) por várias GPU. Exige comunicação de alta largura de banda entre as GPU.

Ideal para: inferência de alto débito, aplicações sensíveis à latência Requisitos: NVLink de preferência, mínimo de PCIe 4.0 x8 por GPU Suportado por: vLLM, TensorRT-LLM, DeepSpeed

Paralelismo de pipeline (PP)

Divide o modelo em fases sequenciais, com cada GPU a tratar de camadas diferentes.

Ideal para: acomodar modelos grandes, processamento em lote Requisitos: largura de banda moderada entre GPU Suportado por: llama.cpp, Ollama, a maioria das frameworks

NVLink vs. PCIe — a dura verdade

NVLink proporciona comunicação direta entre GPU a ~900 GB/s (no NVLink 4.0). Permite um verdadeiro pooling de memória, em que as GPU acedem diretamente à VRAM umas das outras.

O problema: as placas RTX de consumo já não suportam NVLink. As últimas GPU de consumo com NVLink foram as RTX 3090/3090 Ti (NVLink 3.0 @ 112.5 GB/s bidirecional).

Sem NVLink, a comunicação multi-GPU usa PCIe:

• Muito mais lenta (~32-64 GB/s vs 900 GB/s)
• Latência mais elevada
• Não é possível juntar VRAM diretamente

Impacto prático:

Fazer o multi-GPU funcionar sem NVLink

Apesar das limitações, as configurações multi-GPU em hardware de consumo são cada vez mais práticas:

Software recomendado:

• llama.cpp: excelente suporte multi-GPU, distribui as camadas pelas placas
• Ollama: configuração simples, distribuição automática de camadas
• vLLM: serviço de alto desempenho, suporte para paralelismo de tensores
• exllama2: otimizado para inferência multi-GPU

Dicas de configuração:

1. Garanta que ambas as GPU estão no mesmo nó NUMA (verifique com nvidia-smi topo -m)
2. Use no mínimo PCIe x8/x8 para GPU dupla
3. Defina CUDA_VISIBLE_DEVICES corretamente
4. Use modelos de GPU iguais sempre que possível (misturar gerações funciona, mas pode ser ineficiente)

Exemplos de configurações multi-GPU

RTX 5090 dupla (64GB no total)

Modelos suportados:
- Qwen3-70B @ Q4_K_M (precisa de ~42GB) ✓
- DeepSeek R1 70B @ Q4_K_M ✓
- Llama 4 70B @ Q4_K_M ✓
- Qualquer modelo 32B @ FP16 ✓

Desempenho: ~40-50 tokens/seg em modelos 70B
Custo: ~$4,000 (apenas GPU)
Potência: 1,150W de pico (apenas GPU)

Quatro RTX 5090 (128GB no total)

Modelos suportados:
- Qwen3-235B-A22B (MoE, ~22B ativos) ✓
- Qualquer modelo 70B @ Q8_0 ✓
- Modelos densos de 120B+ @ Q4_K_M ✓

Desempenho: variável, depende muito da topologia PCIe
Custo: ~$8,000 (apenas GPU)
Potência: 2,300W de pico (apenas GPU)
Requer: plataforma HEDT/servidor (Threadripper, Xeon)

Build económico: duas RTX 3090 usadas (48GB no total)

Modelos suportados:
- Qwen3-32B @ Q4_K_M ✓
- DeepSeek R1 32B @ Q4_K_M ✓
- Modelos 70B @ quantização Q3 agressiva (marginal)

Desempenho: ~20-30 tokens/seg em modelos 32B
Custo: ~$1,400-1,800 (GPU usadas)
Vantagem: suporte NVLink!

Parte 5: análise aprofundada ao desempenho em vírgula flutuante

Formatos de precisão explicados

A IA moderna utiliza vários formatos de precisão numérica:

A vantagem FP4 e FP8 da Blackwell

A série RTX 50 introduz suporte nativo para FP4 nos núcleos Tensor:

O que isto significa:

• A inferência FP8 e FP4 é drasticamente mais rápida na série RTX 50
• Os modelos otimizados para FP8 registam acelerações enormes
• As gerações dos núcleos Tensor contam tanto como os núcleos CUDA

Largura de banda de memória — o outro estrangulamento

Nos modelos grandes, a largura de banda de memória conta muitas vezes mais do que a capacidade de cálculo:

Os tokens por segundo são limitados por:

Máx. tokens/s = Largura de banda de memória (GB/s) / Bytes por parâmetro

RTX 5090 com modelo 70B Q4_K_M:
1,792 GB/s / 35 GB = ~51 tokens/s máximo teórico

RTX 4090 com o mesmo modelo:
1,008 GB/s / 35 GB = ~29 tokens/s máximo teórico

A melhoria de 78% na largura de banda da RTX 5090 traduz-se diretamente numa geração mais rápida com modelos grandes.

Parte 6: o panorama dos modelos open-source — o que executar

Nível 1: modelos de topo (recomendados 32GB+ de VRAM)

Qwen3-235B-A22B (MoE)

• Parâmetros ativos: 22B (235B total)
• VRAM @ Q4: ~28GB
• Contexto: 32K nativo, 131K com YaRN
• Pontos fortes: matemática, programação, multilingue (119 idiomas)
• Ideal para: utilização geral, programação, investigação

DeepSeek R1 70B

• Parâmetros: 70B
• VRAM @ Q4: ~42GB
• Contexto: 128K
• Pontos fortes: raciocínio, cadeia de pensamento, programação
• Ideal para: resolução de problemas complexos, investigação

Llama 4 70B

• Parâmetros: 70B
• VRAM @ Q4: ~42GB
• Contexto: 128K
• Pontos fortes: capacidades gerais, cumprimento de instruções
• Ideal para: aplicações versáteis

Nível 2: modelos profissionais (16-24GB de VRAM)

Qwen3-32B

• Parâmetros: 32B
• VRAM @ Q4: ~19GB
• Contexto: 128K
• Pontos fortes: programação (ao nível do GPT-4o), raciocínio
• Ideal para: RTX 5090/4090 única, desenvolvimento

DeepSeek R1 Distill 32B

• Parâmetros: 32B
• VRAM @ Q4: ~19GB
• Pontos fortes: raciocínio destilado de um modelo maior
• Ideal para: raciocínio com boa relação custo-benefício

Gemma 3 27B

• Parâmetros: 27B
• VRAM @ Q4: ~16GB
• Contexto: 128K
• Pontos fortes: eficiente, qualidade Google, multimodal
• Ideal para: builds com RTX 5080/5070 Ti

Nível 3: modelos de consumo (8-16GB de VRAM)

Qwen3-14B

• Parâmetros: 14B
• VRAM @ Q4: ~8.4GB
• Contexto: 128K
• Pontos fortes: excelente equilíbrio entre tamanho e capacidade
• Ideal para: RTX 5070 Ti, 4070 Ti, utilização geral

Qwen3-8B

• Parâmetros: 8B
• VRAM @ Q4: ~4.8GB
• Contexto: 32K nativo, 131K alargado
• Pontos fortes: rápido, capaz, cabe em qualquer lado
• Ideal para: builds de gama de entrada, aplicações em tempo real

DeepSeek R1 Distill 14B (base Qwen)

• Parâmetros: 14B
• VRAM @ Q4: ~8.4GB
• Pontos fortes: raciocínio forte graças à destilação
• Ideal para: assistentes de programação, resolução de problemas

Llama 4 8B

• Parâmetros: 8B
• VRAM @ Q4: ~4.8GB
• Pontos fortes: rápido e equilibrado
• Ideal para: tarefas do dia a dia, aplicações de chat

Nível 4: edge/embebido (4-8GB de VRAM)

Qwen3-4B

• Parâmetros: 4B
• VRAM @ Q4: ~2.4GB
• Pontos fortes: rivaliza com o desempenho do Qwen2.5-7B
• Ideal para: portáteis, gráficos integrados, dispositivos edge

Phi-4 (Microsoft)

• Parâmetros: 14B
• VRAM @ Q4: ~8.4GB
• Pontos fortes: excecional para o seu tamanho, foco em STEM
• Ideal para: aplicações educativas e técnicas

Qwen3-0.6B

• Parâmetros: 0.6B
• VRAM @ Q4: <1GB
• Pontos fortes: funciona em qualquer lado
• Ideal para: IoT, dispositivos móveis, ambientes de recursos ultrabaixos

Fluxograma de seleção de modelo

Qual é a sua capacidade principal de VRAM?

├─ 32GB+ (RTX 5090, duas 3090)
│   └─ Qwen3-235B-A22B ou DeepSeek R1 70B @ Q4
│
├─ 24GB (RTX 4090, 3090)
│   └─ Qwen3-32B @ Q4 ou DeepSeek R1 32B @ Q4
│
├─ 16GB (RTX 5080, 5070 Ti, 4080)
│   └─ Qwen3-14B @ Q4 ou Gemma 3 27B @ Q4
│
├─ 12GB (RTX 5070, 4070 Ti)
│   └─ Qwen3-8B @ Q4 ou Llama 4 8B @ Q4
│
└─ 8GB (RTX 4070, 3070)
        └─ Qwen3-4B @ Q4 ou Phi-4 @ quantização agressiva

Parte 7: recomendações completas de configurações

Build 1: a porta de entrada ($1,200-1,500)

Caso de utilização: assistente de IA pessoal, apoio à programação, experimentação

Consegue executar:

• Qwen3-14B @ Q4 (~8.4GB) — excelente
• DeepSeek R1 14B @ Q4 — excelente
• Qwen3-32B @ Q3 (agressivo) — possível, mas apertado
• Vários modelos 8B em simultâneo

Desempenho estimado: 35-50 tokens/seg com modelos 14B

Build 2: o ponto ideal prosumer ($3,500-4,500)

Caso de utilização: desenvolvimento profissional, investigação, criação de conteúdos

Consegue executar:

• Qwen3-32B @ Q4 — confortável, com 13GB de margem
• DeepSeek R1 32B @ Q6 — maior qualidade
• Qwen3-235B-A22B @ Q4 — apertado, mas funciona
• Qualquer modelo abaixo de 32B com alta qualidade

Desempenho estimado: 50-80 tokens/seg com modelos 32B

Build 3: o servidor de IA local ($7,000-10,000)

Caso de utilização: servidor de inferência para equipas, experimentação com modelos, cargas de trabalho em produção

Consegue executar:

• DeepSeek R1 70B @ Q4 — desempenho total
• Qwen3-235B-A22B @ Q4 — excelente
• Qualquer modelo com menos de 120B parâmetros
• Vários modelos 32B para testes A/B

Desempenho estimado: 40-50 tokens/seg com modelos 70B

Build 4: o laboratório económico ($2,000-2,500 no mercado de usados)

Caso de utilização: aprendizagem, desenvolvimento, entusiasta atento ao custo

A vantagem do NVLink: esta é a única configuração de consumo com suporte NVLink, proporcionando verdadeiro pooling de VRAM a 112.5 GB/s, contra os ~32 GB/s do PCIe.

Consegue executar:

• Qwen3-32B @ Q8 (maior qualidade) — confortável
• DeepSeek R1 32B @ FP16 — com gestão cuidadosa do contexto
• Modelos 70B @ Q3 agressivo — possível

Desempenho estimado: 25-35 tokens/seg com modelos 32B (mais rápido do que o esperado graças ao NVLink)

Build 5: a potência portátil (portátil)

Caso de utilização: desenvolvimento de IA em mobilidade, inferência em qualquer lugar

Modelos a destacar:

• ASUS ROG Strix SCAR 18 (2026)
• Razer Blade 18 (2026)
• MSI Titan GT78 (2026)

Consegue executar:

• Qwen3-14B @ Q4 — excelente
• DeepSeek R1 14B @ Q4 — excelente
• Qwen3-32B @ Q4 — apertado, mas funciona

Nota: a RTX 5090 Mobile tem 24GB (não 32GB) e um TDP mais baixo. Conte com ~70% do desempenho da versão desktop.

Parte 8: recomendações de stack de software

Ferramentas essenciais

Ollama — o botão fácil

# Instalar
curl -fsSL https://ollama.ai/install.sh | sh

# Executar o Qwen3 8B
ollama run qwen3:8b

# Executar com quantização específica
ollama run qwen3:14b-q4_K_M

# Multi-GPU (automático)
CUDA_VISIBLE_DEVICES=0,1 ollama run qwen3:32b

Ideal para: começar, implementações simples, serviço de API

LM Studio — a experiência gráfica

• Explorador visual de modelos
• Transferências com um clique
• Interface de chat integrada
• Seleção de quantização

Ideal para: utilizadores não técnicos, exploração de modelos

llama.cpp — controlo máximo

# Compilar com CUDA
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release

# Executar com multi-GPU
./llama-server -m qwen3-32b-q4_k_m.gguf \
  -ngl 99 \
  --tensor-split 0.5,0.5 \
  -c 8192

Ideal para: utilizadores avançados, implementações personalizadas, desempenho máximo

vLLM — serviço em produção

# Instalar
pip install vllm

# Servir com paralelismo de tensores
python -m vllm.entrypoints.openai.api_server \
  --model Qwen/Qwen3-32B \
  --tensor-parallel-size 2 \
  --dtype auto

Ideal para: serviço de alto débito, endpoints de API, produção

Fontes de modelos

Parte 9: dicas de otimização

Otimização da VRAM

1. Use quantização Q4_K_M — melhor equilíbrio entre tamanho e qualidade
2. Limite o comprimento do contexto — 8K em vez de 32K poupa ~40% de VRAM
3. Desative a cache KV para prompts de resposta única
4. Use Flash Attention 2 — reduz a memória em contextos longos
5. Ative a inferência eficiente em memória no vLLM

Otimização da velocidade

1. Maximize a largura de banda de memória da GPU — RAM mais rápida = tokens mais rápidos
2. Use FP8 quando disponível — 2-3x mais rápido na série RTX 50
3. Ative a descodificação especulativa — use um modelo pequeno para acelerar um grande
4. Agrupe os pedidos em lote — maior débito no serviço
5. Use batching contínuo (vLLM) — tratamento dinâmico de pedidos

Otimização multi-GPU

1. Use modelos de GPU iguais — evite misturar gerações
2. Verifique a topologia NUMA — mesmo nó = menor latência
3. Use no mínimo lanes x8 — x4 cria estrangulamentos
4. Monitorize com o nvidia-smi — atenção à utilização desequilibrada
5. Teste diferentes configurações TP/PP — o ideal varia consoante o modelo

Parte 10: resolução de problemas comuns

"CUDA out of memory"

Causas:

• Modelo demasiado grande para a VRAM
• Janela de contexto demasiado longa
• Crescimento da cache KV

Soluções:

1. Use uma quantização mais agressiva (Q4 → Q3)
2. Reduza o comprimento do contexto
3. Reduza o tamanho do lote
4. Ative o flash attention
5. Divida por várias GPU

Geração de tokens lenta

Causas:

• Limitação da largura de banda de memória
• Offloading para o CPU ativo
• Throttling térmico

Soluções:

1. Garanta que o modelo cabe totalmente na VRAM
2. Verifique a temperatura da GPU (alvo <85°C)
3. Use um modelo mais pequeno
4. Ative o modo de desempenho da GPU
5. Melhore o fluxo de ar da caixa

O multi-GPU não escala

Causas:

• Estrangulamento da largura de banda PCIe
• Divisão incorreta das camadas
• Problemas de distância NUMA

Soluções:

1. Verifique nvidia-smi topo -m para ver a topologia
2. Ajuste os rácios de divisão de tensores
3. Garanta PCIe x8 ou superior por GPU
4. Considere NVLink (RTX 3090)
5. Use paralelismo de pipeline em vez de paralelismo de tensores

Conclusão: fazer a escolha certa

Montar um sistema de IA local em 2026 está mais acessível do que nunca. Eis o resumo:

Recomendações rápidas:

As regras de ouro:

1. VRAM > tudo o resto — mais memória = mais opções de modelos
2. A quantização é sua amiga — Q4_K_M é o ponto ideal
3. O multi-GPU tem retornos decrescentes — sem NVLink, conte com ~1.6x a partir de 2 GPU
4. A largura de banda de memória conta — sobretudo nos modelos grandes
5. Comece em pequeno e vá crescendo — teste as suas cargas de trabalho antes de investir

O ecossistema de IA open-source avança rapidamente. Modelos que há dois anos exigiam hardware de $100K correm hoje em sistemas de $2K. Tudo o que construir hoje só se tornará mais capaz à medida que os modelos forem ficando mais eficientes.

Bem-vindo à era da IA pessoal.

Para recomendações de hardware e disponibilidade, visite Kentino.com

Anexo: tabelas de consulta rápida

Requisitos de VRAM por modelo (Q4_K_M)

Comparação de GPU para IA

Última atualização: janeiro de 2026 Artigo preparado pela equipa técnica da Kentino