O que é Ollama: rode LLMs de IA localmente no seu Linux, de graça

Se você já usou algum assistente de IA para resumir um texto, revisar um código ou tirar uma dúvida, provavelmente fez isso por um serviço na nuvem — ou seja, usando o computador dos outros, pagando por uso e entregando seus dados para uma empresa lá longe. O Ollama vira essa lógica de cabeça para baixo: é uma ferramenta livre e de código aberto que permite baixar e rodar modelos de linguagem (os famosos LLMs) diretamente na sua própria máquina, sem mensalidade, sem chave de API e sem enviar uma linha sequer dos seus dados para fora. E, para a alegria de quem vive no terminal, ele foi feito pensando em quem usa Linux.

Neste guia você vai entender o que é o Ollama, por que rodar um LLM localmente faz tanto sentido (privacidade, custo zero, uso offline e controle total), como instalar no Linux com um único comando, quais são os comandos essenciais do dia a dia, que modelos escolher e quanto de hardware você precisa. No fim, a gente ainda mostra a API HTTP local, as interfaces gráficas como o Open WebUI e as limitações que ninguém conta. Prepare o café: dá para ter sua própria IA rodando em poucos minutos.

O que é o Ollama, afinal

O Ollama é um programa que empacota toda a complexidade de rodar um modelo de linguagem grande em uma experiência simples de linha de comando. Antes dele, quem quisesse rodar um LLM em casa precisava caçar os pesos do modelo em repositórios como o Hugging Face, lidar com formatos de arquivo diferentes, configurar bibliotecas de inferência e rezar para que tudo se encaixasse. Era um trabalho de especialista.

Com o Ollama, esse mesmo processo vira um comando só. Ele baixa o modelo já otimizado e comprimido, sobe um servidor de inferência local e abre uma janela de conversa — parecido com o que você já conhece de chatbots na web, só que rodando inteiramente na sua máquina. Uma comparação que ajuda: pense no Ollama como um gerenciador de pacotes para modelos de IA. Assim como o apt instala e gerencia programas, o Ollama instala e gerencia modelos. Você pede, ele baixa, você usa.

Por baixo do capô, ele também abstrai o modelo como um serviço. Quando você conversa pelo terminal, na verdade está falando com um servidor local que faz o trabalho pesado. Isso tem uma consequência ótima para quem desenvolve, mas a gente chega lá — primeiro, o porquê de tudo isso.

Por que rodar um LLM localmente

Rodar IA na nuvem é conveniente, mas tem custos escondidos. Rodar localmente com o Ollama resolve vários deles de uma vez. Vale entender cada motivo:

• Privacidade de verdade. Os seus prompts, documentos e código nunca saem do computador. Para quem lida com dados sensíveis — contratos, informações de clientes, código proprietário — isso não é luxo, é requisito. O dado fica no ambiente seguro do começo ao fim.
• Custo zero de API. Não há cobrança por token, por requisição ou por mês. Depois de baixar o modelo, você usa quanto quiser sem ver a fatura crescer. Se hoje você paga por uma API de IA, essa conta some.
• Funciona offline. Uma vez baixado o modelo, você não depende de internet para conversar com ele. Isso é útil em viagens, em redes instáveis e até em dispositivos com acesso limitado à rede, como aparelhos de IoT.
• Controle e previsibilidade. O modelo não muda de comportamento da noite para o dia porque uma empresa atualizou algo no servidor. A versão que você baixou é a versão que roda, sempre.
• Sem latência de rede. Como a resposta é gerada ali mesmo, não há o vai e volta até um datacenter. Em máquinas capazes, a resposta começa a aparecer quase instantaneamente.

Nem tudo são flores — hardware modesto limita o tamanho dos modelos, e a qualidade dos modelos abertos, embora tenha evoluído muito, nem sempre bate a dos maiores serviços pagos. Mas para uma quantidade enorme de tarefas do dia a dia, a IA local já dá conta com folga. E, se em algum momento você quiser comparar com a abordagem de rodar modelos na nuvem sob demanda, temos um panorama disso no nosso artigo sobre o Replicate.

Como instalar o Ollama no Linux

Aqui é onde o Ollama brilha para quem usa Linux: a instalação é um comando só. Abra o terminal e rode o script oficial de instalação:

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

Esse comando baixa o script e o executa, cuidando de todo o processo: ele detecta a sua arquitetura, instala o binário do Ollama, configura um serviço de sistema (via systemd, na maioria das distribuições) e, quando encontra uma GPU compatível, já prepara o suporte de aceleração. Ao terminar, o Ollama fica rodando em segundo plano como um serviço, pronto para receber comandos.

