Rodando IA local no Linux com Ollama

Rodar modelos de IA localmente deixou de ser coisa de laboratório: com o Ollama você baixa e executa LLMs no seu próprio Linux, sem enviar dados para a nuvem e sem pagar por token. Este post conta de onde o projeto veio — a origem explica muita coisa do desenho dele — e mostra como instalar, ajustar e usar de verdade.

De onde veio o Ollama

Para entender por que o Ollama parece tanto com o Docker, basta olhar quem o escreveu. Jeff Morgan e Michael Chiang são dois canadenses que se conheceram na Universidade de Waterloo e, antes disso tudo, criaram o Kitematic — a interface que tornava o Docker utilizável por gente normal. A Docker comprou o projeto em 2015, e aquilo virou o que hoje se chama Docker Desktop.

A dupla passou pelo Y Combinator na turma de inverno de 2021 e, em 26 de junho de 2023, abriu o repositório do Ollama. A tese era a mesma do Kitematic, trocando container por modelo: existe uma tecnologia poderosa e chata de operar, e alguém precisa embrulhá-la num comando só.

Daí vem tudo o que parece familiar. Você faz pull de um modelo de um registro. Você descreve o seu modelo num arquivo chamado Modelfile, que é um Dockerfile com outro nome. Você lista o que tem instalado com list e apaga com rm. Nada disso é coincidência.

Números de setembro de 2026: escrito em Go, licença MIT, mais de 180 mil estrelas no GitHub e cerca de 9 milhões de desenvolvedores usando. Em julho de 2026 a empresa — de apenas 14 pessoas — levantou uma série B de US$ 65 milhões liderada pela Theory Ventures, chegando a US$ 88 milhões no total, com Benchmark e o próprio Y Combinator na lista.

Um detalhe técnico importante da trajetória: até 2025 o Ollama era, no fundo, uma casca sobre o llama.cpp. Em maio daquele ano o projeto lançou motor próprio, construído sobre a biblioteca de tensores GGML, porque dar suporte a modelo multimodal remendando o llama.cpp tinha virado insustentável. Hoje cada modelo é autocontido e traz a própria camada de projeção — mas o GGML continua ali embaixo, por compatibilidade de CPU.

Por que rodar IA local?

• Privacidade: seus dados não saem da máquina — decisivo para código proprietário, documento interno e qualquer coisa sob LGPD.
• Custo zero por uso: depois de baixar o modelo, rode quantas vezes quiser.
• Funciona offline: útil em rede restrita, laboratório isolado e servidor sem saída para a internet.
• Sem limite de taxa: nenhum “você excedeu a cota” no meio de um processamento em lote.

E o outro lado, que é justo dizer: a qualidade não é a mesma. Um modelo de 8B rodando na sua GPU não substitui um modelo de fronteira. Para tarefa mecânica — resumir, classificar, extrair, reformatar — a diferença some. Para raciocínio difícil, não.

Requisitos reais: é a memória que manda

A conta prática: um modelo quantizado em 4 bits ocupa mais ou menos 0,6 GB por bilhão de parâmetros, mais uma folga para o contexto. Traduzindo:

Tamanho do modelo	VRAM ou RAM necessária	Serve para
1B – 3B	~2–4 GB	Classificar, extrair, autocompletar; roda até em CPU
7B – 8B	~6–8 GB	O ponto ideal de custo-benefício para uso geral
14B	~10–12 GB	Código e raciocínio, com placa de 12 GB ou mais
32B	~20–24 GB	Precisa de placa grande; qualidade bem melhor
70B+	40 GB ou mais	Duas GPUs ou muita paciência com offload para RAM

Se o modelo não couber na VRAM, o Ollama joga o excedente na RAM do sistema e continua funcionando — só que devagar. Se você quer saber onde investir, veja o servidor de IA reacondicionado con 64 GB de VRAM y la Tesla V100 de 32 GB.

Instalando

Instalação em uma linha, direto do site oficial:

curl -fsSL https://ollama.com/install.sh | sh

O instalador cria o serviço systemd ollama e detecta a GPU automaticamente. Confira:

systemctl status ollama
ollama --version
nvidia-smi        # a GPU foi vista?

Se você prefere contêiner — útil para isolar a instalação ou rodar em servidor já containerizado:

docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 
  --name ollama ollama/ollama

docker exec -it ollama ollama run qwen2.5-coder

Baixando e rodando um modelo

# baixa e já abre o chat interativo
ollama run llama3.2

# só baixar, sem abrir o chat
ollama pull qwen2.5-coder

# tamanho específico
ollama pull llama3.2:3b

# listar o que está instalado, com tamanho
ollama list

# ver o que está carregado na memória agora
ollama ps

# uma pergunta só, direto do shell — ótimo para script
ollama run llama3.2 "explique o comando: tar czf backup.tar.gz /etc"

# ler um arquivo e mandar para o modelo
ollama run llama3.2 "resuma os erros deste log" < /var/log/syslog

Dentro do chat interativo, /bye sai, /clear esquece a conversa e /set verbose passa a mostrar a velocidade em tokens por segundo — a métrica que você quer olhar ao comparar modelos.

