<h2>Por Que Rodar LLMs Localmente com Ollama</h2>

O tutorial anterior desta trilha cobriu como instalar o Ollama e rodar seu primeiro modelo. Este tutorial vai além: como escolher os modelos certos para cada caso de uso, usar o Ollama via API em aplicações, e tirar o máximo de performance do seu hardware.

Rodar modelos localmente tem três vantagens que nenhum modelo em nuvem oferece: privacidade total (seus dados não saem do computador), custo zero por token (paga uma vez pela GPU, usa para sempre), e disponibilidade offline (funciona sem internet). Para desenvolvedores, advogados, médicos e qualquer profissional que lida com dados sensíveis, essa é a única opção responsável para muitas tarefas.

<h2>Escolhendo o Modelo Certo: Llama 3, Mistral ou Gemma</h2>

O Ollama tem mais de 100 modelos disponíveis. Saber qual usar depende do hardware e do caso de uso:

Llama 3.2 (3B e 8B): melhor equilíbrio entre qualidade e velocidade. O 3B roda em qualquer Mac M1/M2 com 8GB RAM e é rápido o suficiente para uso diário. O 8B é mais capaz mas precisa de 16GB RAM. Ideal para: tarefas gerais, sumarização, escrita, chatbot local.

Llama 3.1 (70B): qualidade próxima ao GPT-4o mas requer hardware sério — 48GB RAM ou GPU de alta capacidade. Para uso profissional em máquinas potentes.

Mistral 7B e Mistral Nemo: especialmente forte em código e raciocínio matemático. Frequentemente supera o Llama em benchmarks de programação com menos parâmetros. Ideal para: geração de código, análise de dados, tarefas técnicas.

Gemma 2 (2B, 9B, 27B): modelo do Google, muito eficiente. O 2B é surpreendentemente capaz para seu tamanho. Ideal para: tarefas de NLP em português, classificação, extração de informação.

CodeLlama e DeepSeek-Coder: modelos especializados em código. Se você usa Ollama principalmente para programação, estes superam o Llama e o Mistral no domínio de código.

Phi-3 Mini (3.8B): da Microsoft, surpreendentemente capaz para seu tamanho mínimo. Funciona em hardware limitado (4GB RAM) com qualidade acima do esperado.

<h2>Gerenciando Modelos com os Comandos do Ollama</h2>

Todos os comandos são via terminal:

Baixar um modelo: <code>ollama pull llama3.2</code> — baixa a versão padrão (8B). Para versões específicas: <code>ollama pull llama3.2:3b</code> ou <code>ollama pull llama3.2:70b</code>.

Listar modelos instalados: <code>ollama list</code> — mostra nome, ID, tamanho e data de modificação.

Usar um modelo no chat: <code>ollama run mistral</code> — abre o chat interativo. Digite sua mensagem e pressione Enter. Para sair: <code>/bye</code>.

Ver informações de um modelo: <code>ollama show llama3.2</code> — exibe arquitetura, parâmetros, tamanho e o system prompt padrão.

Remover um modelo: <code>ollama rm gemma2:2b</code> — libera espaço em disco.

Ver modelos em execução: <code>ollama ps</code> — mostra modelos carregados na memória (GPU/RAM).

<h2>API REST do Ollama: Integrando em Aplicações</h2>

O Ollama expõe uma API REST local na porta 11434. Isso permite integrar qualquer modelo local em aplicações, scripts e ferramentas. A API é compatível com o formato da OpenAI — qualquer código que usa a OpenAI pode ser adaptado para o Ollama trocando a URL base.

Teste direto com curl:

<pre><code>curl http://localhost:11434/api/generate -d '{

"model": "llama3.2",

"prompt": "Explique o que é machine learning em 3 frases.",

"stream": false

}'</code></pre>

Com streaming (resposta em tempo real):

<pre><code>curl http://localhost:11434/api/generate -d '{

"model": "mistral",

"prompt": "Escreva um poema sobre programação.",

"stream": true

}'</code></pre>

