DEV Community

Cover image for Cómo ejecutar Gemma 4 localmente con Ollama: Guía completa
Roobia
Roobia

Posted on • Originally published at apidog.com

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.

Prueba Apidog hoy

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.

💡 TIP: Una vez que tengas Gemma 4 funcionando localmente, Smart Mock de Apidog puede generar datos de respuesta de API realistas a partir de tu esquema utilizando el mismo tipo de inferencia respaldada por IA. Defines la forma de tu API una vez; Apidog maneja los datos simulados. Esto combina bien con experimentos de modelos locales donde deseas datos de prueba consistentes y conformes al esquema sin tener que escribir accesorios manualmente.

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.

Tabla de variantes

Diferencias clave respecto a Gemma 3:

  • Razonamiento y codificación: El modelo de 31B alcanza el 80% en LiveCodeBench v6, comparado con el 29.1% de Gemma 3 27B.
  • Arquitectura Mixture-of-Experts (MoE): La variante 26B usa MoE con solo 4B de parámetros activos durante la inferencia.
  • Contexto más largo: Modelos E2B y E4B soportan 128K tokens; 26B y 31B hasta 256K.
  • Llamadas a funciones nativas: Todos los modelos soportan herramientas estructuradas y devuelven JSON válido según tu esquema.
  • Entrada de audio e imagen: E2B y E4B aceptan imágenes y audio junto con texto.
  • Modos de pensamiento: Puedes habilitar/deshabilitar razonamiento de cadena de pensamiento por solicitud.

Variantes del modelo Gemma 4 explicadas

Antes de descargar, elige la variante adecuada para tu hardware:

Modelo Tamaño en disco Contexto Arquitectura Mejor para
gemma4:e2b 7.2 GB 128K Densa Portátiles, dispositivos de borde, audio/imagen
gemma4:e4b (def) 9.6 GB 128K Densa La mayoría de los desarrolladores
gemma4:26b 18 GB 256K MoE (4B activos) Mejor calidad por GB
gemma4:31b 20 GB 256K Densa Máxima calidad

El modelo e4b es el predeterminado (ollama run gemma4). Funciona bien en GPUs de consumo (>10GB VRAM) y Apple Silicon con memoria unificada.

La variante MoE 26b ofrece calidad similar a un modelo de 13B pero con requisitos de RAM más bajos. Si tienes >20GB de RAM, pruébalo.

Requisitos previos

  • Ollama v0.20.0 o posterior. Verifica tu versión:

    ollama --version

  • Si necesitas actualizar:

    # macOS
brew upgrade ollama

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

  • Para Windows, descarga desde ollama.com.

  • Hardware recomendado:

    • gemma4:e2b: 8GB RAM mínimo (16GB recomendado)
    • gemma4:e4b: 10GB VRAM o 16GB unificada
    • gemma4:26b: >20GB RAM/unificada
    • gemma4:31b: 24GB VRAM o 32GB unificada

Instalando y ejecutando Gemma 4

Descarga y ejecuta el modelo predeterminado:

ollama run gemma4
Enter fullscreen mode Exit fullscreen mode

Ejecución Gemma 4

Esto descarga ~9.6GB y abre una sesión interactiva. Prueba con:

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

Para variantes específicas:

# Modelo de borde
ollama run gemma4:e2b

# Modelo MoE
ollama run gemma4:26b

# Máxima calidad
ollama run gemma4:31b
Enter fullscreen mode Exit fullscreen mode

Para solo descargar el modelo:

ollama pull gemma4
ollama pull gemma4:26b
Enter fullscreen mode Exit fullscreen mode

Verifica modelos descargados:

ollama list
Enter fullscreen mode Exit fullscreen mode

Uso de la API de Gemma 4 localmente

Ollama expone una API REST local en http://localhost:11434.

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
  }'
Enter fullscreen mode Exit fullscreen mode

Finalización de chat (OpenAI compatible) 

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"
      }
    ]
  }'
Enter fullscreen mode Exit fullscreen mode

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)
Enter fullscreen mode Exit fullscreen mode

Uso del SDK de Python de OpenAI 

from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # requerido pero no usado por 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)
Enter fullscreen mode Exit fullscreen mode

Uso de llamadas a funciones con Gemma 4

Gemma 4 soporta llamadas a funciones nativas. Define un esquema de herramienta y el modelo devuelve JSON estructurado según la firma de tu función.

Ejemplo práctico:

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}
Enter fullscreen mode Exit fullscreen mode

El modelo extrae parámetros correctos y devuelve JSON válido según tu esquema, sin hacks.

Habilitar el modo de pensamiento

Para escenarios complejos, activa el razonamiento de cadena de pensamiento:

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)
Enter fullscreen mode Exit fullscreen mode

Para tareas simples, omite "think": true para evitar latencia innecesaria.

Probando las respuestas de la API de Gemma 4 con Apidog

Cuando tu instancia local de Gemma 4 esté lista, prueba tus endpoints de API de forma automática con Apidog.