Se você é do tipo cauteloso — e faz bem — que não sai executando script da internet direto no shell, baixe primeiro, leia o conteúdo e só então rode. Nunca é demais dar uma olhada no que vai rodar na sua máquina. Se os canos e barras verticais do comando acima parecem magia, vale a leitura do nosso guia de comandos do terminal Linux para entender o que cada pedaço faz.

Para confirmar que deu tudo certo, verifique a versão instalada:

ollama --version

Se aparecer um número de versão, o Ollama está instalado e funcionando. Simples assim. Em algumas distribuições você também encontra o Ollama nos repositórios ou em formatos como Flatpak, mas o script oficial costuma ser o caminho mais direto e atualizado.

E em outros sistemas?

Vale mencionar, para não deixar dúvida: o Ollama também roda no macOS (com instalador próprio, aproveitando a aceleração dos chips Apple) e no Windows (com instalador gráfico). O funcionamento e os comandos são praticamente idênticos. Mas, como aqui a casa é do software livre, o nosso foco é o terminal do Linux — e é lá que a experiência combina melhor com o espírito da ferramenta.

Comandos essenciais do Ollama

A interface de linha de comando do Ollama é enxuta e fácil de decorar. Com meia dúzia de comandos você faz tudo. Vamos aos principais.

ollama run — baixar e conversar

Este é o comando que você mais vai usar. Ele baixa o modelo (se ainda não estiver na máquina) e abre uma sessão de conversa interativa:

ollama run llama3.2

Na primeira vez, o Ollama baixa os pesos do modelo — pode demorar, dependendo do tamanho e da sua conexão. Nas próximas, ele carrega direto do disco e a conversa começa quase na hora. Você digita sua pergunta, o modelo responde ali mesmo no terminal, e a conversa continua mantendo o contexto. Para sair da sessão interativa, digite:

/bye

Você também pode mandar um prompt único sem entrar no modo interativo, passando o texto direto na linha de comando — ótimo para scripts:

ollama run llama3.2 "Explique o que é um kernel em uma frase"

ollama pull — só baixar o modelo

Quando você quer apenas baixar um modelo sem já começar a conversar (para deixar pronto, ou para usar depois via API), use o pull:

ollama pull mistral

É o equivalente a um "instalar sem abrir". Útil para preparar o ambiente com antecedência, especialmente antes de ficar offline.

ollama list — ver o que você tem

Para listar todos os modelos que já estão baixados na sua máquina, com tamanho e data:

ollama list

Como cada modelo ocupa espaço no disco (às vezes bastante), esse comando ajuda a lembrar do que você acumulou. Você pode ter quantos modelos quiser instalados ao mesmo tempo e alternar entre eles à vontade.

ollama serve — subir o servidor manualmente

Na instalação padrão do Linux, o Ollama já roda como serviço em segundo plano. Mas, se você fechou o serviço ou quer rodá-lo manualmente para ver os logs de cada requisição, use:

ollama serve

Isso sobe o servidor HTTP do Ollama e mostra, em tempo real, todas as requisições que chegam. É a forma de deixar a API disponível na porta padrão quando o serviço não está ativo.

Outros comandos úteis

• ollama rm nome-do-modelo — remove um modelo do disco, liberando espaço.
• ollama cp origem destino — copia um modelo com outro nome, útil como base para personalizações.
• ollama ps — mostra quais modelos estão carregados na memória neste momento.
• ollama create — cria um modelo personalizado a partir de um arquivo de configuração (o Modelfile, que a gente vê mais adiante).

Modelos populares: Llama, Mistral, Gemma, Phi, DeepSeek

O grande trunfo do Ollama é o ecossistema de modelos. Você tem acesso a praticamente qualquer modelo aberto relevante, todos disponíveis na biblioteca oficial (em ollama.com/library), onde dá para navegar, filtrar e comparar centenas de opções. Alguns dos nomes mais usados pela comunidade:

• Llama — a família de modelos abertos da Meta, uma das mais populares e versáteis. Vem em várias versões e tamanhos, ajustada para diferentes usos e idiomas. Costuma ser um ótimo ponto de partida.
• Mistral — modelos franceses conhecidos por entregar muita qualidade em um tamanho relativamente enxuto. Bom equilíbrio entre desempenho e consumo de recursos.
• Gemma — a linha aberta do Google, leve e eficiente, com versões que rodam confortavelmente em máquinas modestas.
• Phi — os "pequenos notáveis" da Microsoft, modelos compactos que surpreendem pela capacidade apesar do tamanho reduzido. Ideais para hardware limitado.
• DeepSeek — ganhou fama pelas versões voltadas a raciocínio, que "pensam em voz alta" antes de responder, mostrando a linha de raciocínio até chegar à conclusão.

