Requisitos de hardware para usar Ollama sin cuelgues

Informatec Digital » Recursos » Requisitos de hardware para usar Ollama sin cuelgues

Si te estás planteando ejecutar modelos de inteligencia artificial en tu propio ordenador, tarde o temprano te toparás con Ollama. Y justo ahí llega la gran duda: ¿qué requisitos de hardware necesito para que los modelos vayan realmente fluidos y no a tirones? No basta con que arranquen, la clave es que se puedan usar con comodidad en el día a día y conocer los tipos de hardware de una computadora.

A lo largo de este artículo vamos a ver al detalle qué hace Ollama, qué piden los distintos tipos de modelos (7B, 13B, 70B, etc.), cómo influyen CPU, GPU, RAM y disco, y qué configuraciones son razonables según tu caso, tanto si quieres un simple asistente de texto como si pretendes mover monstruos como Llama 3 de decenas de miles de millones de parámetros o modelos de visión y OCR.

Qué es Ollama y por qué el hardware marca tanta diferencia

Ollama es, en esencia, un cliente de modelos de lenguaje que permite ejecutar LLMs de forma local en tu máquina, sin depender de la nube. Se apoya en motores como llama.cpp para hacer la inferencia y te envuelve toda la complejidad en una herramienta sencilla, con CLI y API REST, ayudando a entender además conceptos de las redes neuronales artificiales que están detrás de los modelos.

Su papel es ser el “centro de mando” desde el que descargas, gestionas y ejecutas modelos como Llama 3, Mistral, Gemma, Phi, Qwen, DeepSeek o modelos multimodales como Llava. La gracia está en que puedes usarlos totalmente offline, manteniendo tus datos en casa y sin pagar cada token como ocurre con las APIs en la nube.

Ahora bien, aunque el propio Ollama pesa poco y no es exigente, los modelos que ejecuta sí son muy tragones. Cada LLM se compone de millones o miles de millones de parámetros, y eso se traduce en gigas de memoria y almacenamiento, además de una carga fuerte sobre CPU y, si tienes, GPU.

Por eso, cuando alguien intenta mover un modelo grande (por ejemplo, un Llama de 70B) en un equipo con CPU potente pero GPU discreta y RAM justa, el resultado suele ser que “funcionar, funciona”, pero va tan lento que es prácticamente inútil. La clave está en equilibrar bien CPU, GPU, RAM, disco y tipo de modelo.

Tipos de modelos en Ollama y cómo afectan a los requisitos

En la biblioteca de Ollama verás modelos organizados por familias y tamaños: 1B, 2B, 4B, 7B, 13B, 30B, 65B, 70B, 405B…. Ese número (B de billions) indica la cantidad aproximada de parámetros, y es uno de los factores que más determina el hardware necesario.

Podemos agruparlos de forma orientativa en cuatro categorías, que ayudan mucho a estimar qué máquina necesitas para ir cómodo con cada grupo de modelos y cuantizaciones:

• Modelos mini (270M – 4B): pensados para dispositivos modestos (portátiles sencillos, incluso algunos móviles o miniPC). Rápidos, pero con menos capacidad de razonamiento.
• Modelos pequeños (4B – 14B): ideales como modelos “domésticos” equilibrados. Buenos para chat general, tareas de ofimática, asistencia ligera de código, etc.
• Modelos medianos (14B – 70B): ya juegan en otra liga; necesitan hardware potente, mucha RAM y, a ser posible, GPU con bastante VRAM.
• Modelos grandes (> 70B): son bestias pensadas para infraestructuras muy serias (GPUs de gama alta, varias tarjetas, servidores dedicados, Mac de gama alta bien aprovechados, etc.).

Además del tamaño, entra en juego la cuantización: en Ollama verás sufijos como q4_K_M, q5_1, q3_K_S, q8_0, f16, etc. Estos formatos indican cómo de comprimidos están los pesos del modelo:

• FP16 / FP32 (f16, f32): apenas comprimidos, máxima calidad pero consumo brutal de memoria. Un 7B en FP16 se puede ir a más de 20 GB de VRAM.
• Q4 (q4_0, q4_K_M…): cuantización de 4 bits, gran reducción de tamaño con impacto moderado en calidad. Suelen ser el “punto dulce”.
• Q3, Q2 (q3_K_S, q2_K…): cuantizaciones más agresivas, tamaño muy reducido a cambio de algo más de pérdida de precisión. Útiles en hardware muy limitado.
• Q5, Q6, Q8: escalones intermedios entre la compresión fuerte y FP16; más calidad, más consumo.

