LLMs locales en Apple Silicon: guía completa para Mac (2026)

Si tienes un Mac con chip M-series (M1 a M5), tienes uno de los mejores entornos del mundo para correr LLMs locales. La memoria unificada y el ancho de banda alto convierten al MacBook Pro y al Mac Studio en máquinas de inferencia que rivalizan con GPUs dedicadas — sin gastar 5.000 € en una RTX 6000.

Esta guía explica cómo correr LLMs locales en Apple Silicon en 2026: qué framework usar (MLX, llama.cpp, Ollama, LM Studio), qué modelos eligen los profesionales, los benchmarks reales que importan, y dónde está el techo del hardware.

Por qué Apple Silicon brilla en LLMs locales

Tres razones técnicas:

1. Memoria unificada (UMA): CPU, GPU y Neural Engine comparten la misma RAM. No hay copia entre VRAM y RAM, que es el cuello de botella en GPUs convencionales.

2. Ancho de banda alto: M4 Max tiene ~546 GB/s; M5 Max ~600 GB/s. Cerca de una RTX 4090 (1 TB/s) por una fracción del consumo.

3. Eficiencia energética: 30-60W para inferir un 13B. Una GPU haciendo lo mismo consume 250-400W.

El resultado: un MacBook Pro M4 Max con 64 GB corre cómodamente modelos de hasta ~70B cuantizados, y un Mac Studio M3 Ultra con 192 GB corre Llama 4 405B en 4-bit sin servidor adicional.

Frameworks: MLX, llama.cpp, Ollama, LM Studio

MLX — el framework nativo de Apple

MLX es la librería de Apple para machine learning en Apple Silicon. Optimizada al milímetro para el hardware: Metal Performance Shaders, scheduler nativo, y estructuras de datos pensadas para UMA.

Pros:

• Rendimiento máximo: 2-2.5x más rápido que llama.cpp en modelos <14B parámetros.

• Fine-tuning nativo: LoRA y QLoRA en el propio Mac sin crashes.

• Hugging Face → MLX: muchos modelos ya tienen versión -mlx lista.

Contras:

• Solo Apple Silicon (no portable).

• Documentación menos abundante que llama.cpp.

• Para modelos grandes (>27B) la ventaja se reduce porque el cuello pasa a ser el ancho de banda.

pip install mlx-lm
mlx_lm.generate --model mlx-community/Llama-3.3-70B-Instruct-4bit \
  --prompt "Explica MCP" --max-tokens 500

llama.cpp — el estándar de facto

llama.cpp es la implementación C++ portable más popular. Soporta GGUF (formato dominante), corre en cualquier OS, y en Mac usa Metal.

Pros:

• Universal: Linux, Windows, Mac, ARM, x86, sin cambios.

• Ecosistema enorme: GGUF en Hugging Face para casi todo.

• Cuantización flexible: Q2 a Q8, según el ratio calidad/tamaño que quieras.

Contras:

• En Apple Silicon, ~30-50% más lento que MLX en modelos pequeños.

• Configuración más manual.

Ollama — UX cómoda

Ollama usa llama.cpp por debajo pero añade gestión de modelos, REST API y CLI cómoda. Es la opción más fácil para empezar.

brew install ollama
ollama pull llama3.3
ollama run llama3.3 "Explica LoRA"

Pros:

• Zero-setup.

• Compatible con la API de OpenAI (drop-in para muchos clientes).

• Buena gestión de versiones.

Contras:

• Misma penalty de rendimiento que llama.cpp vs MLX.

• Menos control fine-grained.

LM Studio — GUI

LM Studio es la app gráfica para descargar y correr LLMs en Mac. UX tipo ChatGPT pero local.

Pros:

• Sin terminal.

• Compara modelos visualmente.

• Buena para no-devs.

Contras:

• Closed-source.

• Menos configurable.

vLLM-MLX — la novedad 2026

vLLM ha portado parcialmente su engine a MLX (vllm-mlx). En modelos pequeños alcanza hasta ~525 tok/s en M4 Max, gracias a continuous batching y PagedAttention sobre Metal.

Aún en madurez, pero apunta a ser la opción cuando Apple Silicon sea servidor de inferencia para varios usuarios.

Benchmarks reales 2026

Mediciones aproximadas (varían según prompt, contexto y temperatura). Datos de la comunidad y de pruebas propias en abril 2026.

Lectura: para uso interactivo (chat) basta con 15-20 tok/s. Para batch o agentes que generan miles de tokens, 70B en M4 Max ya es lento. Las MoE como Qwen 3.5 35B-A3B son el sweet spot: tamaño grande, computación pequeña.

Modelos recomendados por caso de uso

Generalista buena calidad

• Llama 3.3 70B Instruct (Q4_K_M o MLX-4bit) — el referente actual open weights.

• Qwen 3.5 32B / 35B-A3B — chino pero muy fuerte en razonamiento, MoE muy eficiente.

