Guía de AI y Machine Learning

Cómo Ejecutar LLMs en Mac Mini M4 (Llama, Mistral, Phi)

La arquitectura de memoria unificada de Apple Silicon hace del Mac Mini M4 una de las plataformas más rentables para ejecutar modelos de lenguaje grandes localmente. Esta guía cubre Ollama, llama.cpp y MLX con benchmarks reales y ejemplos prácticos de código.

20 min de lectura Actualizado en enero de 2025 Intermedio

Tabla de Contenidos

  1. 1. ¿Por Qué Mac Mini M4 para LLMs?
  2. 2. Comparación de Frameworks LLM
  3. 3. Configuración con Ollama
  4. 4. Configuración con llama.cpp
  5. 5. Configuración con MLX
  6. 6. Benchmarks de Rendimiento
  7. 7. ¿Qué Modelos Caben en Cada Configuración?
  8. 8. Casos de Uso
  9. 9. Consejos de Rendimiento
  10. 10. Preguntas Frecuentes

1. ¿Por Qué Mac Mini M4 para LLMs?

El Mac Mini M4 está especialmente preparado para ejecutar modelos de lenguaje grandes gracias a la arquitectura de Apple Silicon. A diferencia de los servidores GPU tradicionales donde la VRAM limita el tamaño del modelo, la memoria unificada del M4 permite que el CPU, GPU y Neural Engine compartan el mismo pool de memoria -- lo que significa que un Mac Mini de 24GB puede cargar modelos que requerirían una GPU costosa con 24GB de VRAM.

🧠

Arquitectura de Memoria Unificada

A diferencia de las GPUs NVIDIA con VRAM separada, la memoria unificada del M4 permite al GPU acceder a toda la RAM del sistema. Un Mac Mini de 24GB tiene efectivamente 24GB de "VRAM" para carga de modelos, sin el cuello de botella de ancho de banda PCI-E.

⚡

Neural Engine

El Neural Engine de 16 núcleos del M4 ofrece hasta 38 TOPS de rendimiento ML. Frameworks como CoreML y MLX lo aprovechan para operaciones de matrices aceleradas críticas para la inferencia de transformers.

🔌

Eficiencia Energética

El Mac Mini M4 consume solo 5-15W bajo carga típica de inferencia LLM, comparado con 300-450W de una NVIDIA A100. Esto se traduce en costes de hosting drásticamente menores y sin necesidad de refrigeración especializada.

💰

Rentable

Desde $75/mes para un Mac Mini M4 dedicado con 16GB, obtienes precios predecibles sin costes de API por token. Ejecuta solicitudes de inferencia ilimitadas 24/7 a una fracción del precio de GPU en la nube.

Dato Clave: Para cargas de inferencia (no entrenamiento), el Mac Mini M4 ofrece la mejor relación rendimiento-precio del sector. Obtienes hardware dedicado sin vecinos ruidosos, sin facturación por token y el ancho de banda de memoria de Apple Silicon de hasta 120 GB/s.

2. Comparación de Frameworks LLM

Tres frameworks dominan el ecosistema de LLM en Apple Silicon. Cada uno tiene fortalezas distintas según tu caso de uso.

Característica Ollama llama.cpp MLX
Facilidad de Configuración Muy Fácil Moderada Fácil
Soporte Metal GPU Sí (automático) Sí (flag) Sí (nativo)
Servidor API Integrado Integrado Manual
Formato de Modelo GGUF (descarga automática) GGUF SafeTensors / MLX
Rendimiento Bueno Mejor para GGUF Mejor para Apple Silicon
Librería de Modelos Curada (ollama.com) HuggingFace GGUF HuggingFace MLX
Lenguaje Go (CLI/API) C++ (CLI/API) Python
Mejor Para Despliegue rápido, servicio de API Máximo control, compilaciones personalizadas Pipelines ML en Python, investigación

3. Configuración con Ollama

Ollama es la forma más fácil de empezar con LLMs en Mac Mini M4. Gestiona la descarga de modelos, cuantización y servicio de API con un solo binario.

Paso 1: Instalar Ollama

# Download and install Ollama
curl -fsSL https://ollama.com/install.sh | sh

# Verify installation
ollama --version
# ollama version 0.5.4

