Cómo montar tu propia IA local en una Mac (guía paso a paso, sin volverte loco)

Antes de empezar

Esta guía no es para leer. Es para ejecutar. Si estás cómodo con la terminal, te toma una tarde. Si nunca abriste la terminal, te toma un fin de semana y sales del otro lado sabiendo más.

No vas a necesitar pagar nada. No vas a necesitar internet (después de la instalación inicial). No vas a necesitar enviarle datos a OpenAI ni a nadie.

Lo que sí vas a necesitar:

• Una Mac con chip Apple Silicon (M1, M2, M3 o M4 — no sirven los Intel)
• Al menos 16 GB de memoria unificada (mejor 24 o 36 GB si vas a correr modelos grandes)
• Unos 30 GB libres en disco
• Una hora libre para la primera instalación
• Disposición a probar, fallar y volver a probar

Si quieres profundizar antes en qué Mac necesitas exactamente para qué tipo de modelo, en el blog tienes la guía completa de hardware. Esta guía asume que ya tomaste esa decisión.

Paso 1 — Instala Homebrew (si no lo tienes ya)

Homebrew es el gestor de paquetes que vamos a usar para instalar todo lo demás. Si nunca lo instalaste, abre la app **Terminal** (búscala con Spotlight) y pega esto:

/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"

Te va a pedir tu contraseña. La escribes (no se ve mientras la escribes, normal) y enter. Espera a que termine — son unos minutos.

Cuando acabe, asegúrate de que el comando `brew` funciona escribiendo `brew --version` en la terminal. Si ves un número de versión, perfecto.

Paso 2 — Instala MLX (la librería que hace correr modelos IA en tu Mac)

MLX es lo que Apple desarrolló para correr modelos de IA aprovechando el chip de tu Mac. Es lo que hace posible que tengas un asistente local que va rápido.

brew install mlx-lm

Espera a que termine. Cuando vuelva el cursor, comprueba que está bien:

mlx_lm.server --help

Si te sale un texto de ayuda, perfecto. Si te sale "command not found", reinicia la terminal y prueba otra vez.

Antes del paso 3 — qué modelo elegir según tu caso

Aquí es donde la mayoría se pierde. Hay cientos de modelos disponibles y elegir uno cuando empiezas se siente como entrar a un supermercado sin lista. Vamos por partes.

Lo primero: hay familias de modelos según para qué los usas. No todos sirven para todo. Estos son los principales tipos que vas a encontrar:

• Modelos generales (Instruct). Para uso normal: chat, escribir correos, resumir documentos, generar ideas, traducir, hacer brainstorm. Es lo que la mayoría quiere. Ejemplos: Qwen2.5-Instruct, Llama-3-Instruct, Mistral-Instruct.
• Modelos Coder. Especializados en código: generar scripts, refactorizar, debuggear, explicar código. Si tu caso es de programación, vas por aquí. Ejemplos: Qwen-Coder, DeepSeek-Coder, Codestral.
• Modelos multimodales (Vision). Aceptan imágenes además de texto. Para describir fotos, leer documentos escaneados, OCR de tickets, etc. Ejemplos: Llama-3.2-Vision, Qwen2-VL.
• Modelos pequeños (Embeddings). No conversan, sirven para buscar dentro de documentos por significado. Más avanzado, no aplica si recién empiezas.

Lo segundo: hay dos ecosistemas grandes para correr modelos locales en Mac, y conviene que sepas cuál es cuál antes de instalar:

• MLX (lo que vamos a usar nosotros). Apple lo desarrolla, está optimizado para chips Apple Silicon, los modelos van más rápido y consumen menos memoria. Catálogo de modelos en huggingface.co/mlx-community.
• Ollama. Más popular fuera del mundo Apple, multiplataforma (Mac, Linux, Windows), interfaz un poco más amigable para quien nunca tocó la terminal. Catálogo en ollama.com/library. En Mac es ligeramente más lento que MLX pero mucho más fácil para empezar.

Mi recomendación si vienes de cero: empieza con MLX. Si te atascas con la terminal, prueba Ollama después. No es decisión irreversible, puedes tener los dos instalados.