Para máquina modesta, prefira as variantes menores. Para programar, as famílias coder se saem visivelmente melhor que os modelos generalistas do mesmo tamanho.

O Modelfile: a herança do Docker

Aqui a origem dos criadores aparece inteira. Você personaliza um modelo declarando o que quer num arquivo de texto — mesma lógica do Dockerfile:

FROM qwen2.5-coder:7b

# temperatura baixa = respostas mais previsíveis
PARAMETER temperature 0.2
PARAMETER num_ctx 8192

SYSTEM """
Você é um assistente de sysadmin Linux. Responda em português do Brasil,
sempre com o comando pronto para colar. Avise quando o comando for
destrutivo. Não invente flag que você não tem certeza que existe.
"""

ollama create sysadmin -f ./Modelfile
ollama run sysadmin

É o jeito mais rápido de transformar um modelo genérico numa ferramenta com a cara do seu trabalho — e o resultado fica salvo como um modelo local seu, que você pode listar, rodar e apagar como qualquer outro.

Usando pela API

O Ollama sobe uma API HTTP local na porta 11434. A nativa:

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Explique o comando: tar czf backup.tar.gz /etc",
  "stream": false
}'

E — o que resolve a vida de quem já tem código pronto — ele também fala o protocolo da OpenAI. Qualquer aplicação ou SDK que use a API da OpenAI passa a apontar para a sua máquina trocando só a URL:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

resposta = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Escreva uma unit systemd para um script em /opt/job.sh"}],
)
print(resposta.choices[0].message.content)

Os ajustes que importam

O padrão funciona, mas quase nunca é o que você quer num servidor. A configuração vai no systemd:

sudo systemctl edit ollama

[Service]
# escutar na rede, não só no localhost
Environment="OLLAMA_HOST=0.0.0.0:11434"

# guardar os modelos num disco maior
Environment="OLLAMA_MODELS=/dados/ollama"

# manter o modelo carregado (padrão: 5 minutos)
Environment="OLLAMA_KEEP_ALIVE=30m"

# quantas requisições atender em paralelo
Environment="OLLAMA_NUM_PARALLEL=4"

# quantos modelos diferentes manter na memória ao mesmo tempo
Environment="OLLAMA_MAX_LOADED_MODELS=2"

sudo systemctl daemon-reload && sudo systemctl restart ollama

Aviso de segurança: o Ollama não tem autenticação. Ao trocar o OLLAMA_HOST para 0.0.0.0 você abre a porta 11434 para qualquer um que alcance a máquina — e quem alcança pode usar a sua GPU e ler as suas conversas. Em servidor exposto, ponha um proxy reverso com autenticação na frente e feche a 11434 no firewall.

Ollama, llama.cpp ou vLLM?

	Ollama	llama.cpp	vLLM
Para quem	Uso pessoal e equipe pequena	Quem quer controle fino	Serviço multiusuário em produção
Facilidade	Um comando e funciona	Exige compilar e ajustar	Exige planejar VRAM
Formato	GGUF, via registro próprio	GGUF	Pesos do Hugging Face
Modelo não cabe	Faz offload para a RAM	Faz offload para a RAM	Precisa de --cpu-offload-gb
Vazão sob carga	Cai rápido	Cai rápido	É o objetivo do projeto

Resumindo: se é você na sua máquina, Ollama. Se é uma API que várias pessoas ou vários agentes vão consumir ao mesmo tempo, o caminho é o vLLM.

Manutenção e limpeza

Modelo ocupa vários GB e some do radar. De vez em quando:

ollama list                 # o que eu tenho mesmo?
ollama rm llama3.2          # apagar um
du -sh ~/.ollama/models     # quanto isso está comendo de disco

Os modelos ficam em ~/.ollama/models quando você roda como usuário, e em /usr/share/ollama/.ollama/models quando roda como serviço.

Linha do tempo

• 2015 — a Docker compra o Kitematic, de Jeff Morgan e Michael Chiang; o projeto vira a base do Docker Desktop.
• Inverno de 2021 — a dupla passa pelo Y Combinator.
• 26 de junho de 2023 — o repositório do Ollama é criado, em Go e sob licença MIT, como uma camada sobre o llama.cpp.
• Maio de 2025 — o projeto lança motor próprio sobre a biblioteca GGML, para dar conta dos modelos multimodais.
• Julho de 2026 — série B de US$ 65 milhões liderada pela Theory Ventures; total captado chega a US$ 88 milhões, com cerca de 9 milhões de desenvolvedores usando.
• Setembro de 2026 — mais de 180 mil estrelas no GitHub; a linha estável é a 0.33.

Fechando

O mérito do Ollama não é técnico — o llama.cpp já fazia inferência local antes dele. O mérito é de embalagem: dois caras que já tinham feito exatamente isso com o Docker olharam para os LLMs e transformaram um processo de compilar, converter e ajustar parâmetro em ollama run. É a mesma lição do Kitematic, dez anos depois.

Para continuar: asistentes de IA en la terminal Linux mostra como plugar isso no seu fluxo de trabalho, e GPU vs TPU explica o que está acontecendo no hardware enquanto o modelo responde.

Links oficiais: ollama.com · documentação · github.com/ollama/ollama · releases