LLMs locales con Ollama — integración con Open WebUI · Continue.dev

Los LLMs en la nube (Claude, GPT, Gemini) son potentes, pero tienen desventajas: facturas mensuales, privacidad (el código de empresa sale de tu red) y dependencia de internet. Si tu máquina puede ejecutar un modelo suficientemente grande, la opción local se convierte en una alternativa real.

Esta guía ejecuta Llama 3.3 / Qwen 2.5 / DeepSeek-Coder etc. en macOS y Windows con Ollama, añade una UI estilo ChatGPT vía Open WebUI, e integra con VS Code a través de Continue.dev.

Dirigido a desarrolladores que usan un LLM a diario y evalúan la opción local por razones de coste o privacidad. Requisitos mínimos de hardware: M1 Pro o superior, o GPU con 16 GB+ de VRAM.

TL;DR

1. brew install ollama o descargar desde ollama.com
2. ollama pull llama3.3:70b, o el más ligero qwen2.5-coder:7b
3. ollama run qwen2.5-coder:7b → chat
4. ¿Quieres una UI? Open WebUI (Docker — menos de un minuto)
5. Integración con VS Code: instalar Continue.dev y registrar Ollama en ~/.continue/config.json

Requisitos previos

• Mac: M1 Pro o más nuevo + 16GB+ de memoria unificada (32GB recomendado)
• Windows / Linux: GPU NVIDIA con 8GB+ de VRAM (16GB+ recomendado), o una CPU potente + 32GB+ de RAM
• (Opcional) Docker — para Open WebUI

1. Cuándo encajan los LLMs locales

Buenos encajes

• Código sensible: la política de empresa prohíbe los LLMs en la nube (sanidad, finanzas, defensa)
• Uso intensivo: 1000+ solicitudes/día acumulan costes significativos con precios en la nube
• Offline: aviones, conexión inestable
• Experimentación: comparaciones de modelos, ajuste fino
• Automatización de baja latencia: bucles de respuesta de menos de 200 ms

Malos encajes

• Calidad de última generación: el nivel de Claude Opus / GPT-5 aún no está disponible localmente
• Hardware de baja especificación: Mac M1 con 8 GB o GPU de 4 GB; incluso los modelos de 7B responden lentamente
• Multimodal variado: las opciones de imágenes y audio son escasas en local
• Contexto largo: la ventana de 1M tokens de Claude es difícil de igualar localmente

Realidad: un modelo local de 70B está aproximadamente a la altura de GPT-4 en un subconjunto de tareas. Asistencia de codificación, resúmenes, traducción: bien. Razonamiento complejo: la nube sigue ganando.

2. Instalar Ollama

2.1 macOS

brew install ollama

O .dmg desde ollama.com/download.

Ejecutar como aplicación GUI o como servicio en segundo plano:

# Servicio en segundo plano (recomendado)
brew services start ollama

2.2 Windows

winget install Ollama.Ollama

O ollama.com/download.

Después de instalar, el icono de ollama aparece en la bandeja del sistema. Se ejecuta en segundo plano automáticamente.

2.3 Linux

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

2.4 Verificar

ollama --version            # ollama version 0.x.x
curl http://localhost:11434/api/version
# {"version":"0.x.x"}

3. Primer modelo: un asistente de codificación ligero

Comenzar con un modelo pequeño (descarga más rápida, respuestas más rápidas):

3.1 Qwen 2.5 Coder 7B

ollama pull qwen2.5-coder:7b      # 4.7GB
ollama run qwen2.5-coder:7b

Chat:

>>> Escribe una función Python para fusionar dos listas ordenadas.

/bye para salir.

3.2 Modelos más grandes (si tienes las especificaciones)

ollama pull llama3.3:70b
ollama run llama3.3:70b

Tiempo de descarga = tamaño del modelo ÷ ancho de banda. En 1 Gbps, 70B son ~6 minutos.

3.3 Gestionar modelos

ollama list                          # modelos instalados
ollama rm qwen2.5-coder:7b           # eliminar
ollama show llama3.3:70b             # metadatos

4. Open WebUI: interfaz estilo ChatGPT

Usar una interfaz en el navegador en lugar del CLI. Configuración de Docker en menos de un minuto.

4.1 Instalar

docker run -d -p 3000:8080 \
  --add-host=host.docker.internal:host-gateway \
  -v open-webui:/app/backend/data \
  --name open-webui \
  --restart always \
  ghcr.io/open-webui/open-webui:main

Configuración de Docker: /mac/docker-setup o /windows/docker-wsl2.

4.2 Primer uso

Navegador → http://localhost:3000 → crear la primera cuenta (solo local).

Ollama se detecta automáticamente. Elegir un modelo en el desplegable superior izquierdo y chatear.

4.3 Puntos fuertes

• Historial de conversaciones guardado
• Renderizado de Markdown y resaltado de sintaxis de código
• Chatear con múltiples modelos en paralelo (comparación)
• Carga de archivos + RAG (opcional)

5. Integración con VS Code: Continue.dev

5.1 Instalar la extensión

Extensiones de VS Code:

• Continue (Continue.continue)

O code --install-extension Continue.continue.

5.2 Registrar modelos de Ollama

~/.continue/config.json (crear si no existe):

{
  "models": [
    {
      "title": "Qwen Coder 7B",
      "provider": "ollama",
      "model": "qwen2.5-coder:7b"
    },
    {
      "title": "Llama 3.3 70B",
      "provider": "ollama",
      "model": "llama3.3:70b"
    }
  ],
  "tabAutocompleteModel": {
    "title": "Qwen Coder 7B",
    "provider": "ollama",
    "model": "qwen2.5-coder:7b"
  }
}

5.3 Usarlo

