O Que é o Ollama e Por Que Rodar LLMs Localmente?

Ollama é uma ferramenta open-source que permite executar modelos de linguagem de grande escala (LLMs) diretamente no seu computador, sem depender de APIs externas ou conexão com a internet. Com ele, você baixa o modelo uma vez e roda quantas vezes quiser — gratuitamente, com privacidade total e sem latência de rede.

A proposta é simples: transformar a experiência de rodar um LLM em algo tão fácil quanto instalar um aplicativo. Um único comando baixa o modelo e inicia uma interface de chat no terminal. Outro comando expõe uma API REST local compatível com o formato da OpenAI, permitindo integrar qualquer ferramenta que já conheça.

Por que rodar localmente em vez de usar a nuvem?

Privacidade: seus dados nunca saem da sua máquina. Ideal para documentos confidenciais, código proprietário e dados pessoais.
Custo zero de inferência: após baixar o modelo, não há custo por token. Para volumes altos de uso, a economia é enorme.
Disponibilidade offline: funciona sem internet. Útil em ambientes com conectividade limitada ou em viagens.
Latência previsível: sem variações de rede ou throttling de API.
Controle total: você escolhe exatamente qual versão do modelo usa, sem que o provedor altere o comportamento silenciosamente.

A desvantagem é clara: você precisa de hardware capaz. Os maiores modelos exigem GPUs potentes ou muita RAM. Mas para modelos menores (7B a 13B parâmetros), um notebook moderno com 16 GB de RAM já é suficiente.

---

Requisitos de Hardware: O Que Você Precisa

A regra fundamental é: o modelo precisa caber na memória. Se tiver GPU, o modelo precisa caber na VRAM. Se não tiver GPU ou a VRAM for insuficiente, o Ollama usa a RAM do sistema (muito mais lento, mas funciona).

|-------------------|------------|-----------------|----------|---------------------------|

| 1B–3B parâmetros | 4 GB | 8 GB | 4 GB | Rápido (15–30 tok/s) |

| 7B parâmetros | 8 GB | 16 GB | 8 GB | Médio (5–15 tok/s) |

| 13B parâmetros | 16 GB | 32 GB | 12 GB | Lento (2–8 tok/s) |

| 34B parâmetros | 32 GB | 64 GB | 24 GB | Muito lento em CPU |

| 70B parâmetros | 64 GB | 128 GB | 48 GB | Inviável em CPU |

Sobre quantização: o Ollama usa modelos quantizados (Q4, Q5, Q8), que reduzem o tamanho sem perda significativa de qualidade. Um Llama 3 8B quantizado em Q4 ocupa cerca de 4,7 GB — rodável em qualquer máquina com 8 GB de RAM.

GPUs suportadas:

NVIDIA: qualquer placa com suporte a CUDA 11.8+ (RTX 3000 series em diante, ideal)
AMD: suporte via ROCm no Linux (experimental no Windows)
Apple Silicon: suporte nativo e excelente via Metal (M1, M2, M3, M4)
Intel Arc: suporte em desenvolvimento

No Mac com chip Apple Silicon, o Ollama usa o GPU integrado de forma muito eficiente — é um dos melhores ambientes para rodar modelos locais sem GPU dedicada.

---

Instalação do Ollama (Windows, Mac, Linux)

macOS

Baixe o instalador diretamente no site oficial:

# Via Homebrew
brew install ollama

# Ou baixe o .dmg em https://ollama.com/download

Após instalar, o Ollama roda como um serviço em background. O ícone aparece na barra de menu.

Windows

Baixe o instalador .exe em https://ollama.com/download. O instalador configura tudo automaticamente, incluindo o serviço em background. Requer Windows 10 ou 11 (64-bit).

Para usar com GPU NVIDIA no Windows, instale os drivers CUDA mais recentes antes.

Linux

# Instalação com um comando
curl -fsSL https://ollama.com/install.sh | sh

# O serviço é iniciado automaticamente via systemd
sudo systemctl status ollama

# Para iniciar manualmente se necessário
ollama serve

Verifique a instalação:

ollama --version
# ollama version 0.3.x

---

Rodando Seus Primeiros Modelos

Com o Ollama instalado, um único comando baixa e inicia o modelo:

# Baixar e iniciar um chat com Llama 3.2 (3B - leve e rápido)
ollama run llama3.2

# Llama 3.1 8B - melhor equilíbrio qualidade/velocidade
ollama run llama3.1

# Mistral 7B
ollama run mistral

# Microsoft Phi-3 mini (3.8B) - excelente em hardware limitado
ollama run phi3

