IA en local: qué necesitas para ejecutar modelos en tu ordenador

Usar IA en local es ejecutar un modelo de lenguaje en tu propio ordenador, sin enviar lo que escribes a ningún servidor. Lo que decide si puedes hacerlo es, sobre todo, la memoria: un modelo de 8.000 millones de parámetros cuantizado a 4 bits pesa unos 5 GB y cabe en un equipo de 16 GB; uno de 30.000 millones, entre 18 y 25 GB según el modelo. Los programas para empezar, como Ollama o LM Studio, son gratuitos.

Aquí tienes cuánta memoria pide cada modelo (con tamaños reales de descarga), qué es la cuantización y cuánta calidad se pierde, por qué el contexto también ocupa memoria, qué cambia entre Mac, NVIDIA, AMD o solo procesador, y qué programa elegir. Datos de webs y documentación oficiales, consultadas el 8 de octubre de 2026.

Qué es exactamente la IA en local

Una instalación de IA local tiene dos piezas:

1. El modelo: un archivo (o varios) con los pesos de un modelo de lenguaje que su fabricante ha publicado para descargar. Son los llamados modelos de pesos abiertos, como Gemma (Google), Qwen (Alibaba), Llama (Meta) o gpt-oss (OpenAI).
2. El programa que lo ejecuta: un motor que carga esos pesos en la memoria y genera texto, casi siempre con una ventana de chat y un servidor local para que otras aplicaciones lo usen.

Una vez descargado el modelo, todo ocurre en tu máquina. Ollama lo resume así en sus preguntas frecuentes: «Ollama se ejecuta en local. No vemos tus prompts ni tus datos cuando ejecutas en local».

Por qué usarla y cuándo no compensa

Las razones para hacerlo son cuatro:

• Privacidad. Contratos, historiales médicos, código de un cliente: nada sale del ordenador.
• Sin internet. Funciona en un avión o en una red cerrada.
• Coste por uso cero. Pagas el equipo y la luz, no cada consulta. La página de precios de Ollama lo dice sin rodeos: ejecutar modelos en tu propio hardware es ilimitado.
• Control. El modelo que descargas no cambia de comportamiento de un día para otro ni desaparece porque el proveedor lo retire.

La contrapartida es el tamaño. La página de descarga de Ollama avisa de que los modelos grandes van lentos en un equipo sin una buena gráfica, y la propia Ollama lanzó sus modelos en la nube para los que no caben en un ordenador personal. Si tu tarea pide razonamiento largo, mucha precisión o leer documentos enormes de una vez, un servicio en la nube suele dar mejores resultados. Lo local rinde mejor en tareas acotadas y repetitivas: resumir, clasificar, extraer datos, traducir, redactar borradores o autocompletar código.

La memoria: lo que decide qué modelo puedes usar

El tamaño de un modelo se mide en parámetros (los números que ha aprendido). Para generar cada palabra, el programa tiene que tener esos parámetros en memoria:

• En un PC con tarjeta gráfica, en la memoria de vídeo (VRAM) de la gráfica.
• En un Mac con chip Apple, en la memoria unificada, que comparten el procesador y la gráfica.
• Sin gráfica, en la RAM normal, que funciona pero va más despacio.

La cuenta para saber cuánto ocupa un modelo es sencilla:

memoria de los pesos ≈ parámetros × bits por parámetro ÷ 8

Con Llama 3.1 8B (8.000 millones de parámetros) en el formato Q4_K_M, que usa unos 4,9 bits por parámetro, salen unos 4,9 GB. Es justo lo que pesa ese modelo en la biblioteca de Ollama. A eso hay que sumar el contexto (lo vemos más abajo) y lo que necesitan el sistema y tus otros programas.

Cuánta memoria pide cada tamaño

Estos son tamaños de descarga reales, a 4 bits, en la biblioteca de Ollama a 8 de octubre de 2026. En el nombre, la B son miles de millones de parámetros: la tabla va de menos de 1.000 millones (0.8B) a 120.000 millones (120B). La última columna es criterio nuestro: el tamaño del modelo más un margen para el contexto y el sistema, como mínimo.

Muse Glimmer 30B cae en el mismo rango, de 18 a 20 GB. Fuentes: fichas de Qwen 3.5, Llama 3.1, Gemma 4, gpt-oss, Qwen 3.6 y Muse Glimmer en Ollama. Los rangos aparecen porque Ollama ofrece varias versiones de cada modelo.

Parámetros totales y parámetros activos

Verás modelos con nombres como 30b-a3b. Son modelos de mezcla de expertos (MoE): tienen 30.000 millones de parámetros en total, pero para cada palabra solo trabajan unos 3.000 millones. Hugging Face lo explica así: necesitan mucha memoria porque todos los expertos se cargan, y a la vez generan más rápido que un modelo con el mismo número total de parámetros. Para saber si cabe, mira el total. Nemotron 3.5 Lightning de NVIDIA, por ejemplo, tiene 3.000 millones activos de 30.000 y pesa 25 GB en Ollama.