En VS Code:

• Cmd + I (Mac) / Ctrl + I (Win) — chat en línea
• Cmd + L / Ctrl + L — barra lateral de chat
• Tab — autocompletado (usa tabAutocompleteModel)

Continue.dev es una alternativa de código abierto a Cursor / Copilot. Además de modelos locales, también admite claves de Claude o GPT.

6. Optimización del rendimiento

6.1 GPU primero (NVIDIA / Apple Silicon)

Ollama usa la GPU automáticamente. Confirmar:

ollama ps
# NAME                  ID    SIZE  PROCESSOR
# qwen2.5-coder:7b     ...   5GB   100% GPU

¿No aparece GPU? Verificar:

• macOS: Apple Silicon es automático (Mac Intel solo usa CPU)
• NVIDIA: verificar el driver CUDA (nvidia-smi)

6.2 Elegir la cuantización del modelo

Cada modelo tiene variantes de cuantización (rendimiento ↔ calidad):

ollama pull qwen2.5-coder:7b-instruct-q4_K_M      # predeterminado (4-bit, recomendado)
ollama pull qwen2.5-coder:7b-instruct-q8_0         # 8-bit (más preciso, más grande)
ollama pull qwen2.5-coder:7b-instruct-fp16         # precisión completa (más preciso, más grande)

El formato 4-bit es el estándar: pérdida de calidad apenas perceptible con la mitad de la memoria.

6.3 Ampliar la longitud del contexto

El contexto predeterminado es 4K. Para extenderlo:

ollama run qwen2.5-coder:7b
>>> /set parameter num_ctx 16384

O un Modelfile:

FROM qwen2.5-coder:7b
PARAMETER num_ctx 16384

Más contexto = más memoria y respuestas más lentas.

7. Comparación de costes y consumo energético

7.1 Nube vs. local (aproximación mensual)

Hay que tener en cuenta el coste inicial del hardware (M2 Pro 32 GB ~2.500 $). El punto de equilibrio es de 1–2 años incluso para usuarios intensivos.

7.2 Consumo energético (aproximación)

• M2 Pro a plena carga: ~30 W → 24 h = 0,72 kWh/día → 22 kWh/mes × 0,15 $ = 3,3 $/mes
• NVIDIA 4090 a plena carga: ~450 W → 24 h continuas no es realista, pero uso intensivo real ~20–40 $/mes

Lo local solo consume energía mientras se usa. En reposo = 0.

8. Verificar

# 1. Ollama funcionando
ollama --version
curl http://localhost:11434/api/version
 
# 2. Modelo instalado
ollama list
 
# 3. Prueba de respuesta
echo "Escribe hola mundo en Rust" | ollama run qwen2.5-coder:7b
 
# 4. Open WebUI (si se está ejecutando)
curl http://localhost:3000
 
# 5. Continue.dev
code .   # En VS Code: Cmd+L → elegir modelo → chatear

9. Solución de problemas

ollama: command not found

• macOS: verificar que el prefijo de brew está en PATH (/opt/homebrew/bin).
• Windows: reiniciar PowerShell.
• Linux: ~/.ollama/bin o PATH del sistema.

Las respuestas son muy lentas

• ollama ps para confirmar el uso de GPU. Si la CPU está al 100%, la GPU no está reconocida.
• macOS Intel: sin aceleración GPU; se recomienda Apple Silicon.
• NVIDIA: verificar el driver CUDA y reiniciar Ollama.
• RAM insuficiente: tamaño del modelo ÷ 8 ≤ RAM disponible; de lo contrario la inferencia es muy lenta.

Error "Out of memory"

• El modelo supera la RAM / VRAM disponible.
• Probar un modelo más pequeño (:3b en lugar de :7b) o una cuantización menor (q4_K_M).
• Cerrar otras aplicaciones e intentarlo de nuevo.

Continue.dev no ve los modelos de Ollama

• Validar ~/.continue/config.json (jq . config.json).
• Reiniciar VS Code.
• Confirmar que Ollama está en ejecución (curl localhost:11434/api/version).

Bloquear acceso externo a Open WebUI

• El predeterminado es solo localhost: ya está bloqueado externamente.
• Si se expone públicamente, establecer WEBUI_AUTH=True (requiere registro).

Descarga del modelo interrumpida (fallo de red)

• Volver a ejecutar ollama pull: reanuda desde donde se detuvo.
• Verificar ~/.ollama/models/; si un archivo está corrupto, eliminarlo e intentarlo de nuevo.

10. Puntos de partida recomendados

Para empezar:

1. Mac M2 Pro 16 GB: qwen2.5-coder:7b + Continue.dev
2. Mac M2 Pro 32 GB: qwen2.5-coder:32b + Continue.dev + Open WebUI
3. Windows + RTX 4090: llama3.3:70b + Open WebUI
4. Solo CPU, 16 GB: phi3.5:3.8b (lento pero funcional)

Después de 3 meses, compara la satisfacción con el LLM en la nube que habrías pagado de otra manera y decide.

11. Qué sigue

• Configuración de Claude Code — /ai-agents/claude-code — contraparte en la nube
• Configuración de Cursor — /ai-agents/cursor-setup — Cursor también puede apuntar a Ollama
• Flujo de trabajo multi-herramienta — /ai-agents/multi-tool-workflow
• Servidores MCP — /ai-agents/mcp-servers — Ollama + MCP es posible

Referencias

• Ollama oficial
• Open WebUI
• Continue.dev
• Hugging Face — catálogo de modelos

Registro de cambios

• 2026-05-16: Primer borrador. Instalación de Ollama + comparación de modelos + Open WebUI + integración con Continue.dev + ajuste de rendimiento + comparación de costes + seis casos de solución de problemas.