LLMs locais

A execução de grandes modelos de linguagem (LLMs) protege localmente a privacidade dos dados, reduz os custos de API e fornece recursos de inferência offline. Ubuntu 26.04 oferece um excelente ambiente para executar LLMs locais. Este artigo aborda as ferramentas de tempo de execução de modelo local mais populares e os modelos recomendados.

Tip

Quer construir um dispositivo “AI box” dedicado em vez de rodar em seu desktop? Em junho de 2026, a Canonical publicou uma referência oficial baseada em Ubuntu Core 26 + o snap gemma4, expondo uma API compatível com OpenAI (:8336/v1) e uma WebUI (:8337). O bootstrap mínimo está documentado em Notícias pós-lançamento.

Ollama

Ollama é atualmente a estrutura de tempo de execução de modelo local mais popular, oferecendo uma instalação extremamente simples e experiência de uso com suporte para uma ampla variedade de modelos de código aberto.

Instale Ollama


# One-click installation (recommended)
curl -fsSL https://ollama.com/install.sh | bash
 
# Verify installation
ollama --version
 
# Check Ollama service status
systemctl status ollama


# Manual installation (if the auto script doesn't work)
# Download and extract the official tgz package to /usr
curl -L https://ollama.com/download/ollama-linux-amd64.tgz -o /tmp/ollama-linux-amd64.tgz
sudo tar -C /usr -xzf /tmp/ollama-linux-amd64.tgz
 
# Create Ollama user
sudo useradd -r -s /bin/false -m -d /usr/share/ollama ollama
 
# Create systemd service (use sudo tee to write a root-owned file)
sudo tee /etc/systemd/system/ollama.service > /dev/null << 'EOF'
[Unit]
Description=Ollama Service
After=network-online.target
 
[Service]
ExecStart=/usr/bin/ollama serve
User=ollama
Group=ollama
Restart=always
RestartSec=3
Environment="HOME=/usr/share/ollama"
 
[Install]
WantedBy=default.target
EOF
 
sudo systemctl daemon-reload
sudo systemctl enable ollama
sudo systemctl start ollama

Modelos de puxar e executar


# Pull a model (downloads the model file on first run)
ollama pull llama3.2
ollama pull qwen2.5:14b
ollama pull deepseek-r1:14b
 
# Run a model and start chatting
ollama run llama3.2
 
# Run a specific model size
ollama run qwen2.5:7b
ollama run qwen2.5:14b
ollama run qwen2.5:32b
 
# List downloaded models
ollama list
 
# View model details
ollama show qwen2.5:14b
 
# Delete a model
ollama rm llama3.2

Uso de API

Ollama fornece uma API REST compatível com o formato OpenAI, escutando por padrão em http://localhost:11434.


# Generate text (Generate API)
curl http://localhost:11434/api/generate -d '{
  "model": "qwen2.5:14b",
  "prompt": "Explain Python decorators",
  "stream": false
}'
 
# Chat API (conversational format)
curl http://localhost:11434/api/chat -d '{
  "model": "qwen2.5:14b",
  "messages": [
    {"role": "system", "content": "You are a Linux expert"},
    {"role": "user", "content": "How do I check the Ubuntu system version?"}
  ],
  "stream": false
}'
 
# OpenAI-compatible API
curl http://localhost:11434/v1/chat/completions -d '{
  "model": "qwen2.5:14b",
  "messages": [
    {"role": "user", "content": "Hello"}
  ]
}'
 
# List available models
curl http://localhost:11434/api/tags

Exemplo de uso Python


# Ubuntu 26.04 blocks system-wide pip installs (PEP 668); install inside a virtual environment
python3 -m venv ~/ollama-env
source ~/ollama-env/bin/activate
 
# Install the ollama Python library
pip install ollama


import ollama
 
response = ollama.chat(model='qwen2.5:14b', messages=[
    {'role': 'user', 'content': 'Write a quicksort algorithm in Python'},
])
print(response['message']['content'])

Configurar Ollama


