Convierte tu PC en tu API de IA privada (Setup con Ollama y OpenCode)

Para este escenario voy a sacar provecho a la velocidad de inferencia pura y dura. El objetivo es exprimir la GPU del PC (una Nvidia RTX 5080) para que actúe como servidor de inferencia en red local, y conectarme a ella usando OpenCode desde el MacBook Pro.

Cero latencia de red externa y privacidad total. Para la prueba de fuego usaremos el modelo qwen2.5-coder:14b.

1. El Server: Configurando el PC

Lo primero es levantar Ollama en la máquina con Windows.

1. Instalamos Ollama para Windows.
2. Desde la terminal, bajamos el modelo que nos interesa:

PS C:\Users\juanma> ollama pull qwen2.5-coder:14b
pulling manifest
pulling ac9bc7a69dab... 100%
[...]
success

3. Comprobamos que está listo y vemos lo que pesa realmente en disco:

PS C:\Users\juanma> ollama list
NAME                    ID              MODIFIED            SIZE
qwen2.5-coder:14b       9ec8897f747e    About a minute ago  9.0 GB
deepseek-r1:32b         edba8017331d    21 hours ago        19 GB

4. Paso importante: Por defecto, Ollama solo escucha en localhost. Para que el Mac pueda comunicarse con el PC, necesitamos que Ollama escuche en la red local y que Windows Defender no corte la conexión. Desde una terminal con permisos de Administrador, lanzamos esto:

# 1. Le decimos a Ollama que escuche en todas las interfaces
[Environment]::SetEnvironmentVariable("OLLAMA_HOST", "0.0.0.0", "Machine")

# 2. Abrimos el puerto 11434 en el firewall
New-NetFirewallRule -DisplayName "Ollama Network Access" -Direction Inbound -LocalPort 11434 -Protocol TCP -Action Allow

Cerramos el icono de Ollama de la bandeja del sistema si estaba abierto, y levantamos el servicio a mano desde el terminal para ver los logs en tiempo real:

PS C:\Users\juanma> ollama serve

2. El Cliente: Conectando OpenCode desde el Mac

Sorprendentemente OpenCode no trae Ollama como proveedor nativo en la interfaz. Toca trastear en la configuración.

Abrimos el JSON de configuración en ~/.config/opencode/opencode.jsonc y añadimos a Ollama como proveedor compatible con OpenAI (Ollama expone una API REST compatible), apuntando a la IP local del PC (en mi caso, 192.168.1.35):

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama",
      "baseURL": "http://192.168.1.35:11434/v1",
      "apiKey": "ollama",
      "models": {
        "qwen2.5-coder:14b": {
          "name": "qwen2.5-coder:14b"
        }
      }
    }
  }
}

Guardamos, vamos a OpenCode, pulsamos Ctrl+P > Providers > Connect Provider, elegimos Ollama y listo. Ya podemos tirar prompts y ver en la terminal del PC cómo la gráfica se pone a escupir tokens como una ametralladora.

La bofetada de realidad: Límites de hardware

En este setup qwen2.5-coder:14b (9GB) vuela porque cabe entero en los 16GB de VRAM de la RTX 5080. Pero, ¿qué pasa si nos venimos arriba y cargamos algo como deepseek-r1:32b (19GB)?

Que no cabe. Ollama, de forma automática, hace offloading: mete lo que puede en la GPU y el resto lo descarga a la RAM normal del PC. El modelo sigue siendo funcional, pero el rendimiento cae en picado. El ancho de banda de una RTX es hasta 10 veces más rápido que el de la memoria DDR5.

Para lidiar con esto hay que tirar de modelos MoE (Mixture of Experts) que solo cargan partes de sus parámetros en memoria. Pero eso da para otro post.

Conclusión personal

Pros

• Velocidad de inferencia altísima y privacidad absoluta.
• Infinidad de modelos open weight gratis.
• Entorno perfecto para alimentar agentes locales pequeños o side-projects.

Contras

• Barrera de entrada del hardware: una GPU de gama alta no es barata.
• Estamos lejos de emular la capacidad de razonamiento de modelos frontera como Claude Opus.

Para picar código del día a día en pequeños proyectos, sobra. Para arquitectura compleja, sigo tirando de API de pago.