La consecuencia práctica es clara: un mismo modelo de 7B puede ocupar ~26 GB en FP16 o unos ~4 GB en Q4. Eso se traduce directamente en la VRAM de la GPU que necesitas y en la cantidad de RAM que debe apoyar la carga.

Requisitos de hardware mínimos y recomendados para Ollama en local

Si lo que te preocupa es si tu ordenador “aguanta” Ollama, la respuesta suele ser que sí; la cuestión es qué modelo podrás usar con soltura. Vamos a desglosar por componente: RAM, CPU, GPU y disco, con recomendaciones realistas basadas en la práctica y en la documentación de varias guías especializadas.

Memoria RAM: el recurso crítico por excelencia

La RAM es el primer cuello de botella cuando hablamos de LLMs locales. En términos generales, podemos pensar en estos rangos:

• 8 GB de RAM: el suelo práctico. Permite modelos pequeños (1B, 3B, alguna variante de 7B muy cuantizada), pero notarás limitaciones, sobre todo si el sistema y el navegador ya se comen parte de la memoria. Es fácil que todo vaya algo justo y con más lag.
• 16 GB de RAM: el estándar razonable hoy. Ideal para modelos de 7B e incluso 13B cuantizados en Q4, especialmente si ayudas con GPU. Puedes trabajar con chats complejos sin que el sistema se arrastre.
• 32 GB de RAM o más: recomendado si quieres modelos medianos (30B, 40B, 70B) o hacer cosas más pesadas como contextos muy largos, varios modelos en paralelo, servidores multiusuario o herramientas gráficas tipo Open WebUI sobre Ollama.

Ten en cuenta que la RAM no solo se la lleva el modelo: sistema operativo, navegador, IDE, Docker, Open WebUI, etc., también tiran de ella. Si quieres liberar memoria en escenarios concretos puedes aprender a reducir el consumo de memoria RAM en aplicaciones como el navegador. Si piensas en un uso intensivo, 16 GB es hoy el “mínimo cómodo” y 32 GB empieza a ser un escenario realmente holgado.

CPU: instrucciones modernas y número de núcleos

Ollama puede funcionar solo con CPU, pero la experiencia cambia mucho según el procesador. Más que la cantidad de núcleos, importa el soporte de instrucciones avanzadas como AVX2 y, mejor aún, AVX-512, que aceleran operaciones de matrices y vectores usadas masivamente en los LLMs.

Una orientación razonable sería:

• Mínimo aceptable: CPU moderna de 4 núcleos físicos (por ejemplo, un Intel i5 de últimas generaciones o un Ryzen equivalente), con soporte AVX2. Podrás ejecutar modelos 7B con paciencia, sobre todo si están bien cuantizados.
• Recomendado: procesadores más recientes tipo Intel de 11ª generación en adelante o AMD Zen4, con 8 núcleos o más y soporte AVX-512 donde sea posible. Así consigues mejores tiempos de respuesta y menos cuello de botella incluso con GPU.

Si tu idea es usar modelos muy grandes (por ejemplo, intentar un Llama 3 de 70B con CPU + GPU modesta), la CPU va a sufrir y notarás tiempos de generación por token muy altos. En estos escenarios lo más sensato es optar por modelos más pequeños o invertir en GPU adecuada.

GPU y VRAM: cuándo es imprescindible y cuánto hace falta

La GPU no es obligatoria, pero marca un antes y un después. Una GPU decente con suficiente VRAM puede convertir una experiencia lenta en algo perfectamente usable, sobre todo con modelos de 7B a 13B y cuantizados.

Como referencia muy útil, para modelos cuantizados (aproximadamente Q4) se puede estimar algo así:

• 7B → ~4 GB de VRAM
• 13B → ~8 GB de VRAM
• 30B → ~16 GB de VRAM
• 65-70B → ~32 GB de VRAM

Esto son valores aproximados, pero dejan claro que una GPU tipo RTX 2060 SUPER con 8 GB de VRAM va sobrada para 7B y puede pelear 13B, pero se queda corta para 70B aunque tengas un i9 con 64 GB de RAM. En ese caso el modelo se verá obligado a repartir mucha carga en la RAM y CPU, y la latencia se disparará.

En términos prácticos:

• Con 4-6 GB de VRAM: céntrate en modelos de 7B bien cuantizados. Funcionan muy bien para chat, redacción y tareas generales.
• Con 8-12 GB de VRAM: puedes trabajar cómodamente con 7B y 13B e incluso algunos 30B si aceptas ir algo más lento.
• Con 20-24 GB de VRAM: ya entras en terreno de modelos de 30B-40B con bastante dignidad, y algunos 70B muy cuantizados, sobre todo si apoyas con buena RAM.
• Con 32 GB de VRAM o más: es cuando los 70B realmente empiezan a ser razonables para uso interactivo, siempre que el resto del equipo acompañe.

Para un modelo OCR u otros modelos especiales (por ejemplo, visión), una GPU de 20-24 GB de VRAM es una base muy sólida para que vaya fluido, especialmente si el modelo ronda las decenas de miles de millones de parámetros. Para variantes más ligeras (2B-7B) de OCR o visión, con 8-12 GB podrías estar perfectamente servido.

Almacenamiento en disco: cuánto ocupan los modelos

En cuanto al disco, la aplicación de Ollama ocupa muy poco; lo que de verdad pesa son los modelos. En un entorno básico o de pruebas te sirven unos 50 GB, pero si empiezas a coleccionar modelos la cosa escala rápido.

Como guía aproximada para modelos cuantizados:

• Modelos pequeños (1B-4B) → alrededor de 2 GB por modelo.
• Modelos medianos (7B-13B) → normalmente 4-8 GB por modelo según la cuantización.
• Modelos grandes (30B-70B) → fácilmente 16-40 GB cada uno.
• Modelos muy grandes (> 100B) → pueden superar los 200 GB por modelo e incluso pasar el terabyte en algunos casos extremos.

Lo ideal es utilizar SSD rápido (NVMe si es posible) para que la carga inicial de los modelos sea más ágil. Además, Ollama permite cambiar la ruta donde almacena los modelos mediante la variable de entorno OLLAMA_MODELS, de forma que puedas usar un disco secundario grande y dejar el principal más despejado; para profundizar en espacio y tipos de unidades consulta la guía de hardware de almacenamiento.

Requisitos específicos para ejecutar modelos concretos con Ollama

Aunque cada modelo tiene sus matices, con el ecosistema actual de Ollama se pueden dar algunas pautas claras para categorías típicas de uso: chat general, codificación, modelos de visión/OCR y modelos gigantes tipo 70B.

Modelos de chat general (Llama, Mistral, Gemma, Qwen…)

Para un uso típico tipo “ChatGPT local” con modelos como Llama 3.x 7B/8B, Mistral 7B, Gemma 2B/7B o Qwen de tamaño medio, lo razonable hoy sería algo así:

• Mínimo recomendable:
  • CPU moderna de 4 núcleos con AVX2.
  • 16 GB de RAM.
  • Sin GPU o GPU básica con 4-6 GB de VRAM.
  • Al menos 50 GB de SSD para sistema + uno o dos modelos.
• Configuración óptima para ir sobrado con 7B-13B:
  • CPU de 8 núcleos o más (i7/i9 modernos o Ryzen 7/9).
  • 32 GB de RAM si quieres mantener muchas cosas abiertas.
  • GPU con 8-12 GB de VRAM (RTX 3060/3070 o equivalentes, AMD RX 6700 en adelante, o un Mac con M1/M2/M3 bien aprovechado).
  • SSD de 1 TB si vas a coleccionar modelos.

En estos escenarios, los modelos de 7B con cuantización Q4_K_M o Q5_K_M van muy finos y ofrecen una calidad más que suficiente para uso personal, documentación técnica, tareas de estudio o soporte de redacción.

Modelos de codificación (DeepSeek, CodeLlama, Phi orientado a código)

Los modelos especializados en programación suelen tener necesidades similares a los de chat general de su mismo tamaño, pero conviene reservar un poco más de margen en RAM y VRAM si los vas a usar junto con un IDE pesado y muchos proyectos abiertos.

Por ejemplo, para usar algo tipo DeepSeek-Coder de 7B-8B o CodeLlama de tamaño parecido en condiciones, una combinación muy razonable sería:

• CPU de 6-8 núcleos modernos.
• 32 GB de RAM si trabajas con múltiples herramientas a la vez (IDE, navegador con pestañas, Docker, etc.).
• GPU con al menos 8 GB de VRAM para mover el modelo con soltura.