# Change model storage path (default: ~/.ollama/models)
sudo systemctl edit ollama
# Add the following:
# [Service]
# Environment="OLLAMA_MODELS=/data/ollama/models"
 
# Allow remote access (default is local only)
sudo systemctl edit ollama
# [Service]
# Environment="OLLAMA_HOST=0.0.0.0:11434"
 
# Set GPU layers
# Environment="OLLAMA_NUM_GPU=999"
 
# Restart service to apply changes
sudo systemctl restart ollama

Modelos recomendados

Modelo	Parâmetros	VRAM necessária	Destaques
`qwen2.5:7b`	7B	6 GB	Forte habilidade chinesa, boa para bate-papo diário
`qwen2.5:14b`	14B	10GB	Chinês abrangente, boa codificação
`qwen2.5-coder:7b`	7B	6 GB	Focado na geração e compreensão de código
`llama3.2:3b`	3B	3GB	Leve, rápido
`llama3.1:8b`	8B	6 GB	Excelente habilidade em inglês
`deepseek-r1:14b`	14B	10GB	Raciocínio forte
`mistral:7b`	7B	6 GB	Modelo europeu, multilíngue
`gemma2:9b`	9B	7GB	Modelo de código aberto do Google
`phi3:14b`	14B	10GB	Modelo de pesquisa da Microsoft
`nomic-embed-text`	-	1GB	Modelo de incorporação de texto

Tip

Para usuários do idioma chinês, a série Qwen 2.5 é altamente recomendada. A versão 7B é adequada para GPUs com 8 GB de VRAM, enquanto a versão 14B tem um desempenho excelente com 12 GB de VRAM. Para tarefas somente de código, qwen2.5-coder é a melhor escolha.

LM Studio

LM Studio é uma ferramenta gráfica de gerenciamento de modelo local de plataforma cruzada que fornece download de modelo, bate-papo e um servidor API local.

Baixe e instale


# Download LM Studio AppImage from the official site (get the latest link at https://lmstudio.ai/download)
# Replace the URL below with the actual download link from the official site
wget -O ~/LMStudio.AppImage "<latest AppImage download link from the official site>"
 
# Add execute permission
chmod +x ~/LMStudio.AppImage
 
# Move to application directory
mkdir -p ~/.local/bin
mv ~/LMStudio.AppImage ~/.local/bin/lmstudio
 
# Create desktop shortcut
# Note: .desktop Exec does not expand variables like $HOME; you must use an absolute path
# Replace YOUR_USER below with your username (the output of echo $USER)
cat > ~/.local/share/applications/lmstudio.desktop << 'EOF'
[Desktop Entry]
Name=LM Studio
Comment=Local LLM Management
Exec=/home/YOUR_USER/.local/bin/lmstudio --no-sandbox
Icon=lmstudio
Type=Application
Categories=Development;Science;
StartupNotify=true
EOF
 
# Launch LM Studio
~/.local/bin/lmstudio

Instalar dependências


# LM Studio may require FUSE support (AppImage dependency)
sudo apt install -y libfuse2t64

Uso da GUI

Principais áreas de recursos do LM Studio:

Descubra - Pesquise e baixe modelos GGUF em Hugging Face
Bate-papo – Carregue um modelo e converse com ele
Desenvolvedor – Inicie um servidor API local, compatível com o formato OpenAI API

Inicie o servidor API local:

Na aba Desenvolvedor, carregue um modelo e clique em “Iniciar Servidor”. O endereço padrão é http://localhost:1234.


# Test LM Studio's local API
curl http://localhost:1234/v1/chat/completions -d '{
  "model": "loaded-model-name",
  "messages": [
    {"role": "user", "content": "Hello"}
  ]
}'

Note

LM Studio armazena arquivos de modelo no diretório ~/.lmstudio/models/. Arquivos de modelo grandes podem consumir dezenas de GB, portanto, certifique-se de ter espaço em disco suficiente.

llama.cpp

llama.cpp é o mecanismo de inferência local de menor nível, escrito em C/C++ puro, suportando inferência de CPU e GPU com desempenho extremamente alto. O back-end de Ollama também usa llama.cpp.

Construir a partir da fonte


