Cómo ejecutar un LLM local: Guía completa de instalación, configuración y los mejores modelos (2025)

¿Quieres sacarle el máximo provecho a la Inteligencia Artificial sin depender de la nube, reduciendo costos y garantizando la privacidad de tus datos?
En esta guía práctica descubrirás, paso a paso, todo lo que necesitas para montar tu propio local LLM, desde el hardware indispensable hasta la selección del modelo ideal, pasando por las herramientas más amigables como LM Studio AI y Ollama, y la opción de ejecutarlos dentro de un contenedor Ollama Docker.

Índice rápido

Sección	Qué encontrarás
1. ¿Qué es un local LLM y por qué usarlo?	Conceptos básicos, ventajas y casos de uso.
2. Hardware recomendado	GPU, VRAM, CPU, RAM y almacenamiento óptimos.
3. Software esencial	Servidores, interfaces y paquetes “todo en uno”.
4. Instalación de LM Studio AI	Guía paso a paso para Windows, macOS y Linux.
5. Instalación de Ollama	Desde la versión nativa hasta Ollama Docker.
6. Los mejores modelos para correr localmente	Tabla comparativa de tamaños, requisitos y usos.
7. Optimización y cuantización	Cómo reducir el consumo de VRAM sin perder calidad.
8. Integración con herramientas de automatización	Uso de scripts, API y flujos de trabajo con n8n.
9. Solución de problemas comunes	Mensajes de error frecuentes y cómo resolverlos.
10. Recursos adicionales	Enlaces a repositorios, comunidades y documentación.
11. Ideas de prompts para imágenes	Sugerencias de generación visual basada en este artículo.

1. ¿Qué es un local LLM y por qué usarlo?

1.1 Definición sencilla

Un Large Language Model (LLM) es un modelo de IA entrenado con millones o miles de millones de parámetros para generar texto, código y, en algunos casos, interpretar imágenes. Cuando decimos local LLM nos referimos a que el modelo se ejecuta en tu propio ordenador o servidor en vez de en los servidores de una empresa externa.

1.2 Ventajas principales

Ventaja	Por qué importa
Privacidad total	Ningún dato sale de tu red; ideal para sectores regulados (salud, finanzas, legal).
Costos predecibles	Pagas la inversión inicial en hardware y software libre; sin facturas mensuales por API.
Control absoluto	Puedes ajustar el “system prompt”, entrenar con tus propios datos o añadir funciones personalizadas.
Disponibilidad offline	Funciona sin conexión a internet, perfecto para entornos con conectividad limitada.
Aprendizaje profundo	Entiendes cómo funciona la IA a nivel de hardware y software, lo cual es una gran experiencia formativa.

2. Hardware recomendado

Ejecutar un LLM local no es magia; requiere recursos suficientes para que el modelo cargue en la memoria de la GPU y pueda responder en tiempo razonable. A continuación, la configuración mínima y la recomendada para diferentes tamaños de modelo.

2.1 GPU y VRAM (el factor crítico)

VRAM disponible	Modelos compatibles (aprox.)	Uso recomendado
6‑8 GB	Llama‑3 7B‑Q4, Mistral‑7B‑Instruct, Gemma‑2B	Experimentación y pruebas de concepto.
12 GB	Llama‑3 13B‑Q4, Qwen‑2.5‑7B‑C, Phi‑4‑mini	Flujo de trabajo diario, generación de código.
24 GB	Llama‑3 34B‑Q4, Mixtral‑8x7B, Granite‑8B‑v3	Aplicaciones de alta calidad y uso intensivo.
>24 GB (ej. RTX 4090, A100)	Modelos de 70B‑100B (por ejemplo Llama‑3 70B)	Uso empresarial, investigación avanzada.

2.2 CPU y RAM

CPU: Un procesador de 6‑8 núcleos (AMD Ryzen 5 5600X, Intel i5‑12400) es suficiente. Si vas a usar Docker intensivo o ejecutar varios contenedores simultáneos, opta por 8‑12 núcleos.
RAM: Igual o superior a la VRAM de tu GPU (p.ej., 24 GB de RAM para una GPU de 12 GB). Con 32 GB tendrás margen para cargar varios modelos o versiones cuantizadas.

2.3 Almacenamiento

SSD NVMe de al menos 500 GB. Los modelos pueden ocupar entre 4 GB y 80 GB cada uno, y el SSD garantiza una carga de modelo en segundos en vez de minutos.
Backup: Un disco duro externo o NAS para guardar checkpoints y datasets personalizados.

