Saltar al contenido principal

Ejecuta modelos de IA en local con Ollama

Intermedio

Los modelos de frontera viven en la nube, pero toda una clase de modelos de pesos abiertos — Llama, Mistral, Qwen, DeepSeek, Gemma — puedes descargarla y ejecutarla en tu propio portátil o servidor. Ollama es la forma más sencilla de hacerlo: una instalación, un comando y un modelo funcionando en local. Esta página te lleva de cero a un modelo en marcha, a llamarlo desde código y a conocer los compromisos, para que no esperes que un modelo local de 7B se comporte como uno de frontera.

What you'll learn
  • Saber POR QUÉ ejecutarías un modelo en local — y los compromisos honestos frente a los modelos de frontera en la nube
  • Instalar Ollama y ejecutar tu primer modelo con dos comandos
  • Usar la CLI básica: pull, run, list, ps, rm, stop
  • Llamar a tu modelo local desde código mediante la API de Ollama compatible con OpenAI
  • Entender los requisitos de RAM, los tamaños de modelo y la cuantización, para elegir un modelo que tu máquina pueda ejecutar de verdad
  • Saber cuándo LM Studio (una interfaz gráfica) es mejor punto de partida

Por qué ejecutar un modelo en local (y cuándo no)​

Ejecutar un modelo en tu propio hardware te da cuatro cosas:

  • Privacidad — tus prompts y tus datos nunca salen de tu máquina. Es la razón por la que los equipos de ámbitos regulados o sensibles recurren a modelos locales. (Consulta la bifurcación privacidad/autoalojamiento en Elegir un modelo.)
  • Sin conexión — sin internet, sin API, sin depender de caídas. El modelo es un archivo en tu disco.
  • Coste — sin factura por token. Una vez descargado, ejecutarlo es «gratis» (pagas en electricidad y hardware, no en gasto de API). Si el gasto en tokens es tu limitación a escala, lo local puede ganar.
  • Control — fija una versión exacta, personaliza el comportamiento e intégralo sin límites de frecuencia ni sorpresas en los términos de servicio.

Los compromisos honestos:

  • Brecha de capacidad. Un modelo que puedes ejecutar en un portátil (1B–14B parámetros) no está en la misma liga que un modelo de frontera en la nube en razonamiento difícil, contexto largo o tareas agénticas. Para muchas tareas cotidianas la brecha es pequeña; para las más difíciles es grande.
  • Hardware. Los modelos más grandes y capaces necesitan más RAM/VRAM de la que tiene una máquina típica. A menudo eliges el mayor modelo que tu hardware puede ejecutar, no el mejor que existe.
  • Lo operas tú. Sin escalado gestionado, sin actualizaciones automáticas: ese es el precio del control.

Un patrón común y duradero: prototipa y elige con una evaluación minúscula (el mismo método que con los modelos en la nube — consulta Elegir un modelo), usa lo local para trabajo privado/sin conexión/barato a escala y recurre a una API de frontera cuando la tarea de verdad necesite la capacidad extra.

Instala Ollama y ejecuta tu primer modelo​

Guided walkthrough1 of 4
  1. macOS y Windows: descarga el instalador desde ollama.com/download y ejecútalo. Linux: usa el script de instalación oficial (abajo). Esto instala el comando ollama y un servicio local en segundo plano.

Instalación en Linux (macOS/Windows usan en su lugar el instalador descargado):

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

Descarga y ejecuta un modelo pequeño (buena primera elección)

ollama run gemma4:e2b

Ese único comando descarga gemma4:e2b — el modelo con el que empieza la propia guía de inicio rápido de Ollama, una variante Gemma 4 de tamaño edge con ~2,3B parámetros efectivos y unos pocos GB en disco — e inicia un chat interactivo. Para descargar sin chatear todavía, usa ollama pull en su lugar.

La CLI básica​

Un puñado de comandos cubre casi todo. Ejecuta ollama --help para ver la lista completa.

# Download a model without starting a chat
ollama pull qwen3

# Start an interactive chat (downloads first if needed)
ollama run qwen3

# One-shot: pass the prompt inline, get the answer, exit
ollama run qwen3 "Summarize the CAP theorem in two sentences."

# List models you've downloaded
ollama list

# Show models currently loaded in memory
ollama ps

# Stop a running/loaded model (frees memory)
ollama stop qwen3

# Delete a downloaded model to reclaim disk
ollama rm qwen3

Dentro de una sesión interactiva de ollama run, escribe /bye para salir y /? para ver los comandos de la sesión. El servicio en segundo plano que realmente sirve los modelos lo inicia ollama serve (la aplicación de escritorio lo inicia por ti automáticamente).

Llámalo desde código (API compatible con OpenAI)​

Esta es la parte que hace que los modelos locales sean realmente útiles en las aplicaciones. El servicio en segundo plano de Ollama expone una API HTTP local en http://localhost:11434, en el puerto por defecto 11434. Tiene sus propios endpoints nativos (/api/generate, /api/chat) y una capa compatible con OpenAI en /v1, de modo que la mayor parte del código escrito para el SDK de OpenAI funciona con tu modelo local cambiando dos líneas.

