Requisitos de hardware para usar Ollama con modelos locales

Guía Hardware » Guías de compra » Requisitos de hardware para usar Ollama con modelos locales

Si estás pensando en montar Ollama en tu PC o servidor para dejar de depender de la nube, una de las primeras dudas que vas a tener es qué hardware necesitas de verdad para que los modelos se muevan con cierta soltura y no vayan a tirones. Los requisitos varían muchísimo según el tamaño del modelo, la cuantización y si aprovechas o no la GPU, así que conviene tenerlo claro antes de ponerte a descargar gigas y gigas.

A lo largo de esta guía vamos a ver de forma detallada los requisitos de CPU, RAM, GPU, VRAM y almacenamiento para ejecutar Ollama con distintos tipos de modelos (desde los 1B hasta los 70B y más), qué puedes esperar en cada caso y cómo sacarle partido tanto en equipos de escritorio como en servidores VPS o entornos con Docker. También veremos instalación, configuración, API, personalización de modelos y algunos problemas típicos de rendimiento que te puedes encontrar.

Qué es Ollama y por qué importa tanto el hardware

Ollama es un cliente y servidor para LLM locales que simplifica muchísimo todo el lío de descargar, gestionar y ejecutar grandes modelos de lenguaje (Llama, Mistral, Gemma, Qwen, Deepseek, Phi, etc.) directamente en tu máquina, sin depender de servicios externos ni de APIs de pago.

La gran ventaja es que todo el procesamiento ocurre en tu propio hardware, de modo que los prompts, documentos y resultados no salen de tu equipo ni pasan por servidores de terceros. Eso lo hace especialmente interesante para entornos donde la privacidad es crítica: sanidad, finanzas, despachos de abogados, empresas sujetas a GDPR, administración pública, etc.

Además de la parte de privacidad, Ollama permite reducir costes de uso continuado frente a modelos en la nube: la inversión está en el hardware (que puede que ya tengas) y a partir de ahí las consultas al modelo no tienen coste por token. Ideal si vas a usar IA de forma intensiva en tu trabajo o en aplicaciones de clientes.

A cambio, el precio a pagar es que los modelos tienen que caber en la memoria (RAM/VRAM) y tu CPU/GPU debe ser capaz de procesarlos a una velocidad razonable. Un 7B mal configurado puede ir fluido en un portátil decente, mientras que un 70B en un equipo modesto puede ser prácticamente inutilizable, como le ocurre a muchos usuarios con CPUs potentes pero GPUs limitadas.

Requisitos de hardware mínimos y recomendados para Ollama

Aunque Ollama en sí es bastante ligero, los requisitos reales los marca el modelo que quieras ejecutar y cómo esté cuantizado. Aun así, se pueden dar unos mínimos razonables para no frustrarse desde el primer día.

CPU: qué procesador necesita Ollama

Ollama puede funcionar únicamente con CPU, pero para que no sea un suplicio es importante que el procesador tenga un buen conjunto de instrucciones vectoriales y un ancho de banda de memoria decente. Aquí el número de núcleos importa menos que la calidad de las instrucciones soportadas.

Lo ideal hoy en día es irse a una CPU Intel de 11ª generación o superior o a una AMD basada en Zen 4, porque aportan un mejor soporte de instrucciones AVX/AVX2/AVX512 y buena memoria DDR4/DDR5. Estas extensiones aceleran justo las operaciones de multiplicación de matrices que usan los LLM.

Con procesadores más antiguos (por ejemplo, un Intel i7 de 4ª generación con 12 GB de RAM) puedes arrancar modelos pequeños y cuantizados, pero notarás lag considerable en generación de texto, sobre todo si intentas modelos por encima de 7B o con cuantizaciones más “pesadas” (q5, q6, f16).

En VPS, para un uso serio de Ollama se recomienda contar al menos con 4 a 8 núcleos de CPU, especialmente si piensas servir peticiones a múltiples usuarios o ejecutar varios modelos en paralelo.

Memoria RAM: cuánta necesitas según el tamaño del modelo