Além desses, há modelos especializados: os multimodais, que entendem imagens além de texto; os de embeddings, que transformam documentos em vetores para busca semântica (a base de um sistema de perguntas e respostas sobre os seus próprios PDFs); e os de chamada de ferramentas (tool calling), ajustados para acionar funções, APIs e serviços externos de forma confiável — a peça-chave de agentes de IA.

Tamanhos e quantização: o que aquele "7B" significa

Você vai reparar que os modelos vêm marcados com números como 3b, 7b, 13b ou 70b. Esse número é a quantidade de parâmetros (em bilhões) do modelo — grosso modo, o "tamanho do cérebro". Quanto maior, mais capaz o modelo tende a ser, mas também mais memória e poder de processamento ele exige. Um modelo de 7 bilhões de parâmetros roda tranquilo em muitos computadores; um de centenas de bilhões de parâmetros, esse já é assunto para máquinas parrudas, servidores dedicados.

É aqui que entra a quantização, um dos motivos de o Ollama funcionar tão bem em hardware comum. Quantizar é comprimir o modelo, reduzindo a precisão dos números que ele usa internamente (por exemplo, de 16 para 4 bits). O resultado é um modelo bem menor e mais leve, que roda em máquinas modestas, com uma perda de qualidade geralmente pequena. Os modelos que o Ollama distribui já vêm quantizados e otimizados por padrão — por isso você consegue rodar em casa algo que, sem essa mágica, exigiria muito mais recursos.

Requisitos de hardware: o que você precisa

A pergunta inevitável: "será que roda no meu computador?". A resposta depende, principalmente, de dois fatores — memória e (opcionalmente) placa de vídeo.

A regra de bolso mais importante é sobre RAM: o modelo inteiro precisa caber na memória para rodar. Como referência prática, muita gente segue a orientação de ter por volta de 8 GB de RAM para modelos de ~7 bilhões de parâmetros, 16 GB para os de ~13 bilhões e 32 GB ou mais para os de ~33 bilhões. Modelos gigantes, de centenas de bilhões de parâmetros, são desconfortáveis até em máquinas com 64 GB — não à toa, ficam mais para servidores. A boa notícia é que os modelos menores e quantizados de hoje são surpreendentemente capazes, então você não precisa de um monstro para começar.

Sobre processamento, há dois caminhos:

• Com GPU. Se você tem uma placa de vídeo dedicada, o Ollama a usa para acelerar bastante a geração de respostas. No Linux, ele suporta GPUs NVIDIA (com os drivers e o CUDA apropriados) e também placas AMD (via ROCm). O script de instalação já tenta detectar e configurar o suporte. Uma GPU com boa quantidade de memória de vídeo (VRAM) faz muita diferença na velocidade.
• Só CPU. Não tem placa dedicada? Sem problema — o Ollama roda em CPU. Vai ser mais lento, especialmente em modelos maiores, mas funciona. Para modelos pequenos e quantizados, a experiência em CPU costuma ser perfeitamente utilizável para tarefas do dia a dia.

Não custa lembrar do óbvio que a gente às vezes esquece: além da RAM, você precisa de espaço em disco. Cada modelo ocupa de alguns gigabytes a dezenas deles. Se você colecionar modelos, o disco enche rápido — daí a utilidade do ollama rm para fazer faxina.

A API HTTP local: onde a mágica acontece para quem programa

Aqui está talvez o recurso mais poderoso do Ollama, e o que o torna tão querido por quem desenvolve. Quando o Ollama está rodando, ele expõe uma API HTTP local na porta 11434 (endereço localhost:11434). Todo comando que você executa pelo terminal, na verdade, passa por esse servidor — e você também pode acioná-lo diretamente a partir de qualquer código que faça requisições HTTP.

Isso significa que dá para conversar com o modelo a partir de curl, do Postman, de Python, de JavaScript, do que você quiser. Um exemplo mínimo com curl, mandando um prompt para o endpoint de geração:

curl http://localhost:11434/api/generate -d '{"model": "llama3.2", "prompt": "Diga olá em português", "stream": false}'

