Ejecutando IA local en Linux con Ollama

Ejecutar modelos de IA en local dejó de ser cosa de laboratorio: con Ollama descargas y ejecutas LLMs en tu propio Linux, sin enviar datos a la nube y sin pagar por token. Este post cuenta de dónde vino el proyecto — el origen explica muchas cosas de su diseño — y muestra cómo instalar, ajustar y usar de verdad.

¿De dónde vino Ollama?

Para entender por qué Ollama se parece tanto a Docker, basta mirar quién lo escribió. Jeff Morgan e Michael Chiang son dos canadienses que se conocieron en la Universidad de Waterloo y, antes de todo esto, crearon Kitematic — la interfaz que hacía Docker utilizable por gente normal. Docker compró el proyecto en 2015, y aquello se convirtió en lo que hoy se llama Docker Desktop.

La pareja pasó por Y Combinator en la promoción de invierno de 2021 y, en 26 de junio de 2023, abrió el repositorio de Ollama. La tesis era la misma de Kitematic, cambiando contenedor por modelo: existe una tecnología potente y tediosa de operar, y alguien necesita envolverla en un solo comando.

De ahí viene todo lo que parece familiar. Haces pull de un modelo de un registro. Describes tu modelo en un archivo llamado Modelfile, que es un Dockerfile con otro nombre. Listas lo que hay instalado con list y borras con rm. Nada de esto es casualidad.

Cifras de septiembre de 2026: escrito en Go, licencia MIT, más de 180 mil estrellas en GitHub y alrededor de 9 millones de desarrolladores usándolo. En julio de 2026 la empresa — de apenas 14 personas — levantó una serie B de US$ 65 millones liderada por Theory Ventures, alcanzando US$ 88 millones en total, con Benchmark y el propio Y Combinator en la lista.

Un detalle técnico importante de la trayectoria: hasta 2025 Ollama era, en el fondo, una cáscara sobre el llama.cpp. En mayo de ese año el proyecto lanzó motor propio, construido sobre la biblioteca de tensores GGML, porque dar soporte a un modelo multimodal parcheando llama.cpp se había vuelto insostenible. Hoy cada modelo es autosuficiente e incluye su propia capa de proyección, pero GGML sigue ahí debajo, por compatibilidad con la CPU.

¿Por qué ejecutar IA en local?

• Privacidad: tus datos no salen de la máquina, algo decisivo para código propietario, documentos internos y cualquier cosa bajo el RGPD.
• Coste cero por uso: después de descargar el modelo, ejecútalo cuantas veces quieras.
• Funciona sin conexión: útil en una red restringida, un laboratorio aislado y un servidor sin salida a Internet.
• Sin límite de tasa: ningún “has superado la cuota” en mitad de un procesamiento por lotes.

Y la otra cara, que es justo reconocer: la calidad no es la misma. Un modelo de 8B ejecutándose en tu GPU no sustituye a un modelo de frontera. Para tareas mecánicas (resumir, clasificar, extraer, reformatear) la diferencia desaparece. Para razonamiento difícil, no.

Requisitos reales: la memoria manda

La cuenta práctica: un modelo cuantizado de 4 bits ocupa aproximadamente 0,6 GB por cada mil millones de parámetros, más algo de holgura para el contexto. Traduciendo:

Tamaño del modelo	VRAM o RAM necesaria	Sirve para
1B – 3B	~2–4 GB	Clasificar, extraer, autocompletar; funciona incluso en CPU
7B – 8B	~6–8 GB	El punto óptimo de relación calidad-precio para uso general
14B	~10–12 GB	Código y razonamiento, con tarjeta de 12 GB o más
32B	~20–24 GB	Necesita tarjeta grande; calidad mucho mejor
70B+	40 GB o más	Dos GPUs o mucha paciencia con offload a RAM

Si el modelo no cabe en la VRAM, Ollama tira el excedente a la RAM del sistema y sigue funcionando — solo que lento. Si quieres saber dónde invertir, mira el servidor de IA reacondicionado con 64 GB de VRAM y la Tesla V100 de 32 GB.

Instalación

Instalación en una línea, directamente desde el sitio oficial:

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

El instalador crea el servicio systemd ollama y detecta la GPU automáticamente. Compruébalo:

systemctl status ollama
ollama --version
nvidia-smi        # a GPU foi vista?

Si prefieres un contenedor — útil para aislar la instalación o ejecutarla en un servidor ya contenedorizado:

docker run -d --gpus=all -v ollama:/root/.ollama -p 11434:11434 
  --name ollama ollama/ollama

docker exec -it ollama ollama run qwen2.5-coder

Descargando y ejecutando un modelo

# baixa e já abre o chat interativo
ollama run llama3.2

# só baixar, sem abrir o chat
ollama pull qwen2.5-coder

# tamanho específico
ollama pull llama3.2:3b

# listar o que está instalado, com tamanho
ollama list

# ver o que está carregado na memória agora
ollama ps

# uma pergunta só, direto do shell — ótimo para script
ollama run llama3.2 "explique o comando: tar czf backup.tar.gz /etc"

# ler um arquivo e mandar para o modelo
ollama run llama3.2 "resuma os erros deste log" < /var/log/syslog

Dentro del chat interactivo, /bye sal, /clear olvida la conversación y /set verbose pasa a mostrar la velocidad en tokens por segundo — la métrica que quieres observar al comparar modelos.

Para máquinas modestas, prefiere las variantes más pequeñas. Para programar, las familias coder se comportan visiblemente mejor que los modelos generalistas del mismo tamaño.