# Install build dependencies
sudo apt install -y build-essential cmake git
 
# Clone the repository
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
 
# Method 1: CPU-only build
cmake -B build
cmake --build build --config Release -j$(nproc)
 
# Method 2: Enable CUDA GPU acceleration (recommended, requires CUDA)
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j$(nproc)
 
# Method 3: Enable Vulkan GPU acceleration (works with AMD/Intel/NVIDIA)
sudo apt install -y libvulkan-dev
cmake -B build -DGGML_VULKAN=ON
cmake --build build --config Release -j$(nproc)

Baixar modelos


# llama.cpp uses GGUF format models
# Download from Hugging Face (Qwen 2.5 7B example)
mkdir -p ~/models
wget -O ~/models/qwen2.5-7b-q4_k_m.gguf \
  "https://huggingface.co/Qwen/Qwen2.5-7B-Instruct-GGUF/resolve/main/qwen2.5-7b-instruct-q4_k_m.gguf"

Inferência de linha de comando


# Interactive chat
./build/bin/llama-cli \
  -m ~/models/qwen2.5-7b-q4_k_m.gguf \
  -ngl 999 \
  -c 4096 \
  --interactive \
  --color
 
# Start an OpenAI-compatible API server
./build/bin/llama-server \
  -m ~/models/qwen2.5-7b-q4_k_m.gguf \
  -ngl 999 \
  -c 4096 \
  --host 0.0.0.0 \
  --port 8080
 
# Parameter explanations:
# -m        Model file path
# -ngl 999  Use as many GPU layers as possible
# -c 4096   Context length
# --host    Listen address
# --port    Listen port


# Test the API server
curl http://localhost:8080/v1/chat/completions -d '{
  "model": "qwen2.5",
  "messages": [{"role": "user", "content": "Hello"}]
}'

Tip

Os arquivos de modelo GGUF vêm em diferentes níveis de quantização. Q4_K_M é um bom equilíbrio entre qualidade e tamanho de arquivo, Q5_K_M oferece qualidade superior, mas arquivos maiores, e Q8_0 está próximo da precisão original. Para uso diário, Q4_K_M ou Q5_K_M é recomendado.

Jan

Jan é um cliente de chat de IA local de código aberto com uma interface gráfica amigável, suportando vários modelos e inferência local.

Instale Jan


# Download Jan deb package
wget -O /tmp/jan.deb "https://app.jan.ai/download/latest/linux-amd64-deb"
 
# Install
sudo dpkg -i /tmp/jan.deb
sudo apt install -f -y
 
# Launch Jan
jan


# Or install via AppImage
wget -O ~/jan.appimage "https://app.jan.ai/download/latest/linux-amd64-appimage"
chmod +x ~/jan.appimage
~/jan.appimage

Uso da interface

Principais características do Jan:

Hub – Navegue e baixe os modelos recomendados (download com um clique)
Bate-papo – Converse com modelos, suporta múltiplas sessões
Configurações – Configure parâmetros do modelo, aceleração de GPU, etc.

Jan suporta a importação de arquivos de modelo GGUF personalizados. Coloque os arquivos de modelo no diretório ~/jan/models/.


# Jan default data directory
ls ~/jan/
 
# Manually import a model
mkdir -p ~/jan/models/my-custom-model
cp ~/models/qwen2.5-7b-q4_k_m.gguf ~/jan/models/my-custom-model/

Jan também fornece um servidor API local. Quando ativado, é compatível com o formato OpenAI API, sendo o padrão a porta 1337.

Open WebUI

Open WebUI é uma interface web rica em recursos para interagir com modelos locais, suportando conexões com Ollama e APIs compatíveis com OpenAI.

Implantação Docker


# Ensure Docker is installed
sudo apt install -y docker.io docker-compose-v2
sudo usermod -aG docker $USER
newgrp docker
 
# Method 1: Connect to local Ollama (most common)
docker run -d \
  --name open-webui \
  --network=host \
  -v open-webui:/app/backend/data \
  -e OLLAMA_BASE_URL=http://127.0.0.1:11434 \
  --restart always \
  ghcr.io/open-webui/open-webui:main
 
