Ollama: como instalar e executar LLMs localmente

No mês passado, minha conta da API da OpenAI passou de US$ 300. Eu só estava testando alguns recursos repetidamente durante o desenvolvimento, mas os custos se acumularam depressa. Pior ainda: os documentos processados continham dados internos da empresa, e enviá-los para a nuvem sempre me deixava desconfortável.

Naquele momento, decidi procurar uma alternativa local. Passei uma semana experimentando várias ferramentas e, no fim, descobri que o Ollama era a opção que dava menos trabalho.

Talvez você já tenha enfrentado um dilema parecido: os serviços de IA na nuvem estão cada vez mais caros, a privacidade dos dados preocupa ou você simplesmente precisa usar IA em um ambiente offline. O Ollama ajuda a resolver esses problemas. Ele permite executar grandes modelos de linguagem no seu próprio computador, leva poucos minutos para começar, é totalmente gratuito e mantém todos os dados na sua máquina. A seguir, compartilho os problemas que encontrei e o que aprendi, para que você evite os mesmos desvios.

O que é o Ollama?

O nome pode causar um pouco de confusão: Ollama não é um modelo, mas uma ferramenta para executar modelos. Assim como o Docker simplifica o uso de contêineres, o Ollama torna acessível a execução local de grandes modelos de linguagem.

Em termos simples, você usa o Ollama para baixar um modelo, como o Llama 3.2, e então pode conversar com ele, pedir que escreva código, faça traduções e muito mais. Toda a inferência acontece localmente.

Mas por que se dar ao trabalho de usar um modelo local? Serviços na nuvem como ChatGPT e Claude já não são convenientes?

São, de fato. Depois de algum tempo de uso, porém, alguns problemas começam a aparecer:

Custo. As chamadas de API são cobradas por token. Se você faz muitas chamadas durante os testes, a conta pode assustar. Já vi pessoas gastarem centenas ou até milhares de dólares em um único mês de desenvolvimento.

Privacidade. Todas as conversas precisam ser enviadas para a nuvem. Se você trabalha com documentos internos da empresa, dados de clientes ou informações sensíveis, isso pode não atender aos requisitos de conformidade. Quem trabalha em órgãos públicos provavelmente entende muito bem essa preocupação.

Rede. É necessário estar conectado para usar os serviços. Quando a rede está instável, a experiência piora bastante; em cenários totalmente offline, eles simplesmente não funcionam.

Limitações. APIs na nuvem impõem vários limites — de taxa, cota, recursos e outros. Às vezes, você só quer testar uma funcionalidade e acaba travado por alguma restrição.

O Ollama resolve diretamente esses pontos. Depois que o modelo é baixado para o seu computador, toda a inferência ocorre localmente. Ele funciona sem internet, os dados não saem da máquina, não há custo de API nem limite de chamadas.

Para desenvolvedores, há outra vantagem: o Ollama oferece uma API completa e compatível com o formato da OpenAI. Assim, você pode testar com um modelo local durante o desenvolvimento, economizando dinheiro, e trocar para uma API na nuvem em produção. É uma configuração bastante flexível.

Como instalar o Ollama em três etapas

A instalação é realmente simples. Existem pequenas diferenças entre as plataformas, mas em geral tudo fica pronto em poucos minutos.

Linux: a opção mais simples

Se você usa Linux, um comando é suficiente:

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

Ao final da execução, o Ollama estará instalado e o serviço será iniciado automaticamente.

Sinceramente, Linux é a plataforma que mais recomendo. Implantação em servidores e uso em contêineres funcionam muito bem. Se você pretende usar o Ollama em produção, Linux é a primeira opção.

Também é possível instalar manualmente, mas não recomendo esse caminho para iniciantes. Se for realmente necessário, você pode baixar o binário e configurar o serviço systemd por conta própria. Registrei os detalhes no relatório de pesquisa, então não vou me estender aqui.

macOS: interface gráfica mais amigável

No macOS, há duas formas de instalar.

Com Homebrew:

brew install ollama

Depois da instalação, execute ollama serve para iniciar diretamente ou use brew services start ollama para mantê-lo em segundo plano.

Não quer usar o Homebrew? Baixe o instalador .pkg no site oficial e dê dois cliques. Usuários de Mac já conhecem bem esse processo.

