Introducción a Ollama: tu primer paso para ejecutar LLM en local

El mes pasado, la factura de la API de OpenAI superó los 300 dólares. Solo estaba probando funciones en fase de desarrollo, pero el costo se acumuló rápido. Peor aún: los documentos que procesaba incluían datos internos de la empresa; subirlos a la nube nunca me dejó tranquilo.

En ese momento decidí buscar una alternativa local. Tras una semana probando varias herramientas, Ollama resultó ser la opción menos dolorosa.

Quizá te encuentres en una situación parecida: los servicios de IA en la nube cada vez cuestan más, la privacidad de los datos preocupa, o simplemente necesitas IA en un entorno sin conexión. Ollama puede ayudarte. Te permite ejecutar un gran modelo de lenguaje en tu propio equipo, empezar en minutos, sin costo y con los datos siempre en tu máquina. A continuación comparto los tropiezos y lo aprendido, para que evites los mismos errores.

---

¿Qué es Ollama?

Ojo: el nombre puede confundir. Ollama no es un modelo; es la herramienta que ejecuta modelos. Igual que Docker simplificó los contenedores, Ollama hace accesible ejecutar LLM en local.

En pocas palabras: descargas un modelo con Ollama (por ejemplo Llama 3.2) y puedes conversar con él, pedirle código, traducciones… toda la inferencia ocurre en tu equipo.

¿Por qué molestarse con modelos locales si ChatGPT y Claude en la nube ya son tan cómodos?

La nube es cómoda, sí. Pero con el tiempo surgen varios problemas:

El costo. La API cobra por token; en fase de pruebas, con llamadas constantes, la factura asusta. He visto a gente gastar cientos o miles de dólares al mes solo desarrollando.

La privacidad. Toda conversación sube a la nube. Si trabajas con documentos internos, datos de clientes o información sensible, puede incumplir normativas. Quienes trabajan en sectores regulados lo notan especialmente.

La red. Hace falta conexión. Con internet inestable la experiencia empeora; offline, directamente no hay servicio.

Los límites. Rate limits, cuotas, restricciones de funciones… a veces quieres probar algo y los topes te frenan.

Ollama resuelve estos puntos de golpe. Tras descargar el modelo, la inferencia es 100 % local. Funciona sin red, los datos no salen de la máquina, no hay costo de API ni límites de llamadas.

Para desarrolladores, Ollama aporta algo extra: una API completa compatible con el formato de OpenAI. Puedes probar en local ahorrando dinero y pasar a la API en la nube en producción cuando haga falta.

---

Instalar Ollama: tres pasos

La instalación es muy sencilla. Varía un poco según la plataforma, pero en minutos suele estar listo.

Linux (lo más cómodo)

En Linux, un solo comando:

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

Al terminar, Ollama queda instalado y el servicio arranca solo.

Linux es la plataforma que más recomiendo. Servidores, contenedores… encaja bien. Si piensas usar Ollama en producción, Linux es la opción preferida.

También puedes instalar a mano, pero no lo recomiendo a quien empieza. Si de verdad lo necesitas, descarga el binario y configura systemd. Los pasos están en mi informe de investigación; aquí no los desarrollo.

macOS (más amigable con interfaz gráfica)

En macOS hay dos caminos.

Con Homebrew:

brew install ollama

Luego ollama serve para arrancar, o brew services start ollama para dejarlo en segundo plano.

¿Sin Homebrew? Descarga el .pkg del sitio oficial e instálalo con doble clic. Los usuarios de Mac conocen bien ese flujo.

Un consejo: en Apple Silicon (M1/M2/M3) la aceleración Metal GPU se activa sola y rinde bien. En mi MacBook Pro M2, un modelo 8B va fluido; el 13B también corre, con más uso de memoria.

Windows (winget es lo más rápido)

En Windows:

winget install --id=Ollama.Ollama -e

O descarga el .exe del sitio. Tras instalar, Ollama arranca solo y verás el icono en la bandeja del sistema.

Comprueba que todo funciona:

ollama --version