A resposta volta em JSON, gerada localmente. Existem endpoints para conversar em formato de chat, gerar texto, criar embeddings, listar e gerenciar modelos e por aí vai. Muita gente ativa o modo de streaming para receber a resposta token a token, em tempo real, em vez de esperar o texto inteiro ficar pronto.

Para quem prefere não montar as requisições na mão, há bibliotecas oficiais que embrulham tudo isso. Em Python, por exemplo, basta instalar o pacote:

pip install ollama

E aí você cria um cliente, escolhe o modelo, manda o prompt e pega a resposta em poucas linhas — sem se preocupar com URLs e cabeçalhos. Há pacote equivalente para JavaScript, e frameworks de IA populares também se integram ao Ollama sem dificuldade.

O grande valor disso é que o modelo vira um serviço na sua rede. Você pode, inclusive, rodar o Ollama em uma máquina mais potente e acessá-la de outra pela rede — por SSH ou fazendo a requisição remota direto na porta. Se essa ideia de acessar máquinas remotamente é novidade para você, vale conferir o nosso guia de sobrevivência no Linux para iniciantes, que ajuda a pegar o jeito do terminal. De um lado, o servidor faz o trabalho pesado; do outro, seus aplicativos só consomem a resposta.

Interfaces gráficas: Open WebUI e companhia

Conversar pelo terminal é ótimo, mas nem todo mundo quer viver na linha de comando o tempo todo. Como o Ollama expõe aquela API local, floresceu ao redor dele um ecossistema de interfaces gráficas que se conectam a ele.

A mais conhecida é a Open WebUI, uma interface web de código aberto que dá ao Ollama uma cara parecida com a dos chatbots comerciais: histórico de conversas, troca fácil de modelos, upload de arquivos e por aí vai. Com ela, dá para montar um pipeline de RAG (geração aumentada por recuperação) sem escrever código: você joga seus PDFs e documentos, e a interface usa o contexto deles para responder às suas perguntas — tudo local, tudo privado. É a forma mais amigável de colocar a família ou colegas menos técnicos para usar a sua IA caseira.

Além da Open WebUI, existem extensões de editores de código, plugins de navegador e aplicativos de desktop que se conectam ao Ollama pela mesma porta. A lógica é sempre a mesma: o Ollama é o motor; a interface é só a carroceria bonita por cima. Você escolhe a que combina com o seu jeito de trabalhar.

Personalizando modelos com o Modelfile

Um recurso elegante do Ollama é o Modelfile, um arquivo de configuração inspirado no jeito como o Docker descreve contêineres. Com ele, você parte de um modelo existente e o ajusta ao seu gosto — definindo um prompt de sistema fixo, mudando parâmetros como a temperatura (que controla a criatividade das respostas) e outros comportamentos.

Na prática, você escreve um arquivo simples indicando o modelo base e as instruções. Por exemplo, um Modelfile pode dizer "use o Llama 3.2 como base, defina esta temperatura e sempre responda como um assistente especializado em Linux". Depois, você cria o seu modelo personalizado com:

ollama create meu-assistente -f ./Modelfile

Pronto: agora existe um modelo chamado meu-assistente que você pode rodar com ollama run meu-assistente ou chamar pela API, exatamente como qualquer outro. É a maneira de moldar o comportamento do modelo sem precisar treinar nada do zero. O Modelfile também permite importar modelos de fora (como pesos baixados do Hugging Face) e transformá-los em modelos prontos para o Ollama.

Casos de uso do Ollama no dia a dia

Tudo isso é legal, mas para que serve na vida real? Alguns cenários em que o Ollama se encaixa bem:

• Programação em dupla. Um assistente de código rodando localmente, que revisa funções, explica trechos e sugere melhorias sem mandar o seu código proprietário para servidor nenhum.
• Resumo e análise de documentos. Jogue relatórios, artigos ou transcrições e peça resumos, com a certeza de que o conteúdo confidencial fica na sua máquina.
• Perguntas e respostas sobre os seus dados. Com embeddings e uma interface como a Open WebUI, você cria uma "base de conhecimento" pessoal e conversa com os seus próprios arquivos.
• Desenvolvimento de aplicativos com IA. Protótipos e produtos que usam IA sem depender de uma API paga, mantendo os dados dos clientes dentro do ambiente seguro da empresa.
• Aprendizado e experimentação. Testar modelos diferentes, comparar respostas e entender como os LLMs funcionam, sem gastar um centavo em cada tentativa.
• Ambientes isolados. Máquinas com acesso restrito à internet, dispositivos de borda e cenários em que enviar dados para a nuvem simplesmente não é uma opção.

