¿Por qué ejecutar LLMs en local?

  • Privacidad: Tus datos nunca salen de tu máquina.
  • Coste: Cero costes por token tras la configuración.
  • Velocidad: Sin latencia de red para inferencia.
  • Desconectado: Funciona sin conexión a internet.

Instalando a Ollama

  • Descargar desde ollama.com — disponible para macOS, Linux y Windows.
  • Ejecuta 'ollama pull gemma3' para descargar un modelo.
  • Corre 'ollama run gemma3' para empezar a charlar.

Modelos populares

  • Qwen3 8B: Opción equilibrada por defecto, 5.2GB de descarga, contexto de 40K.
  • Gemma 3 12B: El modelo multimodal de Google, 8.2GB, contexto de 128K.
  • DeepSeek-R1 8B: Destilado centrado en razonamiento, 5.2GB, contexto de 128K.
  • Qwen3-Coder 30B: Modelo de código con mezcla de expertos, 19GB, pide una GPU de 24GB.
  • Phi-4 14B: El modelo compacto de razonamiento de Microsoft, 9.1GB, contexto de 16K.

Los tamaños y las ventanas de contexto son los que Ollama publica para cada etiqueta (comprobado el 2026-11-10).

Usando la API

Ollama proporciona una API REST local en 'http://localhost:11434'.

  • 'POST /api/generate' — generación de texto.
  • 'POST /api/chat' — completaciones de chat.
  • Compatible con OpenAI SDK mediante anulación de URL base.

Ambos endpoints exigen un campo 'model' con una etiqueta ya descargada ('ollama list' las muestra); la referencia de la API lo marca como obligatorio. El cuerpo mínimo de una petición de chat es `{"model": "gemma3", "messages": [{"role": "user", "content": "hello"}]}`; envíalo a '/api/chat' y Ollama devuelve objetos JSON en streaming.

Añade "stream": false para recibir un único objeto con la respuesta completa y las estadísticas de tiempo.

Consejos de integración

  • Uso con LangChain mediante la clase 'OllamaLLM'.
  • Usar con OpenWebUI para una interfaz similar a ChatGPT.
  • Aceleración por GPU: Funciona con NVIDIA (CUDA) y Apple Silicon (Metal).

Expectativas de rendimiento

  • Modelo 7B en MacBook M2: ~30 tokens/segundo.
  • Modelo 7B en RTX 4090: ~60 tokens/segundo.
  • Modelo 70B en 48 GB de RAM (CPU): ~3 tokens/segundo. La descarga de 43 GB deja poco margen para un contexto largo.

Elegir el modelo local adecuado

Tu elección depende del hardware y del caso de uso. Para programar en un portátil, Qwen2.5-Coder 7B (4.7GB) o Llama 3.1 8B (4.9GB) con cuantización de 4 bits funcionan muy bien. Para conversación general, Qwen3 8B (5.2GB) o Gemma 3 12B (8.2GB) ofrecen un buen equilibrio. Una GPU de 24GB admite Qwen3-30B-A3B con sus 19GB; Llama 3.1 70B es una descarga de 43GB, así que necesita 48GB de memoria o más, no 24GB.

Ajuste del rendimiento

  • Cuantización: Q4_K_M ofrece la mejor relación calidad-tamaño. Q5_K_M es algo mejor pero un 20 % más grande. Evita Q2/Q3 salvo que sea absolutamente necesario: la calidad cae en picado.
  • Longitud de contexto: por defecto suele ser 2048 o 4096 tokens. Auméntala solo si hace falta: los contextos más largos consumen más RAM.
  • Descarga a GPU: usa --n-gpu-layers para descargar tantas capas como permita la VRAM. Más capas en la GPU significa más velocidad.
  • Tamaño de lote: aumenta --batch-size para procesar el prompt más rápido si la VRAM lo permite.

Errores comunes

El error número uno es ejecutar modelos demasiado grandes para tu hardware. Un modelo de 70B con 16 GB de RAM irá dolorosamente lento (1-2 tokens por segundo). Es mejor ejecutar un modelo de 7B a 30 o más tokens por segundo. El error número dos es ignorar el prompt de sistema: los modelos locales son muy sensibles a él. Un prompt de sistema bien construido puede convertir un modelo mediocre en un asistente útil.

Mide tokens por segundo antes de elegir un modelo

El recuento de parámetros publicado casi no te dice si un modelo es usable en tu máquina. Lo que importa es la velocidad de generación en tokens por segundo en tu hardware, y ese número depende del ancho de banda de memoria mucho más que de la potencia de cálculo bruta. Un modelo que cabe en memoria pero apenas genera más rápido de lo que lees es frustrante; uno a treinta tokens por segundo se siente como una conversación. Cronométralo tú mismo con un prompt fijo y una longitud de salida conocida antes de comprometerte con un tamaño.

Si un modelo no cabe en memoria no corre más lento, corre en la CPU, lo que suele ser un orden de magnitud peor. Así que la pregunta del ajuste es binaria y va primero: comprueba el requisito de memoria en la cuantización elegida contra la memoria disponible, y deja margen para el sistema operativo y el contexto.

La cuantización es la palanca principal

Bajar de pesos de dieciséis bits a ocho o cuatro reduce aproximadamente a la mitad y a un cuarto el consumo de memoria, y para muchas tareas la diferencia de calidad es lo bastante pequeña como para ser invisible en tu propia evaluación. No es gratis: las tareas de razonamiento intensivo y la recuperación de contexto largo se degradan más que la conversación fluida. Prueba con la cuantización que piensas entregar en lugar de asumir que la variante de arriba del archivo es lo que verán tus usuarios.

Dónde ganan de verdad los modelos locales

Privacidad, funcionamiento sin conexión, coste predecible y libertad frente a límites de tasa. Un modelo local que ejecuta una tarea de clasificación a cinco tokens por segundo y nunca sale de tu portátil es mejor que uno alojado para trabajo que no puedes enviar a ningún sitio. Sé honesto también con lo inverso: para razonamiento abierto y generación de código, la frontera alojada sigue claramente por delante, y fingir lo contrario le cuesta calidad a tus usuarios.