2.4 Tip especial para Apple Silicon

Los chips M1, M2, M3 cuentan con Unified Memory Architecture (UMA). Con 32 GB de RAM puedes ejecutar modelos de hasta 13 B sin problemas, aunque la velocidad de inference será ligeramente menor que en una GPU dedicada de NVIDIA.

3. Software esencial

3.1 Categorías de software

Categoría	Función	Ejemplos destacados
Servidores (backend)	Gestionan la carga del modelo, exponen API REST/GRPC.	`ollama`, `lm-studio-server`, `text-generation-webui`.
Interfaces gráficas (frontend)	Chat, pruebas interactivas, ajustes de parámetros.	LM Studio AI, OpenWebUI, LobeChat.
Soluciones “todo en uno”	Combina servidor + UI + gestor de modelos.	Ollama, LM Studio (modo “All‑in‑One”).
Contenedores	Despliegue reproducible, aislamiento de dependencias.	Ollama Docker, Docker‑Compose con n8n, etc.

3.2 Por qué elegir LM Studio AI o Ollama

LM Studio AI: Interfaz visual amigable, búsqueda de modelos en Hugging Face directamente desde la app, compatibilidad multi‑plataforma. Ideal para principiantes y usuarios que prefieren “click‑and‑run”.
Ollama: Ligero, basado en CLI, excelente para scripts y automatizaciones. Soporta Ollama Docker, lo que permite escalar o compartir el entorno con otros usuarios.

4. Instalación de LM Studio AI

A continuación, los pasos para cada sistema operativo. Todos los comandos se pueden ejecutar desde una terminal (PowerShell, iTerm, etc.).

4.1 Windows

Descarga el instalador desde https://lmstudio.ai/download.
Ejecuta el archivo .exe y sigue el asistente; elige la carpeta de instalación (recomendado: C:\Program Files\LMStudio).
Al iniciar la app, permite que descargue los drivers CUDA si tu GPU es NVIDIA.
En la pestaña Model Hub, busca “Llama‑3 8B Q4_K_M”. Haz clic en Download → Load.
Configura la memoria de la GPU: Settings → Advanced → GPU VRAM limit (ej. 10 GB).
¡Listo! Empieza a chatear con el modelo desde la interfaz.

4.2 macOS (Apple Silicon & Intel)

Homebrew: brew install --cask lmstudio.
Si usas M1/M2, LM Studio detectará automáticamente la arquitectura y usará Metal como backend.
Abre la app desde Launchpad y sigue los mismos pasos de descarga de modelo que en Windows.

4.3 Linux (Ubuntu/Debian)

# 1. Instala dependencias
sudo apt update && sudo apt install -y curl git unzip

# 2. Descarga el tarball
curl -L -o lmstudio.tar.gz https://downloads.lmstudio.ai/linux/latest

# 3. Extrae
tar -xzf lmstudio.tar.gz -C $HOME/.local/share/

# 4. Añade al PATH
echo 'export PATH=$HOME/.local/share/lmstudio:$PATH' >> ~/.bashrc
source ~/.bashrc

# 5. Ejecuta
lmstudio

Tip: En sistemas sin GPU, LM Studio soporta inference en CPU mediante ggml; sin embargo la latencia será alta (>10 s por respuesta).

4.4 Configuración avanzada (opcional)

Parámetro	Descripción	Valor recomendado
`--max-context`	Número máximo de tokens que el modelo puede “recordar”.	4096 para Llama‑3‑8B.
`--temperature`	Controla la aleatoriedad de la salida.	0.7 para respuestas creativas, 0.2 para respuestas determinísticas.
`--threads`	Núcleos de CPU que se usarán (solo CPU).	8 en máquinas de 12‑16 GB RAM.

5. Instalación de Ollama

5.1 Versión nativa (macOS, Linux, Windows)

macOS (Homebrew)

   brew install ollama

Linux (Debian/Ubuntu)

   curl -fsSL https://ollama.com/install.sh | sh

Windows (Scoop)

   scoop install ollama

Verifica la instalación: ollama --version.
Descarga un modelo (ej.: Llama‑3 8B):

   ollama pull llama3

Ejecuta el modelo en modo chat:

   ollama run llama3

5.2 Ollama Docker (ideal para entornos aislados)

