Cómo ejecutar Gemma 4 localmente con Ollama: Guía completa

En resumen

Gemma 4 fue lanzado el 3 de abril de 2026, y Ollama v0.20.0 añadió soporte el mismo día. Puedes descargar y ejecutar el modelo predeterminado gemma4:e4b con dos comandos. Esta guía te lleva a través de la configuración, selección del modelo, uso de la API y cómo probar tus puntos finales locales de Gemma 4 con Apidog.

Introducción

Google lanzó Gemma 4 el 2 de abril de 2026. En 24 horas, Ollama lanzó la versión v0.20.0 con soporte completo para las cuatro variantes del modelo.

Para los desarrolladores, esto es importante. Gemma 4 no es una mejora menor. Obtiene una puntuación del 89.2% en AIME 2026 en comparación con el 20.8% de Gemma 3. Su puntuación de referencia en codificación saltó de 110 ELO a 2150 en Codeforces. Obtienes llamadas a funciones nativas, modos de pensamiento configurables y una ventana de contexto de 256K en las variantes más grandes. Todo esto funciona en tu propio hardware.

Si estás creando aplicaciones impulsadas por API, la configuración local desbloquea algo útil: una capa de IA rápida y privada para generar datos simulados, escribir escenarios de prueba y validar respuestas de API sin enviar datos a un servidor remoto.

Esta guía cubre todo, desde la instalación hasta la realización de tu primera llamada API local.

Novedades de Gemma 4

Gemma 4 se envía con cuatro variantes de modelo con capacidades significativamente diferentes.

Esto es lo que lo diferencia de Gemma 3:

Razonamiento y codificación. El modelo de 31B alcanza el 80% en LiveCodeBench v6. El Gemma 3 27B anterior obtuvo un 29.1%. Esa brecha no es una mejora gradual; es una clase de rendimiento diferente.

Arquitectura Mixture-of-Experts. La variante de 26B utiliza MoE con solo 4 mil millones de parámetros activos durante la inferencia. Obtienes una calidad casi insignia a una fracción del coste computacional.

Contexto más largo. Los modelos de borde E2B y E4B soportan 128K tokens. Los modelos de 26B y 31B lo extienden a 256K, suficiente para encajar grandes bases de código o archivos de especificación de API en una sola instrucción.

Llamadas a funciones nativas. Todos los modelos Gemma 4 soportan el uso estructurado de herramientas de forma predeterminada. Puedes definir un esquema de función y el modelo devuelve JSON válido que coincide con ese esquema, sin necesidad de trucos de ingeniería de prompts.

Entrada de audio e imagen. Los modelos E2B y E4B aceptan entrada de audio e imágenes de resolución variable junto con texto.

Modos de pensamiento. Puedes habilitar o deshabilitar el razonamiento de cadena de pensamiento del modelo por solicitud. Para búsquedas simples, omítelo. Para problemas complejos de codificación o matemáticas, actívalo.

Variantes del modelo Gemma 4 explicadas

Antes de descargar nada, elige el modelo adecuado para tu hardware:

El modelo e4b es el predeterminado cuando ejecutas ollama run gemma4. Se adapta a la mayoría de las GPUs de consumo con más de 10 GB de VRAM y se ejecuta razonablemente rápido en la memoria unificada de Apple Silicon.

La variante MoE 26b es la opción subestimada. Debido a que solo 4 mil millones de parámetros se activan por token, la inferencia es más cercana a un modelo de 4B en velocidad, mientras que la calidad se sitúa cerca de un modelo de 13B. Si tienes más de 20 GB de RAM, vale la pena probarlo.

Requisitos previos

Necesitas Ollama v0.20.0 o posterior. Las versiones anteriores no incluyen soporte para Gemma 4.

Comprueba tu versión actual:

ollama --version

Si estás en una versión anterior, actualiza:

# macOS
brew upgrade ollama

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

