Saltar al contenido principal

Ejecutar modelos de IA localmente con Ollama

Intermedio

Los modelos de frontera viven en la nube, pero hay toda una clase de modelos de pesos abiertos — Llama, Mistral, Qwen, DeepSeek, Gemma — que puedes descargar y ejecutar en tu propio portátil o servidor. Ollama es la forma más sencilla de hacerlo: una instalación, un comando, y un modelo se ejecuta localmente. Esta página te lleva de cero a un modelo en marcha, llamándolo desde código y conociendo las contrapartidas 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 localmente — y las contrapartidas honestas frente a los modelos de frontera en la nube
  • Instalar Ollama y ejecutar tu primer modelo en dos comandos
  • Usar la CLI principal: pull, run, list, ps, rm, stop
  • Llamar a tu modelo local desde código a través de la API de Ollama compatible con OpenAI
  • Entender las necesidades de RAM, los tamaños de modelo y la cuantización — para que elijas un modelo que tu máquina realmente pueda ejecutar
  • Saber cuándo LM Studio (una interfaz gráfica) es el mejor punto de partida

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

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

  • Privacidad — tus prompts y datos nunca salen de tu máquina. La razón por la que los equipos en dominios regulados o sensibles recurren a los modelos locales. (Consulta la bifurcación privacidad/self-host en Elegir un modelo.)
  • Sin conexión — sin internet, sin API, sin depender de caídas de servicio. 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 tasa ni sorpresas en los términos de servicio.

Las contrapartidas honestas:

  • Brecha de capacidad. Un modelo que puedes ejecutar en un portátil (1B–14B parámetros) no está a la misma altura 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 estás eligiendo el modelo más grande que tu hardware puede ejecutar, no el mejor modelo que existe.
  • Tú lo operas. 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 pequeña (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 realmente necesite la capacidad extra.

Instalar Ollama y ejecutar 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 el instalador descargado en su lugar):

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

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

ollama run llama3.2

Ese único comando descarga llama3.2 (un modelo pequeño de clase 1B/3B que se ejecuta en hardware modesto) e inicia un chat interactivo. Para descargar sin chatear todavía, usa ollama pull en su lugar.

La CLI principal​

Un puñado de comandos cubre casi todo. Ejecuta ollama --help para 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 se inicia con 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 genuinamente útiles en 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 — así que la mayor parte del código escrito para el SDK de OpenAI funciona contra tu modelo local cambiando dos líneas.

HTTP en crudo con curl (endpoint nativo):

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

Desde Python usando el SDK oficial de OpenAI — simplemente apunta base_url a Ollama y pasa cualquier api_key no vacía (Ollama requiere 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="llama3.2",
    messages=[
        {"role": "system", "content": "You are a concise assistant."},
        {"role": "user", "content": "Explain gradient descent in two sentences."},
    ],
)

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

Como es compatible con OpenAI, los mismos patrones que usarías contra una API alojada se trasladan — incluyendo streaming y uso de herramientas / function calling, que funcionan localmente igual que funcionan en la nube (siempre que el modelo sea realmente bueno en ello). La capa /v1 de Ollama cubre /v1/chat/completions, /v1/completions, /v1/models y /v1/embeddings, entre otros.

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

El número que verás asociado a un modelo — 1B, 7B, 8B, 70B — es su número de parámetros (en miles de millones). Más parámetros generalmente significa más capaz y más ávido 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 hace esto viable en máquinas normales. Los pesos del modelo se almacenan originalmente en alta precisión (por ejemplo, 16 bits), pero pueden comprimirse a ~4 bits con un coste de calidad pequeño y a menudo apenas perceptible. Ollama distribuye la mayoría de los modelos cuantizados por defecto — por eso un modelo con miles de millones de parámetros puede caber en unos pocos GB. Una regla general aproximada (verifica contra la página del modelo específico):

  • Modelos de ~1B–3B: se ejecutan 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; presupuesta 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 (llama3.2), confirma el flujo de trabajo de principio a fin, luego escala hacia arriba hasta el modelo más grande que aún se ejecute con fluidez en tu hardware — no el más grande 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 a través de una interfaz gráfica: explora y descarga modelos abiertos, chatea con ellos en una interfaz integrada y — como Ollama — ejecuta un servidor local compatible con OpenAI para que tu código pueda comunicarse con él. Es la vía de entrada más fácil para quienes no son desarrolladores o para cualquiera que prefiera apuntar y hacer clic en lugar de una terminal; Ollama tiende a ganar cuando quieres una CLI programable y un servicio en segundo plano ligero. Ambos ejecutan los mismos tipos de modelos de pesos abiertos, así que los conceptos de esta página se trasladan directamente.

Comprueba lo aprendido

0/4
  1. ¿Cuál es la mayor contrapartida honesta de ejecutar un modelo localmente frente a un modelo de frontera en la nube?
  2. ¿Qué comando descarga un modelo (si es necesario) 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; la contrapartida es una brecha de capacidad real y límites de hardware.
  • Dos comandos te ponen en marcha: instala Ollama, luego ollama run llama3.2.
  • CLI principal: pull (descargar), run (chatear), list, ps, stop, rm — eso es la mayor parte.
  • Llámalo desde código a través del 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, escala hasta lo que se ejecute 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​