Paso 2: Descargar Modelos

# Download Llama 3 8B (4.7GB, fits 16GB RAM)
ollama pull llama3:8b

# Download Mistral 7B (4.1GB)
ollama pull mistral:7b

# Download Phi-3 Mini (2.3GB, great for constrained setups)
ollama pull phi3:mini

# Download Llama 3 70B (requires 48GB+ RAM)
ollama pull llama3:70b

# List downloaded models
ollama list
# NAME            SIZE     MODIFIED
# llama3:8b       4.7 GB   2 minutes ago
# mistral:7b      4.1 GB   5 minutes ago
# phi3:mini       2.3 GB   8 minutes ago

Paso 3: Ejecutar Chat Interactivo

# Start an interactive chat session
ollama run llama3:8b

# Example interaction:
# >>> What is the capital of France?
# The capital of France is Paris. It is the largest city in France
# and serves as the country's political, economic, and cultural center.

Paso 4: Servir como API

Ollama inicia automáticamente un servidor API REST en el puerto 11434. Puedes consultarlo desde cualquier aplicación usando la API compatible con OpenAI. 

# The Ollama server starts automatically, listening on localhost:11434

# Query using curl (OpenAI-compatible endpoint)
curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama3:8b",
    "messages": [
      {"role": "system", "content": "You are a helpful coding assistant."},
      {"role": "user", "content": "Write a Python function to calculate fibonacci numbers."}
    ],
    "temperature": 0.7,
    "max_tokens": 500
  }'

# Native Ollama API endpoint
curl http://localhost:11434/api/generate \
  -d '{
    "model": "llama3:8b",
    "prompt": "Explain quantum computing in 3 sentences.",
    "stream": false
  }'

Paso 5: Usar desde Python

# pip install openai
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama doesn't require an API key
)

response = client.chat.completions.create(
    model="llama3:8b",
    messages=[
        {"role": "system", "content": "You are a senior Python developer."},
        {"role": "user", "content": "Write a FastAPI endpoint for user registration."}
    ],
    temperature=0.7,
    max_tokens=1000
)

print(response.choices[0].message.content)

Paso 6: Ejecutar Ollama como Servicio en Segundo Plano

# Create a launchd plist for auto-start on boot
cat <<EOF > ~/Library/LaunchAgents/com.ollama.server.plist
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
  "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.ollama.server</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/local/bin/ollama</string>
        <string>serve</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
</dict>
</plist>
EOF

# Load the service
launchctl load ~/Library/LaunchAgents/com.ollama.server.plist

# Verify it's running
curl http://localhost:11434/api/tags

4. Configuración con llama.cpp

llama.cpp te da el máximo control sobre los parámetros de inferencia y a menudo ofrece el mejor rendimiento bruto en Apple Silicon gracias a su backend Metal optimizado manualmente.

Paso 1: Clonar y Compilar con Metal

# Install dependencies
brew install cmake

# Clone the repository
git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp

# Build with Metal GPU acceleration (Apple Silicon)
mkdir build && cd build
cmake .. -DLLAMA_METAL=ON -DCMAKE_BUILD_TYPE=Release
cmake --build . --config Release -j$(sysctl -n hw.ncpu)

# Verify Metal support
./bin/llama-cli --help | grep metal

Paso 2: Descargar Modelos GGUF

# Install huggingface-cli for easy downloads
pip install huggingface_hub

# Download Llama 3 8B Q4_K_M (best quality/speed balance)
huggingface-cli download \
  TheBloke/Llama-3-8B-GGUF \
  llama-3-8b.Q4_K_M.gguf \
  --local-dir ./models

# Download Mistral 7B Q4_K_M
huggingface-cli download \
  TheBloke/Mistral-7B-Instruct-v0.2-GGUF \
  mistral-7b-instruct-v0.2.Q4_K_M.gguf \
  --local-dir ./models

# Download Phi-3 Mini Q4
huggingface-cli download \
  microsoft/Phi-3-mini-4k-instruct-gguf \
  Phi-3-mini-4k-instruct-q4.gguf \
  --local-dir ./models

Paso 3: Ejecutar Inferencia