Si ves el número de versión, listo. ¿Sencillo, verdad?

---

Ejecutar tu primer modelo

Con Ollama instalado, probemos un modelo.

Para empezar recomiendo llama3.2 o qwen:8b. El primero es el último de Meta, con buen equilibrio general; el segundo es Qwen, muy fuerte en chino.

Ejecuta:

ollama run llama3.2

El comando descarga el modelo (la primera vez tarda unos minutos) y abre una interfaz interactiva.

Verás:

>>> Send a message (/? for help)

Ya puedes conversar. Prueba:

>>> Hola, preséntate

El modelo responde en tiempo real, como un chat. Para salir: /bye o Ctrl+D.

Tamaños de modelo

En el nombre verás cifras como 3b o 8b: son los parámetros, el «tamaño del cerebro» del modelo.

Modelo 3B: 3 mil millones de parámetros; corre en portátiles ligeros con ~4 GB de RAM. Rápido, capacidades más básicas. Bueno para chat simple o instrucciones de herramientas.

Modelo 8B: 8 mil millones; el punto dulce en portátiles y sobremesas. Necesita ~8 GB de RAM; cubre conversación diaria y ayuda básica con código. Es el tamaño que más uso.

Modelo 13B: 13 mil millones; ~16 GB de RAM. Mejor calidad de respuesta y contexto más largo; ideal con GPU de gama media-alta.

Modelo 70B: 70 mil millones; 64 GB de RAM o más. Nivel servidor; máxima capacidad y exigencia de hardware. En la práctica, pocos usuarios particulares lo necesitan.

Para empezar, 3B u 8B bastan y corren bien en equipos modernos. No persigas el modelo más grande al inicio; familiarízate con uno pequeño y escala según necesidad.

---

Comandos habituales de gestión de modelos

Ollama ofrece comandos sencillos. Con unos pocos te basta.

Descargar modelos:

ollama pull llama3.2
ollama pull qwen:8b

pull descarga desde la biblioteca y deja caché local; la siguiente vez no vuelve a bajar todo.

Listar modelos instalados:

ollama list

Muestra nombre, tamaño y fecha de modificación.

Eliminar un modelo:

ollama rm llama3.2

Libera espacio si ya no lo necesitas.

Ver detalles:

ollama show llama3.2

Parámetros, cuantización y otros detalles técnicos.

Comandos como cp o push se usan poco; cuando hagan falta, consulta la documentación.

Modelos recomendados

Según el uso:

Conversación diaria:

• llama3.2: último de Meta, buen equilibrio
• qwen:8b: Qwen, excelente en chino
• mistral: modelo open source europeo, buen rendimiento

Asistencia de código:

• codellama: afinado para generación de código
• deepseek-coder: modelo de código, muy usable

Multimodal (imágenes):

• llava: comprensión de imágenes
• llama3.2-vision: variante visual de Llama 3.2

Si dudas, prueba llama3.2:3b o qwen:8b: ideales para empezar y ligeros.

---

Aceleración GPU: la diferencia de velocidad es enorme

Esto importa mucho. La CPU también ejecuta modelos, pero la GPU puede ir 10-20 veces más rápida.

La primera vez no configuré bien la GPU y el modelo iba lentísimo. Al activar la aceleración, la velocidad cambió por completo.

Ollama soporta NVIDIA, AMD y Apple Silicon.

Tarjetas NVIDIA (serie RTX)

En NVIDIA casi todo es automático.

Necesitas:

1. Drivers NVIDIA recientes (531 o superior)
2. CUDA instalado

Comprueba la GPU:

nvidia-smi

Si ves la tarjeta, bien. Ollama usará la GPU al ejecutar modelos.

Para elegir GPUs concretas:

export CUDA_VISIBLE_DEVICES=0,1

Usa solo la primera y segunda GPU; útil en equipos multi-GPU.

GPU en Docker:

Con Docker hace falta NVIDIA Container Toolkit:

docker run --gpus all ollama/ollama

Así el contenedor accede a la GPU del host.