Test con Apidog

  1. Importar especificación: Crea un proyecto en Apidog y usa la base http://localhost:11434.
  2. Define tus endpoints:
    • POST /api/generate
    • POST /v1/chat/completions
    • GET /api/tags
  3. Configura un Escenario de Prueba:
    • Paso 1: GET /api/tags, afirma que gemma4 está en la lista.
    • Paso 2: POST /api/generate, afirma que response no está vacío.
    • Paso 3: POST /v1/chat/completions, valida el formato de respuesta.

Usa el procesador Extraer Variable de Apidog para pasar datos entre pasos y probar flujos multi-turno.

  1. Validar esquemas: Usa Pruebas de Contrato de Apidog para asegurar que las respuestas cumplen tu OpenAPI spec.

  2. Smart Mock para desarrollo paralelo: Si necesitas mockear respuestas mientras el backend no está listo, Smart Mock de Apidog genera respuestas realistas a partir de tu especificación automáticamente.

Entrada multimodal con Gemma 4

Modelos E2B y E4B aceptan imágenes junto a texto. Úsalas como cadenas 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"
                }
            ]
        }
    ]
)
Enter fullscreen mode Exit fullscreen mode

Ideal para analizar diagramas, revisar capturas de documentación o extraer datos visuales para tu API.

Problemas comunes y soluciones

  • Ollama no encuentra el modelo: Ejecuta ollama pull gemma4 o revisa con ollama list.
  • Inferencia lenta en CPU: Usa gemma4:e2b si no tienes GPU.
  • Errores de memoria: Verifica VRAM/memoria con ollama ps. Si el modelo es muy grande, usa e2b.
  • No carga en Apple Silicon: Actualiza Ollama a 0.20.0 o posterior.
  • Puerto en uso: Cambia el puerto: OLLAMA_HOST=0.0.0.0:11435 ollama serve.
  • Respuestas cortadas: Aumenta la ventana de contexto: "options": {"num_ctx": 8192} en tu JSON.

Gemma 4 vs. otros modelos locales

Modelo Mejor tamaño Contexto Llamada a funciones Codificación
Gemma 4 e4b (9.6 GB) 128K-256K Nativa 80% LiveCodeBench
Llama 3.3 70B-Q4 (40 GB) 128K Nativa ~60% LiveCodeBench
Qwen3.6-Plus 72B-Q4 (44 GB) 128K Nativa Fuerte
Mistral Small 24B (14 GB) 128K Nativa Moderado

Ventaja clave: la variante MoE 26B de Gemma 4 entrega calidad insignia con solo 18GB de espacio y 4B activos por token.

Para codificación intensiva, el modelo de 31B es competitivo con modelos mucho más grandes. Para hardware limitado, e2b es ideal.

Conclusión

Gemma 4 con Ollama es una de las opciones locales más potentes hoy. La instalación toma dos comandos y el modelo predeterminado corre en la mayoría de equipos de desarrollo. El salto en calidad de razonamiento y codificación es sustancial respecto a Gemma 3.

Empieza con ollama run gemma4, prueba la API con Apidog y elige la variante que mejor se adapte a tu caso. Para equipos que desarrollan APIs con Gemma 4, la combinación de inferencia local, Smart Mock y Escenarios de Prueba en Apidog cubre todo el ciclo de desarrollo sin dependencias externas.

Preguntas frecuentes

¿Cómo actualizo Gemma 4 en Ollama cuando sale una nueva versión?

Ejecuta ollama pull gemma4 de nuevo. Descarga solo los cambios.

¿Puedo ejecutar Gemma 4 en una máquina sin GPU?

Sí, pero será lento. Usa el modelo e2b para CPUs.

¿Cuál es la diferencia entre gemma4:e2b y gemma4:e4b?

Ambos son densos y optimizados para hardware de borde. E4B tiene más parámetros y mejor razonamiento; E2B es más pequeño y soporta audio.

¿Funciona Gemma 4 con LangChain y LlamaIndex?

Sí, ambos soportan Ollama. Usa http://localhost:11434 como proveedor y gemma4 como modelo.

¿Es la API local de Gemma 4 compatible con la API de OpenAI?

En su mayoría sí. Usa /v1/chat/completions y cambia base_url a http://localhost:11434/v1.

¿Cómo uso el modo de pensamiento de Gemma 4?

Pasa "think": true en extra_body (SDK) o en el cuerpo JSON directo. Desactívalo para tareas simples.

¿Puedo servir Gemma 4 a otras máquinas en mi red?

Sí. Ejecuta OLLAMA_HOST=0.0.0.0:11434 ollama serve y conecta desde otras máquinas por IP.

¿Cuál es el mejor modelo de Gemma 4 para tareas de desarrollo de API?

Para datos simulados y tests, elige e4b por velocidad/calidad. Para análisis complejos, 26b ofrece excelentes resultados sin requerimientos de hardware extremos.

Top comments (0)