Ollama: Guía Completa para Ejecutar Modelos de IA en Local [2026]

En 2026, ejecutar modelos de inteligencia artificial en tu máquina local se ha convertido en más accesible que nunca. Ollama es la herramienta que ha democratizado este acceso, permitiendo a cualquiera ejecutar LLMs poderosos sin depender de APIs de terceros, conexión a internet constante, o gastar dinero en servicios en la nube.

En esta guía completa, te mostraré cómo instalar Ollama, ejecutar modelos como Llama 3 y Mistral, crear modelos personalizados, y aprovechar al máximo esta tecnología en tus proyectos.

¿Qué es Ollama y por qué deberías usarlo?

Ollama es una herramienta de código abierto que simplifica la instalación y ejecución de modelos de lenguaje grandes (LLMs) en tu máquina local. Creada para desarrolladores y entusiastas de IA, Ollama elimina la complejidad técnica de optimización de GPU, manejo de memoria, y configuración.

Ventajas principales de Ollama

Privacidad total: Tu información nunca sale de tu máquina. No hay servidores remotos, no hay historial recopilado por terceros. Esto es crítico si trabajas con datos sensibles, clientes confidenciales, o simplemente valoras tu privacidad.

Sin costos de API: ChatGPT cuesta $20/mes si usas Plus. Las APIs de OpenAI cobran por token. Ollama ejecuta todo localmente, después de la descarga inicial, a costo cero (solo CPU/GPU de tu máquina).

Funciona sin internet: Una vez descargado el modelo, puedes usar Ollama completamente offline. Perfecto para trabajar en trenes, aviones, o lugares sin conectividad confiable.

Modelos de código abierto de calidad: Llama 3, Mistral, Gemma, Orca, y Neural Chat son modelos de alto rendimiento, muchos de ellos rivalizando con GPT-3.5 en tareas específicas.

Integración sencilla: Ollama expone una API REST compatible con OpenAI, permitiendo que cualquier aplicación existente funcione sin cambios.

Desventajas realistas

No es perfecto. Ollama requiere recursos: si tu máquina tiene 4GB de RAM, funcionará pero lentamente. Los modelos más pequeños (Mistral 7B) requieren ~4GB; modelos grandes como Llama 3 70B necesitan GPUs con VRAM significativa.

La velocidad de respuesta es más lenta que servicios cloud con GPUs especializadas. En una GPU consumer como RTX 4090, Llama 3 genera ~10-15 tokens/segundo. OpenAI en servidores cloud es más rápido.

El conocimiento está limitado a la fecha de entrenamiento del modelo. No tiene acceso a internet en tiempo real para consultas actuales.

Instalación de Ollama: Paso a Paso

Requisitos del sistema

Ollama funciona en macOS, Linux, y Windows (via WSL). Los requisitos mínimos son:

• RAM: 4GB mínimo (8GB recomendado, 16GB+ para modelos grandes)
• Almacenamiento: 20GB libres mínimo
• Procesador: Cualquier CPU moderna; GPU NVIDIA/AMD/Metal aceleran significativamente
• Internet: Solo para descargar modelos (después offline completo)

Descarga e instalación

Visita ollama.ai y descarga el instalador para tu sistema operativo.

En macOS:

1# Descarga automática desde el sitio web, o usa Homebrew:
2brew install ollama

En Linux:

1curl https://ollama.ai/install.sh | sh

En Windows:

Descarga el instalador .exe desde ollama.ai. Se instala en C:\Users\[nombre]\AppData\Local\Ollama\.

Después de instalar, abre una terminal y verifica:

1ollama --version
2# Output: ollama version 0.3.14

Descargando tu primer modelo

Ollama usa el comando pull para descargar modelos. El flujo es simple:

1ollama pull llama2

Esto descarga el modelo Llama 2 (7B parámetros, ~4GB). El modelo se almacena en ~/.ollama/models/ y se puede reutilizar infinitamente.

Modelos populares en 2026

Llama 3 70B - El modelo más potente de Meta. Excelente para tareas complejas, razonamiento, y escritura. Requiere ~40GB VRAM.

