---
title: Cómo configurar Gemma 4 con OpenCode usando Ollama (Guía 2026)
description: >-
  Ejecuta Gemma 4 de Google en local y conéctalo a OpenCode como tu asistente de
  programación en terminal. Guía completa de configuración de Ollama + OpenCode
  para Mac.
date: 2026-04-04T00:00:00.000Z
location: 'San Francisco, CA – 4 de abril de 2026'
image: /images/gemma-4-ollama-opencode-setup-hero.jpg
keywords: >-
  gemma 4 opencode, ollama gemma 4, modelo local opencode, configuración gemma 4
  ollama, ejecutar gemma 4 en local, guía opencode ollama
faq:
  - question: ¿Puedo usar Gemma 4 como modelo local en OpenCode?
    answer: >-
      Sí. Instala Ollama, descarga el modelo gemma4 y añade Ollama como
      proveedor personalizado en ~/.config/opencode/opencode.jsonc usando el
      adaptador @ai-sdk/openai-compatible con baseURL
      http://localhost:11434/v1.. Usa /models en OpenCode para cambiar a él.
  - question: ¿Cuánta RAM necesita Gemma 4 para funcionar con OpenCode?
    answer: >-
      El modelo Gemma 4 8B por defecto usa unos 9,6 GB cuando se carga mediante
      Ollama. Un Mac con 16 GB de memoria unificada lo ejecuta cómodamente junto
      a OpenCode. La variante de 26B necesita más de 24 GB y no se recomienda
      para la mayoría del hardware de consumo.
  - question: >-
      ¿Es Gemma 4 lo suficientemente rápido para programación interactiva en
      OpenCode?
    answer: >-
      En Apple Silicon con Ollama v0.19+, Gemma 4 8B ofrece velocidades de
      respuesta utilizables gracias al backend MLX. Gestiona bien el
      autocompletado de código, las explicaciones y las ediciones sencillas.
      Para tareas complejas que requieran razonamiento de vanguardia, añade
      Haimaker como segundo proveedor para acceder a modelos en la nube.
locale: es-es
translationKey: gemma-4-ollama-opencode-setup
---
OpenCode es un asistente de programación para terminal que funciona con cualquier API compatible con OpenAI. Conecta OpenCode a una instancia local de Ollama que ejecute Gemma 4 y tendrás un asistente de programación gratuito que nunca envía tu código a ningún sitio.

Así se configura en un Mac con Apple Silicon: instala Ollama, descarga Gemma 4 y conéctalo a OpenCode.

## Qué necesitas

