Como ajustar e executar LLMs localmente com Ollama em 2026

Por que executar um LLM localmente

A inferência local resolve problemas que as APIs hospedadas estruturalmente não conseguem: os dados nunca saem da sua máquina, não há cobrança por token em escala e a versão do modelo que você testou é a versão do modelo que você executará no próximo mês, independentemente de qualquer cronograma de descontinuação upstream. A compensação é qualidade e conveniência – modelos de peso aberto na faixa 7B-70B são bons, mas geralmente ficam atrás dos modelos hospedados de fronteira em tarefas de raciocínio complexas.

Instalando o Ollama

Ollama fornece instaladores nativos para macOS, Windows e Linux e envolve llama.cpp para uma inferência quantizada eficiente.

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

# Windows: download the installer from ollama.com/download

# Verify install
ollama --version

Hardware e tamanho do modelo

O tamanho do modelo nos parâmetros determina aproximadamente os requisitos de memória, uma vez quantizado. Como regra geral para quantização de 4 bits (o padrão Ollama para a maioria dos pulls):

• Modelos 3B-4B— funcione perfeitamente com 8 GB de RAM, incluindo a maioria dos laptops modernos sem GPU discreta.
• Modelos 7B-8B— precisa de aproximadamente 8 a 12 GB; um local confortável para bate-papo de uso geral e ajuda de codificação.
• Modelos 13B-14B– precisa de 16 a 24 GB para um desempenho suave.
• Modelos da classe 70B– precisa de 48 GB + VRAM para obter boa velocidade ou será executado lentamente dividido entre a RAM e a CPU do sistema.

Os Apple Silicon Macs superam seu peso aqui porque a memória unificada permite que a GPU acesse todo o pool de RAM do sistema, tornando-os surpreendentemente capazes para os modelos 13B-34B.

Seu primeiro modelo local

# Pull and run a general-purpose model
ollama run llama3.1:8b

# Pull a coding-focused model
ollama run qwen2.5-coder:7b

# List installed models
ollama list

# Remove a model to free disk space
ollama rm llama3.1:8b

O primeirorunO comando baixa o modelo (vários gigabytes) e leva você a um prompt de bate-papo interativo. Os modelos são armazenados em cache localmente, portanto, as execuções subsequentes começam instantaneamente.

Personalizando o comportamento com um arquivo de modelo

Um Modelfile permite colocar um prompt de sistema personalizado, temperatura e outros parâmetros sobre um modelo base sem tocar em seus pesos – conceitualmente semelhante a um Dockerfile para configuração LLM.

FROM qwen2.5-coder:7b

PARAMETER temperature 0.2
PARAMETER num_ctx 8192

SYSTEM """
You are a senior backend engineer. Answer concisely with working code.
Prefer Python and explain tradeoffs only when explicitly asked.
"""

ollama create backend-helper -f ./Modelfile
ollama run backend-helper

Chamando Ollama do Python

Ollama expõe uma API REST local na porta 11434, com um cliente Python oficial sobre ela – útil para conectar um modelo local a um script ou serviço de back-end.

pip install ollama

import ollama

response = ollama.chat(model="qwen2.5-coder:7b", messages=[
    {"role": "user", "content": "Write a Python function that flattens a nested list."}
])
print(response["message"]["content"])

# Streaming
for chunk in ollama.chat(model="llama3.1:8b", messages=[
    {"role": "user", "content": "Explain TCP vs UDP in two sentences."}
], stream=True):
    print(chunk["message"]["content"], end="", flush=True)

Ajuste fino com LoRA

Ollama em si é um tempo de execução de inferência, não uma ferramenta de treinamento – para ajuste fino, você treina um adaptador LoRA com uma biblioteca como a do Hugging Facepeftou Unsloth, então mescle o adaptador nos pesos base ou converta-o em GGUF e carregue-o através de um ModelfileADAPTERdirectiva.

pip install unsloth peft transformers datasets trl

from unsloth import FastLanguageModel
from trl import SFTTrainer
from transformers import TrainingArguments
from datasets import load_dataset

model, tokenizer = FastLanguageModel.from_pretrained(
    model_name="unsloth/llama-3.1-8b-bnb-4bit",
    max_seq_length=2048,
    load_in_4bit=True,
)

model = FastLanguageModel.get_peft_model(
    model,
    r=16,
    target_modules=["q_proj", "k_proj", "v_proj", "o_proj"],
    lora_alpha=16,
    lora_dropout=0,
)

dataset = load_dataset("json", data_files="my_training_data.jsonl", split="train")

trainer = SFTTrainer(
    model=model,
    tokenizer=tokenizer,
    train_dataset=dataset,
    dataset_text_field="text",
    max_seq_length=2048,
    args=TrainingArguments(
        per_device_train_batch_size=2,
        gradient_accumulation_steps=4,
        num_train_epochs=3,
        learning_rate=2e-4,
        output_dir="outputs",
    ),
)
trainer.train()
model.save_pretrained_gguf("my-finetuned-model", tokenizer, quantization_method="q4_k_m")

A abordagem QLoRA de 4 bits (carregar o modelo básico em 4 bits, treinar apenas as pequenas matrizes do adaptador LoRA) é o que torna isso viável em uma única GPU de consumidor com 12-24 GB de VRAM para modelos 7B-8B. Uma vez exportado para GGUF, aponte um arquivo de modeloFROMno arquivo local e carregue-o no Ollama como qualquer outro modelo.

Quando o local supera uma API hospedada

Os modelos locais fazem mais sentido para tarefas restritas e repetitivas nas quais você ajustou ou solicitou um modelo menor para corresponder à qualidade de um modelo hospedado naquela tarefa — classificação, extração estruturada, ferramentas internas com dados confidenciais ou implantações off-line/de borda. Para raciocínio aberto, uso complexo de ferramentas em várias etapas ou qualquer coisa em que a qualidade da saída afete diretamente o produto, um modelo hospedado de fronteira como Claude ainda vence; veja nossoTutorial da API Claudese você estiver avaliando essa rota para o mesmo projeto.