1ollama pull llama3:70b

Mistral 7B - Equilibrio perfecto entre calidad y velocidad. Rápido, competente, y ejecutable en hardware consumer. Mi recomendación para la mayoría.

1ollama pull mistral

Gemma 7B - El modelo ligero de Google. Excelente para chatbots simples y tareas de clasificación.

1ollama pull gemma:7b

Neural Chat 7B - Especializado en conversación natural. Muy bueno para aplicaciones interactivas.

1ollama pull neural-chat

Orca 2 13B - Buena relación entre tamaño y capacidad de razonamiento. Modelo versátil.

1ollama pull orca2

Estrategia de descarga inteligente

Descargar modelos toma tiempo (depende de tu conexión). Descarga modelos de noche o cuando no necesites tu ancho de banda.

1# Ver modelos descargados
2ollama list
3 
4# Eliminar un modelo para liberar espacio
5ollama rm llama2

Usando Ollama: Tu primer chatbot

Ejecución interactiva

Una vez descargado un modelo, inicialo con:

1ollama run mistral

Esto abre una sesión interactiva donde escribes prompts y recibes respuestas:

1>>> Explica brevemente qué es machine learning
2 
3Machine learning es un subcampo de la inteligencia artificial que se centra
4en el desarrollo de algoritmos y técnicas que permiten a las máquinas
5aprender de los datos sin ser programadas explícitamente...
6 
7>>> /bye

Escribe /bye para salir de la sesión.

Usando la API REST

Para aplicaciones de verdad, necesitas la API. Ollama expone un servidor REST en localhost:11434 automáticamente:

1# En una terminal, inicia Ollama en modo servidor
2ollama serve
3# Listening on 127.0.0.1:11434

En otra terminal, consulta la API:

1curl http://localhost:11434/api/generate -d '{
2  "model": "mistral",
3  "prompt": "¿Cuál es el mejor lenguaje de programación para empezar?",
4  "stream": false
5}'

Respuesta (formateado):

1{
2  "model": "mistral",
3  "created_at": "2026-02-08T15:32:00Z",
4  "response": "Para un principiante, Python es generalmente la mejor opción porque...",
5  "done": true,
6  "total_duration": 2500000000,
7  "load_duration": 800000000,
8  "prompt_eval_duration": 450000000,
9  "eval_duration": 1250000000,
10  "eval_count": 87
11}

Integrando con Python

La integración más común es con Python. Usa requests para consultar Ollama:

1import requests
2import json
3 
4def chat_with_ollama(prompt: str, model: str = "mistral"):
5    """Envía un prompt a Ollama y retorna la respuesta."""
6 
7    response = requests.post(
8        "http://localhost:11434/api/generate",
9        json={
10            "model": model,
11            "prompt": prompt,
12            "stream": False,
13        }
14    )
15 
16    if response.status_code == 200:
17        return response.json()["response"]
18    else:
19        return f"Error: {response.status_code}"
20 
21# Uso
22respuesta = chat_with_ollama("¿Cómo puedo aprender IA?")
23print(respuesta)

Para streaming (respuestas en tiempo real):

1import requests
2import json
3 
4def stream_chat(prompt: str, model: str = "mistral"):
5    """Streaming de respuestas de Ollama."""
6 
7    response = requests.post(
8        "http://localhost:11434/api/generate",
9        json={
10            "model": model,
11            "prompt": prompt,
12            "stream": True,
13        },
14        stream=True
15    )
16 
17    for line in response.iter_lines():
18        if line:
19            data = json.loads(line)
20            print(data.get("response", ""), end="", flush=True)
21    print()
22 
23# Uso
24stream_chat("Escribe un poema sobre Python")

Creando modelos personalizados con Modelfile

La verdadera potencia de Ollama es la capacidad de crear modelos personalizados usando Modelfiles. Un Modelfile es como un Dockerfile para modelos IA.

Ejemplo: Creando un especialista en IA

Crea un archivo Modelfile (sin extensión):