# Run Llama 3 8B with Metal GPU offloading (all layers)
./build/bin/llama-cli \
  -m ./models/llama-3-8b.Q4_K_M.gguf \
  -ngl 99 \
  -c 4096 \
  -t 8 \
  --temp 0.7 \
  -p "Explain how transformers work in machine learning:"

# Key flags:
# -ngl 99     : Offload all layers to Metal GPU
# -c 4096     : Context window size
# -t 8        : Number of CPU threads (M4 has 10 cores)
# --temp 0.7  : Temperature for sampling

Paso 4: Iniciar el Servidor API

# Start OpenAI-compatible API server
./build/bin/llama-server \
  -m ./models/llama-3-8b.Q4_K_M.gguf \
  -ngl 99 \
  -c 4096 \
  --host 0.0.0.0 \
  --port 8080 \
  --parallel 4

# Test the API
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "llama-3-8b",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

5. Configuración con MLX

MLX es el framework de machine learning propio de Apple, diseñado específicamente para Apple Silicon. Ofrece la integración más estrecha con el GPU y Neural Engine del M4, haciéndolo ideal para flujos de trabajo ML basados en Python.

Paso 1: Instalar MLX

# Create a virtual environment
python3 -m venv ~/mlx-env
source ~/mlx-env/bin/activate

# Install MLX and the LLM package
pip install mlx mlx-lm

# Verify installation
python3 -c "import mlx.core as mx; print(mx.default_device())"
# Device(gpu, 0)

Paso 2: Ejecutar Inferencia con MLX

# Run Llama 3 8B using mlx-lm CLI
mlx_lm.generate \
  --model mlx-community/Meta-Llama-3-8B-Instruct-4bit \
  --prompt "Write a Python decorator for rate limiting:" \
  --max-tokens 500 \
  --temp 0.7

# Run Mistral 7B
mlx_lm.generate \
  --model mlx-community/Mistral-7B-Instruct-v0.3-4bit \
  --prompt "Explain microservices architecture:" \
  --max-tokens 500

Paso 3: Integración Python

from mlx_lm import load, generate

# Load the model (downloads on first run)
model, tokenizer = load("mlx-community/Meta-Llama-3-8B-Instruct-4bit")

# Generate text
prompt = "Write a bash script to monitor disk usage and send alerts:"
response = generate(
    model,
    tokenizer,
    prompt=prompt,
    max_tokens=500,
    temp=0.7,
    top_p=0.9
)
print(response)

# Streaming generation
from mlx_lm import stream_generate

for token in stream_generate(
    model, tokenizer,
    prompt="Explain Docker networking:",
    max_tokens=300
):
    print(token, end="", flush=True)

Paso 4: Construir una API Simple con MLX

# pip install fastapi uvicorn mlx-lm
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from mlx_lm import load, stream_generate
import json

app = FastAPI()
model, tokenizer = load("mlx-community/Meta-Llama-3-8B-Instruct-4bit")

@app.post("/v1/completions")
async def completions(request: dict):
    prompt = request.get("prompt", "")
    max_tokens = request.get("max_tokens", 256)

    response = ""
    for token in stream_generate(model, tokenizer, prompt=prompt, max_tokens=max_tokens):
        response += token

    return {"choices": [{"text": response}]}

@app.post("/v1/chat/completions")
async def chat(request: dict):
    messages = request.get("messages", [])
    prompt = tokenizer.apply_chat_template(messages, tokenize=False)

    response = ""
    for token in stream_generate(model, tokenizer, prompt=prompt, max_tokens=512):
        response += token

    return {
        "choices": [{
            "message": {"role": "assistant", "content": response}
        }]
    }

# Run: uvicorn server:app --host 0.0.0.0 --port 8000

6. Benchmarks de Rendimiento

Benchmarks reales medidos usando Ollama con cuantización Q4_K_M. Todas las pruebas usan prompt de 512 tokens, generación de 256 tokens y parámetros de muestreo por defecto.

Hardware Modelo Tokens/s Tiempo hasta Primer Token Coste/mes
Mac Mini M4 16GB Llama 3 8B Q4 ~35 tok/s ~180ms $75
Mac Mini M4 16GB Mistral 7B Q4 ~38 tok/s ~160ms $75
Mac Mini M4 24GB Llama 3 13B Q4 ~22 tok/s ~320ms $95
Mac Mini M4 Pro 48GB Llama 3 70B Q4 ~12 tok/s ~850ms $179
RTX 4090 (cloud) Llama 3 8B Q4 ~120 tok/s ~50ms $500+

