Cómo usar Ollama: IA local en tu equipo sin pagar suscripciones

Tabla de Contenidos

• Qué es Ollama (y qué no es)
• Por qué correr IA en local puede convenirle a tu negocio

  • Tus datos no salen del equipo
  • El costo deja de crecer con el uso
  • Funciona sin conexión y sin depender de un proveedor
  • Cuándo no conviene
• Qué hardware necesitas para correr un LLM local

  • CPU, GPU NVIDIA o Apple Silicon
  • Qué es la cuantización
  • Cómo calcular la memoria que necesitas
• Qué modelo instalar primero
• Cómo instalar Ollama paso a paso

  • En macOS
  • En Windows
  • En Linux
• Los comandos esenciales de Ollama
• Cómo personalizar un modelo con un Modelfile
• Cómo usar la API local de Ollama (puerto 11434)

  • Conectarlo a editores y agentes de código
  • Conectarlo a Open WebUI, Docker u otros equipos de la red
• Ollama vs LM Studio vs Jan: cuál elegir
• Calcula cuánto te ahorras
• Lo que te llevas

La respuesta corta: Ollama es un programa gratuito que descarga modelos de IA abiertos y los ejecuta en tu propio equipo. Lo instalas en un par de minutos, bajas un modelo con un comando y tienes un chat y una API local que no envía nada a servidores de terceros. Lo que define qué tan bien funciona no es el procesador: es cuánta memoria tienes para cargar el modelo.

Esta guía cubre el camino completo: por qué una pyme o una startup querría correr IA en local, qué hardware necesitas, cómo instalar y configurar Ollama, cómo conectarlo a otras herramientas y cuándo conviene más LM Studio o Jan. Si lo que buscas es qué modelo instalar, eso está en detalle en Mejores modelos de Ollama en 2026.

Qué es Ollama (y qué no es)

Ollama es un motor que empaqueta, descarga y sirve modelos de lenguaje en local. Se instala como un servicio en segundo plano y ofrece tres formas de usarlo:

• La terminal, con comandos como ollama run y ollama pull.
• Una app de escritorio con chat en Mac y Windows (en Linux solo hay terminal).
• Una API HTTP en http://localhost:11434, compatible con el formato de OpenAI, para conectar editores, automatizaciones o tus propias apps.

Lo que no es: Ollama no es un modelo. Es el programa que corre modelos de terceros: Qwen, Gemma, gpt-oss, Llama, DeepSeek y otros. La calidad de las respuestas depende del modelo que elijas y de tu hardware.

Por qué correr IA en local puede convenirle a tu negocio

Para una pyme o una startup que empieza, la IA local no es una moda técnica. Resuelve tres problemas concretos que tiene el modelo de suscripción.

Tus datos no salen del equipo

Cuando usas Ollama en local, el prompt y la respuesta se procesan en tu máquina. No hay un proveedor que retenga conversaciones ni políticas de uso de datos que leer con lupa. Eso importa cuando trabajas con código fuente propio, modelos financieros, contratos o bases de clientes, que es justo lo que no deberías pegar en un chat público (lo explico en qué no compartir con ChatGPT).

La privacidad local tiene un límite: protege el dato mientras está en tu equipo. Si el equipo no está cifrado o lo comparte medio equipo de trabajo, el riesgo se mueve de lugar, no desaparece.

El costo deja de crecer con el uso

En una API comercial pagas por token: cuanto más automatizas, más pagas. Con un modelo local, el costo ya está hecho (el equipo) y cada consulta adicional cuesta lo que consume en electricidad. No hay límites de uso por hora ni sorpresas en la factura de fin de mes.

Eso no significa que sea gratis. Hay que poner en la cuenta el hardware, el tiempo de configuración y que un modelo local de 9B no rinde como uno de frontera. Comparo los escenarios con números en precios reales de la IA en 2026.

Funciona sin conexión y sin depender de un proveedor

Un modelo local responde aunque se caiga internet o el proveedor tenga una interrupción. Para procesos por lotes (clasificar cientos de correos, extraer datos de facturas, resumir documentos internos) eso significa poder dejarlo trabajando sin preocuparte por cuotas ni caídas.

Cuándo no conviene

Sé honesto con la tarea. Si necesitas razonamiento largo, un agente que programe sobre un repositorio grande o respuestas donde un error cuesta dinero, un modelo de frontera en la nube sigue siendo mejor. La estrategia más sensata para la mayoría es mixta: local para el volumen y lo sensible, nube para lo difícil. Es la misma lógica de no depender de un solo proveedor de IA.

Qué hardware necesitas para correr un LLM local

La pregunta clave no es qué procesador tienes, sino cuánta memoria puede usar el modelo y qué tan rápido se mueven los datos dentro de esa memoria.

CPU, GPU NVIDIA o Apple Silicon

