La promesa suena casi demasiado buena: tener un modelo de lenguaje potente corriendo en tu propia máquina, sin pagar suscripciones, sin enviar tus datos a ningún servidor externo, sin depender de que la API de OpenAI no se caiga un martes a las tres de la tarde. Y lo mejor: con un solo comando.

Eso es exactamente lo que ofrece Ollama, y es la razón por la que se convirtió en una de las herramientas más instaladas en máquinas de developers durante el último año. Si trabajas con IA, entender Ollama ya no es opcional: es infraestructura básica.

En este post vamos a recorrer todo el camino. Desde la instalación en Linux hasta cómo consumir la API REST desde tu propio código, pasando por Modelfiles, casos de uso reales y troubleshooting. Al terminar vas a tener un setup de LLM local funcionando y sabrás cuándo conviene (y cuándo no) usarlo.

¿Qué es Ollama y por qué debería importarte?

Ollama es una herramienta de línea de comandos que descarga, ejecuta y gestiona modelos de lenguaje open-source en tu propia máquina. Internamente usa llama.cpp (un port del código original de Llama en C++ optimizado para correr en CPU y GPU de consumo), pero le agrega una experiencia tan pulida que parece magia.

Piensa en Ollama como el "Docker de los LLMs". Así como Docker te abstrae la complejidad de configurar un runtime para un contenedor, Ollama te abstrae la complejidad de configurar cuantización, contexto, GPU offloading y todos los parámetros internos que hacen falta para correr un modelo de 7 mil millones de parámetros sin que tu laptop se prenda fuego.

Lo que no es Ollama: no es un frontend de chat. Si querés una interfaz gráfica estilo ChatGPT, vas a necesitar algo como Open WebUI encima. Ollama es solo el motor — el backend. Y eso, lejos de ser una limitación, es lo que lo hace tan útil para developers.

Instalación en Linux (y por qué es absurdamente fácil)

Si estás en macOS o Windows, Ollama tiene instaladores nativos. Pero como este blog vive en un Ubuntu Server, vamos al camino Linux:

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

Eso es todo. El script detecta tu distribución, instala el binario, crea un servicio systemd y lo deja corriendo en el puerto 11434. Para verificar que todo funciona:

ollama --version

Vas a ver algo como ollama version is 0.32.1. Después:

ollama list

Si acabas de instalar, la lista va a estar vacía. Eso es normal: todavía no descargaste ningún modelo.

¿Y si uso otro sistema operativo? Para macOS y Windows, descargá el instalador desde ollama.com/download. La experiencia es idéntica una vez que el demonio está corriendo.

Tu primer modelo: del pull al primer prompt

La librería de modelos disponible es enorme. Los nombres siguen el formato modelo:tag, donde el tag suele indicar el tamaño (en miles de millones de parámetros) o la cuantización.

Para empezar con algo rápido y útil:

ollama pull llama3.2:3b

El 3b significa 3 mil millones de parámetros. Es un modelo chico que corre bien hasta en máquinas modestas, perfecto para probar. Si tenés más RAM (16 GB o más), podés ir directo a llama3.2:7b o mistral:7b.

Una vez que terminó la descarga:

ollama run llama3.2:3b "Explicame la diferencia entre TCP y UDP en dos párrafos"

Y ahí mismo, en tu terminal, empieza a generarse la respuesta token por token. Sin internet, sin latencia de API, sin que tu prompt pase por un servidor de San Francisco.

Cuánta RAM necesitás según el modelo

La regla de dedo es: un modelo cuantizado en Q4 necesita aproximadamente 0.5 GB de RAM por cada mil millones de parámetros.

Modelo	Tamaño aprox	RAM mínima	Ideal para
llama3.2:1b	1.3 GB	4 GB	Máquinas muy viejas, respuestas rápidas
llama3.2:3b	2.0 GB	8 GB	Balance entre velocidad y calidad
mistral:7b	4.1 GB	16 GB	Default razonable para developers
llama3.1:70b	40 GB	64 GB+	Workstations con GPU seria

Si tu máquina tiene poca RAM En vez de tirar el modelo por OOM (out of memory), Ollama lo detecta y degrada a CPU. Funciona, pero la inferencia se vuelve dolorosamente lenta. Mejor empezar con un modelo chico.

La API REST: el verdadero superpoder

Hasta ahora usamos Ollama como una herramienta de chat por terminal. Pero el valor real para developers está en la API REST local que Ollama expone en el puerto 11434. Eso significa que cualquier lenguaje que pueda hacer un POST HTTP puede usar tus modelos locales.

El endpoint /api/generate

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2:3b",
  "prompt": "¿Por qué Rust es más rápido que Python?",
  "stream": false
}'

La respuesta es un JSON con el texto generado:

{
  "model": "llama3.2:3b",
  "response": "Rust es más rápido que Python principalmente porque...",
  "done": true
}

Pasando "stream": true recibís la respuesta token por token, igual que en el chat. Útil para interfaces en tiempo real.

Consumirlo desde Python

import requests

response = requests.post(
    "http://localhost:11434/api/generate",
    json={
        "model": "llama3.2:3b",
        "prompt": "Resumí este log de error en una línea: [tu log acá]",
        "stream": False
    }
)
print(response.json()["response"])

Y desde JavaScript (Node)

const response = await fetch("http://localhost:11434/api/generate", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "llama3.2:3b",
    prompt: "Generame un commit message para este diff: [tu diff acá]",
    stream: false,
  }),
});
const data = await response.json();
console.log(data.response);