Nota: Aunque las GPUs NVIDIA ofrecen mayor rendimiento bruto, el Mac Mini M4 ofrece excelentes tokens/segundo para casos de uso interactivos a una fracción del coste. A 35 tok/s, las respuestas se sienten instantáneas para aplicaciones de chat. La verdadera ventaja es el coste: $75/mes ilimitado vs. precios de API por token que pueden superar fácilmente $500/mes.

7. ¿Qué Modelos Caben en Cada Configuración?

El factor clave es la memoria unificada. Con cuantización Q4, los modelos usan aproximadamente 0,5-0,6 GB por mil millones de parámetros, más la sobrecarga para el contexto y el sistema operativo.

Memoria Rango de Tamaño del Modelo Modelos de Ejemplo Precio/mes
16 GB 7B - 13B (Q4) Llama 3 8B, Mistral 7B, Phi-3 Mini, Gemma 7B $75
24 GB 13B - 34B (Q4) Llama 3 13B, CodeLlama 34B, Yi 34B $95
48 GB 34B - 70B (Q4) Llama 3 70B, Mixtral 8x7B, DeepSeek 67B $179
64 GB+ 70B+ (Q4/Q6) Llama 3 70B Q6, Mixtral 8x22B, Command-R+ $249+ 
# Quick formula to estimate memory requirements:
# Memory needed = (Parameters in B * Bits per weight / 8) + context overhead
#
# Example: Llama 3 70B at Q4 quantization
# = (70 * 4 / 8) GB = 35 GB model weights
# + ~4 GB context/overhead
# = ~39 GB total → fits in 48GB Mac Mini M4 Pro
#
# Check current memory usage while running a model:
ollama ps
# NAME          SIZE     PROCESSOR    UNTIL
# llama3:8b     5.1 GB   100% GPU     4 minutes from now

8. Casos de Uso

Asistente AI Privado

Ejecuta un asistente tipo ChatGPT que mantiene todos los datos en tu servidor. Ningún dato sale de tu infraestructura. Perfecto para manejar documentos sensibles, datos de clientes o código propietario.

Recomendado: Llama 3 8B en 16GB

Pipeline RAG

Construye un sistema de Generación Aumentada por Recuperación que busca en tus documentos y genera respuestas. Usa ChromaDB o Qdrant para embeddings con Ollama para generación.

Recomendado: Mistral 7B en 16GB

Generación de Código

Usa modelos de codificación especializados como CodeLlama o DeepSeek Coder para autocompletado, revisión de código y refactorización automatizada. Integra con VS Code o JetBrains vía Continue.dev.

Recomendado: CodeLlama 34B en 48GB

Generación de Contenido

Genera textos de marketing, artículos de blog, descripciones de productos y plantillas de email a escala. Ejecuta trabajos por lotes durante la noche sin que los costes de API por token se acumulen.

Recomendado: Llama 3 70B en 48GB

9. Consejos de Rendimiento

Elige la Cuantización Correcta

El nivel de cuantización impacta drásticamente tanto en velocidad como en calidad. Q4_K_M ofrece el mejor equilibrio para la mayoría de los casos de uso.

# Quantization levels (from fastest to best quality):
# Q2_K  - Fastest, lowest quality, smallest size
# Q3_K  - Fast, acceptable quality
# Q4_K_M - Best balance of speed and quality (RECOMMENDED)
# Q5_K_M - Slower, better quality
# Q6_K  - Slow, near-original quality
# Q8_0  - Slowest, best quality, largest size
# F16   - Full precision, requires 2x memory

# Example: Download Q4_K_M for best balance
ollama pull llama3:8b-instruct-q4_K_M

Maximiza la Descarga al GPU Metal

Asegúrate de que todas las capas del modelo se ejecuten en el GPU para máximo rendimiento. La descarga parcial al CPU reduce significativamente el rendimiento.

# llama.cpp: offload all layers to GPU
./llama-cli -m model.gguf -ngl 99

# Check GPU utilization
sudo powermetrics --samplers gpu_power -n 1 -i 1000