Uma dica: Macs com Apple Silicon (M1/M2/M3) ativam automaticamente a aceleração por GPU via Metal, com desempenho muito bom. Meu MacBook Pro M2 executa modelos 8B com fluidez e também roda modelos 13B, embora o consumo de memória seja maior.

Windows: winget é o jeito mais prático

No Windows, você pode usar o winget:

Alibaba Cloud - Escolha dos desenvolvedores, 15% de desconto exclusivo em Lighthouse

Ganhar 15% off →Anúncio

winget install --id=Ollama.Ollama -e

Outra opção é baixar diretamente o instalador .exe no site oficial. Depois da instalação, o Ollama inicia automaticamente e aparece na bandeja do sistema.

Para confirmar que a instalação deu certo:

ollama --version

Se o número da versão aparecer, está tudo instalado. Simples, não é?

Como executar seu primeiro modelo

Depois de instalar, vamos executar um modelo.

Primeiro, escolha um. Para começar, recomendo llama3.2 ou qwen:8b. O primeiro é o modelo mais recente da Meta e tem boa capacidade geral; o segundo é o Qwen, com compreensão especialmente boa de chinês.

Execute:

ollama run llama3.2

O comando baixa o modelo automaticamente — na primeira vez, isso leva alguns minutos — e então abre uma interface interativa.

Você verá:

>>> Send a message (/? for help)

Agora já pode conversar. Experimente:

>>> Olá, apresente-se

O modelo responderá em tempo real, como em uma conversa. Para sair, digite /bye ou pressione Ctrl+D.

O que significa o tamanho do modelo

Talvez você tenha notado números como 3b e 8b nos nomes dos modelos. Eles indicam a quantidade de parâmetros, ou seja, o tamanho do “cérebro” do modelo.

Modelos 3B: 3 bilhões de parâmetros. Rodam até em notebooks leves e exigem apenas 4 GB de memória. São rápidos, mas têm recursos mais básicos. Funcionam bem para conversas simples e instruções de ferramentas.

Modelos 8B: 8 bilhões de parâmetros. São o “ponto de equilíbrio” para a maioria dos notebooks e desktops. Precisam de 8 GB de memória e atendem bem a conversas do dia a dia e tarefas simples de programação. É a categoria que mais uso.

Modelos 13B: 13 bilhões de parâmetros e 16 GB de memória. A qualidade das respostas melhora visivelmente, o contexto também é maior e eles combinam com máquinas equipadas com placas de vídeo intermediárias ou avançadas.

Modelos 70B: 70 bilhões de parâmetros e 64 GB de memória ou mais. São voltados a servidores profissionais, com mais capacidade, mas exigem muito do hardware. Para ser sincero, usuários individuais raramente precisam de um modelo desse porte.

Para começar, um modelo entre 3B e 8B é suficiente. Eles rodam bem na maioria dos notebooks modernos. Não tente começar pelo maior modelo: primeiro conheça a ferramenta com um modelo pequeno e faça o upgrade conforme a necessidade.

Comandos mais usados para gerenciar modelos

O Ollama oferece um conjunto simples de comandos para gerenciar modelos. Basta memorizar os mais comuns.

Baixar um modelo:

ollama pull llama3.2
ollama pull qwen:8b

O comando pull baixa o modelo da biblioteca para a máquina local. Depois disso, ele permanece em cache e não precisa ser baixado novamente na próxima execução.

Listar os modelos instalados:

ollama list

Esse comando mostra todos os modelos baixados, incluindo nome, tamanho e data de modificação.

Excluir um modelo:

ollama rm llama3.2

Se não precisar mais de um modelo, remova-o para liberar espaço.

Ver os detalhes de um modelo:

ollama show llama3.2

O resultado inclui detalhes técnicos, como quantidade de parâmetros e método de quantização.

Outros comandos, como cp para copiar e push para enviar, são usados com menos frequência, então não entrarei em detalhes. Consulte a documentação quando precisar.

Alguns modelos recomendados

Estas são minhas recomendações para diferentes usos:

Conversas cotidianas:

• llama3.2: o modelo mais recente da Meta, com boa capacidade geral
• qwen:8b: Qwen, excelente em chinês
• mistral: modelo europeu de código aberto, com bom desempenho