# Method 2: Bundled Ollama version (all-in-one deployment)
docker run -d \
  --name open-webui \
  --gpus all \
  -p 3000:8080 \
  -v ollama:/root/.ollama \
  -v open-webui:/app/backend/data \
  --restart always \
  ghcr.io/open-webui/open-webui:ollama

Acesse Open WebUI


# After deployment, open your browser
# Method 1 (--network=host): http://localhost:8080
# Method 2 (-p 3000:8080): http://localhost:3000
 
# First visit requires creating an admin account

Conecte-se a Ollama

Se Ollama e Open WebUI estiverem na mesma máquina:


# Ensure Ollama is running
systemctl status ollama
 
# Open WebUI connects to http://localhost:11434 by default
# Confirm the Ollama URL in Open WebUI Settings > Connections

Docker Compor implantação


# Create project directory
mkdir -p ~/open-webui && cd ~/open-webui
 
# Create docker-compose.yml
cat > docker-compose.yml << 'EOF'
services:
  open-webui:
    image: ghcr.io/open-webui/open-webui:main
    container_name: open-webui
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://host.docker.internal:11434
      - WEBUI_AUTH=true
    volumes:
      - open-webui-data:/app/backend/data
    extra_hosts:
      - "host.docker.internal:host-gateway"
    restart: always
 
volumes:
  open-webui-data:
EOF
 
# Start the service
docker compose up -d
 
# View logs
docker compose logs -f open-webui

Note

Open WebUI oferece suporte a contas multiusuário, histórico de conversas, gerenciamento de modelo, RAG (Retrieval-Augmented Generation), pesquisa na web e outros recursos avançados. É uma das melhores interfaces web para indivíduos e equipes que usam modelos locais.

Tabela de comparação de modelos

Aqui está uma comparação dos principais modelos de código aberto atuais para ajudá-lo a escolher:

Série de modelos	Desenvolvedor	Tamanhos disponíveis	chinês	Codificação	Raciocínio	Licença
Chama 3.1/3.2	meta	1B/3B/8B/70B/405B	Justo	Bom	Bom	Lhama 3
Qwen 2.5	Alibaba	0,5B-72B	Excelente	Excelente	Bom	Apache 2.0
Codificador Qwen 2.5	Alibaba	1,5B-32B	Bom	Fora do comum	Bom	Apache 2.0
DeepSeek R1	DeepSeek	1.5B-671B	Excelente	Excelente	Fora do comum	MIT
DeepSeek V3	DeepSeek	671B	Excelente	Excelente	Excelente	MIT
Mistral	Mistral	7B/8x7B/8x22B	Justo	Bom	Bom	Apache 2.0
Gema 2	Google	2B/9B/27B	Justo	Bom	Bom	Gema
Phi-3/4	Microsoft	3.8B-14B	Justo	Bom	Bom	MIT
Sim	01.AI	6B/9B/34B	Excelente	Bom	Bom	Apache 2.0
GLM-4	IA Zhipu	9B	Excelente	Bom	Bom	Personalizado

Recomendações de casos de uso

Bate-papo diário em chinês (8GB VRAM):


ollama pull qwen2.5:7b
ollama run qwen2.5:7b

Assistência para escrita de código (12GB VRAM):


ollama pull qwen2.5-coder:14b
ollama run qwen2.5-coder:14b

Tarefas de raciocínio complexas (16 GB+ VRAM):


ollama pull deepseek-r1:14b
ollama run deepseek-r1:14b

Somente CPU (sem GPU):


ollama pull qwen2.5:3b
ollama run qwen2.5:3b
 
# Or use an even smaller model
ollama pull llama3.2:1b
ollama run llama3.2:1b

Tip

Se você não tiver certeza de qual modelo escolher, começar com qwen2.5:7b é uma boa aposta. Possui forte habilidade no idioma chinês, uso moderado de recursos e é adequado para a maioria dos casos de uso diário. Para tarefas de codificação, qwen2.5-coder:14b tem desempenho próximo aos modelos comerciais.