<h2>Usando Ollama com Python</h2>

Instale a biblioteca oficial: <code>pip install ollama</code>. Uso básico:

<pre><code>import ollama

response = ollama.chat(model='llama3.2', messages=[

{'role': 'user', 'content': 'Resuma este texto: [TEXTO]'}

])

print(response['message']['content'])</code></pre>

Com streaming:

<pre><code>import ollama

stream = ollama.chat(

model='mistral',

messages=[{'role': 'user', 'content': 'Explique recursão em Python'}],

stream=True,

)

for chunk in stream:

print(chunk['message']['content'], end='', flush=True)</code></pre>

Compatibilidade com a API da OpenAI (drop-in replacement):

<pre><code>from openai import OpenAI

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

response = client.chat.completions.create(

model='llama3.2',

messages=[{'role': 'user', 'content': 'Olá, tudo bem?'}]

)

print(response.choices[0].message.content)</code></pre>

Isso significa que qualquer aplicação que usa a OpenAI SDK pode ser rodada localmente trocando apenas a <code>base_url</code> e o <code>api_key</code> — zero mudança no resto do código.

<h2>Modelfiles: Customizando Comportamento dos Modelos</h2>

O Modelfile permite criar versões personalizadas de qualquer modelo — com system prompt fixo, parâmetros ajustados e comportamento específico. Útil para criar assistentes especializados que rodam localmente.

Exemplo — criando um assistente de código Python:

<pre><code>FROM codellama

SYSTEM """Você é um assistente especializado em Python.

Sempre escreva código com type hints, docstrings e tratamento de erros.

Prefira soluções Pythônicas e explique cada decisão importante."""

PARAMETER temperature 0.1

PARAMETER num_predict 2048</code></pre>

Salve como <code>Modelfile</code> e crie o modelo: <code>ollama create python-expert -f Modelfile</code>. Use com: <code>ollama run python-expert</code>.

Parâmetros importantes: <code>temperature</code> (0 = determinístico, 1 = criativo), <code>num_predict</code> (máximo de tokens gerados), <code>num_ctx</code> (tamanho da janela de contexto — padrão 4096, pode aumentar se tiver RAM).

<h2>Performance: Otimizando para o Seu Hardware</h2>

A velocidade do Ollama depende do hardware: GPU NVIDIA ou Apple Silicon gera tokens muito mais rápido que CPU pura.

Mac com Apple Silicon (M1/M2/M3/M4): a GPU unificada acelera automaticamente. M1 Pro com 16GB RAM roda Llama 3.2 8B a ~25–40 tokens/segundo — velocidade de leitura confortável. Nenhuma configuração adicional necessária.

GPU NVIDIA: o Ollama detecta automaticamente e usa CUDA. 8GB VRAM suporta modelos 7B/8B com velocidade excelente. 16GB suporta modelos 13B.

CPU apenas: funciona, mas lento. Llama 3.2 3B em CPU gera 3–10 tokens/segundo — usável para tarefas pontuais, não para uso intensivo.

Dica de performance: o primeiro run de um modelo é mais lento (carrega para memória). Nas execuções seguintes, o modelo já está carregado e responde mais rápido. O comando <code>ollama ps</code> mostra os modelos atualmente em memória.

<h2>Casos de Uso Práticos: O Que Fazer com Modelos Locais</h2>

Processar documentos confidenciais: contratos, prontuários médicos, dados financeiros — analise sem enviar para nenhuma nuvem.

Assistente de código offline: integre o Ollama ao Continue (extensão para VS Code/Cursor) para ter autocomplete e chat de código que funciona sem internet.

Automações de texto em escala: processe centenas de documentos por dia sem custo por token — extração de informação, classificação, sumarização em batch.

Experimentação rápida: teste múltiplos modelos para um mesmo prompt sem custo para encontrar o melhor para o seu caso de uso específico.

Ollama: Use Llama 3, Mistral e Gemma Localmente — Tutorial Prático

Tutoriais relacionados