Assistência de programação:

• codellama: ajustado especificamente para geração de código
• deepseek-coder: modelo de código da DeepSeek, bastante útil

Multimodais, capazes de interpretar imagens:

• llava: oferece suporte à compreensão de imagens
• llama3.2-vision: versão visual do Llama 3.2

Se não souber qual escolher, comece com llama3.2:3b ou qwen:8b. Ambos são ótimos para iniciantes e rodam com leveza.

Aceleração por GPU: a diferença de velocidade é enorme

Este ponto é muito importante. Também é possível executar modelos na CPU, mas a diferença de desempenho é enorme: uma GPU pode ser de 10 a 20 vezes mais rápida que uma CPU.

Na primeira vez que usei o Ollama, não prestei atenção à configuração da GPU, e o modelo ficou lento a ponto de ser frustrante. Só depois percebi que a aceleração por GPU não estava ativa. Quando a configurei corretamente, a velocidade aumentou de imediato.

O Ollama oferece suporte a três tipos de GPU: NVIDIA, AMD e Apple Silicon.

Placas NVIDIA da série RTX

A configuração da NVIDIA é a mais simples e costuma ser automática.

Você precisa:

KiloClaw - OpenClaw gerenciado para empresas: orquestração de agentes IA e roteamento inteligente

Começar →Anúncio

1. Instalar o driver NVIDIA mais recente, versão 531 ou posterior
2. Confirmar que o CUDA está instalado

Verifique se a GPU está disponível:

nvidia-smi

Se as informações da placa aparecerem, está tudo certo. Ao executar um modelo, o Ollama usará a GPU automaticamente.

Para especificar quais GPUs devem ser usadas:

export CUDA_VISIBLE_DEVICES=0,1

Isso limita o uso à primeira e à segunda GPU. Em máquinas com várias placas, essa configuração às vezes é necessária.

Usar GPU no Docker:

Se você executa o Ollama no Docker, precisa do NVIDIA Container Toolkit:

docker run --gpus all ollama/ollama

Só assim o contêiner poderá acessar a GPU da máquina host.

Placas AMD

A configuração da AMD é um pouco mais complexa e exige a instalação do ROCm.

Entre as GPUs AMD compatíveis com ROCm estão:

• Série Radeon Instinct (MI100, MI210, MI250, MI300X e outras)
• Série Radeon RX (5700 XT, 5500 XT, 7600, 9070 e outras)
• Série Radeon PRO

Depois de instalar o ROCm v7 ou uma versão posterior, o Ollama detectará e utilizará automaticamente a GPU AMD.

Algumas arquiteturas de GPU não têm suporte oficial. Nesse caso, você pode tentar sobrescrever a variável de ambiente:

export HSA_OVERRIDE_GFX_VERSION=10.3.0

Além disso, a AMD conta com suporte experimental ao Vulkan:

export OLLAMA_VULKAN=1

Apple Silicon (M1/M2/M3)

Para usuários de Mac, é ainda mais simples. O Apple Silicon ativa automaticamente a aceleração por GPU via Metal, sem qualquer configuração adicional.

Um chip da série M com 16 GB de memória executa modelos 8B com fluidez; com 32 GB, é possível rodar modelos 13B e até 30B. Como o Apple Silicon usa uma arquitetura de memória unificada, compartilhada por GPU e CPU, a quantidade de memória determina diretamente o tamanho do modelo que a máquina consegue executar.

Algumas dicas de desempenho

Além da aceleração por GPU, há outras maneiras de melhorar a velocidade:

Modelos quantizados. O padrão é a quantização Q4_K_M, um bom equilíbrio entre qualidade e velocidade. Se faltar memória, experimente Q4_K_S: a qualidade é um pouco menor, mas o consumo também cai.

Flash Attention. Essa otimização pode acelerar bastante o processamento de contextos grandes:

export OLLAMA_FLASH_ATTENTION=1

Tamanho do contexto. O contexto padrão é 2048. Se você não precisa de tanto, pode reduzi-lo:

export OLLAMA_CONTEXT_LENGTH=4096

Isso economiza memória e também melhora a velocidade.