La RAM es probablemente el factor que más va a limitar qué puedes cargar. Para un uso básico, Ollama puede arrancar con 8 GB de RAM, pero irás muy justo y limitado a modelos pequeños (1B-3B) o a 7B muy agresivamente cuantizados.

Para una experiencia razonable, la recomendación práctica es disponer de 16 GB de RAM, que permiten mover con soltura modelos de unos 7B parámetros y algunos 13B bien cuantizados, sobre todo si apoyas parte de la carga en la GPU.

Si quieres jugar en serio con modelos medianos o grandes, a partir de 32 GB de RAM la cosa cambia: puedes trabajar con 13B cómodamente, empezar a trastear con 30B e incluso con 70B muy cuantizados, siempre que la GPU acompañe. Además, más RAM ayuda a usar ventanas de contexto más grandes (num_ctx altos) sin que el sistema se ahogue.

Almacenamiento: espacio en disco para Ollama y los modelos

La propia aplicación Ollama ocupa poco, pero los modelos no son precisamente ligeros. De forma orientativa, un modelo de 1,5B parámetros ya puede rondar el gigabyte en disco, y un 70B cuantizado en q4 puede llegar fácilmente a los 40 GB de tamaño o más.

Para un entorno mínimo de pruebas, un VPS o servidor con más de 12 GB de espacio puede servir si solo vas a descargar uno o dos modelos pequeños, pero es fácil quedarte corto en cuanto te dé por probar varias variantes. En equipos de usuario, lo sensato es reservar al menos 50 GB para contenedores, modelos y herramientas auxiliares (Open WebUI, logs, etc.).

Si planeas trabajar con varios modelos grandes o combinar diferentes cuantizaciones, valora directamente dedicar un SSD secundario exclusivo para Ollama y configurarlo con la variable de entorno OLLAMA_MODELS para que toda la biblioteca de modelos se guarde ahí.

GPU y VRAM: el verdadero acelerador de Ollama

La GPU no es obligatoria, pero en la práctica marca la diferencia entre un sistema usable y uno desesperante cuando subes de 7B. Ollama puede funcionar solo con CPU, pero la aceleración por GPU (NVIDIA, AMD o Apple Silicon) reduce muchísimo los tiempos de generación.

La clave es la VRAM. Para modelos no cuantizados (FP16), las cifras se disparan: un modelo de 7B en FP16 puede requerir en torno a 26 GB de VRAM, lo que deja fuera a muchas tarjetas de consumo. Por suerte, Ollama y llama.cpp trabajan muy bien con modelos cuantizados (4 bits, 5 bits, etc.), que rebajan bastante la exigencia.

Como referencia, en modelos cuantizados 4-bit puedes orientarte con estas cifras aproximadas de VRAM necesaria:

• 7B parámetros: ~4 GB de VRAM
• 13B parámetros: ~8 GB de VRAM
• 30B parámetros: ~16 GB de VRAM
• 65B parámetros: ~32 GB de VRAM

Esto significa que con una GPU de 20-24 GB de VRAM puedes mover de forma relativamente cómoda modelos tipo 30B cuantizados y, con ajustes finos, atreverte con algunos 70B en cuantizaciones algo más agresivas. La CPU sigue importando, pero la GPU se lleva la mayor parte del trabajo.

En hardware estándar de escritorio, intentar usar modelos por encima de 13B sin una GPU decente se vuelve bastante poco práctico: la generación se hace lenta, la latencia aumenta y la experiencia recuerda a la de aquel i7 de 4ª generación con 12 GB de RAM intentando mover un modelo grande “a pelo”.

Requisitos concretos por tipo de modelo y tamaño

Además del hardware, cada modelo viene con variantes y etiquetas que influyen en el consumo de recursos: tamaño (1B, 3B, 7B, 13B, 70B, 405B…), tipo (chat, instruct, code, vision, thinking, embedding…) y cuantización (q2_K, q3_K_S, q4_0, q4_K_M, q5_K_M, q6_K, q8_0, f16, etc.).

Cuantos más parámetros tenga el modelo y menos comprimido esté (q6, q8, f16), más RAM y VRAM vas a necesitar, aunque en general también obtendrás mejor calidad y mejores capacidades de razonamiento, sobre todo en los modelos “thinking” o de gran tamaño.