Lo tercero: el tamaño del modelo según tu RAM. Esto sí es regla dura. Cuanto más grande el modelo, más capaz, pero también más memoria consume. La regla básica:

• 16 GB de RAM → modelos hasta 7-8 mil millones de parámetros (4-bit). Suficiente para uso personal: chat, ideas, escribir.
• 24 GB de RAM → modelos hasta 14 mil millones (4-bit). Mejor calidad, sigue siendo cómodo.
• 36 GB o más → modelos hasta 32 mil millones (4-bit) o MoE de 30 mil millones. Calidad casi de nube top para muchas tareas.

Para profundizar en la elección concreta de hardware (qué Mac comprar para qué modelo) tenemos otra guía completa en el hub: la encuentras al final de este artículo.

Paso 3 — Descarga tu primer modelo

Aquí es donde tomas tu primera decisión. Hay tres opciones según tu hardware:

**Si tienes 16 GB de memoria:**

mlx_lm.generate --model mlx-community/Qwen2.5-7B-Instruct-4bit --prompt "Hola"

**Si tienes 24 GB de memoria:**

mlx_lm.generate --model mlx-community/Qwen2.5-14B-Instruct-4bit --prompt "Hola"

**Si tienes 36 GB o más:**

mlx_lm.generate --model mlx-community/Qwen2.5-32B-Instruct-4bit --prompt "Hola"

La primera vez que ejecutes esto, va a descargar el modelo (unos 5-20 GB según cuál elijas). Tarda según tu conexión a internet. Después la primera vez, queda guardado y no se vuelve a descargar.

Cuando termine, deberías ver el modelo respondiendo a "Hola". Si responde, ya tienes IA local funcionando. Felicidades.

Paso 4 — Levanta el servidor para que el modelo esté siempre disponible

Hasta ahora invocaste el modelo cada vez. Eso es lento porque carga el modelo en memoria cada vez. Lo que queremos es que el modelo esté cargado y disponible para responder en milisegundos.

Para eso, levantamos un servidor local:

mlx_lm.server --model mlx-community/Qwen2.5-14B-Instruct-4bit --port 11437

(Cambia el modelo por el que elegiste en el paso 3.)

Esto deja el servidor corriendo en el puerto 11437 de tu Mac. Mientras la terminal esté abierta, el servidor responde. Si cierras la terminal, el servidor se cae.

**Para probar que funciona**, abre OTRA terminal (deja la primera con el servidor corriendo) y ejecuta:

curl -s http://127.0.0.1:11437/v1/models

Si te devuelve un JSON con el nombre del modelo, perfecto. Tu servidor está vivo.

Paso 5 — Crea tu wrapper (un comando corto para invocarlo)

Escribir el `curl` completo cada vez es engorroso. Vamos a crear un comando corto llamado `ai` que tú puedas usar siempre.

Abre la terminal y pega esto (es un solo comando largo):

mkdir -p ~/bin && cat > ~/bin/ai << 'EOF'
#!/bin/bash
PROMPT="$*"
[[ -z "$PROMPT" ]] && { echo "uso: ai \"tu pregunta\""; exit 1; }
curl -s http://127.0.0.1:11437/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d "$(printf '{"model":"local","messages":[{"role":"user","content":%s}],"temperature":0.2}' "$(printf '%s' "$PROMPT" | python3 -c 'import sys,json; print(json.dumps(sys.stdin.read()))')")" \
  | python3 -c "import sys,json; print(json.load(sys.stdin)['choices'][0]['message']['content'])"
EOF
chmod +x ~/bin/ai
echo 'export PATH="$HOME/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

Ahora reinicia la terminal y prueba:

ai "Dame un comando bash para listar los 5 archivos más grandes en el directorio actual"

Si te responde con un comando, ya tienes tu IA local funcionando vía un solo comando corto.

Paso 6 — Dale contexto: enséñale quién eres y cómo te gusta trabajar

Hasta ahora tu modelo responde "como cualquiera". Lo bueno de tener uno propio es que puedes enseñarle tu manera de trabajar.