1FROM mistral
2 
3# Configura el sistema para ser especialista en IA
4SYSTEM Eres un experto en inteligencia artificial, machine learning y deep learning.
5Tu objetivo es explicar conceptos complejos de forma clara y práctica.
6Siempre proporciona ejemplos de código cuando sea relevante.
7Responde en español, usando terminología técnica precisa pero accesible.
8 
9# Parámetros de comportamiento
10PARAMETER temperature 0.7
11PARAMETER num_predict 512

Construye el modelo:

1ollama create ia-expert -f Modelfile

Úsalo:

1ollama run ia-expert "¿Qué es fine-tuning y cuándo se usa?"

Configuración avanzada con Modelfile

1FROM llama3:70b
2 
3# Instrucciones del sistema
4SYSTEM Eres un programador Python experto. Ayudas a otros desarrolladores
5a escribir código limpio, eficiente y bien documentado.
6 
7# Parámetros de generación
8PARAMETER temperature 0.3        # Más enfocado, menos creativo
9PARAMETER top_p 0.9
10PARAMETER top_k 40
11PARAMETER num_predict 1024       # Máximo de tokens a generar
12PARAMETER repeat_penalty 1.1     # Evita repetición
13 
14# Parámetros contextuales
15PARAMETER num_ctx 4096           # Ventana de contexto
16 
17# Template personalizado (raro, pero posible)
18TEMPLATE [INST] {{ .Prompt }} [/INST]

Optimización de GPU y rendimiento

NVIDIA CUDA

Si tienes una GPU NVIDIA, Ollama automáticamente usa CUDA (si está instalado):

1# Verifica que NVIDIA CUDA Toolkit esté instalado
2nvcc --version
3 
4# Ollama detecta automáticamente y usa GPU
5ollama run mistral
6# Loaded in 1.2s (GPU acceleration active)

AMD ROCm

Para AMD:

1# Linux con ROCm
2export HSA_OVERRIDE_GFX_VERSION=gfx90a  # Ajusta según tu GPU
3ollama run mistral

macOS con Metal

En macOS, Ollama automáticamente usa Metal GPU acceleration. Sin configuración extra necesaria.

Monitoreando GPU

1# En una terminal, monitorea uso de GPU en tiempo real
2nvidia-smi -l 1  # Actualiza cada 1 segundo
3 
4# O en macOS
5# Activity Monitor → GPU tab

Comparación: Ollama vs LM Studio vs Alternatives

LM Studio es mejor para: Usuarios no-técnicos, UI visual, experimentación rápida.

Integrando Ollama con Open WebUI

Open WebUI proporciona una interfaz web tipo ChatGPT para Ollama:

1# Con Docker (recomendado)
2docker run -d -p 3000:8080 \
3  -e OLLAMA_API_BASE_URL=http://host.docker.internal:11434/api \
4  --name open-webui \
5  ghcr.io/open-webui/open-webui:latest
6 
7# Accede en http://localhost:3000

Luego selecciona Ollama como backend, elige tu modelo, y ¡tienes ChatGPT en casa!

Casos de uso prácticos en 2026

1. Automatización de documentación

1from ollama import Client
2 
3client = Client(host='http://localhost:11434')
4 
5def generar_documentacion_api(nombre_funcion: str, codigo: str):
6    """Genera documentación automática para funciones."""
7 
8    prompt = f"""Genera documentación estilo docstring para esta función Python:

{codigo}

1Incluye descripción, parámetros, y ejemplo de uso."""
2 
3    response = client.generate(
4        model="mistral",
5        prompt=prompt,
6        stream=False
7    )
8    return response['response']
9 
10# Uso
11codigo = '''
12def validar_email(email: str) -> bool:
13    import re
14    patron = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}___CODE_BLOCK_26___#039;
15    return bool(re.match(patron, email))
16'''
17 
18doc = generar_documentacion_api("validar_email", codigo)
19print(doc)

2. Clasificación de textos sin entrenar