Tarjetas AMD

AMD es un poco más laborioso: requiere ROCm.

GPUs compatibles con ROCm incluyen:

• Radeon Instinct (MI100, MI210, MI250, MI300X, etc.)
• Radeon RX (5700 XT, 5500 XT, 7600, 9070, etc.)
• Radeon PRO

Con ROCm v7 o superior, Ollama detecta y usa la GPU AMD.

Si tu arquitectura no está soportada oficialmente, prueba:

export HSA_OVERRIDE_GFX_VERSION=10.3.0

AMD también ofrece soporte experimental Vulkan:

export OLLAMA_VULKAN=1

Apple Silicon (M1/M2/M3)

En Mac es lo más sencillo: Metal GPU se activa solo, sin configuración extra.

Con 16 GB de RAM en chip M, un 8B va fluido; con 32 GB puedes usar 13B o incluso 30B. La memoria unificada compartida entre CPU y GPU define qué tamaño de modelo aguanta el equipo.

Trucos de rendimiento

Además de la GPU:

Modelos cuantizados. Por defecto Q4_K_M equilibra calidad y velocidad. Si falta memoria, prueba Q4_K_S: algo menos calidad, menos consumo.

Flash Attention. Acelera escenarios con contexto largo:

export OLLAMA_FLASH_ATTENTION=1

Longitud de contexto. Por defecto 2048; si no la necesitas, redúcela:

export OLLAMA_CONTEXT_LENGTH=4096

Ahorra memoria y gana velocidad.

Mantener el modelo cargado. Por defecto se descarga tras 5 minutos inactivo. Si lo usas seguido:

export OLLAMA_KEEP_ALIVE=30m

O -1 para no descargarlo mientras el servicio Ollama siga activo. Así cada conversación responde al instante, sin recargar el modelo.

---

Integración API: conectar Ollama a tu aplicación

Aquí está el valor real de Ollama: una API completa integrable en tus apps.

Fundamentos de la REST API

Ollama expone servicio API en el puerto local 11434.

Dos endpoints muy usados:

Generación de texto:

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Why is the sky blue?"
}'

Chat completions:

curl http://localhost:11434/api/chat -d '{
  "model": "llama3.2",
  "messages": [
    {"role": "user", "content": "Hello!"}
  ]
}'

Por defecto la respuesta es en streaming. Para el resultado completo: "stream": false.

API compatible con OpenAI: la joya

Muy práctico: Ollama ofrece interfaz compatible con OpenAI; casi no cambias el código existente.

Endpoint compatible:

http://localhost:11434/v1/chat/completions

Ejemplo en Python:

from openai import OpenAI

client = OpenAI(
    base_url='http://localhost:11434/v1',
    api_key='ollama'  # Cualquier valor; no importa
)

response = client.chat.completions.create(
    model="llama3.2",
    messages=[
        {"role": "user", "content": "Say this is a test"}
    ]
)

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

Ejemplo en JavaScript:

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'http://localhost:11434/v1',
  apiKey: 'ollama'
});

const response = await client.chat.completions.create({
  model: 'llama3.2',
  messages: [{ role: 'user', content: 'Hello!' }]
});

console.log(response.choices[0].message.content);

Desarrollo con modelo local (ahorro); producción con API en la nube (estabilidad). O todo en local: costo y privacidad bajo control.

Mi enfoque: variable de entorno que alterna local y nube según el entorno. En desarrollo uso local por defecto; solo cambio a la nube cuando hace falta capacidad cloud.

Biblioteca Python de Ollama

Además del cliente OpenAI, Ollama tiene su propia librería:

pip install ollama

Uso básico:

import ollama

response = ollama.chat(model='llama3.2', messages=[
  {'role': 'user', 'content': 'Why is the sky blue?'},
])

print(response['message']['content'])

Modo streaming:

import ollama

stream = ollama.chat(
    model='llama3.2',
    messages=[{'role': 'user', 'content': 'Why is the sky blue?'}],
    stream=True,
)

for chunk in stream:
    print(chunk['message']['content'], end='', flush=True)