Crea un archivo de contexto con tus reglas. Abre tu editor preferido y crea el archivo `~/.ai-context.md`:

# Mi contexto

Soy [tu nombre]. Trabajo en [tu negocio o profesión].

## Cómo quiero que me respondas

- Conciso. Sin preámbulos tipo "claro, aquí tienes...".
- En español neutro (no España).
- Si me das código, dame solo el código en bloque, sin explicación salvo que pida.
- Si te pido un comando bash, asume macOS (no Linux).
- Si no sabes algo, dilo. NO inventes.

## Mis convenciones

- Uso bash (no zsh para scripts) salvo que avise.
- Doble quotes en todas las variables.
- Validación de argumentos al inicio de cualquier script.

## Lo que NO debes hacer nunca

- Inventar nombres de archivos o paths que no te di.
- Generar código sin haber confirmado los detalles.
- Usar palabras tipo "revolucionario", "increíble", "disruptivo".

Ahora vamos a hacer que tu wrapper `ai` cargue este contexto antes de cada consulta. Edita el archivo `~/bin/ai` que creaste antes y modifícalo así:

mkdir -p ~/bin && cat > ~/bin/ai << 'EOF'
#!/bin/bash
PROMPT="$*"
[[ -z "$PROMPT" ]] && { echo "uso: ai \"tu pregunta\""; exit 1; }
SYSTEM=$(cat ~/.ai-context.md 2>/dev/null || echo "Eres un asistente conciso. Sin preámbulos.")
curl -s http://127.0.0.1:11437/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d "$(python3 -c "
import sys, json
sys_msg = '''$SYSTEM'''
user_msg = '''$PROMPT'''
print(json.dumps({
  'model':'local',
  'messages':[
    {'role':'system','content':sys_msg},
    {'role':'user','content':user_msg}
  ],
  'temperature':0.2
}))")" \
  | python3 -c "import sys,json; print(json.load(sys.stdin)['choices'][0]['message']['content'])"
EOF
chmod +x ~/bin/ai

Ahora cada vez que invoques `ai "lo que sea"`, tu IA recibe primero tu contexto. Y empieza a responder como TÚ quieres, no como cualquier IA genérica.

Paso 7 — Configura el arranque automático (que esté siempre vivo)

Hasta ahora tu servidor se cae cuando cierras la terminal. Vamos a hacer que arranque solo cuando enciendas tu Mac y se mantenga vivo.

En macOS esto se hace con un archivo plist. Crea `~/Library/LaunchAgents/local.ai-server.plist` con este contenido (cambia el nombre del modelo por el tuyo):

<?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>local.ai-server</string>
    <key>ProgramArguments</key>
    <array>
        <string>/opt/homebrew/bin/mlx_lm.server</string>
        <string>--model</string>
        <string>mlx-community/Qwen2.5-14B-Instruct-4bit</string>
        <string>--port</string>
        <string>11437</string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>KeepAlive</key>
    <true/>
    <key>EnvironmentVariables</key>
    <dict>
        <key>KMP_DUPLICATE_LIB_OK</key>
        <string>TRUE</string>
        <key>OMP_NUM_THREADS</key>
        <string>1</string>
    </dict>
</dict>
</plist>

Las dos variables del final (KMP_DUPLICATE_LIB_OK y OMP_NUM_THREADS) son obligatorias si usas Apple Silicon — sin ellas, hay un bug conocido que hace crashear procesos Python aleatoriamente. Esto te lo ahorra.

Para activar el servicio:

launchctl bootstrap gui/$(id -u) ~/Library/LaunchAgents/local.ai-server.plist

Y para verificar que está corriendo:

launchctl print gui/$(id -u)/local.ai-server | grep state

Si dice `state = running`, tu servidor de IA está vivo y se va a quedar vivo aunque cierres todas las terminales.

Paso 8 — Empieza a usarlo de verdad (y a corregirlo cuando se equivoque)

Ahora tienes una IA local funcionando con tu contexto. Vamos al uso real.