1def clasificar_sentimiento(texto: str):
2    """Clasifica sentimiento sin ML training."""
3 
4    prompt = f"""Clasifica el sentimiento del siguiente texto como POSITIVO, NEUTRAL, o NEGATIVO.
5Responde SOLO con la clasificación, nada más.
6 
7Texto: "{texto}"
8Clasificación:"""
9 
10    response = requests.post(
11        "http://localhost:11434/api/generate",
12        json={"model": "mistral", "prompt": prompt, "stream": False}
13    )
14 
15    return response.json()["response"].strip()
16 
17# Uso
18print(clasificar_sentimiento("Me encanta este producto, superó mis expectativas"))
19# Output: POSITIVO

3. Extracción de entidades

1def extraer_datos_contrato(texto_contrato: str):
2    """Extrae información clave de contratos."""
3 
4    prompt = f"""Extrae del siguiente contrato:
51. Fecha de inicio
62. Fecha de fin
73. Monto del contrato
84. Partes involucradas
9 
10Responde en formato JSON.
11 
12Contrato:
13{texto_contrato}
14 
15JSON:"""
16 
17    response = requests.post(
18        "http://localhost:11434/api/generate",
19        json={"model": "llama3:70b", "prompt": prompt, "stream": False}
20    )
21 
22    import json
23    return json.loads(response.json()["response"])

Mejores prácticas y tips

Mantén modelos actualizados: De vez en cuando, ejecuta ollama pull [modelo] para obtener actualizaciones.

Usa el modelo correcto para cada tarea: Mistral 7B es rápido; Llama 3 70B es potente. Elige según tus necesidades.

Monitorea consumo de RAM: Ten un monitor de sistema abierto si trabajas con modelos grandes.

Experimenta con parámetros: Temperature afecta creatividad (0.1 = enfocado, 1.0 = creativo). Ajusta según tu caso.

Cachea respuestas: Si haces la misma pregunta múltiples veces, cachea localmente.

1import json
2from pathlib import Path
3 
4cache_file = Path("cache.json")
5 
6def respuesta_con_cache(prompt: str, model: str = "mistral"):
7    # Intenta cargar del cache
8    if cache_file.exists():
9        with open(cache_file) as f:
10            cache = json.load(f)
11            if prompt in cache:
12                return cache[prompt]
13    else:
14        cache = {}
15 
16    # Si no está en cache, consulta Ollama
17    response = requests.post(
18        "http://localhost:11434/api/generate",
19        json={"model": model, "prompt": prompt, "stream": False}
20    )
21    resultado = response.json()["response"]
22 
23    # Guarda en cache
24    cache[prompt] = resultado
25    with open(cache_file, "w") as f:
26        json.dump(cache, f)
27 
28    return resultado

Preguntas frecuentes

¿Ollama envía datos a servidores remotos?

No. Ollama es completamente local. Los modelos se descargan una sola vez de Hugging Face o registros similares, pero después todo funciona offline. Tu privacidad está garantizada.

¿Cuál es el modelo más pequeño y rápido?

Mistral 7B es el mejor equilibrio. Orca Mini 3B es aún más pequeño (~2GB) pero menos capaz. Para máquinas muy limitadas, prueba Phi 2.7B.

¿Puedo usar Ollama en producción?

Sí, pero con consideraciones. Ollama no es un servidor production-ready completo (sin autenticación, rate limiting, etc.). Usa un reverse proxy como Nginx en frente para producción.

¿Ollama funciona sin GPU?

Sí, pero es significativamente más lento. Una GPU acelera respuestas 5-10x. En CPU, Mistral 7B tarda ~30 segundos por respuesta; en GPU NVIDIA, ~3 segundos.

¿Cómo comparto un modelo personalizado con otros?

Pushea a Ollama Registry:

1ollama push tu-usuario/tu-modelo
2ollama pull tu-usuario/tu-modelo  # Otros descargan así

Ollama ha revolucionado el acceso a IA local. Con esta guía, estás equipado para ejecutar modelos potentes en tu máquina, construir aplicaciones, y experimentar sin límites de API. ¡Comienza ahora!