Cómo Ejecutar un LLM en Local con Ollama

Cada llamada a una API de LLM alojada envía tu prompt al servidor de otra persona y te cobra por token. Se cae la red y deja de responder. Ollama elimina los dos problemas: descarga un modelo de pesos abiertos en tu máquina y lo sirve mediante una API REST en localhost:11434. Un solo binario hace de gestor de modelos, cliente de chat y servidor.

Qué hace Ollama en realidad

Ollama envuelve llama.cpp y motores de inferencia similares, así que nunca tocas un flag del compilador ni una ruta de biblioteca CUDA. ollama pull llama3.2 descarga un archivo de modelo cuantizado (formato GGUF) desde el propio registro de Ollama en lugar de Hugging Face, aunque también puede importar archivos GGUF desde allí. Ejecutar el modelo pasa esos pesos a un servidor en segundo plano, que los carga en RAM (o VRAM, si encuentra una GPU compatible), los mantiene en memoria unos minutos después de tu última petición para que la siguiente sea rápida, y los libera en cuanto dejas de preguntar.

La CLI, la API y el sistema de Modelfiles se apoyan todos en la misma tarea: llevar los pesos a memoria y encaminar las peticiones hacia ellos.

Cómo instalar Ollama y ejecutar tu primer modelo

En Linux o macOS:

1

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

En Windows, ejecuta el instalador desde ollama.com, o usa:

1

irm https://ollama.com/install.ps1 | iex

En ambos casos terminas con la CLI ollama y un servidor en segundo plano escuchando en el puerto 11434. Descarga un modelo pequeño y habla con él:

1
2

ollama pull llama3.2
ollama run llama3.2

ollama run te lleva a un prompt interactivo. Haz una pregunta, lee la respuesta, /bye para salir. Otros tres comandos que usarás constantemente:

1
2
3

ollama list   # los modelos que has descargado, con su tamaño en disco
ollama ps     # los modelos cargados actualmente en memoria
ollama rm llama3.2   # libera el espacio en disco

llama3.2 es una buena primera descarga: unos 2 GB, lo bastante rápido para correr en la CPU de un portátil. No es el modelo más potente de su categoría de tamaño. gemma4 lidera ahora la gama pequeña y además procesa imágenes, y qwen3-coder es mejor opción si estás probando asistencia de programación. Aun así, empieza con llama3.2: confirma que tu configuración funciona antes de comprometerte con una descarga de 20 GB.

Cómo hablar con Ollama a través de su API REST

El prompt interactivo sirve para comprobar que todo funciona. Cualquier cosa que construyas llama a la API. El formato nativo de Ollama es este:

1
2
3
4
5

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Write a one-line commit message for a typo fix in README.md",
  "stream": false
}'

Con "stream": false recibes un único objeto JSON, que incluye eval_count y eval_duration, suficiente para medir los tokens por segundo en tu propio hardware. Ponlo en true y obtienes en su lugar una serie de objetos de respuesta parcial, que es lo que necesita una interfaz de chat.

Para conversaciones de varios turnos, /api/chat recibe un array messages con el mismo formato que usa la API de OpenAI:

1
2
3
4
5
6
7

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "user", "content": "What port does Ollama listen on by default?"}
  ],
  "stream": false
}'

Ollama también habla el formato de la API de OpenAI de forma nativa en /v1, así que los SDK oficiales de OpenAI funcionan contra él sin modificarlos:

1
2
3
4
5
6
7
8
9

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

response = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Summarize this changelog in two sentences."}],
)
print(response.choices[0].message.content)

Ollama ignora api_key, pero el constructor del SDK exige uno, así que sirve cualquier cadena no vacía. Eso lo convierte en la forma más rápida de apuntar una herramienta ya basada en OpenAI a un modelo local: cambias base_url y dejas el resto del código igual.

Hay otro endpoint que importa si estás montando una pipeline de retrieval-augmented generation en local. POST /api/embed convierte texto en vectores usando un modelo de embeddings (nomic-embed-text es la opción habitual), algo que un modelo de chat por sí solo no te da.

Cómo ejecutar Ollama en Docker

Si todo lo demás en la máquina ya es un contenedor, Ollama ofrece una imagen oficial en lugar de pedirte que instales algo en el host:

1
2
3
4
5