En Windows, descarga el instalador más reciente desde ollama.com.

Requisitos de hardware:

• gemma4:e2b: 8 GB de RAM mínimo (16 GB recomendados)
• gemma4:e4b: 10 GB de VRAM o 16 GB de memoria unificada
• gemma4:26b: Más de 20 GB de RAM o memoria unificada
• gemma4:31b: 24 GB de VRAM o 32 GB de memoria unificada

Instalando y ejecutando Gemma 4

Descarga y ejecuta el modelo e4b predeterminado:

ollama run gemma4

Esto descarga aproximadamente 9.6 GB en la primera ejecución, luego te lleva a una sesión interactiva. Escribe un mensaje para probarlo:

>>> ¿Cuáles son los códigos de estado HTTP para errores de cliente?

Para ejecutar una variante específica:

# Modelo de borde, menor huella
ollama run gemma4:e2b

# Modelo MoE, mejor relación calidad-tamaño
ollama run gemma4:26b

# Insignia completa
ollama run gemma4:31b

Para descargar sin ejecutar inmediatamente:

ollama pull gemma4
ollama pull gemma4:26b

Comprueba qué modelos tienes:

ollama list

Uso de la API de Gemma 4 localmente

Ollama expone una API REST local en http://localhost:11434. Una vez que el modelo ha sido descargado, puedes acceder a él desde cualquier cliente HTTP sin iniciar la CLI interactiva.

Generar una finalización

curl http://localhost:11434/api/generate \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "prompt": "Write a JSON response for a user profile API endpoint",
    "stream": false
  }'

Finalización de chat (punto final compatible con OpenAI)

Ollama también soporta el formato de chat de OpenAI:

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4",
    "messages": [
      {
        "role": "user",
        "content": "Generate a realistic JSON mock for an e-commerce order API response"
      }
    ]
  }'

Cliente Python

import requests

def ask_gemma4(prompt: str, model: str = "gemma4") -> str:
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    response.raise_for_status()
    return response.json()["response"]

result = ask_gemma4("List the fields a payment API response should include")
print(result)

Uso del SDK de Python de OpenAI

Debido a que la API de Ollama es compatible con OpenAI, puedes apuntar el SDK oficial a tu instancia local:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # required by the SDK but unused by Ollama
)

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "system",
            "content": "You generate realistic API response data in JSON format."
        },
        {
            "role": "user",
            "content": "Generate a sample response for a GET /users/{id} endpoint"
        }
    ]
)

print(response.choices[0].message.content)

Uso de llamadas a funciones con Gemma 4

Gemma 4 soporta llamadas a funciones nativas. Defines un esquema de herramienta y el modelo devuelve JSON estructurado que coincide con la firma de tu función.

Esto es útil para construir agentes que llaman a tus APIs de forma programática:

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_user",
            "description": "Retrieve a user by ID from the API",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {
                        "type": "integer",
                        "description": "The unique user ID"
                    },
                    "include_orders": {
                        "type": "boolean",
                        "description": "Whether to include order history"
                    }
                },
                "required": ["user_id"]
            }
        }
    }
]

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {"role": "user", "content": "Get user 42 with their order history"}
    ],
    tools=tools,
    tool_choice="auto"
)

tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.function.name)       # get_user
print(tool_call.function.arguments)  # {"user_id": 42, "include_orders": true}

El modelo extrae los parámetros correctos del lenguaje natural y devuelve un objeto JSON válido que coincide con tu esquema. No se necesita análisis de expresiones regulares ni limpieza de salida.

Habilitar el modo de pensamiento

Para tareas complejas como escribir escenarios de prueba o analizar especificaciones de API, puedes habilitar el razonamiento de cadena de pensamiento de Gemma 4:

response = client.chat.completions.create(
    model="gemma4",
    messages=[
        {
            "role": "user",
            "content": "Design a complete test scenario for a payment processing API with edge cases"
        }
    ],
    extra_body={"think": True}
)

