- O Ollama permite executar modelos de IA como Llama, Mistral e Gemma localmente por meio de uma única ferramenta de linha de comando
- Instalação em segundos:
curl https://ollama.com/install.sh | sh(Linux/macOS) ou baixe o instalador para Windows - Modelos de entrada exigem 4–8 GB de VRAM; modelos de produção de 70B exigem cerca de 40 GB de VRAM com quantização de 4 bits
- Ponto de equilíbrio versus APIs em nuvem: cerca de 500 mil tokens/mês para um modelo de 70B, menos para modelos menores
O Ollama é uma ferramenta de linha de comando que empacota modelos de linguagem de IA em contêineres executáveis em seu próprio hardware. Em vez de enviar prompts ao OpenAI, à Anthropic ou ao Google e pagar por token, você baixa um modelo uma única vez —Llama 3.3 70B, Mistral 7B, Phi-4, ou qualquer um dos dezenas de modelos suportados— e a inferência é executada inteiramente em sua GPU ou CPU. Seus dados permanecem locais, você não paga nada por requisição após o custo inicial do hardware e mantém controle total sobre o comportamento do modelo e sua disponibilidade.
A contrapartida é o hardware: você precisa de VRAM suficiente para armazenar o modelo. Um modelo de 7B parâmetros com quantização de 4 bits requer cerca de 4–5 GB de memória de GPU, o que cabe em uma RTX 4060 de consumo. Um modelo de 70B precisa de aproximadamente 40 GB com quantização de 4 bits, exigindo uma placa workstation como a RTX 6000 Ada ou uma configuração multi-GPU. A Calculadora de VRAM mostra os requisitos exatos para qualquer tamanho de modelo e nível de quantização.
Instalando o Ollama
Linux
Execute o script oficial de instalação, que detecta sua distribuição e configura o ollama serviço:
curl -fsSL https://ollama.com/install.sh | sh
Isso instala o binário em /usr/local/bin/ollama e registra um serviço systemd. O serviço inicia automaticamente e persiste após reinicializações. Para verificar:
ollama --version
Se você estiver atrás de um proxy corporativo ou precisar de instalação manual, baixe o binário diretamente das versões no GitHub e coloque-o em seu PATH.
macOS
Baixe o .dmg instalador do ollama.com/download, abra-o e arraste o Ollama para a pasta Aplicativos. O aplicativo da barra de menus inicia o servidor local em localhost:11434. Para usar o Ollama no Terminal:
ollama --version
Usuários de macOS com Apple Silicon (M1/M2/M3/M4) podem executar modelos usando memória unificada em vez de VRAM dedicada. Um Mac Studio com 192 GB de memória unificada pode servir um Llama 4 Maverick (240 GB com quantização de 4 bits) usando paginação em disco, embora a velocidade de inferência caia significativamente ao ultrapassar a RAM física.
Windows
Baixe o OllamaSetup.exe instalador do ollama.com/download e execute-o. O instalador adiciona ollama.exe ao seu PATH e inicia o serviço em segundo plano. Abra o PowerShell ou o Prompt de Comando e verifique:
ollama --version
O Windows Subsystem for Linux (WSL2) com passagem de GPU é suportado: instale o Ollama dentro de sua distribuição WSL2 seguindo as instruções para Linux e certifique-se de ter os drivers NVIDIA CUDA instalados no host Windows.
Executando seu primeiro modelo
Baixe e execute o Llama 3.1 8B, um modelo capaz de seguir instruções que cabe em 5 GB de VRAM:
ollama run llama3.1:8b
O Ollama baixa o modelo (aproximadamente 4,7 GB) para ~/.ollama/models (Linux/macOS) ou %USERPROFILE%\.ollama\models (Windows), carrega-o na memória e abre um prompt interativo. Digite uma mensagem, pressione Enter e o modelo gera uma resposta localmente. Pressione Ctrl+D ou digite /bye para sair.
Para executar um modelo em segundo plano e consultá-lo via API:
ollama serve
Isso inicia um servidor em http://localhost:11434. Em outro terminal:
curl http://localhost:11434/api/generate -d '{
"model": "llama3.1:8b",
"prompt": "Explique o controle de congestionamento TCP",
"stream": false
}'
A resposta é retornada em JSON, com a conclusão completa no campo response .
Seleção de modelos e requisitos de VRAM
O Ollama suporta modelos de pesos abertos da Meta, Mistral AI, Microsoft, Google, Alibaba e outras empresas. A tabela abaixo mostra opções populares e sua ocupação de memória com quantização de 4 bits, extraídas do banco de dados de requisitos de VRAM:
| Modelo | Parâmetros | Comprimento do contexto | VRAM em 4 bits | Caso de uso |
|---|---|---|---|---|
| Llama 3.1 8B | 8B | 128K | ~5 GB | Seguimento geral de instruções, adequado para GPUs de consumo |
| Mistral 7B | 7B | 32K | ~4,5 GB | Inferência rápida, boa geração de código |
| Phi-4 | 14B | 16K | ~9 GB | Raciocínio e matemática, eficiente para seu tamanho |
| Mistral NeMo 12B | 12B | 128K | ~7,5 GB | Tarefas de contexto longo, multilíngue |
| Qwen3 8B | 8B | 128K | ~5 GB | Fortemente multilíngue, competitivo com modelos maiores |
| Gemma 3 4B | 4B | 128K | ~3 GB | Menor modelo viável, executa em GPUs integradas |
| Llama 3.3 70B | 70B | 128K | ~40 GB | Raciocínio de nível produtivo, equivalente à classe GPT-4 |
| DeepSeek R1 Distill Llama 70B | 70B | 128K | ~40 GB | Modelo de raciocínio destilado, com desempenho sólido em STEM |
Para listar todos os modelos disponíveis no seu sistema:
ollama list
Para excluir um modelo e liberar espaço em disco:
ollama rm llama3.1:8b
As tags dos modelos seguem o formato nome:tamanho ou nome:versão. Omitir a tag assume como padrão :latest. Veja o catálogo completo em melhores LLMs locais para Ollama.
Comandos comuns e configuração
Execute um modelo com parâmetros personalizados:
ollama run llama3.1:8b --temperature 0.7 --top-p 0.9
Passe um prompt diretamente, sem entrar no modo interativo:
ollama run llama3.1:8b "Escreva uma função Python para analisar datas no formato ISO 8601"
Carregue um modelo na memória sem exibir o prompt (útil para pré-aquecimento antes de atender requisições):
ollama pull llama3.1:8b
Verifique quais modelos estão atualmente carregados na VRAM:
ollama ps
Defina o número de camadas da GPU a serem descarregadas (útil para descarregamento parcial na GPU quando a VRAM é limitada):
OLLAMA_NUM_GPU=35 ollama run llama3.3:70b
Por padrão, o Ollama descarrega todas as camadas para a GPU. Reduzir OLLAMA_NUM_GPU mantém algumas camadas na CPU, trocando velocidade por menor uso de VRAM. Um modelo de 70B com 20 camadas na GPU pode exigir apenas 20 GB de VRAM, mas executará 3–5× mais lentamente.
Para alterar o diretório de armazenamento dos modelos, defina OLLAMA_MODELS antes de executar:
export OLLAMA_MODELS=/mnt/nvme/ollama_models ollama pull llama3.1:8b
O Ollama usa arquivos mapeados em memória, portanto os modelos são carregados mais rapidamente a partir de unidades NVMe do que de SSDs SATA. Espere de 10 a 15 segundos para carregar um modelo de 8B em um sistema moderno, e de 60 a 90 segundos para um modelo de 70B.
Requisitos de hardware
O fator limitante é a VRAM, não o poder computacional. Um modelo de 70B quantizado em 4 bits requer 40 GB de memória GPU, mas executa adequadamente em arquiteturas de gerações anteriores. Uma RTX 3090 (24 GB) pode servir dois modelos de 8B ou um modelo de 30B. Uma RTX 4090 (24 GB) lida com a mesma carga com 30–40% mais alto throughput graças aos núcleos tensoriais aprimorados da arquitetura Ada Lovelace.
GPUs recomendadas por faixa de preço:
- Entrada ($300–500): RTX 4060 Ti 16 GB executa modelos de 8B e 12B
- Usuário avançado ($1000–1500): RTX 4090 ou A4000 Ada executa modelos de 30B confortavelmente
- Estação de trabalho ($4000–7000): RTX 6000 Ada (48 GB) ou duas RTX 4090 para modelos de 70B
- Atendimento a múltiplos modelos ($10.000+): A100 80GB ou H100 80GB para executar várias instâncias de modelos de 70B
Veja o Guia de compra de GPUs para comparações detalhadas. Usuários de Apple Silicon se beneficiam da memória unificada: um M2 Ultra com 192 GB pode executar modelos que exigiriam uma configuração NVIDIA de $25.000, embora o throughput de tokens seja 2–3× menor que o de um A100.
Comparação de custos: local versus API
As APIs em nuvem cobram por token. Claude Sonnet 5 custa $2,00 por milhão de tokens de entrada e $10,00 por milhão de tokens de saída. Uma sessão típica de assistente de programação gera 500 mil tokens por mês (250 mil de entrada, 250 mil de saída), custando $3.000 anualmente.
Um modelo Llama 3.3 70B auto-hospedado em uma estação de trabalho de $6.000 (RTX 6000 Ada) tem custo marginal zero após a aquisição do hardware. O ponto de equilíbrio ocorre aproximadamente em 500 mil tokens por mês. Abaixo disso, as APIs são mais baratas; acima disso, a inferência local é vantajosa. Use a calculadora de hospedagem própria para modelar sua carga de trabalho específica.
Modelos menores atingem o ponto de equilíbrio mais rapidamente. Um modelo de 8B em uma RTX 4060 Ti de $500 paga-se em 3–4 meses comparado ao uso de APIs em nuvem com uso moderado (100 mil tokens/mês). A vantagem adicional é a privacidade: seu código, documentos e dados internos nunca deixam sua rede.
Perguntas frequentes
O Ollama pode executar modelos apenas na CPU?
Sim, mas a inferência é 10–50× mais lenta, dependendo do tamanho do modelo. Um modelo de 8B gera 1–3 tokens por segundo em uma CPU moderna Ryzen ou Intel, comparado a 40–80 tokens/seg em uma RTX 4090. Defina OLLAMA_NUM_GPU=0 para forçar o modo somente CPU. É prático para processamento em lote ou uso com baixo tráfego, mas inviável para chat interativo.
Como a quantização afeta a qualidade?
A quantização em 4 bits reduz o tamanho do modelo em 75%, com perda mínima de qualidade — benchmarks mostram degradação de 1–3% na precisão em MMLU e HumanEval comparado ao FP16. A quantização em 3 bits (Q3) reduz ainda mais o tamanho, mas degrada significativamente o raciocínio e o seguimento de instruções. O Ollama usa Q4_0 como padrão, equilibrando qualidade e uso de VRAM. Você pode baixar versões em 8 bits ou FP16 especificando tags como llama3.1:8b-q8_0, dobrando os requisitos de VRAM.
Posso ajustar finamente modelos com o Ollama?
Não. O Ollama é um ambiente de execução para inferência, não um framework de treinamento. Para ajuste fino de um modelo, use ferramentas como Hugging Face Transformers, Axolotl ou LLaMA Factory, exporte o resultado no formato GGUF e importe-o para o Ollama via um Modelfile. O processo está documentado no repositório GitHub do Ollama em docs/import.md.
O que é a API do Ollama e como usá-la?
O Ollama expõe uma API REST compatível com OpenAI em localhost:11434. O bloco /api/generate o endpoint lida com conclusões, e /api/chat suporta conversas com múltiplas voltas, mantendo o histórico de mensagens. Você pode integrá-lo a bases de código existentes simplesmente alterando a URL base: em vez de https://api.openai.com/v1, aponte seu cliente para http://localhost:11434. Muitos frameworks, como LangChain e LlamaIndex, possuem suporte nativo ao Ollama.
Quantas requisições por segundo o Ollama consegue lidar?
Um único modelo carregado atende uma requisição por vez. O throughput depende do tamanho do modelo e do hardware: uma RTX 4090 gera 60–80 tokens/seg para um modelo de 8B e 15–25 tokens/seg para um modelo de 70B. Para lidar com usuários simultâneos, você pode escalar horizontalmente (várias máquinas) ou usar agrupamento (batching) na camada de aplicação. O Ollama não possui fila de requisições embutida; você precisa de um proxy reverso como o NGINX ou de um balanceador de carga.
Posso executar vários modelos simultaneamente?
Sim, desde que você tenha VRAM suficiente. Carregue um segundo modelo com ollama run em um novo terminal enquanto o primeiro estiver em execução. O Ollama compartilha a GPU entre os modelos. Dois modelos de 8B (10 GB no total) rodam confortavelmente em uma RTX 4090 de 24 GB. A alternância entre modelos é quase instantânea se ambos já estiverem carregados; caso contrário, espere tempos de carregamento de 10 a 90 segundos, dependendo do tamanho do modelo.