- Mac con Apple Silicon (M1/M2/M3/M4/M5) y al menos 16 GB de memoria unificada
- macOS con Homebrew instalado
- OpenCode instalado (consulta [opencode.ai](https://opencode.ai) o instálalo mediante tu gestor de paquetes)

El modelo Gemma 4 8B por defecto usa unos 9,6 GB una vez cargado, así que 16 GB de memoria unificada te dan espacio suficiente para ejecutar Ollama y OpenCode sin problemas.

## Paso 1: Instalar Ollama

```bash
brew install --cask ollama-app
```

Esto instala `Ollama.app` en `/Applications/` y el CLI `ollama` en `/opt/homebrew/bin/ollama`.

## Paso 2: Iniciar Ollama

```bash
open -a Ollama
```

Espera a que aparezca el icono en la barra de menús y luego comprueba que el servidor está en marcha:

```bash
ollama list
```

## Paso 3: Descargar Gemma 4

```bash
ollama pull gemma4
```

Descarga unos 9,6 GB. Verifica:

```bash
ollama list
# NAME             ID              SIZE      MODIFIED
# gemma4:latest    ...             9.6 GB    ...
```

Pruébalo:

```bash
ollama run gemma4:latest "Hello, what model are you?"
```

Comprueba la aceleración por GPU:

```bash
ollama ps
# Should show CPU/GPU split, e.g. 14%/86% CPU/GPU
```

Ollama v0.19+ en Apple Silicon usa automáticamente el framework MLX de Apple para una inferencia más rápida.

## Paso 4: Configurar OpenCode para usar Gemma 4

OpenCode usa un archivo de configuración en `~/.config/opencode/opencode.jsonc`. Añade Ollama como proveedor personalizado:

```jsonc
{
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "gemma4:latest": {}
      }
    }
  }
}
```

Como Ollama se ejecuta en local, no necesitas una clave de API. Pero OpenCode espera una entrada de autenticación, así que añade un marcador de posición en `~/.local/share/opencode/auth.json`:

```json
{
  "ollama": {
    "type": "api",
    "key": "ollama"
  }
}
```

Reinicia OpenCode y usa `/models` para cambiar a `ollama/gemma4:latest`.

## Paso 5: Mantener Gemma 4 cargado

Ollama libera los modelos de la memoria tras 5 minutos de inactividad por defecto. Para un asistente de programación que usas durante todo el día, eso significa arranques en frío innecesarios.

Establece el keep-alive en indefinido:

```bash
launchctl setenv OLLAMA_KEEP_ALIVE "-1"
```

Reinicia Ollama para que surta efecto. Para que persista entre reinicios, añádelo a `~/.zshrc`:

```bash
export OLLAMA_KEEP_ALIVE="-1"
```

Activa el arranque al iniciar sesión: haz clic en el icono de Ollama en la barra de menús → **Abrir al iniciar sesión**.

#### Precarga automática al arrancar

Crea un LaunchAgent para que Gemma 4 esté cargado y listo después de cada reinicio:

```bash
cat << 'EOF' > ~/Library/LaunchAgents/com.ollama.preload-gemma4.plist
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.ollama.preload-gemma4</string>
    <key>ProgramArguments</key>
    <array>
        <string>/opt/homebrew/bin/ollama</string>
        <string>run</string>
        <string>gemma4:latest</string>
        <string></string>
    </array>
    <key>RunAtLoad</key>
    <true/>
    <key>StartInterval</key>
    <integer>300</integer>
    <key>StandardOutPath</key>
    <string>/tmp/ollama-preload.log</string>
    <key>StandardErrorPath</key>
    <string>/tmp/ollama-preload.log</string>
</dict>
</plist>
EOF

launchctl load ~/Library/LaunchAgents/com.ollama.preload-gemma4.plist
```

Esto envía un ping al modelo cada 5 minutos con un prompt vacío para mantenerlo en memoria.

## Qué funciona bien con Gemma 4 en OpenCode

Gemma 4 8B es gratuito y local, y resulta sorprendentemente útil para el trabajo diario de programación:

- **Explicaciones de código.** Pregunta qué hace una función, cómo está estructurado un módulo o con qué coincide una expresión regular. Las respuestas son claras y normalmente precisas para bases de código estándar.
- **Ediciones rápidas.** Corrige una errata, actualiza un import, añade un campo a una definición de tipo, renombra una variable. Los cambios en un solo archivo son su punto fuerte.
- **Generación de boilerplate.** Archivos de configuración, stubs de prueba, scaffolding de rutas de API, plantillas de Dockerfile. Patrones comunes que no requieren mucho razonamiento.
- **Ayuda con comandos de shell.** ¿Olvidaste un flag de `git` o un filtro de `jq`? Gemma 4 te da el comando sin tener que recurrir a Stack Overflow.

## Dónde se queda corto

- **Razonamiento en varios pasos.** Las tareas que requieren planificar entre varios archivos o entender un flujo de control complejo tienden a producir resultados incompletos.
- **Refactorizaciones grandes.** Si necesitas cambios coordinados en toda una base de código, el modelo de 8B pierde coherencia. Funciona archivo a archivo, pero no mantiene la visión de conjunto.
- **Casos límite y bugs sutiles.** Gemma 4 detecta problemas obvios, pero pasa por alto el tipo de bugs que requieren conocimiento profundo del dominio o razonamiento sobre casos extremos.

## Ve más allá: añade Haimaker para modelos en la nube

Gemma 4 en local cubre lo básico. Cuando te topes con algo que no puede manejar — depuración compleja, refactorizaciones que afectan a varios archivos, cualquier cosa que requiera razonamiento profundo — querrás un modelo en la nube. [Haimaker](https://haimaker.ai) te da una sola clave de API para Claude Opus, GPT-5, Gemini Pro y otros.

Añade Haimaker como segundo proveedor junto a Ollama:

```jsonc
{
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "gemma4:latest": {}
      }
    },
    "haimaker": {
      "npm": "@ai-sdk/openai-compatible",
      "options": {
        "baseURL": "https://api.haimaker.ai/v1"
      },
      "models": {
        "anthropic/claude-sonnet-4-6": {},
        "openai/gpt-5": {},
        "google/gemini-2.5-pro": {}
      }
    }
  }
}
```

Añade tu clave de API de Haimaker a `~/.local/share/opencode/auth.json`:

```json
{
  "ollama": {
    "type": "api",
    "key": "ollama"
  },
  "haimaker": {
    "type": "api",
    "key": "YOUR_HAIMAKER_API_KEY"
  }
}
```

Ahora puedes alternar entre modelos locales y en la nube con `/models` en OpenCode. Usa Gemma 4 para las tareas rápidas. Cambia a Sonnet o GPT-5 cuando la tarea se complique.

Regístrate en [haimaker.ai](https://haimaker.ai) para obtener tu clave de API y explorar el [catálogo de modelos](https://haimaker.ai/models).

<a href="https://app.haimaker.ai/sign-up?utm_source=blog&utm_medium=cta&utm_campaign=gemma4-opencode" class="cta-button">OBTÉN TU CLAVE DE API DE HAIMAKER</a>

## Solución de problemas

**El proveedor no aparece en /models.** Reinicia OpenCode después de editar los archivos de configuración. Los cambios en `opencode.jsonc` no se aplican mientras OpenCode está abierto.

**Error "Model not found".** Asegúrate de que el ID del modelo en tu configuración coincide exactamente con lo que reporta Ollama. Ejecuta `ollama list` y usa el nombre tal como aparece — normalmente `gemma4:latest`.

**Errores de autenticación con Ollama.** Aunque Ollama no necesita autenticación, el sistema de proveedores de OpenCode espera una entrada en `auth.json`. El marcador de posición `"key": "ollama"` es suficiente.

**Respuestas lentas.** Asegúrate de tener Ollama v0.19+ para obtener aceleración MLX en Apple Silicon. Ejecuta `ollama --version` para comprobarlo. Cierra también las aplicaciones que compiten por la memoria unificada — los navegadores con muchas pestañas suelen ser los principales responsables.

**Problemas con la ventana de contexto.** Gemma 4 admite ventanas de contexto grandes, pero en hardware de 16 GB mantén las entradas por debajo de 32K tokens para una calidad de salida estable. Si notas que la calidad de las respuestas baja con prompts largos, probablemente se deba a eso.

## Comandos útiles de Ollama

| Comando | Descripción |
|---|---|
| `ollama list` | Lista los modelos descargados |
| `ollama ps` | Muestra los modelos en ejecución y el uso de memoria |
| `ollama run gemma4:latest` | Chat interactivo |
| `ollama stop gemma4:latest` | Libera el modelo de la memoria |
| `ollama pull gemma4:latest` | Actualiza a la última versión |
| `ollama rm gemma4:latest` | Elimina el modelo |

---

*¿Ya usas Haimaker con OpenCode? Consulta la [guía completa de configuración de proveedores personalizados](/blog/how-to-add-haimaker-opencode) para añadir más modelos.*