Qué es la cuantización y cuánta calidad se pierde

Cuantizar un modelo es guardar sus parámetros con menos precisión para que ocupe menos. Un modelo se publica normalmente a 16 bits por parámetro; cuantizado a 4 bits, ocupa más o menos una cuarta parte.

El formato más extendido para modelos cuantizados es GGUF, el de llama.cpp. Según Hugging Face, es un formato binario pensado para cargar modelos rápido y que guarda en un solo archivo los pesos y sus metadatos. Los nombres de las variantes indican los bits: Q8_0 son 8 bits, Q5_K_M unos 5,7, Q4_K_M unos 4,9. En Mac existe además MLX, el framework de Apple para su chip, con sus propios formatos.

¿Cuánto se nota? El proyecto llama.cpp publica mediciones. La perplejidad mide lo bien que el modelo predice un texto de referencia: cuanto más baja, mejor.

Fuentes: tamaños de la documentación de cuantización de llama.cpp (Llama 3.1 8B); perplejidad de su documentación de perplejidad (Llama 3 8B, la misma arquitectura). El porcentaje entre paréntesis, la diferencia con 16 bits, es cálculo nuestro.

La misma documentación mide otra cosa más intuitiva: en cuántas ocasiones la palabra más probable coincide con la del modelo original. Con Q8_0 coincide el 97,7 % de las veces; con Q4_K_M, el 91,9 %; con Q2_K, solo el 71,1 %. Por eso Q4_K_M es el punto de partida habitual: ocupa menos de un tercio y pierde poco. Por debajo de 4 bits la calidad cae deprisa. Son datos de un modelo concreto; en otros la pérdida varía.

Hay formatos de 4 bits más nuevos. Ollama asegura, con su propia medición en Gemma 4 12B, que el formato NVFP4 reduce aproximadamente a la mitad la pérdida de calidad de Q4_K_M.

El contexto también ocupa memoria

El contexto es todo lo que el modelo tiene presente a la vez: tus instrucciones, la conversación y los documentos que le pegues. Para no recalcularlo en cada palabra, el programa lo guarda en una caché (la caché KV), y esa caché crece con cada token.

Hemos hecho la cuenta para Llama 3.1 8B con los datos de su archivo de configuración (32 capas, 8 cabezas de clave y valor de 128 dimensiones, a 16 bits):

2 (clave y valor) × 32 capas × 8 cabezas × 128 dimensiones × 2 bytes = 128 KiB por token

Con 4.096 tokens de contexto, la caché KV a 16 bits ocupa 0,5 GiB; con 32.768 tokens, 4 GiB; y con 131.072 tokens, el máximo del modelo, 16 GiB. Con el contexto al máximo, la caché ocupa más del triple que el propio modelo cuantizado. Cada arquitectura gasta distinto, así que tómalo como orden de magnitud.

Ollama ajusta el contexto por defecto según tu VRAM: 4K (4.096 tokens) con menos de 24 GiB, 32K entre 24 y 48 GiB y 256K a partir de 48 GiB. La misma documentación recomienda al menos 64.000 tokens para agentes, búsqueda web y herramientas de programación. Si necesitas más contexto del que te cabe, Ollama permite guardar la caché a 8 bits con OLLAMA_KV_CACHE_TYPE=q8_0, que usa más o menos la mitad de memoria con una pérdida de precisión muy pequeña.

Mac, NVIDIA, AMD o solo procesador

Mac con chip Apple

La ventaja del Mac es la memoria unificada: la gráfica usa la misma memoria que el resto del sistema, así que un Mac de 32 o 64 GB carga modelos que en un PC pedirían una gráfica muy cara. Eso sí, macOS no le deja a la gráfica toda la memoria: fija un máximo recomendado, que Apple define como lo que la GPU puede reservar sin afectar al rendimiento, y el resto queda para el sistema y tus programas. En un Mac de 16 GB no cuentes con 16 GB para el modelo.

En Mac tienes dos motores: llama.cpp (con Metal) para GGUF y MLX. LM Studio usa los dos, y Ollama ejecuta modelos con MLX desde 2026 (anuncio en preview en marzo y mejoras en junio). En su biblioteca, las versiones para este motor aparecen marcadas como MLX. LM Studio pide un Mac con chip Apple y macOS 14 o posterior, y recomienda 16 GB de memoria (requisitos); los Mac con procesador Intel no aparecen entre los equipos compatibles.

PC con gráfica NVIDIA

Es la opción con mejor soporte en todos los programas, gracias a CUDA. Aquí el límite es la VRAM de la tarjeta: si el modelo no cabe, parte se ejecuta en el procesador. Ollama admite gráficas NVIDIA con capacidad de cómputo 5.0 o superior y controlador 550 o posterior; vLLM pide capacidad 7.5 o superior (de la serie RTX 20 en adelante).

Gráficas AMD e Intel