print(response.choices[0].message.content)

Para solicitudes más simples, como generar un único valor simulado, omite el modo de pensamiento. Añade una latencia que no necesitas.

Probando las respuestas de la API de Gemma 4 con Apidog

Una vez que tu instancia local de Gemma 4 esté en funcionamiento, querrás probar los puntos finales de la API de forma sistemática. Apidog se encarga de esto sin herramientas adicionales.

Importar la especificación de la API de Ollama. El servidor local de Ollama expone puntos finales REST estándar. Crea un nuevo proyecto en Apidog y añade la URL base http://localhost:11434.

Define tus puntos finales. Añade los puntos finales que estás probando:

• POST /api/generate para finalizaciones de un solo turno
• POST /v1/chat/completions para chat multi-turno
• GET /api/tags para listar modelos disponibles

Configura un Escenario de Prueba. En Apidog, un Escenario de Prueba encadena múltiples solicitudes con aserciones entre ellas. Para las pruebas de Gemma 4:

1. Paso 1: GET /api/tags para afirmar que gemma4 aparece en la lista de modelos
2. Paso 2: POST /api/generate para enviar una instrucción y afirmar que el campo response no está vacío
3. Paso 3: POST /v1/chat/completions para enviar un mensaje de chat y afirmar que la respuesta coincide con tu formato esperado

Usa el procesador Extraer Variable de Apidog para capturar la respuesta del paso 2 y pasarla al paso 3. Esto te permite probar flujos de conversación multi-turno automáticamente.

Validar esquemas de respuesta. Las Pruebas de Contrato de Apidog validan las respuestas de la API contra tu especificación OpenAPI. Define la forma de respuesta esperada para cada punto final de Gemma 4, luego ejecuta pruebas de contrato después de las actualizaciones del modelo para detectar cualquier cambio que rompa la compatibilidad en el formato de la API de Ollama.

Smart Mock para desarrollo paralelo. Si tu backend depende de las respuestas de Gemma 4 pero quieres que los equipos de frontend trabajen sin esperar al modelo local, Smart Mock de Apidog genera respuestas conformes al esquema a partir de tu especificación de API automáticamente. Define cómo se ve una respuesta de Gemma 4, y Smart Mock sirve datos realistas bajo demanda.

Entrada multimodal con Gemma 4

Los modelos E2B y E4B aceptan imágenes junto con texto. Pasa las imágenes como cadenas codificadas en base64:

import base64

with open("api_diagram.png", "rb") as f:
    image_data = base64.b64encode(f.read()).decode()

response = client.chat.completions.create(
    model="gemma4:e4b",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "image_url",
                    "image_url": {
                        "url": f"data:image/png;base64,{image_data}"
                    }
                },
                {
                    "type": "text",
                    "text": "Describe the API flow shown in this diagram and identify potential error paths"
                }
            ]
        }
    ]
)

Esto es útil para analizar diagramas de arquitectura, revisar capturas de pantalla de documentación de API o extraer datos de imágenes que tu API necesita procesar.

Problemas comunes y soluciones

Ollama dice que no se encuentra el modelo. Ejecuta ollama pull gemma4 primero, o verifica con ollama list.

Inferencia lenta en CPU. Gemma 4 está optimizado para GPU. En máquinas solo con CPU, espera de 1 a 3 tokens por segundo con el modelo e4b. Usa gemma4:e2b para un mejor rendimiento en CPU.

Errores de falta de memoria. Comprueba tu VRAM disponible o memoria unificada con ollama ps. Si el modelo es demasiado grande, cambia a gemma4:e2b (7.2 GB).

El modelo no carga en Apple Silicon. Ollama 0.20.0 añadió soporte MLX para Apple Silicon en vista previa. Si estás en una versión anterior de Ollama, actualiza primero.