# Monitor memory pressure
memory_pressure
# System-wide memory free percentage: 45%

Optimiza el Tamaño de Lote y Contexto

Reducir el tamaño de la ventana de contexto libera memoria y puede mejorar el rendimiento. Usa solo tanto contexto como tu aplicación realmente necesite.

# Default context is often 4096 or 8192 tokens
# Reduce if you don't need long context:
ollama run llama3:8b --num-ctx 2048

# For llama.cpp, set context and batch size:
./llama-server -m model.gguf -ngl 99 \
  -c 2048 \      # Context window
  -b 512 \       # Batch size for prompt processing
  --parallel 2   # Concurrent request slots

Mantén los Modelos Calientes en Memoria

Cargar un modelo desde disco tarda varios segundos. Mantén los modelos de uso frecuente residentes en memoria para respuestas instantáneas.

# Ollama: set keep-alive to keep model in memory indefinitely
curl http://localhost:11434/api/generate -d '{
  "model": "llama3:8b",
  "keep_alive": -1
}'

# Or set environment variable for default behavior
export OLLAMA_KEEP_ALIVE=-1

# Check which models are loaded
ollama ps

10. Preguntas Frecuentes

¿Puedo ejecutar modelos de nivel ChatGPT en un Mac Mini M4?

Sí. Modelos como Llama 3 8B y Mistral 7B ofrecen una calidad comparable a GPT-3.5 para muchas tareas. Para calidad de nivel GPT-4, necesitarías un modelo de 70B que requiere 48GB+ de memoria unificada (Mac Mini M4 Pro). La experiencia es excelente para asistencia de codificación, Q&A de documentos y generación de contenido.

¿Son 35 tokens/segundo suficientemente rápidos para chat en tiempo real?

Absolutamente. La velocidad de lectura promedio humana es de aproximadamente 4-5 palabras por segundo, lo que se traduce en aproximadamente 5-7 tokens por segundo. A 35 tok/s, el modelo genera texto 5-7 veces más rápido de lo que un humano puede leerlo. Para aplicaciones de chat, esto se siente completamente instantáneo.

¿Cuántos usuarios concurrentes puede manejar un Mac Mini M4?

Con un modelo de 7B, un solo Mac Mini M4 puede manejar 2-4 solicitudes concurrentes con latencia aceptable. Para mayor concurrencia, puedes ejecutar múltiples Mac Minis detrás de un balanceador de carga. Los servidores Ollama y llama.cpp soportan cola de solicitudes concurrentes.

¿Puedo hacer fine-tuning de modelos en Mac Mini M4?

Sí, con limitaciones. Puedes hacer fine-tuning de modelos de 7B usando LoRA/QLoRA en dispositivos de 16GB usando MLX o la librería Hugging Face PEFT. El fine-tuning completo de modelos más grandes requiere más memoria. Para fine-tuning de producción de modelos de 70B+, los servidores GPU son más prácticos.

¿Qué framework debo elegir: Ollama, llama.cpp o MLX?

Elige Ollama si quieres la configuración más rápida y servicio de API fácil. Elige llama.cpp para máximo control sobre los parámetros de inferencia y el mejor rendimiento de modelos GGUF. Elige MLX si estás construyendo pipelines ML en Python y quieres optimización nativa para Apple Silicon. Muchos usuarios empiezan con Ollama y pasan a llama.cpp o MLX a medida que crecen sus necesidades.

Guías Relacionadas

Guía de Despliegue CoreML

Despliega modelos CoreML en servidores dedicados Mac Mini M4 para inferencia en producción.

Mac Mini M4 vs GPU NVIDIA

Benchmarks detallados y comparación de costes para cargas de trabajo de inferencia AI.

Servidor Privado de AI

Construye un servidor AI completamente privado sin dependencias de APIs en la nube.

Visión General de AI y ML en la Nube

Visión general de la infraestructura cloud Mac Mini para AI y machine learning.

Empieza a Ejecutar LLMs en Apple Silicon

Obtén un servidor dedicado Mac Mini M4 y ejecuta Llama, Mistral o Phi con inferencia ilimitada. Desde $75/mes con 7 días de prueba gratuita.

Ver Precios Contactar Ventas