Funcionan, con más matices. En Linux, Ollama usa ROCm 7 y admite una lista amplia de Radeon. En Windows, por ROCm solo admite algunas Radeon RX 7000 y Radeon PRO W7000 (documentación). Para el resto está Vulkan, que Ollama activa por defecto desde su versión 0.30, de junio de 2026, y que extiende la aceleración a más gráficas AMD e Intel sin instalar librerías del fabricante. llama.cpp soporta HIP (AMD), Vulkan y SYCL (Intel).

Solo procesador

Se puede, pero lo sensato es quedarse en los modelos pequeños de la tabla (hasta unos 4.000 millones de parámetros), porque Ollama avisa de que los grandes van lentos sin una buena gráfica. LM Studio recomienda al menos 16 GB de RAM y, en Windows, 4 GB de VRAM dedicada, y funciona también en portátiles Windows con Snapdragon X Elite.

Qué programa usar

Casi todos estos programas levantan un servidor compatible con la API de OpenAI, así que tu editor o tus scripts pueden usar el modelo local cambiando solo la dirección. Los datos de cada uno son oficiales, a 8 de octubre de 2026.

Una nota sobre GPT4All, que sigue en muchas listas: su última versión publicada es la 3.10.0, de febrero de 2025, y su repositorio no recibe cambios desde mayo de 2025.

Ollama, si quieres lo más sencillo y conectar otras aplicaciones

Ollama es un motor para macOS, Windows y Linux que se maneja desde la terminal y, desde julio de 2025, también con una app de escritorio para macOS y Windows. Tiene licencia MIT, es gratis en local y su nube es opcional y de pago. Descargas un modelo con un comando y queda disponible para tu editor, tus scripts o una interfaz como Open WebUI, con API compatible con OpenAI en el puerto 11434. Lo explicamos paso a paso en el tutorial de Ollama. Para empezar basta una línea, que descarga el modelo la primera vez y abre un chat:

ollama run qwen3.5:9b

LM Studio, si no quieres tocar la terminal

LM Studio es una app de escritorio con buscador de modelos para macOS (con chip Apple), Windows y Linux. Busca y descarga modelos de Hugging Face desde la propia app y permite chatear con documentos adjuntos sin conexión. Es gratis también para empresas desde julio de 2025; se paga solo por funciones de equipo como el inicio de sesión único. Su API compatible con OpenAI escucha en el puerto 1234.

Jan, si prefieres software libre de principio a fin

Jan es una app de chat de código abierto para macOS, Windows y Linux, gratuita, con licencia Apache 2.0 y llama.cpp debajo. Su API compatible con OpenAI usa el puerto 1337.

llama.cpp, si quieres el máximo control

llama.cpp es el motor que usan muchos de los anteriores. Funciona en macOS, Windows y Linux, tiene licencia MIT e incluye llama-server, con API compatible con OpenAI en el puerto 8080. Usado directamente, tú eliges cuantización, contexto y cuántas capas van a la gráfica.

Open WebUI y vLLM, si vas a dar servicio a varias personas

Open WebUI es una interfaz web tipo ChatGPT que se instala con Docker o con pip y se conecta a Ollama y a cualquier API compatible. Delante de Ollama, sirve para una casa u oficina pequeña. Ojo con su licencia propia, que lleva una cláusula de marca: si pasas de 50 usuarios en 30 días, no puedes quitar su marca sin permiso (licencia).

Para servir a muchos usuarios con gráficas potentes está vLLM, un servidor de alto rendimiento para Linux (en Windows, con WSL), con licencia Apache 2.0 y API compatible con OpenAI.

LocalAI, si necesitas algo más que texto

LocalAI es un servidor para texto, voz, imagen y vídeo que funciona con Docker, en macOS y en Linux. Tiene licencia MIT y es compatible con la API de OpenAI y también con la de Anthropic.

Qué modelo usar según tu equipo

Qué modelo abierto es mejor para cada tarea lo analizamos en la guía de modelos de IA de código abierto. Como punto de partida, por memoria disponible, con modelos que están en la biblioteca de Ollama a octubre de 2026:

• 8 GB: Qwen 3.5 en sus tamaños de 0,8B a 4B, o Gemma 4 E2B (4,6 GB).
• 16 GB: Llama 3.1 8B, Qwen 3.5 9B o Gemma 4 12B. gpt-oss 20B entra, pero justo.
• 24 a 32 GB: Qwen 3.6 27B, Gemma 4 26B o 31B, o Muse Glimmer 30B, el modelo abierto de Meta pensado para agentes que se ejecutan en local (anuncio en Ollama).
• 64 GB o más: Llama 3.1 70B (43 GB) y, a partir de unos 80 GB, gpt-oss 120B (65 GB).

Prueba con tus tareas reales antes de subir de tamaño: un modelo que cabe entero en la gráfica responde mucho más rápido que uno más grande repartido entre gráfica y procesador.

Por dónde seguir

• Ollama paso a paso: instalación en Windows, macOS y Linux, comandos, Modelfile y API local.
• Los mejores modelos de IA de código abierto, para elegir qué descargar.
• Las mejores herramientas de IA para cada tarea, si buscas también opciones en la nube.