Tool calling (llamadas a herramientas)

Ollama soporta tool calling: el modelo puede invocar funciones o APIs externas. Muy útil para apps de IA complejas.

Ejemplo:

import ollama

response = ollama.chat(
    model='llama3.1',
    messages=[{'role': 'user', 'content': 'What is the weather in Toronto?'}],
    tools=[{
        'type': 'function',
        'function': {
            'name': 'get_current_weather',
            'description': 'Get the current weather for a city',
            'parameters': {
                'type': 'object',
                'properties': {
                    'city': {'type': 'string', 'description': 'The name of the city'},
                },
                'required': ['city'],
            },
        },
    }],
)

print(response['message']['tool_calls'])

El modelo decide si necesita la herramienta y devuelve los parámetros; tu código ejecuta la función y devuelve el resultado al modelo.

---

¿Ollama o LM Studio?

Quizá conozcas LM Studio, otra herramienta para LLM locales. ¿Cuál elegir?

Cada una tiene ventajas según el caso.

Ollama:

• Orientado a línea de comandos; ideal para desarrolladores
• Instalación simple, un comando
• API automática al arrancar
• Excelente en servidores y contenedores
• Pensado para apps, automatización e integración

LM Studio:

• Interfaz gráfica intuitiva
• Navegador de modelos integrado
• Hay que iniciar la API manualmente
• Poco apto para servidores
• Mejor para explorar modelos y aprender

En resumen:

• Apps de IA, servidores, scripts → Ollama
• Probar modelos rápido, poca experiencia en terminal, solo explorar → LM Studio

Pueden complementarse: descubro modelos en LM Studio y, si funcionan bien, los integro en Ollama. Ambos usan llama.cpp; los modelos son compatibles.

---

Casos de uso reales

Algunos escenarios que he usado yo.

Asistente de código local

Integra Ollama en VS Code o Cursor para escribir, explicar o refactorizar código. Recomiendo codellama o deepseek-coder.

Continue.dev y Aider se conectan a la API de Ollama. Configurados, tienes un asistente de código gratis en local.

Sistema de preguntas sobre documentación

Con muchos documentos, combina Ollama y una base vectorial para un knowledge base privado:

1. Embeddings con la API de Ollama
2. Almacenar vectores (Chroma, Qdrant, etc.)
3. Al preguntar, recuperar fragmentos relevantes
4. Pasarlos como contexto al modelo

Arquitectura RAG clásica, 100 % local; los datos no salen de la red interna.

Base de conocimiento privada

Documentos internos, material técnico, datos de clientes… no encajan en la nube. Ollama procesa todo en local y cumple requisitos de privacidad.

Escenarios offline

Viajes, trabajo de campo, red inestable… la IA en la nube no sirve; Ollama funciona sin conexión. Con batería, el asistente sigue activo.

Entorno de desarrollo y pruebas

Al desarrollar apps de IA, llamar a la API en la nube cuesta. Ollama como entorno de pruebas ahorra dinero; cuando todo funciona, pasas a producción en la nube.

---

Preguntas frecuentes

He tropezado con varios problemas; aquí van las soluciones que me funcionaron.

---

Para cerrar

En el fondo, la idea es simplificar los LLM locales. Ollama lo consigue: sin configuración compleja ni doctorado en IA, en minutos estás operativo. Gratis, offline y con privacidad de datos.

Próximos pasos:

• Probar distintos modelos y encontrar el que encaje contigo
• Integrar Ollama en tu flujo de desarrollo
• Explorar RAG y montar una base de conocimiento privada
• Desplegar en servidor y compartir IA en equipo

La era de la IA local ya está aquí. Con Ollama no dependes de la nube: modelos potentes en tu propia máquina. Empieza tu camino en IA local.

Autor: Easton (bloguero técnico, enfocado en desarrollo de IA y despliegue local)

---

Referencias:

• Sitio oficial de Ollama
• Ollama en GitHub
• Documentación de Ollama
• Biblioteca de modelos de Ollama