Puerto ya en uso. Si algo más está usando el puerto 11434, establece un puerto personalizado: OLLAMA_HOST=0.0.0.0:11435 ollama serve.

Las respuestas se cortan. Aumenta la ventana de contexto en tu solicitud: añade "options": {"num_ctx": 8192} a tu cuerpo JSON.

Gemma 4 vs. otros modelos locales

La ventaja de Gemma 4 es la variante MoE 26B. Con 18 GB, ofrece una calidad casi insignia con 4 mil millones de parámetros activos en el momento de la inferencia, lo que te proporciona más tokens por segundo que cualquiera de los modelos densos más grandes de esta lista.

Para tareas de codificación pura, el modelo de 31B es competitivo con modelos mucho más grandes. Para despliegues en dispositivos de borde o portátiles, e2b se ejecuta con menos de 8 GB.

Conclusión

Gemma 4 con Ollama es una de las configuraciones locales más capaces disponibles actualmente. La instalación se realiza con dos comandos. El modelo predeterminado se ejecuta en la mayoría de las máquinas de desarrollo. Y el salto en la calidad de razonamiento y codificación con respecto a Gemma 3 es sustancial.

Empieza con ollama run gemma4, prueba la API con Apidog para asegurarte de que tus puntos finales se comportan como se espera, luego elige la variante adecuada para tu carga de trabajo basándote en la tabla de modelos anterior.

Para equipos que construyen características impulsadas por API sobre Gemma 4, combinar la inferencia local con Smart Mock y los Escenarios de Prueba de Apidog te proporciona un ciclo de desarrollo completo sin dependencias remotas.

Preguntas frecuentes

¿Cómo actualizo Gemma 4 en Ollama cuando sale una nueva versión?Ejecuta ollama pull gemma4 de nuevo. Ollama comprueba la última versión y descarga solo lo que ha cambiado.

¿Puedo ejecutar Gemma 4 en una máquina sin GPU?Sí, pero es lento. Espera de 1 a 3 tokens por segundo en CPU. El modelo e2b es la opción más práctica para máquinas solo con CPU.

¿Cuál es la diferencia entre gemma4:e2b y gemma4:e4b?Ambos son modelos "efectivos" densos optimizados para hardware de borde. E4B tiene más parámetros y maneja mejor el razonamiento complejo. E2B es más pequeño y soporta entrada de audio. Para la mayoría de las tareas de texto, e4b es el predeterminado preferible.

¿Funciona Gemma 4 con LangChain y LlamaIndex?Sí. Ambos frameworks soportan Ollama como backend. Apunta el proveedor de Ollama a http://localhost:11434 y usa gemma4 como nombre del modelo.

¿Es la API local de Gemma 4 compatible con el código escrito para la API de OpenAI?En su mayor parte, sí. El punto final /v1/chat/completions de Ollama sigue el formato de OpenAI. Cambia base_url a http://localhost:11434/v1 y api_key a cualquier cadena no vacía. La mayoría de las llamadas al SDK de OpenAI funcionan sin cambios.

¿Cómo uso el modo de pensamiento de Gemma 4?Pasa "think": true en el parámetro extra_body al usar el SDK de OpenAI, o añade "think": true al cuerpo JSON de nivel superior en las llamadas directas a la API. Desactívalo para tareas simples para reducir la latencia.

¿Puedo servir Gemma 4 a otras máquinas en mi red?Sí. Inicia Ollama con OLLAMA_HOST=0.0.0.0:11434 ollama serve y otras máquinas podrán acceder a él en tu dirección IP en el puerto 11434.

¿Cuál es el mejor modelo de Gemma 4 para tareas de desarrollo de API?Para generar datos simulados y escribir casos de prueba, e4b es el equilibrio adecuado entre velocidad y calidad. Para el análisis complejo de especificaciones o la revisión de arquitectura, el modelo MoE 26b ofrece mejores resultados sin el coste del modelo completo de 31B.