Manter o modelo carregado. Por padrão, o modelo é descarregado após 5 minutos ocioso. Se você o usa com frequência, aumente esse período:

export OLLAMA_KEEP_ALIVE=30m

Você pode até usar -1 para nunca descarregá-lo, desde que o serviço Ollama continue em execução. Assim, cada conversa começa imediatamente, sem esperar o modelo carregar outra vez.

Integração por API: conecte o Ollama à sua aplicação

É aqui que aparece o verdadeiro valor do Ollama: ele oferece uma API completa para integração com aplicações.

Fundamentos da API REST

Depois de iniciado, o Ollama disponibiliza um serviço de API local na porta 11434.

Os dois endpoints mais usados são:

Geração de texto:

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Why is the sky blue?"
}'

Conclusão de chat:

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "user", "content": "Hello!"}
  ]
}'

Por padrão, a resposta usa streaming e entrega o resultado aos poucos. Para receber tudo de uma vez, defina "stream": false.

API compatível com a OpenAI: o recurso mais valioso

Esse recurso é realmente útil. O Ollama oferece uma interface compatível com a OpenAI, então você pode trocar o modelo na nuvem por um modelo local quase sem alterar seu código existente.

Endpoint compatível com a OpenAI:

http://localhost:11434/v1/chat/completions

Exemplo em Python:

from openai import OpenAI

client = OpenAI(
    base_url='http://localhost:11434/v1',
    api_key='ollama'  # Pode ser qualquer valor; não faz diferença
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[
        {"role": "user", "content": "Say this is a test"}
    ]
)

print(response.choices[0].message.content)

Exemplo em JavaScript:

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'http://localhost:11434/v1',
  apiKey: 'ollama'
});

const response = await client.chat.completions.create({
  model: 'llama3.2',
  messages: [{ role: 'user', content: 'Hello!' }]
});

console.log(response.choices[0].message.content);

Dessa forma, você economiza usando um modelo local durante o desenvolvimento e muda para a API na nuvem em produção para garantir estabilidade. Também pode trabalhar apenas com o modelo local e manter sob controle tanto o custo quanto a privacidade dos dados.

Minha abordagem é configurar uma variável de ambiente que alterna automaticamente entre o serviço local e a nuvem conforme o ambiente. No desenvolvimento, uso o modelo local por padrão e só mudo para a nuvem quando preciso explicitamente dos recursos disponíveis nela.

Vultr - Servidor cloud NVMe de alto desempenho, 32 locais globais, deploy Docker com um clique

Ver preços →Anúncio

Biblioteca Python do Ollama

Além da biblioteca da OpenAI, o Ollama tem sua própria biblioteca Python, que oferece acesso mais direto:

pip install ollama

Uso básico:

import ollama

response = ollama.chat(model='llama3.2', messages=[
  {'role': 'user', 'content': 'Why is the sky blue?'},
])

print(response['message']['content'])

Modo de streaming:

import ollama

stream = ollama.chat(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Why is the sky blue?'}],
    stream=True,
)

for chunk in stream:
    print(chunk['message']['content'], end='', flush=True)

Chamada de ferramentas (Tool Calling)

O Ollama permite que o modelo faça chamadas a funções ou APIs externas. Esse recurso é útil para criar aplicações de IA mais complexas.

Exemplo:

import ollama

response = ollama.chat(
    model='llama3.1',
    messages=[{'role': 'user', 'content': 'What is the weather in Toronto?'}],
    tools=[{
        'type': 'function',
        'function': {
            'name': 'get_current_weather',
            'description': 'Get the current weather for a city',
            'parameters': {
                'type': 'object',
                'properties': {
                    'city': {'type': 'string', 'description': 'The name of the city'},
                },
                'required': ['city'],
            },
        },
    }],
)

print(response['message']['tool_calls'])

O modelo decide, de acordo com a pergunta, se precisa chamar uma ferramenta e então retorna os parâmetros da chamada. Seu código executa a ferramenta de fato e devolve o resultado ao modelo.

Ollama ou LM Studio: qual escolher?

Você talvez já tenha ouvido falar do LM Studio, outra ferramenta para executar LLMs localmente. Qual das duas é melhor?

Sinceramente, cada uma tem suas vantagens; a escolha depende do que você precisa.

