IA en un USB: ejecutando Llama y Qwen localmente

tech

2026-03-07

Las API en la nube son cómodas. Mientras tengas internet, dinero para la suscripción y te parezca bien que alguien más lea cada prompt. Si al menos un punto no te convence, bienvenido a la inferencia local.

Por qué hacerlo

Cuatro razones para ejecutar LLM en tu propio hardware:

• Privacidad. Los datos no salen de la máquina. Sin telemetría, sin registros en servidores ajenos. El prompt vive y muere en tu equipo.
• Sin conexión. Avión, tren, búnker sin wifi: el modelo funciona. No necesitas internet en ninguna etapa después de la descarga.
• Gratuito. Cero dólares por token. Para siempre. La única inversión es el hardware que ya tienes.
• Sin censura. Un modelo local responde a lo que responde. Sin filtros corporativos, sin «I cannot help with that».

Herramientas

Dos opciones. Ambas funcionales, la elección depende de cuánto quieras controlar el proceso.

llama.cpp — motor de inferencia en C/C++ puro. Funciona en CPU, opcionalmente en GPU (CUDA, Metal, Vulkan). Sin dependencias, sin Python. Compilas y ejecutas. Soporta el formato GGUF, que se ha convertido en el estándar para modelos cuantizados.

Ollama — envoltorio sobre llama.cpp con interfaz amigable. Descarga modelos con un solo comando, los gestiona y expone una API. Si no quieres lidiar con compilaciones y configuraciones, esta es tu opción.

# Instalación de ollama (Linux/macOS)
curl -fsSL https://ollama.com/install.sh | sh

# O descarga el binario desde https://ollama.com/download

Modelos

Dos familias que realmente vale la pena ejecutar localmente en 2026:

Llama 3.x (Meta) — el caballo de batalla. Buena para inglés, aceptable con ruso. 8B parámetros cabe en 8GB de RAM. Hay versiones de 70B y 405B para quienes tienen hardware serio.

Qwen 2.5 / Qwen 3 (Alibaba) — la mejor opción para tareas multilingües. Ruso, chino, código: a buen nivel. La versión de 7B compite con Llama 3 8B y en algunos aspectos la supera. Qwen 3 añadió el modo de pensamiento (thinking mode): una cadena de razonamiento dentro del propio modelo.

GGUF y cuantizaciones

Los pesos originales de los modelos pesan decenas de gigabytes y requieren GPU. La cuantización los comprime a un tamaño razonable con una pérdida mínima de calidad.

El formato GGUF es un contenedor único: pesos + tokenizador + metadatos en un solo archivo. Descargas y ejecutas.

Recomendación: Q4_K_M es el punto medio ideal. La pérdida de calidad es mínima, y la diferencia en velocidad y tamaño es significativa. Q5_K_M si tienes memoria de sobra y quieres un poco más de precisión.

Hardware mínimo

La GPU acelera enormemente la generación, pero no es obligatoria. En CPU también funciona, solo que más lento. Apple Silicon (M1/M2/M3) es una excelente opción: la memoria unificada permite cargar modelos grandes sin una tarjeta gráfica discreta.

Inicio rápido

De cero a un modelo funcionando en dos comandos:

# Llama 3 8B
ollama run llama3

# Qwen 2.5 7B
ollama run qwen2.5

# Qwen 3 8B (con modo de pensamiento)
ollama run qwen3

# Cuantización específica
ollama run llama3:8b-instruct-q5_K_M

La primera ejecución descargará el modelo (~4-5 GB). A partir de ahí, todo es local.

Ollama levanta una API en localhost:11434. Puedes usarla desde código:

curl http://localhost:11434/api/generate -d '{
  "model": "qwen2.5",
  "prompt": "Explica la cuantización de redes neuronales en tres oraciones",
  "stream": false
}'

Para los más hardcore: llama.cpp directamente

# Clonar y compilar
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp && make -j$(nproc)

# Ejecutar el modelo
./llama-cli -m /ruta/al/modelo.gguf \
  -p "Escribe una función de ordenamiento en Python" \
  -n 512 -t 4

# O levantar un servidor con API
./llama-server -m /ruta/al/modelo.gguf \
  --host 0.0.0.0 --port 8080

Los archivos GGUF se obtienen de HuggingFace. Fuentes verificadas de cuantizaciones: bartowski, TheBloke (legado), Qwen official.

IA en un USB

Instalación portátil: todo en una sola unidad USB. La conectas a cualquier ordenador y la ejecutas.

Qué necesitas:

• USB 3.0+ o SSD externo (desde 32 GB)
• Binarios de ollama o llama.cpp (compilación estática, ~50 MB)
• Uno o dos modelos en GGUF (~4-5 GB cada uno)

# Estructura del USB
/LLM/
├── ollama              # binario
├── models/
│   ├── llama3-8b-q4_k_m.gguf
│   └── qwen2.5-7b-q4_k_m.gguf
└── run.sh              # script de inicio

#!/bin/bash
# run.sh — ejecución desde USB
export OLLAMA_MODELS="$(dirname "$0")/models"
export OLLAMA_HOST="127.0.0.1:11434"
"$(dirname "$0")/ollama" serve &
sleep 2
"$(dirname "$0")/ollama" run llama3

Un SSD externo en lugar de un USB es mucho más rápido para cargar el modelo. Un USB normal funcionará, pero la primera ejecución será lenta. Una vez cargado en RAM, la velocidad del almacenamiento ya no importa.

Rendimiento

Qué esperar realmente. Modelo 7B, cuantización Q4_K_M:

Para modelos de 13B, aproximadamente la mitad. Para 70B, necesitas una GPU con 48GB de VRAM o mucha RAM para inferencia en CPU (lento, pero funciona).

Otro detalle: el primer token siempre es más lento (procesamiento del prompt). Un prompt largo significa una demora notable antes de la primera palabra de la respuesta. Prompts cortos son casi instantáneos.

Qué elegir

• Para textos y chat en ruso — Qwen 2.5 7B. El mejor ruso entre modelos de este tamaño.
• Para código — Qwen 2.5 Coder 7B o Llama 3 8B. Ambos son buenos.
• Para razonamiento — Qwen 3 8B con modo de pensamiento. Más lento, pero más inteligente.
• Para máxima velocidad — Llama 3 8B Q4_K_M. Ligero y rápido.

· · ·

Los LLM locales no reemplazan a GPT-4 o Claude. Son otra herramienta para otras tareas. Un asistente privado, un ayudante sin conexión, un campo de experimentación. Un modelo en un USB es como una navaja suiza: no reemplaza un taller, pero en el campo es indispensable.

Dos gigas en un USB. Cero dependencias de servidores ajenos. Tu propia IA de bolsillo.

← Volver a la base