A nivel práctico se suelen distinguir cuatro grandes rangos de tamaño:

• Modelos mini (270M-4B): válidos para móviles, mini-PCs o equipos con muy poca memoria. Ideales para tareas sencillas o como asistentes rápidos donde la calidad absoluta no es crítica.
• Modelos pequeños (4B-14B): el rango más equilibrado para uso doméstico y profesional ligero. Aquí entran muchos Llama 3, Gemma, Phi y Mistral que corren bien en PCs “normales”.
• Modelos medianos (14B-70B): ya piden un hardware serio, especialmente si quieres respuestas ágiles. A cambio ofrecen un salto notable en calidad, contexto y razonamiento.
• Modelos grandes (>70B): terreno de estaciones de trabajo, servidores con varias GPUs o Macs de gama muy alta. El rendimiento en un equipo estándar suele ser testimonial.

Dentro de cada rango, Ollama te permite elegir cuantizaciones más agresivas (q3, q4) para rebajar consumo de memoria a costa de algo de calidad, o cuantizaciones más suaves (q5, q6, q8, f16) para rascar precisión y coherencia si tu hardware lo soporta.

En la práctica, los perfiles más habituales que funcionan bien en PCs de gama media son cosas como llama3.2:8b-instruct-q5_K_M o mistral:7b-instruct-v0.2-q5_K_M, que logran un buen equilibrio entre velocidad y nivel de respuesta.

Ollama en escritorio, servidores VPS y Docker

Ollama se puede instalar tanto en equipos personales (Windows, macOS, Linux) como en VPS o servidores dedicados. La lógica de recursos es la misma, pero hay matices según el entorno.

En un VPS Linux típico, para algo más que pruebas es aconsejable partir de al menos 16 GB de RAM, más de 12 GB de disco y 4-8 vCPU. Con eso puedes servir modelos de 7B a usuarios web mediante una interfaz tipo Open WebUI u otra integración personalizada.

Si usas Docker, Ollama ofrece imágenes oficiales tanto para CPU pura como para GPU NVIDIA y para AMD con ROCm. Lo importante es mapear bien el directorio de modelos con un volumen (-v ollama_data:/root/.ollama) y, en el caso de las GPUs, añadir –gpus=all o los dispositivos ROCm adecuados (/dev/kfd, /dev/dri).

En macOS con chips M1/M2/M3/M4, Ollama aprovecha de forma automática la GPU integrada vía Metal, sin que tengas que tocar nada especial. En Windows y Linux, el rendimiento dependerá mucho de tener drivers actualizados de NVIDIA o AMD y, en contenedores, del toolkit de contenedores correspondiente.

Instalación básica de Ollama en cada sistema operativo

Uno de los puntos fuertes de Ollama es que la instalación es bastante directa en las tres grandes plataformas, sin necesidad de pelearte con compilaciones manuales de llama.cpp, conversión de modelos, etc.

Instalar Ollama en Linux

En distribuciones modernas (Ubuntu, Debian, Fedora…) lo más cómodo es usar el script oficial de instalación. Desde la terminal basta con ejecutar:

Comando de instalación: curl -fsSL https://ollama.com/install.sh | sh

Este script detecta la arquitectura, descarga el binario adecuado, lo instala en /usr/local/bin/ollama, configura un servicio systemd, crea el usuario/grupo de sistema si hace falta y activa el servicio para que se inicie al arrancar.

Verificar versión: ollama --version

En servidores con GPU NVIDIA o AMD, conviene instalar antes los drivers propietarios o ROCm, porque Ollama va a intentar utilizar la aceleración GPU automáticamente. Si algo falla, habilitar OLLAMA_DEBUG=1 y revisar los logs es la mejor forma de ver qué está pasando.

Instalar Ollama en Windows

En Windows solo tienes que descargar el instalador .exe desde la web oficial de Ollama, ejecutar el asistente y seguir los pasos. Es compatible con Windows 10 (22H2 o superior) y Windows 11, tanto Home como Pro.