Esto convierte a Ollama en un backend de IA que podés usar desde cualquier aplicación sin pagar un centavo por tokens ni compartir datos con terceros.

Modelfile: crear tu propio modelo custom

Acá es donde Ollama se pone realmente interesante. Con un Modelfile podés tomar un modelo base y configurarlo con un system prompt, parámetros de inferencia y hasta mensajes de contexto persistente.

Ejemplo: un asistente que siempre responde en español rioplatense y con tono técnico:

FROM llama3.2:3b

SYSTEM """Sos un asistente técnico que responde en español rioplatense.
Usá 'vos' en vez de 'tú'. Sé conciso y evitá explicaciones innecesarias.
Cuando des código, explicá brevemente qué hace."""

PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER num_ctx 4096

Guardás eso como Modelfile y creás tu modelo custom:

ollama create dev-asistente -f Modelfile
ollama run dev-asistente "Explicame qué es un closure en JavaScript"

Ahora dev-asistente es tu modelo personalizado, disponible igual que cualquier otro. Lo podés correr desde la terminal, consumirlo por API, lo que quieras.

El formato Modelfile es deliberadamente parecido a un Dockerfile Eso es intencional. Si ya sabés Docker, la curva de aprendizaje es casi nula. FROM, SYSTEM, PARAMETER, COPY (para meter contexto estático) son los comandos principales.

Casos de uso prácticos para developers

Más allá del "wow, corre en mi máquina", ¿para qué sirve realmente Ollama en el día a día? Acá van los casos que más uso:

1. Pair programming sin filtrar código a la nube

Si trabajás con código propietario o de clientes con NDA, mandar snippets a ChatGPT es un problema. Con Ollama, el modelo corre local, tu código nunca sale de tu máquina, y la calidad de las sugerencias es sorprendentemente buena con codellama:7b o deepseek-coder:6.7b.

2. Resumir logs y stack traces

Un script en Python que lea el último error de tu app y se lo mande al modelo local con un prompt tipo "resumí este error en una línea y sugerí la causa más probable" ahorra horas de debugging. Todo en un cron, sin costo.

3. Clasificar y etiquetar contenido

¿Tenés mil tickets de soporte y querés categorizarlos automáticamente? Un modelo local de 3b es más que suficiente para eso y corre en milisegundos.

4. Integración con el ecosistema MCP

Si te interesa el mundo de los agentes, Ollama se integra perfecto con servidores MCP. En mi post sobre MCP-el-puente-entre-la-ia-y-tus-datos explico el protocolo; lo importante acá es que cualquier cliente compatible con MCP puede usar Ollama como backend de LLM, manteniendo todo el flujo local.

5. Privacidad total para notas y datos sensibles

En mi flujo personal, donde proceso notas y journals privados, no quiero que nada de eso pase por una API externa. Ollama + un modelo local es la solución: las notas viven en mi vault (como expliqué en Mi sistema PKM con Zettelkasten y PARA en Obsidian) y los resúmenes o análisis los hace un LLM que nunca toca internet. Este setup es el mismo que uso para todo el pipeline del blog que expliqué en Cómo construí mi blog con next.js y obsidian: cero servidores externos manejando mi contenido.

Ollama vs LM Studio vs llama.cpp

No es la única opción en la mesa. Vale la pena entender cuándo usar cada una:

Herramienta	Mejor para	Diferencia clave
Ollama	Developers que quieren una CLI y una API REST	La más fácil de automatizar
LM Studio	Usuarios que prefieren GUI tipo ChatGPT	Interfaz gráfica pulida, sin tocar terminal
llama.cpp	Investigadores y optimizadores extremos	Máximo control, pero hay que compilar

Si tu objetivo es integrar un LLM en código, Ollama gana por goleada. Si solo querés chatear con un modelo local, LM Studio es más amigable. Si estás investigando cuantización o querés exprimir cada ciclo de CPU, llama.cpp directo es el camino.

Troubleshooting común

Aunque Ollama es bastante robusto, hay tres problemas que vas a encontrar sí o sí:

El modelo corre lento

Probable causa: el modelo no cabe entero en RAM y está swapeando a disco. Solución: bajá a un modelo más chico o cerrá otras aplicaciones. Para ver el uso en tiempo real:

ollama ps

"Connection refused" en localhost:11434

El servicio no está corriendo. En Linux:

sudo systemctl status ollama
sudo systemctl start ollama

Quiero usar GPU pero Ollama insiste con CPU

Ollama detecta automáticamente GPUs NVIDIA con CUDA instalado. Si tenés una GPU AMD, vas a necesitar ROCm. En máquinas sin GPU dedicada (como es mi caso en este server), no hay drama: CPU funciona bien para modelos chicos, solo tarda más.

Conclusión: tu propio OpenAI, en una línea

Ollama democratiza el acceso a LLMs. Lo que hace dos años requería un cluster de GPUs y un especializado, hoy se instala con un comando y corre en una laptop de 8 GB de RAM. Para los developers eso cambia las reglas del juego: podemos experimentar, prototipar y hasta poner en producción aplicaciones con LLMs sin que el costo de la API coma el margen del proyecto.

Mi recomendación: instalalo hoy, bajá llama3.2:3b o mistral:7b según tu hardware, y dedicá una hora a probar. Te vas a sorprender de lo lejos que llegó la tecnología open-source.

---

¿Ya probaste Ollama o seguís dependiendo 100% de APIs cloud? Contame en los comentarios qué modelo te funcionó mejor y para qué caso de uso. Si tuviste problemas de RAM o compatibilidad, también armé este post justamente porque en mi setup limitado quería documentar qué opciones reales hay.