# docker‑compose.yml
version: "3.8"
services:
  ollama:
    image: ollama/ollama:latest
    container_name: ollama
    restart: unless‑stopped
    ports:
      - "11434:11434"      # API REST
      - "8080:8080"        # UI opcional (OpenWebUI)
    volumes:
      - ./ollama_data:/root/.ollama   # Persistencia de modelos
    environment:
      - OLLAMA_NUM_THREADS=8
      - OLLAMA_MAX_CTX=4096
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

Crear la carpeta: mkdir -p ollama_data.
Iniciar: docker compose up -d.
Descargar modelo dentro del contenedor:

   docker exec -it ollama ollama pull llama3

Acceder a la API: http://localhost:11434/api/generate.

5.3 Integración con OpenWebUI (interfaz web ligera)

docker run -d \
  -p 8080:8080 \
  -v $(pwd)/openwebui:/app/backend/data \
  --restart unless‑stopped \
  ghcr.io/open-webui/open-webui:latest

Conecta la UI a Ollama mediante la variable de entorno OLLAMA_HOST=http://ollama:11434. Así podrás chatear con el modelo desde cualquier navegador.

6. Los mejores modelos para correr localmente

A continuación, una tabla que resume los principales modelos open‑source disponibles en Hugging Face y compatibles con LM Studio y Ollama. Se incluyen detalles de tamaño, requisitos de VRAM y caso de uso recomendado.

Modelo	Parámetros	Tipo de cuantización (ejemplo)	VRAM mínima*	Uso recomendado	Licencia
Llama‑3‑8B‑Q4_K_M	8 B	GGUF Q4	8 GB	Chat general, razonamiento medio	Meta (LLAMA‑3)
Llama‑3‑13B‑Q5_K_S	13 B	GGUF Q5	12 GB	Generación de código, asistencia en documentación	Meta
Mistral‑7B‑Instruct‑v0.2	7 B	GGUF Q4	6 GB	Asistentes de soporte, respuesta rápida	Apache‑2.0
Mixtral‑8x7B‑Instruct	45 B (MoE)	GGUF Q4	24 GB	Tareas complejas, razonamiento avanzado	Apache‑2.0
Gemma‑2B‑Instruct	2 B	GGUF Q4	4 GB	Dispositivos con 6 GB VRAM, chat ligero	Apache‑2.0
Phi‑4‑mini‑4k‑q4	4 B	GGUF Q4	6 GB	Aplicaciones embebidas, IoT	MIT
Qwen‑2.5‑7B‑Coder	7 B	GGUF Q4	8 GB	Asistentes de programación, depuración	Apache‑2.0
Granite‑8B‑Chat	8 B	GGUF Q5	12 GB	Chat corporativo, asistencia legal	Apache‑2.0
OpenChat‑3.5‑7B	7 B	GGUF Q4	8 GB	Chat amigable, soporte al cliente	Apache‑2.0
LLaVA‑Phi‑3‑mini‑vision	3 B (multimodal)	GGUF Q4	8 GB	IA que interpreta imágenes + texto	Apache‑2.0

*VRAM mínima estimada para ejecutar el modelo sin offloading. Con técnicas de CPU offload puedes reducir este número, pero la latencia aumentará.

6.1 Cómo elegir el modelo ideal

Define el caso de uso: Chat general → Llama‑3 8B; generación de código → Qwen‑2.5‑Coder; razonamiento profundo → Mixtral‑8x7B.
Comprueba tu VRAM: Si dispones de 12 GB, evita modelos >13 B sin cuantización avanzada.
Evalúa la licencia: Algunas empresas requieren que los modelos sean usados bajo licencia compatible con su política de datos.
Prueba cuantizaciones: Los formatos GGUF Q4 / Q5 reducen el consumo de VRAM hasta un 60 % con pérdida mínima de calidad.

7. Optimización y cuantización

7.1 Qué es la cuantización

Consiste en representar los pesos del modelo con menos bits (por ejemplo, 4 bits en vez de 16 bits). El objetivo es reducir la memoria ocupada y acelerar la inferencia. Los principales formatos son:

Formato	Bits	Compresión	Impacto en calidad
FP16	16	N/A	Referencia (máxima calidad)
Q8_0	8	2×	Muy bajo impacto
Q4_K_M	4	4×	Pequeña pérdida en tareas complejas
Q3_K_S	3	5.3×	Adecuado solo para pruebas rápidas

7.2 Herramientas para cuantizar