El instalador configura el servicio en segundo plano y añade ollama.exe al PATH, así que desde PowerShell o el Símbolo del sistema podrás usar directamente comandos como ollama run o ollama pull.

Para la GPU, instala los últimos drivers de NVIDIA (Game Ready o Studio) o drivers de AMD Adrenalin. A partir de ahí, si todo está correcto, Ollama debería detectar y usar esa GPU para acelerar la inferencia.

Instalar Ollama en macOS

En macOS la instalación es la clásica de aplicaciones de escritorio: descargas el DMG de Ollama, lo abres, arrastras la app a la carpeta de Aplicaciones y la ejecutas.

Al iniciarla por primera vez, se levanta el servidor Ollama como proceso en segundo plano y se añade la CLI al PATH para que puedas usarla desde Terminal. En Macs con Apple Silicon, la GPU integrada se aprovecha vía Metal sin pasos adicionales.

Si quieres hacer instalaciones automáticas en servidores macOS o cambiar la ruta de los modelos, puedes tirar de variables de entorno y launchctl, pero para un usuario normal no hace falta meterse en ese jardín.

Primeros pasos: descargar y ejecutar modelos con Ollama

Una vez instalado, el flujo base con Ollama es muy sencillo: descargar un modelo y ejecutarlo. Todo se hace desde la terminal, aunque luego puedes enganchar interfaces gráficas u otros frontends.

Ejemplo de pull: ollama pull llama3.2

Ejecutar: ollama run llama3.2

Prompt interactivo: >>> Envía un mensaje (/? para ayuda)

Desde ahí ya puedes empezar a escribir tus preguntas o instrucciones. La respuesta se irá generando token a token, por lo que incluso en equipos modestos vas viendo el texto aparecer poco a poco en lugar de esperar a que termine la generación completa.

Opciones de contexto, creatividad y rendimiento del modelo

Para ajustar el comportamiento del modelo a tu gusto, Ollama expone un buen número de parámetros de generación heredados de llama.cpp: temperatura, top_p, top_k, num_ctx, num_predict, stop, repeat_penalty, etc.

La temperatura controla el nivel de “creatividad” o aleatoriedad: valores cercanos a 0,2 producen respuestas mucho más previsibles y enfocadas (perfecto para programación o respuestas técnicas), mientras que subir a 1,0-1,2 da lugar a textos más imaginativos pero también más inestables.

top_p y top_k determinan cuántos tokens “probables” se consideran en cada paso de generación. Reducirlos filtra las opciones raras y aumenta la coherencia, a costa de variedad. En muchos casos basta con tocar top_p y dejar un top_k razonable por defecto.

Uno de los parámetros más delicados es num_ctx, que define el tamaño máximo de la ventana de contexto (cuántos tokens totales -sistema, historial de chat, prompt actual- puede “recordar” el modelo a la vez). Aumentarlo permite conversaciones largas y análisis de documentos extensos, pero dispara el consumo de RAM/VRAM y el tiempo de cálculo.

Cada modelo viene entrenado con una longitud de contexto máxima. Subir num_ctx muy por encima de ese valor puede dar lugar a comportamientos raros o a que el modelo “olvide” información pasada. En el Modelfile de cada modelo suele aparecer un num_ctx por defecto acorde a su capacidad.

Gestión de modelos, almacenamiento y API de Ollama

Cuando empieces a probar diferentes modelos, tamaños y cuantizaciones, enseguida tendrás la carpeta de modelos llena. Ollama facilita bastante la gestión rápida de la biblioteca local desde la línea de comandos.

Comandos útiles: Con ollama list puedes ver los modelos descargados, su tamaño y fecha de modificación, mientras que ollama rm <modelo> te permite borrar los que ya no quieras para liberar espacio en disco.

Inspectar modelo: Si quieres inspeccionar cómo está configurado un modelo (parámetros por defecto, plantilla de prompt, mensaje de sistema, etc.), ollama show <modelo> te mostrará el contenido relevante del Modelfile. Esto es muy útil para entender por qué un modelo se comporta de cierta forma o para clonarlo y modificarlo.