Cosas que puedes pedirle desde ya:

ai "Genera un script bash que renombre todos los .jpeg a .jpg en este directorio"
ai "Resume estos 5 errores en 3 causas raíz: [pega los errores]"
ai "Escribe un docstring para esta función Python: [pega la función]"
ai "Dame los 10 comandos git más útiles para resolver conflictos"

Va a fallar a veces. Cuando falle, anota qué pasó. Por ejemplo, si te entrega bullets cuando pediste prosa, o si usa comandos de Linux cuando pediste bash de macOS, esa información es oro.

Cómo lo anotas (lo más simple): cada vez que el modelo se equivoque en algo, abre tu archivo `~/.ai-context.md` y añade una sección al final:

## Lecciones del [fecha de hoy]

- Cuando pido bash, asume macOS (no usar `stat -c %s`, usar `stat -f %z`).
- No respondas con bullets cuando pido prosa estructurada.
- Si pido "1 palabra", responde 1 palabra (no 3 oraciones).

Cada vez que añadas una lección, tu IA la lee al inicio de la siguiente consulta. Va aprendiendo, sesión tras sesión.

Paso 9 — Cuándo vale la pena ir más allá

Cuando llevas 2-3 semanas usando esto, vas a notar dos cosas:

**Una:** que el archivo de contexto se hace cada vez más útil. Es tu "memoria del asistente".

**Dos:** que algunas tareas las hace ya muy bien y otras siguen costándole. En esas que le cuestan, anotas la lección. Y poco a poco mejora.

Llegado un punto (típicamente cuando llevas unos meses y has acumulado 100-200 ejemplos buenos), tiene sentido dar el siguiente salto: fine-tuning con LoRA. Eso es ajustar el modelo en sí, no solo darle contexto. En el blog tienes el artículo donde lo explicamos en detalle.

Pero no te preocupes por eso ahora. Llega cuando llegue. Empieza con esto.

Errores comunes y cómo resolverlos

**El servidor no arranca y veo "command not found".** Es porque MLX no quedó bien instalado o el PATH no lo encuentra. Reinicia la terminal y prueba `which mlx_lm.server`. Si no devuelve un path, ejecuta `brew reinstall mlx-lm`.

**El modelo carga pero responde lentísimo o se queda colgado.** Probablemente elegiste un modelo muy grande para tu RAM. Bájate al siguiente tamaño abajo (de 30B a 14B, o de 14B a 7B).

**Mi Mac se calienta mucho cuando uso la IA.** Normal. El chip está trabajando. No es un fallo. Si te molesta el ventilador, baja el tamaño del modelo o úsalo solo cuando lo necesites.

**Veo el alerta "Python se cerró inesperadamente" cada vez que invoco la IA.** Es el bug de OpenMP que te mencioné. Asegúrate de que las variables KMP_DUPLICATE_LIB_OK y OMP_NUM_THREADS están en tu plist (paso 7).

**No me funciona el comando `ai`.** Verifica que el archivo `~/bin/ai` exista (`ls ~/bin/ai`), que tenga permisos de ejecución (`chmod +x ~/bin/ai`) y que tu PATH lo incluya (`echo $PATH | grep bin`).

Lo que viene después

Esta guía te dejó con una IA local básica funcionando. Si quieres ir más profundo, en el blog publicamos otras dos guías relacionadas:

• **Cómo elegir el hardware adecuado para tu IA local** — qué Mac comprar según tu uso real
• **El asistente IA que vive dentro de tu Mac y aprende contigo** — la versión narrativa de cómo montamos esto en IA & Negocios y por qué

Y si prefieres ahorrarte el trabajo de montarlo tú y que te lo dejemos llave en mano (en tu hardware o en uno que tú compres), eso es exactamente lo que hacemos en IA & Negocios. Habla con Aria por WhatsApp en iaynegocios.net y te decimos en una conversación si te conviene.

Si lo intentas y algo no funciona, escríbeme. Me interesa saber qué falla en la práctica para mejorar esta guía con casos reales.

— Francisco Ocaña
Fundador de IA & Negocios