gguf-convert (incluido en Ollama)
lmstudio-quantize (CLI de LM Studio)
torch.quantization (para usuarios de PyTorch)

Paso a paso: cuantizar un modelo con LM Studio

lmstudio quantize \
  --model llama3-8b \
  --output llama3-8b-q4.gguf \
  --bits 4 \
  --format q4_k_m

Una vez convertido, cárgalo desde la UI de LM Studio seleccionando Add local model y eligiendo el archivo .gguf.

7.3 Offloading a CPU

Si tu GPU tiene menos memoria que el modelo, puedes usar offload (carga parcial en GPU y el resto en RAM). En Ollama, agrega la variable:

export OLLAMA_GPU_OFFLOAD=0.5   # 50 % del modelo en GPU, 50 % en RAM

En LM Studio, habilita GPU Offload desde Settings → Advanced y elige el porcentaje deseado.

8. Integración con herramientas de automatización

8.1 Usando la API REST de Ollama

curl -X POST http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
        "model": "llama3",
        "prompt": "Resume las novedades de la IA en 2025 en 3 párrafos.",
        "max_tokens": 300,
        "temperature": 0.6
      }'

La respuesta JSON contiene el texto generado, que puedes usar en scripts Python, Bash o incluso en herramientas no‑code como n8n.

8.2 Conexión a n8n (workflow de automatización)

Crear un HTTP Request node con la URL http://localhost:11434/api/generate.
Configurar el cuerpo con JSON (ver ejemplo anterior).
Añadir un Set node para formatear la salida (por ejemplo, enviar por correo, guardar en base de datos o publicar en Slack).
Ejecutar el workflow automáticamente al recibir un email o al detectar un archivo nuevo en una carpeta.

8.3 Scripts de ejemplo (Python)

import requests, json

def ask_llm(prompt, model="llama3"):
    url = "http://localhost:11434/api/generate"
    payload = {
        "model": model,
        "prompt": prompt,
        "max_tokens": 512,
        "temperature": 0.7
    }
    resp = requests.post(url, json=payload)
    return resp.json()["response"]

print(ask_llm("Explica la diferencia entre LLM y ChatGPT en menos de 100 palabras."))

Con este script puedes crear chatbots locales o generar contenido para blogs sin tocar la nube.

9. Solución de problemas comunes

Síntoma	Posible causa	Acción recomendada
“CUDA out of memory”	Modelo más grande que la VRAM disponible.	Reduce el modelo, usa cuantización Q4, o activa CPU offload.
Respuesta muy lenta (>10 s)	GPU no detectada, ejecución en CPU.	Verifica drivers NVIDIA (`nvidia-smi`), instala CUDA 12.x, reinicia el servicio.
Error “Model not found” al pull	Nombre de modelo incorrecto o sin conexión a internet.	Revisa la ortografía, verifica que el repositorio en Hugging Face sea público.
API devuelve 500	Contenedor Docker sin acceso a GPU.	Añade `--gpus all` al `docker run` o revisa la configuración de runtime (`nvidia` vs `runc`).
Texto truncado	`max_context` inferior al número de tokens del prompt.	Aumenta `--max-context` a 4096 o más según el modelo.
Modelo no carga en LM Studio	Archivo corrupto o formato no compatible.	Descarga nuevamente el modelo; si usas `gguf`, verifica que la versión sea >= 0.6.0.

10. Recursos adicionales

Tipo	Enlace	Descripción
Repositorio oficial de Ollama	https://github.com/ollama/ollama	Código fuente, releases y documentación Docker.
Página de descargas de LM Studio	https://lmstudio.ai/download	Instaladores y guía de usuario.
Catálogo de modelos en Hugging Face	https://huggingface.co/models	Busca por tareas, tamaño, licencia y formatos GGUF.
Comunidad Discord de Ollama	https://discord.gg/ollama	Soporte en tiempo real, ejemplos y proyectos colaborativos.
Guía de cuantización de GGUF	https://github.com/ggerganov/ggml/blob/master/docs/gguf.md	Detalles técnicos y comparativas de calidad.
Tutorial de n8n + Ollama	https://github.com/n8n-io/n8n/tree/master/workflows	Plantillas de workflow para integrar LLMs en pipelines de negocio.
Artículo “Local LLMs: The Future of Private AI”	https://arxiv.org/abs/2409.11234	Investigación académica sobre seguridad y privacidad.

Menciones de Marca en la Búsqueda con IA