En hardware más modesto también funciona, pero notarás tiempos de respuesta más lentos al generar bloques de código largos o análisis complejos. Para modelos compactos tipo Phi-4 Mini la exigencia es mucho menor y se defienden bien incluso en equipos de 16 GB con GPU ligera.

Modelos de visión y OCR (Llava, modelos OCR, multimodales)

Los modelos con capacidad de procesar imágenes (visión/ocr) como Llava o las variantes multimodales de Llama 3.x, así como modelos OCR específicos, añaden un plus de complejidad. A nivel de hardware, se acercan a los requisitos de un modelo de texto del mismo tamaño, pero con mayor beneficio de usar GPU.

Si hablamos de un modelo OCR mediano (pongamos del orden de 7B-13B) y quieres usarlo a gusto en local, para reconocimiento de documentos, imágenes escaneadas, etc., es sensato plantear algo como:

• GPU con 20-24 GB de VRAM si el modelo es realmente grande o si quieres dejar casi todo el procesamiento en la tarjeta.
• GPU con 8-12 GB de VRAM si eliges variantes más ligeras y bien cuantizadas; seguirá yendo bien siempre que no abuses del tamaño de imagen ni de contextos gigantescos.
• Mínimo 16 GB de RAM, aunque 32 GB ofrecen un margen muy cómodo para uso intensivo.
• CPU moderna para que no haga cuello de botella cuando la GPU está cargada.

La respuesta directa a la pregunta típica de “¿puedo ejecutar un modelo OCR en una GPU con 20-24 GB de VRAM?” es que sí, es un rango excelente para modelos de visión/OCR medianos o grandes en Ollama, siempre que acompañes con suficiente RAM y CPU decente.

Modelos gigantes (Llama 3:70B y similares)

Intentar mover en Windows un Llama 3 de 70B con una CPU muy potente (por ejemplo, un i9 de 11ª generación) y 64 GB de RAM pero GPU como una RTX 2060 SUPER de 8 GB es un ejemplo perfecto de “sí, pero no”. El modelo puede llegar a cargar, pero:

• Parte del modelo no cabe en VRAM y se apoya masivamente en la RAM.
• La CPU tiene que asumir mucho peso de inferencia.
• El tiempo por token se dispara y la experiencia se vuelve prácticamente inutilizable.

Para que un 70B tenga sentido en entornos domésticos o semiprofesionales, necesitas, como mínimo, algo en esta línea:

• 32 GB de RAM como base, 64 GB si quieres ir con margen.
• GPU con al menos 24-32 GB de VRAM para cargar la mayor parte del modelo con una cuantización razonable (Q4_K_M o similar).
• CPU potente de gama alta con 8-16 núcleos.

Si no cumples estas cifras, es mucho más práctico usar modelos de 7B-13B bien cuantizados o, si realmente necesitas 70B por calidad, plantearte un servidor especializado (local o en la nube), un Mac muy potente o varias GPUs trabajando en paralelo.

Requisitos para instalar Ollama en un VPS o servidor

Otra opción muy habitual es montar Ollama en un VPS o servidor dedicado y consumirlo vía API o interfaz web (por ejemplo, con Open WebUI). Aquí entran en juego no solo los recursos, sino también el sistema operativo y permisos.

En guías de proveedores como Hostinger se recomiendan los siguientes mínimos para un VPS orientado a Ollama:

• RAM: mínimo 16 GB para que los modelos pequeños/medios no ahoguen al sistema.
• CPU: 4-8 vCores, dependiendo del tamaño de los modelos y del número de usuarios concurrentes.
• Almacenamiento: más de 12 GB mínimos, aunque en la práctica conviene apuntar más alto (50-100 GB) si vas a probar varios modelos.
• Sistema operativo: sobre todo Linux, con preferencia por Ubuntu 22.04 o superior, o Debian estable reciente.
• Acceso root o permisos sudo para poder instalar dependencias, configurar systemd, etc.

Si tu VPS incluye GPU NVIDIA, tendrás que instalar y configurar CUDA o el toolkit de contenedores de NVIDIA si vas por Docker. Con AMD, en Linux se suele usar ROCm y, en Windows, los controladores Adrenalin adecuados. En entornos sin GPU, el servidor tirará de CPU y RAM, así que no conviene racanear ahí; además puedes gestionarlo remotamente mediante conexión de escritorio remoto si necesitas una interfaz gráfica.

Escenarios concretos de hardware y qué modelos usar

Para que todo lo anterior no se quede en teoría, puede ser útil ver algunas combinaciones típicas de hardware y qué tipo de modelos se ajustan bien a cada caso usando Ollama.