Ollama:

• Baseado principalmente em linha de comando e voltado a desenvolvedores
• Instalação simples com um único comando
• Inicia automaticamente o serviço de API
• Excelente suporte a servidores e implantação em contêineres
• Adequado para criar aplicações e integrações automatizadas

LM Studio:

• Interface gráfica intuitiva e fácil de usar
• Navegador de modelos integrado, que facilita os downloads
• Exige iniciar manualmente o serviço de API
• Não é adequado para implantação em servidores
• Indicado para explorar modelos, aprender e fazer testes

Em resumo:

• Para criar aplicações de IA, implantar em servidores ou automatizar com scripts → Ollama
• Para experimentar modelos rapidamente, evitar a linha de comando ou apenas estudar e explorar → LM Studio

Na prática, as duas ferramentas podem se complementar. Eu descubro e testo novos modelos no LM Studio e, depois de confirmar que funcionam bem, faço a integração definitiva no Ollama. Ambas usam llama.cpp por baixo, portanto os modelos são totalmente compatíveis.

Onde o Ollama pode ser usado na prática?

Estes são alguns cenários em que já o utilizei.

Assistente de programação local

Integre o Ollama ao VS Code ou ao Cursor para pedir ao modelo que escreva, explique ou refatore código. Recomendo usar codellama ou deepseek-coder.

Entre as ferramentas disponíveis, Continue.dev e Aider conectam-se diretamente à API do Ollama. Depois de configuradas, você terá um assistente de programação local e gratuito.

Sistema de perguntas e respostas sobre documentos

Se você precisa pesquisar e responder perguntas em muitos documentos, pode combinar o Ollama com um banco de dados vetorial para criar uma base de conhecimento privada. O fluxo é o seguinte:

1. Use o endpoint de embeddings do Ollama para gerar os vetores dos documentos
2. Armazene-os em um banco de dados vetorial, como Chroma ou Qdrant
3. Quando o usuário fizer uma pergunta, recupere primeiro os trechos relevantes dos documentos
4. Envie esses trechos como contexto para o modelo responder

Essa é a arquitetura típica de RAG, ou geração aumentada por recuperação. Tudo funciona localmente, sem que os dados saiam da rede interna.

Base de conhecimento privada

Documentos internos da empresa, materiais técnicos, informações de clientes e outros dados sensíveis não devem ser enviados para a nuvem. Com o Ollama, todo o processamento acontece localmente e pode atender aos requisitos de privacidade e conformidade.

Ambientes offline

Viagens, trabalho em campo, locais com rede instável: nesses cenários, uma IA na nuvem não funciona, mas o Ollama pode operar totalmente offline. Enquanto o computador tiver energia, o assistente de IA estará disponível.

Ambiente de desenvolvimento e testes

Ao desenvolver aplicações de IA, fazer chamadas frequentes para APIs na nuvem custa caro. Usar o Ollama como ambiente de desenvolvimento e testes reduz os custos e simplifica o trabalho. Depois dos testes, basta trocar para a API na nuvem em produção.

Perguntas frequentes

Encontrei alguns problemas pelo caminho; as soluções estão reunidas abaixo.

Para concluir

Depois de tantos detalhes, o objetivo é simples: facilitar o uso local de LLMs. O Ollama realmente cumpre essa proposta. Você não precisa de configurações complexas nem de uma formação avançada em IA e pode começar em poucos minutos. Além disso, a ferramenta é gratuita, funciona offline e protege a privacidade dos dados.

Agora você pode:

• Testar modelos diferentes e descobrir qual atende melhor às suas necessidades
• Integrar o Ollama ao seu fluxo de desenvolvimento
• Explorar a arquitetura RAG e criar uma base de conhecimento privada
• Implantá-lo em um servidor para oferecer um serviço de IA compartilhado à equipe

A era da IA local já começou. Com o Ollama, você não precisa depender da nuvem: pode executar modelos de linguagem avançados na sua própria máquina. Agora é hora de começar sua jornada com IA local.

Autor: Easton (blogueiro de tecnologia especializado em desenvolvimento de IA e implantação local)

Referências:

• Site oficial do Ollama
• Ollama no GitHub
• Documentação do Ollama
• Biblioteca de modelos do Ollama