El Modelfile: la herencia de Docker

Aquí aparece el origen de los creadores al completo. Personalizas un modelo declarando lo que quieres en un archivo de texto — la misma lógica que un Dockerfile:

FROM qwen2.5-coder:7b

# temperatura baixa = respostas mais previsíveis
PARAMETER temperature 0.2
PARAMETER num_ctx 8192

SYSTEM """
Você é um assistente de sysadmin Linux. Responda em português do Brasil,
sempre com o comando pronto para colar. Avise quando o comando for
destrutivo. Não invente flag que você não tem certeza que existe.
"""

ollama create sysadmin -f ./Modelfile
ollama run sysadmin

Es la forma más rápida de transformar un modelo genérico en una herramienta con la pinta de tu trabajo — y el resultado queda guardado como un modelo local tuyo, que puedes listar, ejecutar y borrar como cualquier otro.

Uso mediante la API

Ollama levanta una API HTTP local en el puerto 11434. La nativa:

curl http://localhost:11434/api/generate -d '{
  "model": "llama3.2",
  "prompt": "Explique o comando: tar czf backup.tar.gz /etc",
  "stream": false
}'

Y — lo que resuelve la vida de quien ya tiene código listo — también habla el protocolo de OpenAI. Cualquier aplicación o SDK que use la API de OpenAI pasa a apuntar a tu máquina cambiando solo la URL:

from openai import OpenAI

client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")

resposta = client.chat.completions.create(
    model="llama3.2",
    messages=[{"role": "user", "content": "Escreva uma unit systemd para um script em /opt/job.sh"}],
)
print(resposta.choices[0].message.content)

Los ajustes que importan

El estándar funciona, pero casi nunca es lo que quieres en un servidor. La configuración va en systemd:

sudo systemctl edit ollama

[Service]
# escutar na rede, não só no localhost
Environment="OLLAMA_HOST=0.0.0.0:11434"

# guardar os modelos num disco maior
Environment="OLLAMA_MODELS=/dados/ollama"

# manter o modelo carregado (padrão: 5 minutos)
Environment="OLLAMA_KEEP_ALIVE=30m"

# quantas requisições atender em paralelo
Environment="OLLAMA_NUM_PARALLEL=4"

# quantos modelos diferentes manter na memória ao mesmo tempo
Environment="OLLAMA_MAX_LOADED_MODELS=2"

sudo systemctl daemon-reload && sudo systemctl restart ollama

Aviso de seguridad: Ollama no tiene autenticación. Al cambiar la OLLAMA_HOST para 0.0.0.0 abres la puerta 11434 para cualquiera que alcance la máquina — y quien alcance puede usar tu GPU y leer tus conversaciones. En un servidor expuesto, pon un proxy inverso con autenticación delante y cierra el 11434 en el firewall.

Ollama, llama.cpp o vLLM?

	Ollama	llama.cpp	vLLM
Para quien	Uso personal y equipo pequeño	Quién quiere control fino	Servicio multiusuario en producción
Facilidad	Un comando y funciona	Requiere compilar y ajustar	Requiere planificar VRAM
Formato	GGUF, mediante registro propio	GGUF	Pesos de Hugging Face
El modelo no cabe	Hace offload a la RAM	Hace offload a la RAM	Necesita --cpu-offload-gb
Rendimiento bajo carga	Cae rápido	Cae rápido	Es el objetivo del proyecto

Resumiendo: si eres tú en tu máquina, Ollama. Si es una API que varias personas o varios agentes van a consumir al mismo tiempo, el camino es el vLLM.

Mantenimiento y limpieza

El modelo ocupa varios GB y desaparece del radar. De vez en cuando:

ollama list                 # o que eu tenho mesmo?
ollama rm llama3.2          # apagar um
du -sh ~/.ollama/models     # quanto isso está comendo de disco

Los modelos están en ~/.ollama/models cuando lo ejecutas como usuario, y en /usr/share/ollama/.ollama/models cuando se ejecuta como servicio.

Línea de tiempo

• 2015 — Docker compra Kitematic, de Jeff Morgan y Michael Chiang; el proyecto se convierte en la base de Docker Desktop.
• Invierno de 2021 — la pareja pasa por Y Combinator.
• 26 de junio de 2023 — el repositorio de Ollama se crea, en Go y bajo licencia MIT, como una capa sobre llama.cpp.
• Mayo de 2025 — el proyecto lanza un motor propio sobre la biblioteca GGML, para hacer frente a los modelos multimodales.
• Julio de 2026 — serie B de US$ 65 millones liderada por Theory Ventures; el total recaudado alcanza los US$ 88 millones, con cerca de 9 millones de desarrolladores usándolo.
• Septiembre de 2026 — más de 180 mil estrellas en GitHub; la línea estable es la 0.33.

Cerrando

El mérito de Ollama no es técnico — llama.cpp ya hacía inferencia local antes que él. El mérito es de empaquetado: dos tíos que ya habían hecho exactamente eso con Docker miraron a los LLMs y transformaron un proceso de compilar, convertir y ajustar parámetros en ollama run. Es la misma lección de Kitematic, diez años después.

Para continuar: asistentes de IA en la terminal Linux muestra cómo conectarlo en tu flujo de trabajo, y GPU vs TPU explica qué está ocurriendo en el hardware mientras el modelo responde.

Enlaces oficiales: ollama.com · documentación · github.com/ollama/ollama · releases