# Posso rodar Ollama ou um LLM pequeno em um VPS com vCPU dedicada e sem GPU?

> Posso rodar Ollama em um VPS sem GPU? Sim: LLMs quantizados de até cerca de 32B em 2 a 16 vCPU dedicadas, RAM por modelo e dados de velocidade. Cripto, sem KYC.

- URL: https://cobaltfell.com/pt/vps-for-llm-without-gpu/
- Última atualização: 2026-11-02
- Editor: Cobaltfell (https://cobaltfell.com)

Posso rodar Ollama ou um LLM em um VPS sem GPU? Quais modelos quantizados cabem na RAM de cada plano, o que testes de CPU publicados mostram sobre velocidade, como configurar o Ollama em um VPS só com CPU e quando a GPU é a ferramenta certa.

**Resposta rápida — Posso rodar Ollama ou um LLM em um VPS sem GPU?**

Sim: o Ollama roda um LLM em um VPS sem GPU quando o modelo quantizado cabe na RAM. Na **Cobaltfell**, o Fell 8 (16 GB) roda modelos de 8B a 14B como o qwen3:8b, um download de 5,2 GB, e o Fell 16 (32 GB) roda modelos de 27B a 32B de 17 a 20 GB (biblioteca do Ollama, verificada em 2 de novembro de 2026). Uma GPU leva vantagem para muitos usuários ao mesmo tempo, prompts longos ou modelos maiores que a RAM.

## Quais modelos cabem na RAM de cada plano?

**Em uma CPU, a RAM decide qual modelo roda e as vCPU decidem quão rápido ele roda.** O modelo inteiro fica na memória do sistema, e o tamanho do download que o Ollama mostra é uma boa primeira estimativa da memória que ele ocupa. O contexto, o sistema e qualquer outra coisa no VPS entram na conta por cima: a documentação do Ollama diz que a RAM necessária cresce com `OLLAMA_NUM_PARALLEL` vezes `OLLAMA_CONTEXT_LENGTH`, e o contexto padrão é de 4.096 tokens.

*Tamanhos de download das tags padrão nas páginas da biblioteca do Ollama, lidos em 2 de novembro de 2026. "Cabe com folga" mantém o modelo em até cerca de 60% da RAM do plano, uma regra prática e não uma medição. Fora do alcance em todos os planos: deepseek-r1:70b (43 GB) e deepseek-r1:671b (404 GB).*

| Plano | RAM | Cabe com folga | Cabe com um contexto curto e pouco mais rodando |
| --- | --- | --- | --- |
| Fell 2 | 4 GB | gemma3:1b (806 MB), llama3.2:1b (1,3 GB), qwen3:1.7b (1,4 GB), llama3.2:3b (2,0 GB) | qwen3:4b (2,5 GB) |
| Fell 4 | 8 GB | qwen3:4b (2,5 GB), gemma3:4b (3,4 GB), deepseek-r1:7b (4,7 GB) | qwen3:8b e deepseek-r1:8b (5,2 GB) |
| Fell 8 | 16 GB | qwen3:8b (5,2 GB), gemma3:12b (8,2 GB), deepseek-r1:14b (9,0 GB), qwen3:14b (9,3 GB) | dois modelos pequenos carregados lado a lado |
| Fell 16 | 32 GB | gemma3:27b (17 GB), qwen3:30b (19 GB) | qwen3:32b e deepseek-r1:32b (20 GB) |

**Segundo o levantamento da Cobaltfell de 2 de novembro de 2026, 4 dos 6 hosts que vendem vCPU dedicada em um processador de 2022 ou mais novo sem verificação de identidade listavam um plano com 32 GB de RAM ou mais; o mais barato era o R9 Ultra da VPSLab, 12 vCores e 48 GB, a €69,99 (US$ 78,19) por mês.**

## Quão rápida é a inferência de LLM em uma CPU?

**A inferência em CPU é mais lenta que em GPU por uma margem definida pelas threads, pela largura de banda de memória e pela quantização.** A Cobaltfell não publica nenhum número de tokens por segundo próprio: Os nossos próprios resultados do YABS e do Geekbench 6, junto com o steal time que medimos, serão publicados com a data assim que a nossa primeira máquina de teste for entregue. Até lá, não divulgamos nenhum número de desempenho nosso.

O número público mais útil é um teste que a Leaseweb publicou em 5 de abril de 2026 (página atualizada em 20 de agosto de 2026). Em um servidor com dois processadores AMD EPYC 9334 (Zen 4) rodando 24 threads, o teste gerou **27,8 tokens por segundo** com um modelo de 8B em quantização de 4 bits (DeepSeek-R1-0528-Qwen3-8B, Q4_K_M), e **8,1 tokens por segundo** com o mesmo modelo em FP16. Uma GPU NVIDIA L4 alcançou 16,7 tokens por segundo nesse modelo em FP16. O tempo até o primeiro token em Q4 variou de 3,6 a 4,8 segundos entre os modelos testados.

*Números conforme publicados pela Leaseweb (5 de abril de 2026, atualizado em 20 de agosto de 2026), consultados em 2 de novembro de 2026. Bare metal com dois sockets, não um VPS.*

| Hardware no teste da Leaseweb | Modelo e precisão | Velocidade de geração |
| --- | --- | --- |
| 2 × AMD EPYC 9334, 24 threads | DeepSeek-R1-0528-Qwen3-8B, Q4_K_M | 27,8 tokens/s |
| 2 × AMD EPYC 9334, 24 threads | DeepSeek-R1-0528-Qwen3-8B, FP16 | 8,1 tokens/s |
| NVIDIA L4 | DeepSeek-R1-0528-Qwen3-8B, FP16 | 16,7 tokens/s |

Esses números vêm de bare metal com dois sockets e 24 threads. Um VPS com 8 ou 16 vCPU tem menos threads e uma fração de um socket, então o número dele é menor; quanto menor, não foi medido.

Uma lição se aplica diretamente: o mesmo modelo rodou mais de três vezes mais rápido em Q4 do que em FP16 na mesma CPU. **Em uma CPU, um arquivo quantizado menor é o primeiro ganho de velocidade a testar.**

## Como rodar o Ollama em um VPS somente com CPU?

**Instale o Ollama com o script oficial, baixe um modelo que caiba no plano e confirme que ele roda inteiramente na CPU.** `ollama ps` mostra onde um modelo carregado fica: a coluna `PROCESSOR` dele lê `100% CPU` em um VPS. O Ollama escuta em 127.0.0.1, porta 11434, por padrão; acesse por um túnel SSH, ou coloque um proxy reverso com autenticação na frente antes de alterar `OLLAMA_HOST`.

*Instalar o Ollama, rodar um modelo, definir contexto e paralelismo*

```bash
# official install script for Linux
curl -fsSL https://ollama.com/install.sh | sh

# pull and run a model that fits the plan (here about 2.5 GB)
ollama run qwen3:4b "Summarize what a dedicated vCPU is in one sentence."

# where the model is loaded: expect 100% CPU
ollama ps

# service settings: add these two lines under [Service]
sudo systemctl edit ollama
#   Environment="OLLAMA_CONTEXT_LENGTH=4096"
#   Environment="OLLAMA_NUM_PARALLEL=1"
sudo systemctl daemon-reload
sudo systemctl restart ollama
```

## Devo usar o llama.cpp diretamente?

**O llama.cpp é a escolha quando a quantização, o número de threads e as flags do servidor importam.** O README dele lista suporte a AVX, AVX2, AVX512 e AMX em x86, e quantização inteira de 1,5 bit a 8 bits para reduzir o uso de memória e acelerar a inferência. Ele vem com `llama-bench`, uma ferramenta de teste de desempenho cujo padrão processa um prompt de 512 tokens e gera 128 tokens, e que testa vários números de threads em uma única execução.

Duas verificações levam um minuto em qualquer VPS: quais instruções vetoriais o processador expõe, e se o modelo roda mais rápido com tantas threads quanto vCPU ou com uma thread por núcleo físico. Na Cobaltfell, Uma vCPU é um thread de hardware do processador do host. As suas são fixadas uma a uma ao seu VPS e nunca são emprestadas a outro cliente, e os dois threads de um núcleo físico ficam juntos, então cada 2 vCPU formam um núcleo inteiro que nenhum vizinho compartilha, então o Fell 16 oferece 16 threads em 8 núcleos para comparar; a regra é explicada em [um vCPU dedicado é um núcleo ou uma thread](https://cobaltfell.com/pt/vcpu-vs-core/ "Um vCPU dedicado é um núcleo ou uma thread em um VPS?").

*Recursos da CPU e uma comparação de número de threads*

```bash
# vector instructions the VPS can use
grep -o -w -E 'avx2|avx512f|avx512_bf16|amx_tile' /proc/cpuinfo | sort -u

# prompt 512 tokens, generate 128, on 8 and then 16 threads
llama-bench -m qwen3-8b-q4_k_m.gguf -p 512 -n 128 -t 8,16
```

## O que os vCPU dedicados mudam para a inferência?

**A geração mantém todas as threads ocupadas durante toda a extensão de uma resposta, então o tempo de CPU perdido se converte diretamente em tokens mais lentos.** Em um vCPU compartilhado, o pico de um vizinho alonga cada resposta como steal time, explicado em [o que é CPU steal time e como verificar em um VPS](https://cobaltfell.com/pt/cpu-steal-time/ "O que é CPU steal time e como verificá-lo na minha VPS?"), e os limites de uso justo em longos períodos de carga total limitam a inferência primeiro.

Na Cobaltfell: Carga total é permitida pelo tempo que o seu trabalho precisar: sem créditos de CPU, sem janela de burst e sem throttling depois de alguns minutos a 100%. A RAM do seu plano é reservada para o seu VPS e não é overcommitted, então um modelo carregado nunca é empurrado para fora da RAM pelo host. A família de processadores é AMD EPYC 9004/9005 (Zen 4 / Zen 5). Rodar um modelo a 100% é permitido; a linha é traçada em outro lugar: Mineração de qualquer criptomoeda não é permitida, em nenhum plano e com nenhum software. O seu próprio trabalho pesado de CPU, como builds, encoding, inferência ou bancos de dados, pode rodar em carga total, e um nó que apenas valida uma blockchain não é mineração.

Hosts que vendem vCPU dedicado, e o preço de um núcleo, são comparados em [quanto custa um VPS com CPU dedicada por núcleo em novembro de 2026](https://cobaltfell.com/pt/dedicated-cpu-vps-price-index/ "Dedicated CPU VPS price per core, survey of 2 November 2026").

## Quando uma GPU é a resposta certa para um LLM?

**Uma GPU é a resposta certa quando a velocidade por usuário, o número de usuários ou o tamanho do modelo importam mais que o custo.** O teste da Leaseweb traça a mesma linha: a CPU serve para cargas em lote, assíncronas e leves, enquanto as GPUs continuam à frente para trabalho sensível à latência, alta concorrência e modelos acima de 20B parâmetros sem quantização. Mais três casos apontam para uma GPU:

- **Modelos maiores que a RAM.** O Fell 16 tem 32 GB; um modelo de 70B em 43 GB não cabe em nenhum plano.
- **Prompts longos.** Recuperação e chat com documentos alimentam milhares de tokens antes da primeira palavra, e é nesse estágio de prompt que uma CPU espera mais.
- **Treinamento e ajuste fino.** São trabalhos de GPU na prática.

A Cobaltfell não vende GPU. Para esses casos, um servidor com GPU é o aluguel certo, com um VPS de CPU mantido para a API, a fila e o banco de dados vetorial em torno do modelo. A codificação de vídeo levanta a mesma questão, respondida em [um VPS consegue transcodificar vídeo com FFmpeg sem GPU](https://cobaltfell.com/pt/vps-for-video-transcoding/ "Posso transcodificar vídeo com FFmpeg em uma VPS com vCPU dedicada sem GPU?").

## Que outras perguntas as pessoas fazem sobre LLMs em um VPS sem GPU?

### O DeepSeek R1 roda em um VPS sem GPU?

As versões destiladas, sim: deepseek-r1:8b (5,2 GB) no Fell 8, e deepseek-r1:32b (20 GB) no Fell 16 com um contexto curto. O deepseek-r1:671b completo é um download de 404 GB e não cabe em nenhum plano de VPS.

### Vários usuários podem compartilhar um modelo em uma CPU?

Sim, com um custo de memória por requisição paralela. O Ollama atende uma requisição por modelo por vez por padrão (`OLLAMA_NUM_PARALLEL=1`), e a RAM necessária cresce com essa configuração vezes o comprimento do contexto. Aumente um passo de cada vez e observe `free -h`.

### Como medir a velocidade com que um modelo roda no meu plano?

`llama-bench` informa a velocidade de prompt e de geração em tokens por segundo para um arquivo de modelo e um número de threads. Ele repete cada teste 5 vezes por padrão e dá a média com seu desvio padrão.

### Quantos modelos o Ollama consegue manter carregados em uma CPU?

Até 3 por padrão para inferência em CPU, cada um mantido na memória por 5 minutos após o último uso. No Fell 2 e no Fell 4, um modelo por vez evita que o segundo empurre o primeiro para o swap.

### A Cobaltfell oferece servidores com GPU?

Não. A Cobaltfell vende VPS Linux com vCPU dedicado em processadores AMD EPYC 9004/9005, a partir de $10.49 por mês no plano de 12 meses, conforme listado em [quanto custa um VPS com núcleo dedicado](https://cobaltfell.com/pt/pricing/ "Quanto custa um VPS com vCPU dedicada?").

## Fontes

1. [FAQ do Ollama (comprimento de contexto, requisições paralelas, modelos carregados, endereço de bind)](https://docs.ollama.com/faq) — Ollama (checked 2026-11-02)
2. [Ollama no Linux (script de instalação, systemd)](https://docs.ollama.com/linux) — Ollama (checked 2026-11-02)
3. [Biblioteca Ollama: qwen3](https://ollama.com/library/qwen3) — Ollama (checked 2026-11-02)
4. [Biblioteca Ollama: gemma3](https://ollama.com/library/gemma3) — Ollama (checked 2026-11-02)
5. [Biblioteca Ollama: llama3.2](https://ollama.com/library/llama3.2) — Ollama (checked 2026-11-02)
6. [Biblioteca Ollama: deepseek-r1](https://ollama.com/library/deepseek-r1) — Ollama (checked 2026-11-02)
7. [README do llama.cpp](https://github.com/ggml-org/llama.cpp/blob/master/README.md) — ggml-org (checked 2026-11-02)
8. [llama-bench](https://github.com/ggml-org/llama.cpp/tree/master/tools/llama-bench) — ggml-org (checked 2026-11-02)
9. [AMD EPYC LLM Inference Benchmark: CPU Performance for 7B-20B Models and TTS Workloads](https://blog.leaseweb.com/2026/04/05/amd-epyc-llm-inference-benchmark-cpu-vs-gpu/) — Leaseweb (published 2026-04-05, updated 2026-08-20, checked 2026-11-02)
10. [VPSLab Ryzen VPS (R9 Ultra, 48 GB)](https://vpslab.cloud/ryzen-vps) — VPSLab (checked 2026-11-02)

---

Cobaltfell: A Cobaltfell é uma provedora de VPS com núcleos vCPU dedicados, paga em cripto, sem envio de documento de identidade e operada pela DomaineGoat LLC, empresa registrada no Panamá. Cada vCPU é fixado exclusivamente no seu servidor, em processadores AMD EPYC 9004/9005 (Zen 4 / Zen 5) com armazenamento NVMe, em Amsterdã (Países Baixos), Zurique (Suíça) e Bucareste (Romênia). No período de 12 meses, cada plano tem preço pelo menos 25% abaixo de um plano comparável de CPU dedicada nomeado, escolhido entre 6 provedores de VPS com cripto e sem KYC e consultado em 2 de novembro de 2026.