• Solo CPU (x86): sirve para probar y para modelos pequeños de 2B a 4B. Funciona, pero lento, porque la RAM del sistema tiene poco ancho de banda.
• GPU NVIDIA: la opción más rápida en tokens por segundo, siempre que el modelo quepa en la VRAM de la tarjeta. Si no cabe, Ollama reparte capas entre GPU y CPU, y la velocidad cae mucho.
• Apple Silicon (M1 a M4): la memoria es unificada, así que la GPU puede usar gran parte de la RAM del equipo. Un MacBook Pro con 64 o 128 GB carga modelos que en un PC exigirían varias tarjetas gráficas. Es más lento que una NVIDIA de gama alta con el mismo modelo, pero llega a tamaños que el PC no alcanza.

Qué es la cuantización

La cuantización reduce la precisión de los pesos del modelo para que ocupe menos memoria. Los niveles que vas a ver:

• FP16: precisión completa, 2 bytes por parámetro. Máxima fidelidad, mucha memoria.
• Q8: 8 bits, 1 byte por parámetro. La mitad de memoria y una pérdida de calidad casi imperceptible.
• Q4_K_M: 4 bits, unos 0,5 bytes por parámetro. Una cuarta parte de la memoria de FP16 y el estándar práctico para uso local. La calidad baja un poco, pero en tareas cotidianas se nota poco.

Casi todos los modelos de Ollama se descargan en Q4 por defecto. En la guía de modelos explico las variantes QAT y MLX, que mejoran este equilibrio.

Cómo calcular la memoria que necesitas

Una regla rápida:

Memoria (GB) ≈ parámetros en miles de millones × bytes por peso + 2 a 4 GB para el contexto

Un modelo de 8B en Q4 ocupa unos 4 GB de pesos, más el espacio del contexto (la KV cache): con 6 GB arranca y con 8 GB va cómodo.

Tamaño del modelo	Cuantización	Memoria mínima	Memoria cómoda
7B / 8B	Q4_K_M	6 GB	8 GB
7B / 8B	Q8	9 GB	12 GB
7B / 8B	FP16	16 GB	20 GB
14B	Q4_K_M	12 GB	16 GB
32B	Q4_K_M	20 GB	24 GB
70B	Q4_K_M	40 GB	48–64 GB

Son estimaciones: el consumo real sube con la ventana de contexto que configures. Si un modelo va lento, lo primero es revisar si cabe completo en la GPU (más abajo te digo cómo).

Qué modelo instalar primero

No hace falta empezar por el más grande. Como punto de partida en 2026:

• 8 GB de RAM: qwen3.5:4b.
• 16 GB: qwen3.5:9b, el mejor equilibrio entre calidad y peso.
• 24 GB de VRAM o Mac de 32 GB: qwen3.5:27b, o qwen3-coder:30b si es para programar.

La comparativa completa por memoria, con Gemma 4, gpt-oss y los modelos de embeddings, está en Mejores modelos de Ollama en 2026. Si dudas entre las dos familias principales, mira Qwen vs Gemma.

Cómo instalar Ollama paso a paso

En macOS

Descarga el instalador desde ollama.com/download, arrastra la app a Aplicaciones y ábrela. La app deja el servicio corriendo y añade el comando ollama a la terminal.

En Windows

Descarga y ejecuta OllamaSetup.exe desde la misma página. No necesita WSL: corre de forma nativa, detecta GPUs NVIDIA y AMD compatibles y queda como icono en la bandeja del sistema.

En Linux

Un solo comando instala el servicio:

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

Como con cualquier script que pasas a sh, puedes descargarlo y leerlo antes de ejecutarlo. En Linux, Ollama queda como servicio de systemd.

Para comprobar que funciona:

ollama --version

Los comandos esenciales de Ollama

Comando	Qué hace
ollama run <modelo>	Descarga el modelo si no lo tienes y abre un chat en la terminal
ollama pull <modelo>	Descarga el modelo sin abrir el chat
ollama list	Lista los modelos descargados, con tamaño y fecha
ollama ps	Muestra los modelos cargados en memoria y si corren en GPU o CPU
ollama show <modelo>	Muestra los detalles del modelo: parámetros, cuantización y contexto
ollama rm <modelo>	Borra un modelo para liberar disco

Un primer uso real:

ollama pull qwen3.5:9b
ollama run qwen3.5:9b

Dentro del chat, /bye sale. Revisa ollama ps la primera vez: si la columna de procesador dice algo como 40%/60% CPU/GPU, el modelo no cabe entero en tu GPU. Elige uno más pequeño o reduce el contexto.

Cómo personalizar un modelo con un Modelfile

Un Modelfile es un archivo de texto que define cómo se comporta un modelo: el prompt de sistema, la temperatura, el tamaño del contexto. Sirve para tener un asistente fijo para una tarea sin repetir instrucciones en cada chat.

FROM qwen3.5:9b

# Temperatura: 0 = respuestas más deterministas, 1 = más creativas
PARAMETER temperature 0.2

# Ventana de contexto en tokens
PARAMETER num_ctx 8192

SYSTEM """
Eres un arquitecto de software senior con foco en seguridad.
Respondes de forma directa y técnicamente precisa, sin relleno, en Markdown.
"""

Guárdalo como Modelfile y empaquétalo:

ollama create mi-arquitecto -f ./Modelfile
ollama run mi-arquitecto

Sobre el contexto: por defecto, Ollama ajusta la ventana de contexto a tu VRAM, y con menos de 24 GB empieza en 4.096 tokens. Para resumir documentos largos o usar agentes de código se queda corto. Súbelo con num_ctx en el Modelfile, con la variable OLLAMA_CONTEXT_LENGTH para todo el servidor o desde los ajustes de la app. Más contexto consume más memoria, así que vuelve a revisar ollama ps después de subirlo.

Cómo usar la API local de Ollama (puerto 11434)

Ollama expone un servidor HTTP en http://localhost:11434 con dos sabores:

• API nativa: /api/generate y /api/chat.
• API compatible con OpenAI: /v1, para usar Ollama con cualquier SDK o herramienta que ya hable con OpenAI.

Una llamada de prueba:

curl http://localhost:11434/api/generate -d '{
  "model": "qwen3.5:9b",
  "prompt": "Resume en tres puntos por qué correr IA en local reduce costos",
  "stream": false
}'

Con la API compatible con OpenAI, en tu código solo cambias la URL base:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
respuesta = client.chat.completions.create(
    model="qwen3.5:9b",
    messages=[{"role": "user", "content": "Clasifica este correo: ..."}],
)
print(respuesta.choices[0].message.content)

La api_key es obligatoria para el SDK, pero Ollama la ignora.

Conectarlo a editores y agentes de código

Herramientas como OpenCode aceptan un proveedor personalizado: apuntas la URL base a http://localhost:11434/v1 y eliges el modelo. Así tienes autocompletado y ayuda con el código sin que salga de tu equipo. Lo configuro paso a paso en cómo instalar y configurar OpenCode. Para agentes, usa un modelo pensado para código y sube el contexto a 32K o más.

Conectarlo a Open WebUI, Docker u otros equipos de la red

Por defecto, Ollama solo escucha en 127.0.0.1. Si conectas una interfaz como Open WebUI desde un contenedor Docker o desde otro equipo de la red, configura estas variables de entorno en el servicio:

• OLLAMA_HOST=0.0.0.0 para que acepte conexiones de fuera de localhost.
• OLLAMA_ORIGINS con los orígenes permitidos, si una app web llama a la API desde el navegador.

Ojo con la seguridad: la API de Ollama no tiene autenticación. Con 0.0.0.0, cualquiera en tu red puede usar tus modelos. Hazlo solo en redes de confianza o detrás de un proxy con autenticación, y nunca abras el puerto 11434 a internet. Evita OLLAMA_ORIGINS="*" fuera de pruebas.

Ollama vs LM Studio vs Jan: cuál elegir

Los tres corren modelos en local. La diferencia está en para qué están pensados.

Criterio	Ollama	LM Studio	Jan
Enfoque	Servicio y API para integrar la IA en otras herramientas	App gráfica para descubrir, probar y comparar modelos	App de chat open source, alternativa local a ChatGPT
Interfaz	Terminal y API; app de chat simple en Mac y Windows	Interfaz gráfica completa, con ajustes visuales	Interfaz gráfica de chat
API local	Siempre activa en el puerto 11434	Hay que iniciar el servidor desde la app	Servidor compatible con OpenAI, activable en ajustes
Modelos	Catálogo de Ollama e importación de GGUF	Descarga GGUF directo de Hugging Face	Descarga de modelos y conexión a otros backends
Ideal para	Automatizaciones, servidores sin pantalla, editores y agentes	Comparar modelos y cuantizaciones, probar prompts	Usuarios no técnicos que quieren un chat privado

Mi recomendación: Ollama si vas a integrar la IA en algo (un editor, un script, un flujo de trabajo). LM Studio si quieres explorar modelos antes de decidir. Jan si lo que necesitas es un chat privado para alguien que no va a abrir una terminal. No son excluyentes.

Calcula cuánto te ahorras

Pasar parte del trabajo a un modelo local solo tiene sentido si los números cierran. Dos herramientas gratuitas de Crea Cosas te ayudan a verlo:

1. Calculadora de margen: resta del costo de tus proyectos lo que hoy pagas en suscripciones y tokens, y mira cuánto mejora el margen.
2. Business Model Canvas: lleva el cambio al bloque de estructura de costos. Un gasto que antes crecía con cada cliente pasa a ser un costo fijo que amortizas.

Pon en la cuenta el hardware y el tiempo de configuración. Si el ahorro mensual no paga el equipo en un plazo razonable, sigue en la nube y vuelve a revisarlo cuando crezca el volumen.

Lo que te llevas

Correr IA en local ya no es cosa de laboratorio. Con Ollama, un equipo de 16 GB y un modelo bien elegido tienes un asistente privado, sin cuota mensual y con una API que puedes conectar a tus herramientas. No reemplaza a los modelos de frontera para todo, pero sí puede quitarte de encima buena parte del volumen diario y los datos que no deberían salir de la empresa. Empieza con un modelo pequeño, mide si te sirve y crece desde ahí.