# Google Gemma 2 (2B) - muito leve
ollama run gemma2:2b

Ao rodar, você entra em modo de chat interativo no terminal. Para sair, digite /bye ou pressione Ctrl+D.

Comandos úteis do Ollama:

# Listar modelos baixados
ollama list

# Baixar modelo sem entrar no chat
ollama pull llama3.1

# Remover modelo
ollama rm llama3.1

# Ver informações do modelo
ollama show llama3.1

# Rodar com prompt direto (sem chat interativo)
ollama run llama3.1 "Explique o que é machine learning em 3 frases"

# Passar texto via stdin
echo "Resuma este texto: ..." | ollama run mistral

O servidor REST é iniciado automaticamente quando você instala o Ollama. Ele roda em http://localhost:11434 por padrão.

# Verificar se o servidor está ativo
curl http://localhost:11434
# Ollama is running

---

Modelos Disponíveis: Llama 3, Mistral, Phi-3, Gemma

|--------|---------|----------------|-------------|------------|

Para ver todos os modelos disponíveis: https://ollama.com/library

---

Ollama com Python via API REST

O Ollama expõe uma API REST compatível com o formato da OpenAI. Você pode usar a biblioteca oficial ou fazer chamadas HTTP diretas.

pip install ollama requests

Usando a biblioteca oficial do Ollama:

import ollama

# Chat simples
response = ollama.chat(
    model='llama3.1',
    messages=[
        {'role': 'user', 'content': 'Explique o que é uma rede neural em linguagem simples'}
    ]
)
print(response['message']['content'])

# Streaming (exibe tokens em tempo real)
stream = ollama.chat(
    model='llama3.1',
    messages=[{'role': 'user', 'content': 'Escreva um poema sobre Python'}],
    stream=True
)
for chunk in stream:
    print(chunk['message']['content'], end='', flush=True)

# Geração de texto (sem histórico de chat)
response = ollama.generate(
    model='llama3.1',
    prompt='O capital do Brasil é'
)
print(response['response'])

# Embeddings
response = ollama.embeddings(
    model='nomic-embed-text',
    prompt='Este texto será convertido em um vetor'
)
vector = response['embedding']
print(f'Dimensões do vetor: {len(vector)}')

Usando com a biblioteca OpenAI (compatibilidade):

from openai import OpenAI

# Apontar para o servidor local do Ollama
client = OpenAI(
    base_url='http://localhost:11434/v1',
    api_key='ollama'  # qualquer string funciona
)

response = client.chat.completions.create(
    model='llama3.1',
    messages=[
        {'role': 'system', 'content': 'Você é um assistente especialista em Python.'},
        {'role': 'user', 'content': 'Como faço um decorador em Python?'}
    ]
)
print(response.choices[0].message.content)

Essa compatibilidade com a API da OpenAI significa que qualquer código que já usa openai pode ser redirecionado para o Ollama com apenas duas linhas de mudança.

---

Ollama + LangChain para RAG Local

RAG (Retrieval-Augmented Generation) permite que o LLM responda com base em seus próprios documentos. Com Ollama, o pipeline inteiro roda localmente — sem nenhum dado saindo da sua máquina.

pip install langchain langchain-community langchain-ollama chromadb

from langchain_ollama import OllamaLLM, OllamaEmbeddings
from langchain_community.vectorstores import Chroma
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.chains import RetrievalQA
from langchain_community.document_loaders import TextLoader

# 1. Carregar documentos
loader = TextLoader('meus_documentos.txt', encoding='utf-8')
docs = loader.load()

# 2. Dividir em chunks
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50
)
chunks = text_splitter.split_documents(docs)

# 3. Criar embeddings e vector store (tudo local)
embeddings = OllamaEmbeddings(model='nomic-embed-text')
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory='./chroma_db'
)

# 4. Configurar o LLM local
llm = OllamaLLM(model='llama3.1', temperature=0)

# 5. Criar a chain de RAG
qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type='stuff',
    retriever=vectorstore.as_retriever(search_kwargs={'k': 3}),
    return_source_documents=True
)

# 6. Fazer perguntas
result = qa_chain.invoke({'query': 'Qual é o prazo de entrega mencionado no contrato?'})
print('Resposta:', result['result'])
print('\nFontes:')
for doc in result['source_documents']:
    print(f'- {doc.page_content[:100]}...')

Para documentos PDF, substitua TextLoader por PyPDFLoader:

from langchain_community.document_loaders import PyPDFLoader
loader = PyPDFLoader('contrato.pdf')

---

Open WebUI: Interface Visual para o Ollama

