# Cómo ejecutar modelos de IA localmente con Ollama

**Categoría:** Inteligencia artificial · **Nivel:** Inicial · **Lectura:** 13 min
**Publicada:** 2026-07-27 · **Actualizada:** 2026-07-27 · **Autoría:** Underc0de
**Versión HTML (canónica):** https://underc0de.org/guias/inteligencia-artificial/ejecutar-modelos-de-ia-localmente-con-ollama/

## Respuesta rápida

**Ollama** permite descargar y ejecutar modelos de lenguaje en tu propia máquina, y corre en **macOS, Windows y Linux**. Con `ollama run <modelo>` ya se puede conversar. Lo que decide si sirve para trabajar son dos ajustes: el **tamaño del modelo**, limitado por la memoria de video, y la **longitud de contexto**, que la documentación define como «la cantidad máxima de tokens a los que el modelo tiene acceso en memoria» y que por defecto queda en **4k con menos de 24 GiB de VRAM**. Para agentes, programación o búsqueda web, la documentación recomienda **al menos 64000 tokens**. Además expone una **API local** en el puerto **11434**, con compatibilidad parcial con la API de OpenAI.

## Qué se gana y qué se pierde

| Se gana | Se pierde |
|---|---|
| Los datos **no salen del equipo** | **Capacidad**: los modelos que entran en una máquina común son más chicos |
| Sin costo por uso y sin límite de peticiones | Velocidad, si no hay placa de video adecuada |
| Funciona sin conexión | Hay que administrarlo: actualizaciones, disco, memoria |
| La versión del modelo **no cambia bajo tus pies** | Tampoco mejora sola |
| Se puede experimentar sin miedo a la factura | Servir a varias personas a la vez no es viable en un escritorio |

**Si el modelo local hace mal la tarea, el resultado es un sistema privado que no sirve**, y eso no es una mejora. La decisión razonable es por tarea: clasificar, extraer datos estructurados, resumir, traducir y generar embeddings son trabajos donde un modelo local suele alcanzar.

## Instalación