HTTP directo con curl (endpoint nativo):

curl http://localhost:11434/api/chat -d '{
  "model": "gemma4:e2b",
  "messages": [
    { "role": "user", "content": "Why is the sky blue?" }
  ],
  "stream": false
}'

Desde Python con el SDK oficial de OpenAI — basta con apuntar base_url a Ollama y pasar cualquier api_key no vacía (Ollama exige el campo pero ignora su valor):

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama",  # required by the SDK, ignored by Ollama
)

response = client.chat.completions.create(
    model="gemma4:e2b",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain gradient descent in two sentences."},
    ],
)

print(response.choices[0].message.content)

Al ser compatible con OpenAI, los mismos patrones que usarías con una API alojada se mantienen — incluidos el streaming y el uso de herramientas / function calling, que funcionan en local igual que en la nube (siempre que el modelo sea realmente bueno en ello). La capa /v1 de Ollama cubre /v1/chat/completions, /v1/completions, /v1/responses, /v1/models (y /v1/models/{model}) y /v1/embeddings.

Hardware, tamaños de modelo y cuantización​

El número que verás junto a un modelo — 1B, 7B, 8B, 70B — es su cantidad de parámetros (en miles de millones). Más parámetros suele significar más capaz y más hambriento de memoria. El límite práctico de lo que puedes ejecutar es la RAM (y en una GPU, la VRAM).

La cuantización es el truco clave que lo hace viable en máquinas normales. Los pesos del modelo se almacenan originalmente en alta precisión (p. ej., 16 bits), pero pueden comprimirse a ~4 bits con un coste de calidad pequeño, a menudo apenas perceptible. Ollama distribuye la mayoría de los modelos cuantizados por defecto, y por eso un modelo con miles de millones de parámetros cabe en unos pocos GB. Una regla general aproximada (verifícala en la página del modelo concreto):

  • Modelos de ~1B–3B: funcionan cómodamente en la mayoría de los portátiles modernos (unos pocos GB de RAM).
  • Modelos de ~7B–8B: el punto óptimo entre capaz y ejecutable; calcula varios GB de RAM libre.
  • Modelos de ~13B–14B: necesitan una máquina bastante bien equipada.
  • Modelos de ~70B+: necesitan una estación de trabajo/servidor con mucha RAM o una GPU potente — no es territorio típico de portátil.

Una receta práctica: empieza con un modelo pequeño (gemma4:e2b), confirma el flujo de principio a fin y luego sube al mayor modelo que siga funcionando con fluidez en tu hardware — no al mayor que exista.

Vocabulario de modelos locales
Pulsa Intro o Espacio para girar la tarjeta. Usa las flechas izquierda y derecha para moverte entre las tarjetas.Término mostrado.
1 / 6

LM Studio: una alternativa con interfaz gráfica​

Si la línea de comandos no es lo tuyo, LM Studio es una aplicación de escritorio (macOS, Windows, Linux) que hace el mismo trabajo mediante una interfaz gráfica: explorar y descargar modelos abiertos, chatear con ellos en una interfaz integrada y — como Ollama — ejecutar un servidor local compatible con OpenAI para que tu código pueda comunicarse con él. Es la puerta de entrada más fácil para quienes no desarrollan o prefieren apuntar y hacer clic en lugar del terminal; Ollama suele ganar cuando quieres una CLI programable por scripts y un servicio ligero en segundo plano. Ambos ejecutan los mismos tipos de modelos de pesos abiertos, así que los conceptos de esta página se trasladan directamente.

Compruébalo tú mismo

0/4
  1. ¿Cuál es el mayor compromiso honesto de ejecutar un modelo en local frente a un modelo de frontera en la nube?
  2. ¿Qué comando descarga un modelo (si hace falta) Y empieza a chatear con él?
  3. Para llamar a tu modelo local desde código con el SDK de OpenAI, ¿qué configuras?
  4. ¿Por qué un modelo con miles de millones de parámetros puede caber en solo unos pocos GB de RAM?
Key takeaways
  • Local = privacidad + sin conexión + sin coste por token + control; el compromiso es una brecha de capacidad real y los límites del hardware.
  • Dos comandos te ponen en marcha: instala Ollama y luego ollama run gemma4:e2b.
  • CLI básica: pull (descargar), run (chatear), list, ps, stop, rm — eso es casi todo.
  • Llámalo desde código mediante el endpoint compatible con OpenAI: base_url http://localhost:11434/v1, cualquier api_key no vacía.
  • El número de parámetros + la cuantización deciden si tu máquina puede ejecutar un modelo — empieza pequeño y sube hasta lo que funcione con fluidez.
  • ¿Prefieres una interfaz gráfica? LM Studio hace el mismo trabajo apuntando y haciendo clic, y también expone un servidor local compatible con OpenAI.

Fuentes y lecturas adicionales​

Siguiente​