O Open WebUI é uma interface web open-source que transforma o Ollama em algo visualmente similar ao ChatGPT — com histórico de conversas, upload de arquivos, seleção de modelos e muito mais.

Instalação com Docker (recomendada):

# Sem GPU
docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

# Com GPU NVIDIA
docker run -d -p 3000:8080 \
  --gpus all \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:cuda

Após iniciar, acesse http://localhost:3000. Na primeira vez, crie uma conta de administrador local.

Instalação via pip (sem Docker):

pip install open-webui
open-webui serve

Recursos principais do Open WebUI:

Seleção de qualquer modelo Ollama disponível
Upload de documentos para RAG automático
Histórico de conversas persistente
Criação de personas e system prompts customizados
Suporte a imagens (com modelos multimodais como LLaVA)
API compatível com OpenAI para integrar ferramentas externas

---

Comparação: Ollama vs LM Studio vs GPT4All

|----------------|--------|-----------|----------|

| Windows | Sim | Sim | Sim |

| Linux | Sim | Sim (beta) | Sim |

| Open Source | Sim | Não (free) | Sim |

Quando usar cada um:

Ollama: você quer integrar LLMs em código, scripts ou pipelines. É a escolha dos desenvolvedores.
LM Studio: você quer experimentar modelos com interface gráfica bonita e acesso direto ao HuggingFace.
GPT4All: você quer a experiência mais simples possível, sem linha de comando.

---

Limitações e Quando Usar a Nuvem

Limitações do Ollama / LLMs locais:

1. Qualidade inferior em modelos menores: um Llama 3.1 8B não chega perto do GPT-4o ou Claude 3.5 Sonnet em tarefas complexas de raciocínio, análise jurídica, código avançado.

2. Hardware é o gargalo: para modelos acima de 13B, você precisa de hardware caro. Um RTX 4090 com 24 GB de VRAM já não comporta modelos 70B.

3. Sem atualizações automáticas: você precisa baixar novas versões manualmente. Modelos na nuvem são atualizados sem intervenção.

4. Consumo de energia: rodar modelos localmente aumenta o consumo elétrico da sua máquina, especialmente com GPU.

5. Latência em CPU: sem GPU dedicada, modelos acima de 7B ficam lentos demais para uso interativo.

Quando preferir a nuvem:

Tarefas que exigem máxima qualidade (análise jurídica, código crítico, pesquisa)
Você não tem hardware adequado para o tamanho de modelo necessário
Uso esporádico (o custo de API é menor que manter hardware)
Modelos multimodais de alta qualidade (GPT-4 Vision, Claude com imagens)
Precisa dos modelos mais recentes assim que lançados

Quando preferir local (Ollama):

Dados confidenciais que não podem sair da sua máquina
Volume alto de requisições onde o custo de API seria proibitivo
Ambientes sem internet
Experimentação e prototipagem rápida
Pipelines automatizados que rodam centenas de vezes por dia

---

Perguntas Frequentes

1. O Ollama funciona sem internet após baixar o modelo?

Sim. Após o download inicial, o Ollama funciona completamente offline. O único momento que precisa de internet é ao baixar ou atualizar modelos.

2. Posso rodar múltiplos modelos ao mesmo tempo?

O Ollama mantém o último modelo carregado em memória por padrão (5 minutos de cache). Você pode ter vários modelos baixados, mas apenas um carregado por vez (a menos que tenha RAM/VRAM suficiente para ambos e configure OLLAMA_NUM_PARALLEL).

3. Como ajustar a temperatura e outros parâmetros do modelo?

Via API: passe "options": {"temperature": 0.7, "top_p": 0.9} na requisição. Via terminal: use /set parameter temperature 0.7 durante uma sessão de chat.

4. O Ollama usa GPU automaticamente?

Sim. Se detectar uma GPU NVIDIA com CUDA ou um Mac com Apple Silicon, o Ollama automaticamente usa a GPU. Você pode verificar com ollama ps para ver onde o modelo está carregado.

5. Como criar um modelo customizado com system prompt fixo?

Crie um arquivo Modelfile:

FROM llama3.1
SYSTEM "Você é um assistente especializado em direito brasileiro."

Depois: ollama create meu-assistente-juridico -f Modelfile

6. Existe limite de contexto nos modelos locais?

Sim. Cada modelo tem uma janela de contexto máxima (geralmente 4K a 128K tokens dependendo do modelo). O Ollama usa 2048 tokens por padrão para economizar memória. Para aumentar: ollama run llama3.1 --num-ctx 8192 ou configure via API com "options": {"num_ctx": 8192}.

Como Rodar LLMs Localmente com Ollama