«Ollama corre en macOS, Windows y Linux» y la descarga sale de [ollama.com/download](https://ollama.com/download).

```bash
ollama run gemma4              # descarga si hace falta y abre el chat

# Para entrada de varias líneas, se envuelve con tres comillas
#   >>> """Hola,
#   ... mundo!
#   ... """

# Con modelos multimodales se pasa la ruta de la imagen en el pedido
ollama run gemma4 "¿Qué hay en esta imagen? /ruta/a/imagen.png"
```

> **Los nombres de modelo cambian seguido.** Antes de copiar un nombre de cualquier tutorial, conviene mirar el catálogo oficial en `ollama.com/search`. Los ejemplos de esta guía usan los nombres que figuran en la documentación al momento de escribirla.

## Los comandos que se usan

| Comando | Qué hace |
|---|---|
| `ollama run <modelo>` | Ejecuta un modelo y abre el chat interactivo |
| `ollama pull <modelo>` | Descarga un modelo sin ejecutarlo |
| `ollama ls` | Lista los modelos descargados |
| `ollama ps` | Lista los modelos en ejecución. Muestra si está en placa o en procesador |
| `ollama stop <modelo>` | Detiene un modelo y libera la memoria |
| `ollama rm <modelo>` | Borra un modelo del disco |
| `ollama create -f Modelfile` | Crea un modelo propio a partir de un archivo de configuración |
| `ollama serve` | Arranca el servicio. Con `--help` lista las variables de entorno |
| `ollama launch` | Configura y arranca aplicaciones externas para que usen tus modelos |

**`ollama ps`** es el comando de diagnóstico más útil: muestra bajo la columna de procesador si el modelo se descargó parcialmente al procesador, que es la causa número uno de «anda lentísimo».

## Elegir modelo según tu equipo

En **Nvidia**, Ollama soporta placas con **capacidad de cómputo 5.0 o superior** y controlador **550 o más nuevo**; las de capacidad 5.0 a 6.2 requieren el **570 o posterior**. En **AMD** funciona por **ROCm** —en Linux hace falta el controlador **ROCm v7**— y hay soporte adicional por **Vulkan**. Sin placa compatible corre en el procesador.

El número que gobierna todo es la **memoria de video disponible**, porque de ella dependen el tamaño del modelo y el contexto, y las dos cosas compiten por el mismo espacio. Criterio: **empezar por un modelo chico que entre con holgura y subir**. Un modelo que apenas entra queda parcialmente en el procesador y anda peor que uno más chico que corre entero en la placa.

## La longitud de contexto

Es «la cantidad máxima de **tokens** a los que el modelo tiene acceso en memoria», y Ollama fija valores por defecto **según la memoria de video**:

| Memoria de video | Contexto por defecto | Qué implica |
|---|---|---|
| Menos de 24 GiB | **4k** | Una conversación larga o un documento mediano no entran |
| Entre 24 y 48 GiB | 32k | Alcanza para trabajo normal con documentos |
| 48 GiB o más | 256k | Contexto amplio, sin ajustes |

«Las tareas que requieren contexto grande, como búsqueda web, agentes y herramientas de programación, deberían configurarse en **al menos 64000 tokens**.»

```bash
# Subir el contexto al arrancar el servicio
OLLAMA_CONTEXT_LENGTH=64000 ollama serve

# Verificar dónde quedó el modelo: mirá la columna PROCESSOR.
# Si aparece reparto con CPU, el contexto o el modelo no entran en la placa.
ollama ps
```

«Configurar una longitud de contexto mayor va a aumentar la cantidad de memoria requerida.» Son tres variables —tamaño de modelo, contexto y memoria— y hay que elegir dos.

## La API local

```bash
# API propia de Ollama
curl http://localhost:11434/api/generate -d '{
  "model": "gemma4",
  "prompt": "¿Por qué el cielo es azul?"
}'
```

Y la **compatibilidad parcial con la API de OpenAI**, «para ayudar a conectar aplicaciones existentes con Ollama», en `http://localhost:11434/v1/`:

```python
from openai import OpenAI

client = OpenAI(
    base_url='http://localhost:11434/v1/',
    api_key='ollama',   # «requerida pero ignorada»
)

respuesta = client.chat.completions.create(
    model='gpt-oss:20b',
    messages=[{'role': 'user', 'content': 'Decí que esto es una prueba'}],
)
print(respuesta.choices[0].message.content)
```

Eso permite **desarrollar y probar contra un modelo local** y cambiar la URL base al proveedor remoto solo cuando la tarea lo justifique.

## Personalizar con Modelfile

```bash
# Archivo: Modelfile
FROM gemma4
SYSTEM """Sos un asistente que responde solo en español rioplatense,
en un máximo de tres oraciones, y aclara cuando no sabe algo."""

# Después:
ollama create -f Modelfile
```

**No es entrenamiento ni ajuste fino**: es configuración empaquetada con un nombre. Para la mayoría de los casos donde se cree necesitar ajuste fino —fijar un rol, un tono, un formato— esto alcanza y se puede versionar en el repositorio.

## Para qué sirve de verdad

- **Datos que no pueden salir.** Historias clínicas, documentación interna, código propietario.
- **Generar embeddings para un [sistema RAG](../como-crear-un-sistema-rag-con-documentos-propios/index.md).** Los modelos chicos rinden bien y es la tarea que más contenido procesa.
- **Trabajo de volumen y bajo criterio.** Clasificar, etiquetar, extraer campos, normalizar texto.
- **Desarrollar y probar.** Iterar sobre un prompt o un [conjunto de evaluación](../evaluacion-de-aplicaciones-con-modelos-de-lenguaje/index.md) sin consumir cuota.
- **Aprender cómo funcionan.** Ver el efecto del contexto y del tamaño en tu propia máquina enseña más que leerlo.

## Errores frecuentes

- **Dejar el contexto por defecto.** Con menos de 24 GiB son 4k.
- **Elegir el modelo más grande que «entra».**
- **No mirar `ollama ps`.**
- **Copiar nombres de modelo de tutoriales viejos.**
- **Esperar la calidad de un modelo grande remoto.**
- **Exponer el puerto a la red sin pensarlo.** Es una API sin autenticación por defecto.
- **Olvidarse del disco.** Cada modelo pesa varios gigabytes.
- **Usarlo por privacidad sin medir si sirve.**

## Preguntas frecuentes

**¿Qué se gana y qué se pierde ejecutando un modelo localmente?**
Se gana privacidad, costo cero por uso, funcionamiento sin conexión y estabilidad de versión. Se pierde capacidad. La decisión honesta es por tarea.

**¿Qué placa de video hace falta?**
Ninguna para empezar: corre en procesador. Con placa, Nvidia con capacidad de cómputo 5.0+ y controlador 550+, o AMD por ROCm v7 en Linux. Lo que más importa es la memoria de video.

**¿Por qué el modelo local se olvida de lo que le dije?**
Por la longitud de contexto. Con menos de 24 GiB de VRAM el valor por defecto es 4k, y lo viejo se descarta.

**¿Se puede usar Ollama desde una aplicación propia?**
Sí: API local en `http://localhost:11434/api` y compatibilidad parcial con la de OpenAI en `/v1/`, donde la clave es «requerida pero ignorada».

**¿Cómo se personaliza un modelo sin reentrenarlo?**
Con un Modelfile: modelo base más mensaje de sistema. Es configuración empaquetada, no ajuste fino.

**¿Para qué no conviene un modelo local?**
Para razonamiento largo, problemas difíciles y para servir muchas peticiones simultáneas desde un escritorio.

## Fuentes

Fecha de consulta: 27 de julio de 2026.

**Aportes de la comunidad Underc0de**

1. Underc0de, blog. [Malware en Hugging Face suplanta modelo de OpenAI](https://blog.underc0de.org/malware-en-hugging-face-suplanta-modelo-de-openai/), 12 de mayo de 2026.
2. Underc0de, foro. [Sección GNU/Linux](https://underc0de.org/foro/gnulinux/).

**Documentación oficial**

3. Ollama. [CLI Reference](https://docs.ollama.com/cli).
4. Ollama. [Context length](https://docs.ollama.com/context-length).
5. Ollama. [Hardware support](https://docs.ollama.com/gpu).
6. Ollama. [OpenAI compatibility](https://docs.ollama.com/api/openai-compatibility).
7. Ollama. [API introduction](https://docs.ollama.com/api/introduction).

## Guías relacionadas

- [Cómo crear un sistema RAG con documentos propios](../como-crear-un-sistema-rag-con-documentos-propios/index.md)
- [Agentes de inteligencia artificial y Model Context Protocol](../agentes-de-ia-y-model-context-protocol/index.md)
- [Evaluación de aplicaciones con modelos de lenguaje](../evaluacion-de-aplicaciones-con-modelos-de-lenguaje/index.md)
- [Índice de Inteligencia artificial](../index.md)