Para integrarlo en aplicaciones, Ollama expone una API HTTP en localhost:11434. Tienes endpoints para generación simple (/api/generate), chat con historial (/api/chat), embeddings (/api/embeddings), listado, creación, borrado de modelos, etc. También cuenta con una capa de compatibilidad con la API de OpenAI bajo /v1/, lo que te permite reutilizar muchas librerías cliente cambiando solo la URL base.

A nivel de red y almacenamiento, las variables de entorno más importantes son OLLAMA_HOST (interfaz y puerto de escucha), OLLAMA_MODELS (directorio donde se guardan los modelos) y OLLAMA_ORIGINS (origins permitidos para CORS, útil si usas interfaces web como Open WebUI sirviéndose desde otro puerto). Ajustarlas bien marca la diferencia en entornos multiusuario o servidores expuestos.

Interfaces gráficas y ejecución en web: Open WebUI y compañía

Si no te apetece vivir en la terminal, puedes enganchar Ollama a interfaces web como Open WebUI, que ofrecen una experiencia tipo ChatGPT pero tirando de tu instancia local.

Open WebUI se puede desplegar fácilmente con Docker, montando el volumen de Ollama para que comparta los modelos y exponiendo un puerto HTTP propio. Una vez levantado, solo hay que indicarle la URL de la API de Ollama (normalmente http://localhost:11434) y desde el panel web puedes elegir modelo, gestionar historiales, cargar documentos, etc.

También se puede correr en un entorno virtual de Python si prefieres evitar Docker. En ese caso es importante estar atento a la versión de Python (por ejemplo, algunas versiones recientes como la 3.12 pueden dar problemas con ciertas dependencias, obligando a usar 3.11 en entornos como Ubuntu).

En cualquier caso, la carga de trabajo pesada la sigue realizando Ollama, así que los requisitos de hardware no cambian: si tu GPU es modesta, un modelo de 70B seguirá yendo lento aunque lo lances desde una interfaz web preciosa.

Modelos open source, licencias y personalización con Modelfiles

Una de las grandes ventajas de Ollama es que trabaja muy bien con modelos de código abierto y libres, es decir, aquellos cuyos pesos se pueden descargar sin restricciones, cuyo código es accesible y que están licenciados bajo MIT, Apache 2.0, GPL u otras licencias compatibles con uso y modificación.

En este ecosistema destacan modelos como Deepseek-r1 (MIT, orientado a razonamiento y código), Phi-4 de Microsoft (14B parámetros, licencia MIT, rendimiento muy bueno para su tamaño), Mistral 7B (Apache) o Qwen2.5 en distintas escalas (con parte de la familia bajo Apache 2.0).

Para adaptar el comportamiento de un modelo a tu gusto, Ollama usa ficheros de definición llamados Modelfiles. En ellos indicas de qué modelo partes (FROM), qué parámetros por defecto quieres (PARAMETER), qué plantilla de prompt usas (TEMPLATE), qué mensaje de sistema aplicas (SYSTEM) e incluso qué adaptadores LoRA añades (ADAPTER).

Esto te permite, por ejemplo, construir un modelo derivado que se comporte como un asistente de programación, otro que esté optimizado para redacción creativa, o uno que responda como un personaje ficticio; todo ello sin necesidad de reentrenar los pesos base, ajustando únicamente prompts de sistema, plantillas y parámetros de muestreo.

Además, si tienes pesos externos en formato GGUF o Safetensors descargados de Hugging Face u otros repositorios, puedes importarlos fácilmente creando un Modelfile que apunte al archivo o directorio adecuado, definiendo la plantilla correcta y, si quieres, cuantizando en el propio proceso de creación con la opción -q de ollama create.

Con una combinación razonable de CPU moderna, suficiente RAM, una GPU con VRAM acorde al tamaño de los modelos que te interesan y algo de cuidado con la cuantización, ejecutar LLMs de forma local con Ollama resulta accesible y potente: permite trabajar de forma privada y sin costes recurrentes, tanto en ordenadores personales como en servidores o VPS, ya sea desde la línea de comandos, a través de la API o integrando interfaces gráficas como Open WebUI.