Limitações: o que o Ollama não faz milagre

Para ser justo e honesto, o Ollama tem seus limites, e é bom conhecê-los antes de criar expectativas irreais.

O principal é o hardware. Você está limitado ao que a sua máquina aguenta. Os modelos verdadeiramente enormes, que rivalizam com os melhores serviços pagos, exigem recursos que a maioria dos computadores domésticos não tem. Na prática, você vai rodar modelos menores — que são bons, mas nem sempre alcançam a mesma qualidade dos gigantes hospedados na nuvem.

Há também a questão da velocidade: em CPU ou em GPUs modestas, modelos maiores respondem devagar. E os modelos abertos, embora avancem num ritmo impressionante, ainda podem ficar atrás dos líderes de mercado em tarefas mais sofisticadas de raciocínio. Por fim, gerenciar modelos, atualizações e espaço em disco é responsabilidade sua — não há uma equipe cuidando disso nos bastidores como acontece num serviço gerenciado.

Nada disso desmerece a ferramenta. O Ollama não promete ser a IA mais poderosa do universo; ele promete colocar IA capaz, privada e gratuita ao alcance da sua mão. E isso ele cumpre com louvor.

Perguntas frequentes

O Ollama é gratuito mesmo?

Sim. O Ollama é um projeto de código aberto e gratuito, e os modelos que ele distribui também são abertos e sem custo. Depois de baixar, você usa quanto quiser sem pagar por token ou por requisição. O único "custo" é o hardware que você já tem e a energia elétrica para rodá-lo.

Preciso de placa de vídeo para usar o Ollama?

Não é obrigatório. O Ollama roda em CPU, embora mais devagar. Uma GPU (NVIDIA ou AMD, no Linux) acelera muito a geração de respostas, especialmente em modelos maiores. Para começar com modelos pequenos e quantizados, muita gente se vira bem só com a CPU e uma boa quantidade de RAM.

Quanto de RAM eu preciso?

Depende do tamanho do modelo, porque ele precisa caber na memória. Como referência geral, modelos de ~7 bilhões de parâmetros pedem por volta de 8 GB de RAM; os de ~13 bilhões, cerca de 16 GB; e os maiores, 32 GB ou mais. Os modelos pequenos de hoje são capazes o suficiente para a maioria das tarefas, então não é preciso ter uma máquina de ponta.

Os meus dados ficam mesmo privados?

Ficam. Como o modelo roda inteiramente na sua máquina, nada do que você digita é enviado para a internet. É exatamente por isso que o Ollama é tão indicado para trabalhar com informações sensíveis. A única exceção seria se você mesmo configurasse o servidor para ser acessado por outras máquinas — aí vale tomar os cuidados de segurança de rede de sempre.

Dá para usar o Ollama nos meus próprios programas?

Sim, e é um dos seus pontos fortes. O Ollama expõe uma API HTTP local na porta 11434, que você chama de qualquer linguagem — Python, JavaScript, ou via curl. Há bibliotecas oficiais que facilitam a integração, e os principais frameworks de IA se conectam a ele sem dificuldade. Para o desenvolvedor, o modelo vira apenas mais um serviço local.

Qual modelo eu escolho para começar?

Comece por um modelo pequeno e versátil, como uma versão recente do Llama, do Mistral, do Gemma ou do Phi na faixa de 3 a 7 bilhões de parâmetros. Eles baixam rápido, rodam na maioria das máquinas e dão uma boa noção do que a ferramenta oferece. Depois, com o gosto pego, você experimenta modelos maiores ou especializados conforme o seu hardware e a sua necessidade.

Conclusão: sua IA, na sua máquina

O Ollama pegou algo que era território de especialistas — rodar grandes modelos de linguagem localmente — e transformou em um comando de terminal que qualquer usuário de Linux consegue executar. Em troca, você ganha privacidade real, custo zero de API, uso offline e controle total sobre a sua IA. Não é a única ferramenta para isso, e não faz milagre com hardware fraco, mas entrega uma experiência simples e poderosa que dificilmente decepciona.

Se você chegou até aqui, o próximo passo é o mais divertido: abrir o terminal, rodar aquele curl de instalação, dar um ollama run em um modelo pequeno e conversar com a sua primeira IA local. Em poucos minutos, você terá um assistente rodando na sua máquina, sem enviar um byte para lugar nenhum. No fim das contas, é o espírito do software livre aplicado à inteligência artificial: a tecnologia na sua mão, do seu jeito, no seu computador. E isso, convenhamos, é bem legal.