docker run -d \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

El volumen con nombre no es opcional en la práctica: sin él, cada modelo que descargaste desaparece en cuanto se elimina el contenedor. Para descargar y ejecutar un modelo dentro del contenedor en marcha:

1

docker exec -it ollama ollama run llama3.2

En una máquina con GPU NVIDIA, instala primero el NVIDIA Container Toolkit en el host y luego añade un solo flag:

1
2
3
4
5

docker run -d --gpus=all \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama

Las GPU de AMD usan una etiqueta de imagen distinta y montajes de dispositivo en lugar de --gpus:

1
2
3
4
5

docker run -d --device /dev/kfd --device /dev/dri \
  -v ollama:/root/.ollama \
  -p 11434:11434 \
  --name ollama \
  ollama/ollama:rocm

Como servicio de Docker Compose, lo mismo se reduce al puerto y al volumen, nada más:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

services:
  ollama:
    image: ollama/ollama
    ports:
      - "11434:11434"
    volumes:
      - ollama:/root/.ollama

volumes:
  ollama:

Exponer ese contenedor más allá de localhost es tarea de un reverse proxy con TLS por delante, igual que con cualquier otro servicio backend. Ollama no tiene autenticación propia, así que un puerto 11434 accesible desde la red es un servidor de modelos que cualquiera puede usar.

Cómo personalizar un modelo con un Modelfile

Un Modelfile fija un system prompt, una temperatura y una secuencia de parada sobre un modelo existente sin reentrenarlo. Crea un archivo llamado Modelfile:

1
2
3
4
5
6
7
8

FROM llama3.2

PARAMETER temperature 0.3

SYSTEM """
You are a terse code reviewer. Reply with the diff and one sentence of
rationale. Never restate the code you were not asked to change.
"""

Luego constrúyelo y ejecútalo:

1
2

ollama create code-reviewer -f Modelfile
ollama run code-reviewer

code-reviewer aparece ahora como su propia entrada en ollama list, aunque los pesos son exactamente los que usa llama3.2. Solo el system prompt y los parámetros de muestreo quedan integrados. La ventaja es que cualquier cliente que llame a ese nombre hereda la configuración sin tener que enviarla.

Qué tamaño de modelo se ajusta a tu RAM

El número en el nombre de un modelo es su recuento de parámetros, y predice bastante bien cuánta RAM (o VRAM, para inferencia en GPU) necesitas:

Esas cifras suponen la cuantización de 4 bits que Ollama descarga por defecto, que sacrifica algo de calidad de salida a cambio de un tamaño de descarga y una huella de memoria unas cuatro veces menores que los pesos de precisión completa. Para resumir texto o redactar mensajes de commit, la cuantización no es lo que vas a notar. Quedarte sin RAM sí. En cuanto el modelo empieza a usar swap en disco, pasa de lento a inutilizable, una diferencia mucho mayor que un punto de precisión.

Cuándo Ollama no es la herramienta adecuada

Ollama está pensado para que una persona hable con un modelo en su propia máquina. No hace batching de peticiones ni ningún tipo de scheduling que permita a una GPU servir a decenas de usuarios simultáneos de forma eficiente; para eso están vLLM, TGI o una API alojada. Si vas a poner un modelo local delante de tráfico real, mide el throughput de Ollama bajo carga concurrente antes de comprometerte: una sola instancia se cae mucho antes de lo que lo haría un servidor con batching de verdad.

Tampoco es una herramienta de fine-tuning. Un Modelfile cambia un system prompt y los parámetros de muestreo, nunca los pesos. Conseguir que un modelo aprenda un comportamiento nuevo a partir de tus ejemplos es un pipeline aparte.

Ninguno de los dos límites afecta a un desarrollador con un portátil. Descarga un modelo que quepa cómodamente bajo tu tope de RAM, ejecútalo una vez desde la CLI y luego llámalo con curl en /api/generate. Si la respuesta vuelve en un par de segundos y dice lo que esperabas, tienes un servidor de inferencia local que cualquier herramienta compatible con OpenAI puede usar.

Artículos relacionados

• Qué es RAG: Retrieval-Augmented Generation Explicado
• Qué Es Docker Compose y Cómo Se Usa
• Qué Es un Reverse Proxy y Cómo Funciona