Running local AI on Linux with Ollama

Running AI models locally is no longer a lab curiosity: with Ollama you download and run LLMs on your own Linux machine, without sending data to the cloud and without paying per token. This post explains where the project came from — the origin explains a lot about its design — and shows how to install, configure, and actually use it.

Where Ollama came from

Para entender por que o Ollama parece tanto com o Docker, basta olhar quem o escreveu. Jeff Morgan and 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.

The duo went through Y Combinator in the class of winter of 2021 and, in 26 June of 2023, they opened Ollama's repository. The thesis was the same as Kitematic, swapping container for model: there exists a powerful technology that's annoying to operate, and someone needs to wrap it in a single command.

From there comes everything that seems familiar. You do pull from a model from a registry. You describe your model in a file called Modelfile, which is a Dockerfile with another name. You list what's installed with list and delete with rm. None of this is a coincidence.

September numbers of 2026: written in Go, , 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.

Why run local AI?

• 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.

Real requirements: it's memory that matters

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 refurbished AI server with 64 GB of VRAM and the Tesla V100 de 32 GB.

Installing

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

Downloading and running a model

# 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.

The Modelfile: Docker's legacy

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.

Using the 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 to 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
Ease of use	One command and it works	Exige compilar e ajustar	Exige planejar VRAM
Format	GGUF, via its own registry	GGUF	Hugging Face weights
Modelo não cabe	Faz offload para a RAM	Faz offload para a RAM	Precisa de --cpu-offload-gb
Throughput under load	Cai rápido	Cai rápido	It is the project's objective

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.

Timeline

• 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 June of 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.
• July 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.

Closing

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.

To continue: AI assistants on the Linux terminal mostra como plugar isso no seu fluxo de trabalho, e GPU vs TPU explica o que está acontecendo no hardware enquanto o modelo responde.

Official links: ollama.com · documentation · github.com/ollama/ollama · releases