Coding

• Qwen 3 Coder 32B — mejor open weights coder de inicios 2026.

• DeepSeek Coder V3 — corre con problemas en 64GB pero excelente.

• Codestral 22B — bueno y ligero.

Código + razonamiento ligero

• Llama 3.3 13B — sweet spot rendimiento/calidad para Mac base.

• Phi-4 14B — Microsoft, sorprendentemente fuerte en razonamiento.

Embeddings y RAG

• mxbai-embed-large — 335M parámetros, excelente.

• nomic-embed-text-v2 — multilingüe, muy buena calidad.

Visión

• Qwen2.5-VL 32B — multimodal completo, MLX disponible.

• Llama 3.2 Vision 11B — más ligero.

Cuánto Mac necesitas

Si vas a usar el Mac también como dev machine y quieres correr LLMs sin penalizar el resto, apunta a 64 GB mínimo.

Cuantización: GGUF vs MLX-4bit vs AWQ

• GGUF (Q4_K_M, Q5_K_M, Q8_0): formato de llama.cpp. Soporte universal. Q4_K_M es el equilibrio típico.

• MLX-4bit / 8bit: nativo MLX. Más rápido en Apple Silicon, mismo nivel de calidad que GGUF Q4.

• AWQ: orientado a GPU, no usual en Mac.

Para Apple Silicon, MLX 4-bit si el modelo tiene versión MLX, GGUF Q4_K_M si no.

Privacidad y cumplimiento

Ventaja masiva de inferencia local: no sale ningún dato del Mac. Para sectores con datos sensibles (legal, salud, finanzas), esto cierra cuestiones de RGPD que con APIs cloud requieren DPAs complejos y AIPD detallada.

Casos donde Mac local gana fácil:

• Asistente de un abogado con borradores de clientes.

• Agente médico con historiales.

• Prototipos antes de aprobar el subencargado cloud.

• Personal AI que toca emails y notas privadas.

Limitaciones:

• No escala a múltiples usuarios sin red infra.

• El frontier (Opus 4.7, GPT-5.5) sigue siendo cloud-only por tamaño.

Setup recomendado paso a paso

# 1. Ollama para empezar rápido
brew install ollama
ollama pull llama3.3            # 70B base
ollama pull qwen2.5-coder:32b   # coding

# 2. Si quieres rendimiento máximo, MLX
pip install mlx-lm
mlx_lm.convert --hf-path meta-llama/Llama-3.3-70B-Instruct -q

# 3. LM Studio para GUI / no-devs
# https://lmstudio.ai/ — descarga e instala

# 4. Para integrar con apps tipo Continue.dev o Claude Code
# Apunta a http://localhost:11434/v1 (Ollama es OpenAI-compatible)

Comparativa: Mac vs API cloud para uso real

Decisión típica: usa cloud para la frontier en cargas críticas y Mac local para lo demás (drafting, code completion, RAG sobre datos privados).

Errores comunes

1. Comprar 16 GB pensando que basta: en 6 meses te quedas sin margen. 32 GB mínimo si vas en serio.

2. No cuantizar: en 16-bit casi nada cabe. Q4_K_M o 4-bit MLX es tu base.

3. Ignorar MLX: Si tu modelo tiene versión MLX, úsala. Es 2x.

4. Mezclar cargas: si renderizas vídeo en paralelo, la GPU compite. Pausa Final Cut antes de inferir.

5. No actualizar el Mac: cada release de macOS y MLX trae mejoras de 5-15%.

Conclusión

En 2026, un MacBook Pro M4 Max o un Mac Studio M3 Ultra es la herramienta de inferencia local más eficiente del mercado para profesionales. Rivaliza con GPUs dedicadas en tokens por segundo y las supera en consumo, tamaño y silencio.

El stack mínimo: Ollama para la mayoría, MLX para rendimiento, LM Studio para clientes y prototipos. Llama 3.3 70B y Qwen 3.5 35B-A3B son los modelos a tener.

Local no reemplaza al cloud para tareas frontier, pero devuelve control y abre todos los casos de uso con datos sensibles donde antes era imposible mover la aguja sin un DPA imposible.

Para profundizar:

• vLLM vs Ollama — cuándo escalar a servidor.

• LLMs en empresa y RGPD — base regulatoria.

• DeepSeek V3.2 vs Claude Opus 4.7 — alternativa low-cost.

• Modelos open source en producción — pillar del cluster.

Fuentes verificadas

• llama.cpp GitHub Discussion #4167 — Performance Apple Silicon — benchmarks comunidad.

• MLX GitHub oficial — framework Apple.

• Ollama oficial — distribución LLMs local.

• LM Studio — GUI Mac.

• Apple Silicon LLM Benchmarks (llmcheck.net) — tabla comunitaria de tok/s.

• Datos verificados el 30 de abril de 2026.