LLM locales

La ejecución de modelos de lenguaje grandes (LLM) localmente protege la privacidad de los datos, reduce los costos de API y proporciona capacidades de inferencia fuera de línea. Ubuntu 26.04 ofrece un entorno excelente para ejecutar LLM locales. Este artículo cubre las herramientas de ejecución de modelos locales más populares y los modelos recomendados.

Tip

¿Quiere crear un dispositivo “AI box” dedicado en lugar de ejecutarlo en su escritorio? In June 2026 Canonical published an official reference based on Ubuntu Core 26 + the gemma4 snap, exposing an OpenAI-compatible API (:8336/v1) and a WebUI (:8337). El arranque mínimo está documentado en Noticias posteriores al lanzamiento.

Ollama

Ollama es actualmente el marco de ejecución de modelo local más popular y ofrece una instalación y una experiencia de uso extremadamente simples con soporte para una amplia gama de modelos de código abierto.

Instalar 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 tirar y ejecutar


# 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 proporciona una API REST compatible con el formato OpenAI, escuchando de forma predeterminada en 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

Python Ejemplo de uso


# 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 requerida	Reflejos
`qwen2.5:7b`	7B	6GB	Fuerte habilidad china, buena para el chat diario.
`qwen2.5:14b`	14B	10GB	Chino completo, buena codificación.
`qwen2.5-coder:7b`	7B	6GB	Centrado en la generación y comprensión de código.
`llama3.2:3b`	3B	3GB	Ligero, rápido
`llama3.1:8b`	8B	6GB	Excelente habilidad en inglés
`deepseek-r1:14b`	14B	10GB	Razonamiento fuerte
`mistral:7b`	7B	6GB	Modelo europeo, multilingüe.
`gemma2:9b`	9B	7GB	Modelo de código abierto de Google
`phi3:14b`	14B	10GB	modelo de investigación de microsoft
`nomic-embed-text`	-	1 GB	Modelo de incrustación de texto

Tip

Para los usuarios de idioma chino, se recomienda encarecidamente la serie Qwen 2.5. La versión 7B se adapta a GPU con 8 GB de VRAM, mientras que la versión 14B funciona excelentemente con 12 GB de VRAM. Para tareas de solo código, qwen2.5-coder es la mejor opción.

LM Studio

LM Studio es una herramienta gráfica de gestión de modelos locales multiplataforma que proporciona descarga de modelos, chat y un servidor API local.

Descargar e instalar


# 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 dependencias


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

Uso de la interfaz gráfica de usuario

Principales áreas de características de LM Studio:

Descubrir - Busque y descargue modelos GGUF de Hugging Face
Chat: carga un modelo y chatea con él.
Desarrollador: inicia un servidor API local, compatible con el formato API OpenAI

Inicie el servidor API local:

En la pestaña Desarrollador, cargue un modelo, luego haga clic en “Iniciar servidor”. La dirección predeterminada es 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 almacena archivos de modelo en el directorio ~/.lmstudio/models/. Los archivos de modelos grandes pueden consumir decenas de GB, así que asegúrese de tener suficiente espacio en disco.

llama.cpp

llama.cpp es el motor de inferencia local de más bajo nivel, escrito en C/C++ puro, que admite inferencia tanto de CPU como de GPU con un rendimiento extremadamente alto. El backend de Ollama también usa llama.cpp.

Construir desde la fuente


# 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)

Descargar 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"

Inferencia de línea de comandos


# 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

Los archivos de modelo GGUF vienen en diferentes niveles de cuantificación. Q4_K_M ofrece un buen equilibrio entre calidad y tamaño de archivo, Q5_K_M ofrece mayor calidad pero archivos más grandes, y Q8_0 se acerca a la precisión original. Para uso diario, se recomienda Q4_K_M o Q5_K_M.

Jan

Jan es un cliente de chat de IA local de código abierto con una interfaz gráfica amigable, que admite múltiples modelos e inferencia local.

Instalar 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 de la interfaz

Principales características de Jan:

Hub: busque y descargue modelos recomendados (descarga con un solo clic)
Chat: chatea con modelos, admite múltiples sesiones
Configuración: configura los parámetros del modelo, la aceleración de GPU, etc.

Jan admite la importación de archivos de modelo GGUF personalizados. Coloque los archivos de modelo en el directorio ~/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 también proporciona un servidor API local. Cuando está habilitado, es compatible con el formato API OpenAI y el puerto predeterminado es 1337.

Open WebUI

Open WebUI es una interfaz web rica en funciones para interactuar con modelos locales, que admite conexiones a Ollama y API compatibles con OpenAI.

Docker Implementación


# 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

Acceder a 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

Conéctese a Ollama

Si Ollama y Open WebUI están en la misma 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 Redactar implementación


# 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 admite cuentas multiusuario, historial de conversaciones, gestión de modelos, RAG (generación de recuperación aumentada), búsqueda web y otras funciones avanzadas. Es una de las mejores interfaces web para individuos y equipos que utilizan modelos locales.

Tabla de comparación de modelos

Aquí hay una comparación de los principales modelos actuales de código abierto para ayudarlo a elegir:

Serie de modelos	Revelador	Tamaños disponibles	Chino	Codificación	Razonamiento	Licencia
Llama 3.1/3.2	Meta	1B/3B/8B/70B/405B	Justo	Bien	Bien	Llama 3
Qwen 2.5	Alibaba	0.5B-72B	Excelente	Excelente	Bien	Apache 2.0
Qwen 2.5 Codificador	Alibaba	1.5B-32B	Bien	Pendiente	Bien	Apache 2.0
DeepSeek R1	búsqueda profunda	1.5B-671B	Excelente	Excelente	Pendiente	MIT
DeepSeek V3	búsqueda profunda	671B	Excelente	Excelente	Excelente	MIT
Mistral	Mistral	7B/8x7B/8x22B	Justo	Bien	Bien	Apache 2.0
Gema 2	Google	2B/9B/27B	Justo	Bien	Bien	Gema
Fi-3/4	microsoft	3.8B-14B	Justo	Bien	Bien	MIT
Sí	01.AI	6B/9B/34B	Excelente	Bien	Bien	Apache 2.0
GLM-4	AI Zhipu	9B	Excelente	Bien	Bien	Costumbre

Recomendaciones de casos de uso

Chat diario en chino (8GB VRAM):


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

Asistencia para escritura de código (12 GB de VRAM):


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

Tareas de razonamiento complejas (16 GB+ VRAM):


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

Solo CPU (sin 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

Si no está seguro de qué modelo elegir, comenzar con qwen2.5:7b es una buena apuesta. Tiene un gran dominio del idioma chino, un uso moderado de recursos y es adecuado para la mayoría de los casos de uso cotidianos. Para tareas de codificación, qwen2.5-coder:14b se desempeña cerca de los modelos comerciales.