Equipo modesto de escritorio o portátil medio

Imaginemos un equipo tipo:

• CPU i5 o Ryzen 5 de hace unos años (4-6 núcleos).
• 16 GB de RAM.
• GPU integrada o dedicada de 4 GB.
• SSD de 512 GB.

En este escenario, lo sensato es apuntar a:

• Modelos 1B-3B cuantizados (Gemma 2B, Phi-4 Mini, Llama 3.x 1B) para máxima fluidez.
• Modelos 7B en Q4 si aceptas algo más de tiempo de respuesta.
• Uso de Ollama con terminal y, si quieres interfaz web, Open WebUI con cuidado para no saturar la RAM.

Podrás tener tu asistente local de texto, hacer resúmenes, algo de análisis y tareas ligeras de programación, pero no es el entorno ideal para modelos de 13B en adelante.

Equipo de gama media-alta orientado a IA local

Aquí hablamos de un PC tipo:

• CPU i7/i9 moderno o Ryzen 7/9, 8-16 núcleos.
• 32 GB de RAM.
• GPU con 12-24 GB de VRAM (RTX 4070/4080, 3090, 4090, equivalentes AMD o similar).
• SSD de 1-2 TB.

Con esta configuración se abre mucho el abanico:

• Modelos 7B-13B en Q4/Q5 para chat, código, análisis de datos… con tiempos de respuesta muy buenos.
• Modelos de 30B y algunos 70B cuantizados si aceptas algo más de latencia.
• Modelos de visión/OCR medianos usando ampliamente la GPU.

Es el tipo de máquina con el que puedes montar un entorno serio de IA local, con varios modelos, interfaz web, integración vía API REST y flujo de trabajo profesional sin depender de servicios externos.

Servidor o estación de trabajo “bestia”

En el extremo superior están los entornos con:

• Varias GPUs de 24-48 GB de VRAM cada una, o una sola de gama altísima.
• 64-128 GB de RAM.
• CPU con muchos núcleos, tipo Threadripper o Xeon recientes.

Aquí es donde los modelos gigantes (> 70B, MoE, vision heavy, etc.) empiezan a ser realistas incluso con varios usuarios concurrentes o integraciones complejas. Es, obviamente, un escenario de coste elevado, pero también el que te permite tener capacidades similares a algunas APIs comerciales, con todo el control de datos en tu propia infraestructura.

Consejos prácticos para sacar más partido al hardware con Ollama

Más allá de comprar o no más RAM o una GPU mejor, hay varias prácticas que ayudan a exprimir lo que ya tienes y evitar sustos al ejecutar modelos grandes con Ollama.

Para empezar, conviene escoger bien el modelo según el uso: no tiene sentido tirar de un 70B para redactar correos sencillos cuando un 7B bien afinado hace el papel de sobra. Tampoco tiene sentido un 30B si tu GPU solo tiene 6 GB de VRAM; saldrá más rentable un 7B en Q4.

Otra medida clave es jugar con los parámetros de ejecución (temperature, num_ctx, num_predict, etc.), ya sea en el Modelfile o vía CLI/API. Usar contextos ridículamente grandes (num_ctx de 32k o más) con poca RAM o VRAM va a lastrar todo el sistema sin aportar tanto en muchos casos.

También es recomendable monitorizar qué modelos están cargados y en qué procesador usando ollama ps: ahí verás si el modelo se está ejecutando realmente en GPU, en CPU, y qué tamaño tiene cargado. Ajustar la variable OLLAMA_KEEP_ALIVE ayuda a que los modelos se descarguen de memoria cuando no se usan y así liberar recursos.

Por último, recuerda que la cuantización es tu aliada: crear variantes Q4_K_M o Q5_K_M de un modelo original en FP16 permite aprovechar hardware mucho más modesto con una pérdida de calidad a menudo casi imperceptible para uso real.

Después de ver todo este panorama, la idea que se queda clara es que Ollama no es la parte exigente, lo son los modelos. Entender cómo se relacionan tamaño, cuantización, RAM y VRAM te permite elegir la combinación adecuada de hardware y LLM para tu caso: desde un portátil con 16 GB moviendo un 7B ligero hasta una estación con GPU de 24 GB levantando modelos de visión y OCR robustos. Ajustando bien expectativas y parámetros, es perfectamente viable tener una IA potente, privada y sin cuotas mensuales corriendo en tu propia máquina.