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.

💡 Transparencia: algunos enlaces a productos de este articulo son enlaces de afiliado de Amazon. Si compras a traves de ellos, Javadex recibe una pequena comision sin coste adicional para ti. Las recomendaciones salen de especificaciones y pruebas reales, nunca de la comision.

Guía escrita por Javier Santos Criado, consultor de IA en Javadex. Ollama es la vía más rápida para tener un modelo corriendo en tu máquina y también la más fácil de abandonar en la semana dos: se instala en cinco minutos y después llega la parte que casi nadie cuenta —cuánta RAM se come de verdad, qué cuantización elegir, y por qué el modelo que va fino en el portátil se arrastra en el servidor—. Esa segunda parte es la que cubre esta guía.

¿Quieres desplegar Ollama en tu empresa sin filtrar datos a OpenAI? Diseño la arquitectura completa (VPS o servidor propio, modelos, RAG, API interna) y formo al equipo. Cuéntame el caso en 30 min →

¿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)

Esos mínimos te dejan arrancar, pero el tamaño de modelo que puedes mover lo decide el hardware. Si vas a comprar equipo para esto, mira los mejores mini PC para IA local —hay opciones desde 320 EUR que mueven modelos de 7B con soltura— o la comparativa de mejores GPUs para IA si necesitas VRAM para modelos de 30B o más. Con presupuesto ajustado, el ranking de mini PC baratos por menos de 500 EUR lleva benchmarks medidos con Ollama.

Y si el modelo que tienes en mente es Qwen 3.8, la tabla de VRAM por cuantización con el KV cache incluido está en los requisitos de hardware de Qwen 3.8 en local: con 16 GB se queda más justo de lo que parece sobre el papel.

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#

Antes de tocar parametros conviene ser honesto con el hardware: Ollama no hace milagros y el 90% de los problemas de lentitud se resuelven con mas memoria, no con mas configuracion. Si vas a dejar un equipo encendido para esto, un mini PC dedicado sale mas barato que actualizar el portatil. El GMKtec G10 es el escalon de entrada y cumple si te vale con modelos de 7B — es el que tengo yo, y da unos 5 tokens/s con Qwen en Q4. Si quieres llegar a los 14B y 32B sin pelearte con la memoria, el salto es a 64 GB de doble canal, como el Beelink SER10 Max. Y para un 70B en local la unica via asequible es un Ryzen AI MAX+ 395, donde la GPU integrada comparte toda la memoria del sistema: GMKtec EVO-X2 o Minisforum MS-S1 MAX. Dicho eso, todo lo que viene a continuacion funciona igual en el equipo que ya tienes.

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. Si quieres desplegar Ollama en un servidor accesible desde cualquier sitio sin depender de tu red doméstica, un VPS modesto (unos 8 GB de RAM) es suficiente para servir modelos de hasta 7B parámetros con tráfico moderado.

¿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.

Si vas a comprar hardware para esto, el escalón que cambia lo que puedes hacer son los 16 GB de VRAM: la forma más barata de tenerlos es una RTX 5060 Ti de 16 GB a 679,99 EUR (verificado el 17 de agosto de 2026). Si prefieres un equipo ya montado y encendido 24/7, el GMKtec G10 a 288,95 EUR mueve modelos de 7B con 10 W en reposo. La comparación completa está en qué torre montar para IA local en 2026.

¿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!

Posts Relacionados#

• Mejores Modelos IA Marzo 2026: Ranking y Comparativa - Descubre cuales son los mejores LLMs para ejecutar con Ollama en marzo 2026
• Mejor Inteligencia Artificial 2026: Ranking Completo - Ranking por categoria

¿Quieres IA local en tu empresa (sin que tu equipo toque nada técnico)?#

Probar IA local en tu portátil lleva 5 minutos. Tener IA local funcionando para todo tu equipo —que cada persona le pregunte a los documentos de la empresa, conectada a vuestras herramientas, sin que los datos salgan y con control de quién accede a qué— es otra cosa. Y justo ahí es donde muchos negocios se atascan meses.

Eso no lo montas tú: te lo monto yo, llave en mano. Lo que recibes:

1. IA local lista para usar, en la infraestructura de tu empresa o en un servidor europeo bajo tu control. Tú no tocas nada técnico.
2. Que pregunte a tus propios documentos (contratos, manuales, expedientes) y responda con la fuente.
3. Tu marca, tus datos en Europa, sin quedar atado a ningún proveedor.
4. Formación a tu equipo para que lo usen sin depender de mí.

Eso es exactamente tu plataforma de IA privada (Cortex) y lo que cuento en IA local para empresa. Para hacerte una idea del presupuesto, mira cuánto cuesta implantar IA en una empresa española. Si el caso es real (no "lo quiero probar"), cuéntame tu caso y te respondo en menos de 24 h.

En Resumen#

• Ollama es una herramienta open source que permite ejecutar LLMs (Large Language Models) en local sin conexión a internet, sin costes de API y con privacidad total, disponible para macOS, Linux y Windows
• Requisitos mínimos: 4GB RAM (8GB recomendado, 16GB+ para modelos grandes), 20GB de almacenamiento libre, cualquier CPU moderna; GPU NVIDIA/AMD/Apple Metal acelera la inferencia entre 5x y 10x
• Modelos soportados: Llama 3 70B (Meta, ~40GB VRAM), Mistral 7B (~4GB, mejor equilibrio calidad/velocidad), Gemma 7B (Google), Neural Chat 7B, Orca 2 13B, y +50 modelos adicionales
• Instalación en un comando: brew install ollama (macOS), curl https://ollama.ai/install.sh | sh (Linux), o instalador .exe (Windows); ejecutar un modelo con ollama run mistral
• API REST compatible con OpenAI: Ollama expone un servidor en localhost:11434 que permite integrar modelos locales en cualquier aplicación existente sin cambios de código
• Rendimiento real: En una RTX 4090, Mistral 7B genera ~10-15 tokens/segundo; en CPU pura tarda ~30 segundos por respuesta vs ~3 segundos con GPU
• Modelos personalizados con Modelfile: Permite crear modelos especializados (experto en IA, programador Python, etc.) definiendo system prompts, temperatura y parámetros de generación, similar a un Dockerfile para IA