# Cómo instalar una IA en local: qué ordenador necesitas y qué modelo

> Guía para instalar una IA en local con Ollama en Windows, macOS o Linux: cuánta memoria pide cada modelo con sus tamaños reales, cómo comprobar que usa la GPU, el ajuste de contexto que casi todos se saltan y cómo verificar que nada sale de tu equipo.

- Fuente canónica: https://www.ricardovelit.com/blog/p/instalar-ia-en-local
- Nivel: principiante · Lectura: 8 min · Publicado: 2026-10-06
- Etiquetas: ia-local, ollama, hardware, privacidad, modelos-abiertos
- Relacionados: [ia-local-en-colombia](https://www.ricardovelit.com/blog/p/ia-local-en-colombia.md), [tokens-y-tokenizacion](https://www.ricardovelit.com/blog/p/tokens-y-tokenizacion.md), [rag-recuperacion-aumentada](https://www.ricardovelit.com/blog/p/rag-recuperacion-aumentada.md)
- Contiene componentes interactivos que solo funcionan en la versión web.

---
## Qué significa instalar una IA en local

Una **IA local** es un modelo de lenguaje que se ejecuta en tu propio ordenador. Descargas
un archivo de varios gigas, lo carga un programa, y a partir de ahí escribes y te contesta
sin que tu texto pase por el servidor de nadie. Funciona sin internet.

No es una versión recortada de ChatGPT ni un acceso distinto a él. Es otro modelo, más
pequeño, de los que las empresas publican con sus pesos abiertos: Gemma de Google, Qwen de
Alibaba, Llama de Meta, Phi de Microsoft, Mistral.

Esta guía cubre lo que necesitas para hacerlo hoy: qué ordenador hace falta, qué modelo
elegir, cómo instalarlo y cómo comprobar que funciona como esperas. Si lo que buscas es
decidir si le conviene a tu empresa, eso está en
[IA local en Colombia](/p/ia-local-en-colombia).

## Qué ordenador necesitas

La pregunta se contesta con un solo dato: **cuánta memoria tienes**. La velocidad del
procesador importa poco al lado de eso.

Un modelo es una lista enorme de números, sus parámetros. Para usarlo hay que cargarlos
todos en memoria a la vez. En local se usan versiones cuantizadas a 4 bits, donde cada
parámetro ocupa más o menos medio byte, así que un modelo de 8.000 millones de parámetros
ocupa unos 5 GB. Si ese archivo no cabe en la memoria de tu tarjeta gráfica, se reparte
con la memoria normal del equipo y todo va mucho más lento. Si tampoco cabe ahí, no
arranca.

Qué memoria cuenta depende del equipo:

- **PC con tarjeta gráfica dedicada:** cuenta la memoria de la tarjeta, la VRAM. Una
  tarjeta de 8 GB mueve con soltura modelos de hasta unos 5 GB.
- **Mac con chip de Apple:** la memoria es unificada, la comparten el procesador y la
  gráfica. Un Mac de 16 GB puede dedicar buena parte de ellos al modelo.
- **Portátil sin gráfica dedicada:** el modelo corre en el procesador con la RAM normal.
  Funciona, pero despacio. Quédate en modelos pequeños.

### Cuánto ocupa cada modelo

Estos son los tamaños de descarga que publica la biblioteca de Ollama para dos familias
actuales, en su cuantización por defecto:

| Modelo | Descarga | Dónde cabe con holgura |
| --- | --- | --- |
| `gemma3:1b` | 815 MB | Cualquier equipo con 8 GB de RAM |
| `qwen3:4b` | 2,5 GB | Portátil de 8 GB, sin gráfica dedicada |
| `gemma3:4b` | 3,3 GB | Portátil de 8 a 16 GB |
| `qwen3:8b` | 5,2 GB | Gráfica de 8 GB o Mac de 16 GB |
| `gemma3:12b` | 8,1 GB | Gráfica de 12 GB o Mac de 16 GB |
| `qwen3:14b` | 9,3 GB | Gráfica de 12 a 16 GB o Mac de 24 GB |
| `gemma3:27b` | 17 GB | Gráfica de 24 GB o Mac de 32 GB |
| `qwen3:32b` | 20 GB | Gráfica de 24 GB o Mac de 32 GB o más |

La columna de la derecha deja margen a propósito: además del modelo hay que guardar en
memoria la conversación, y eso crece con cada mensaje. La regla práctica es que el archivo
no pase de dos tercios de la memoria disponible.

### Sobre los "PC con IA"

Muchos portátiles nuevos se venden como "PC con IA" porque llevan una NPU, un chip
pensado para cálculos de redes neuronales. Sirve para las funciones que el fabricante o el
sistema operativo han preparado para él, como desenfocar el fondo en una videollamada.

Para ejecutar los modelos de esta guía no es lo que cuenta. La documentación de Ollama
lista como aceleradores las gráficas de NVIDIA, las de AMD, el sistema Metal de Apple y,
en Windows y Linux, Vulkan. No menciona las NPU. Si vas a comprar un equipo para esto,
mira los gigas de memoria de la tarjeta gráfica, o los de memoria unificada si es un Mac,
antes que la pegatina.

En NVIDIA, Ollama pide una tarjeta con *compute capability* 5.0 o superior y controladores
en la versión 550 o posterior. Eso incluye tarjetas con muchos años.

## Instalar paso a paso con Ollama

[Ollama](https://ollama.com) es la vía más corta. Es gratuito, funciona en Windows, macOS
y Linux, y se maneja con cuatro órdenes.

### 1. Instala el programa

En **Windows** y **macOS**, descarga el instalador desde
[ollama.com/download](https://ollama.com/download) y ejecútalo.

En **Linux**, una línea:

```bash
curl -fsSL https://ollama.com/install.sh | sh
```

Como con cualquier script que se descarga y se ejecuta en un paso, conviene abrirlo antes
y leer qué hace.

### 2. Descarga un modelo y habla con él

Abre una terminal y escribe:

```bash
ollama run gemma3:4b
```

La primera vez descarga los 3,3 GB. Después abre un chat en la propia terminal. Para salir,
escribe `/bye`.

Si tu equipo es justo, empieza por `gemma3:1b`. Si tienes una gráfica de 12 GB o más,
prueba `gemma3:12b`. La diferencia de calidad entre tamaños se nota.

### 3. Comprueba que usa la gráfica

Con el modelo cargado, en otra terminal:

```bash
ollama ps
```

La columna `PROCESSOR` dice dónde está corriendo: `100% GPU` si cabe entero en la tarjeta,
`100% CPU` si va con la memoria normal, o un reparto entre las dos. Si esperabas GPU y ves
CPU, el modelo no cabe o faltan los controladores. Baja un tamaño y vuelve a mirar.

### 4. Gestiona lo descargado

```bash
ollama list          # qué modelos tienes y cuánto ocupan
ollama rm gemma3:4b  # borra uno
```

Los modelos se guardan en `~/.ollama/models` en macOS, en
`C:\Users\tu_usuario\.ollama\models` en Windows y en `/usr/share/ollama/.ollama/models` en
Linux. Si el disco principal va justo, la variable de entorno `OLLAMA_MODELS` cambia la
carpeta.

## El ajuste que casi todos se saltan: el contexto

Este es el motivo más común de que una IA local "se olvide" de lo que le pegaste.

El contexto es cuánto texto puede tener presente el modelo a la vez, medido en
[tokens](/p/tokens-y-tokenizacion). La ficha de `gemma3:4b` anuncia 128.000 tokens. Pero
Ollama, por defecto, carga los modelos con **4.096**, unas tres mil palabras. Si pegas un
documento más largo, el principio se descarta sin aviso y el modelo responde como si no lo
hubiera leído.

Se cambia de tres maneras:

```bash
# Para todo lo que sirva Ollama
OLLAMA_CONTEXT_LENGTH=8192 ollama serve

# Dentro de un chat ya abierto
/set parameter num_ctx 8192
```

La tercera es el parámetro `num_ctx` en cada petición a la API.

No lo subas al máximo por costumbre. El contexto ocupa memoria: un modelo que cabía en tu
gráfica con 4.096 tokens puede dejar de caber con 32.000 y pasar a ir por CPU. Súbelo
hasta lo que necesites y vuelve a mirar `ollama ps`.

## Usarlo desde otros programas

Ollama deja un servidor escuchando en tu equipo, en `127.0.0.1`, puerto `11434`. Cualquier
programa local puede enviarle peticiones:

```bash
curl http://localhost:11434/api/chat -d '{
  "model": "gemma3:4b",
  "messages": [{ "role": "user", "content": "Resume en una frase qué es un token." }],
  "stream": false
}'
```

Eso es lo que usan por debajo las aplicaciones que se conectan a Ollama para darte una
interfaz de chat o para preguntarle a tus documentos con
[RAG](/p/rag-recuperacion-aumentada).

Si prefieres no tocar la terminal, **LM Studio** y **Jan** hacen lo mismo con ventanas:
eliges el modelo en un buscador, lo descargas y chateas. Las reglas de memoria de más
arriba son las mismas, porque los modelos son los mismos.

## En el móvil

Se puede, con límites estrechos. Un teléfono tiene menos memoria que un portátil y la
comparte con todo lo demás, así que el terreno son los modelos de 1.000 a 4.000 millones
de parámetros. Valen para redactar, resumir un texto corto o traducir sin conexión. No
esperes de ellos lo que da un modelo de 12.000 millones en un ordenador.

## Comprueba que de verdad es local

"Local" es una afirmación que puedes verificar tú, sin fiarte de nadie.

1. **Desconecta la red y pregunta.** Apaga el wifi y haz una pregunta. Si responde, el
   modelo está en tu equipo.
2. **Mira qué modelo has elegido.** Ollama ofrece también modelos que se ejecutan en su
   nube. Su documentación dice que cuando corres en local no ve tus textos ni tus datos, y
   que los modelos en la nube sí procesan la petición en sus servidores. Si elegiste esto
   por privacidad, usa modelos descargados.
3. **No abras el puerto.** Ollama escucha solo en `127.0.0.1`, es decir, solo acepta
   conexiones de tu propio equipo. Hay tutoriales que recomiendan poner
   `OLLAMA_HOST=0.0.0.0` para usarlo desde otro dispositivo. Eso lo expone a toda tu red,
   y la API no pide contraseña. Si lo necesitas, pon delante algo que sí la pida.

## Lo que no vas a conseguir

- **La calidad de un modelo grande en la nube.** Un modelo de 4.000 millones de parámetros
  redacta y resume bien. Falla más en razonamientos largos, en cálculo y en temas poco
  comunes, y lo hace con la misma seguridad con la que acierta.
- **Información actual.** Sabe lo que sabía al entrenarse y no busca en internet salvo que
  le conectes una herramienta para hacerlo.
- **Velocidad sin gráfica.** En procesador, un modelo mediano escribe despacio. Para un uso
  ocasional sirve. Para trabajar todo el día con él, no.
- **Servicio para un equipo.** Ollama en tu portátil es para ti. Atender a veinte personas
  a la vez pide un servidor y otro tipo de software.

## Pruébalo

Antes de descargar nada, pide una recomendación para tu equipo. Cambia los datos por los
tuyos.

> **[Componente interactivo: PromptPlayground]** — playground de prompts: ejecuta un prompt contra un modelo real o simulado. Solo en la versión web: https://www.ricardovelit.com/blog/p/instalar-ia-en-local

## Para llevarte

- Lo que decide qué modelo puedes usar es la memoria: la de la tarjeta gráfica en un PC, la
  unificada en un Mac.
- Regla rápida: el archivo del modelo no debería pasar de dos tercios de esa memoria.
- Con Ollama son tres pasos: instalar, `ollama run gemma3:4b` y `ollama ps` para ver si usa
  la gráfica.
- El contexto por defecto es de 4.096 tokens aunque el modelo admita muchos más. Súbelo si
  trabajas con documentos, y vigila la memoria.
- Verifica que es local desconectando la red, usa modelos descargados y no abras el puerto
  11434.

## Fuentes

- Ollama, [preguntas frecuentes](https://docs.ollama.com/faq): contexto por defecto, dirección y puerto, carpeta de modelos, privacidad y `ollama ps`.
- Ollama, [compatibilidad de hardware](https://docs.ollama.com/gpu): NVIDIA, AMD, Metal y Vulkan.
- Biblioteca de Ollama, etiquetas de [gemma3](https://ollama.com/library/gemma3/tags) y [qwen3](https://ollama.com/library/qwen3/tags), consultadas el 6 de octubre de 2026.
