Conclusión clave

Ejecutar Gemma 4 localmente toma menos de 5 minutos con Ollama: instala Ollama, ejecuta un comando y tendrás un modelo de AI plenamente capaz funcionando en su propio hardware con cero costos de API, cero datos saliendo de su máquina y cero restricciones de uso bajo Apache 2.0. El modelo E2B funciona en cualquier laptop. El modelo 26B MoE cabe en una sola RTX 4090 y ofrece una calidad que rivaliza con modelos con 10 veces su conteo de parámetros activos.

Ejecutar Gemma 4 localmente: La guía completa

¿Por qué ejecutar Gemma 4 localmente?

Antes de sumergirse en la configuración, aquí explicamos por qué la inferencia local es importante en 2026:

• Privacidad — Sus datos nunca salen de su máquina. No se envían prompts a servidores externos. Crítico para código propietario, documentos legales, datos médicos o cualquier información sensible.
• Costo — Cero costo por tokens después de la inversión única en hardware. Los usuarios intensivos ahorran cientos de dólares por mes en comparación con los precios de API.
• Latencia — Sin viajes de ida y vuelta por la red. Los modelos E2B y E4B responden en milisegundos en hardware moderno.
• Confiabilidad — Sin límites de tasa de API, sin interrupciones, sin cambios en las políticas del proveedor. Su modelo siempre está disponible.
• Personalización — Realice fine-tune, cuantice y modifique el modelo libremente bajo Apache 2.0.
• Acceso offline — Funciona sin una conexión a internet una vez que el modelo se ha descargado.

Gemma 4 es particularmente adecuado para el despliegue local porque Google diseñó los modelos más pequeños específicamente para el uso en el borde y en dispositivos. Los modelos E2B y E4B no son una ocurrencia tardía; son modelos de primera clase optimizados para las limitaciones del hardware local.

Requisitos previos

Requisitos de hardware por modelo

Conclusión clave: Si tiene una laptop fabricada después de 2022, puede ejecutar E2B o E4B. Si tiene una RTX 4090 (24 GB VRAM) o una Mac de la serie M de Apple con 32 GB+ de RAM, puede ejecutar el 26B MoE o el 31B Dense con una cuantización de 4-bit.

Requisitos de software

• Sistema operativo: macOS, Linux o Windows
• Ollama: Versión 0.6+ (descargar desde ollama.com)
• GPU drivers (opcional): NVIDIA CUDA 12+ para GPUs NVIDIA, no se necesitan controladores adicionales para Apple Silicon

Paso 1: Instalar Ollama

macOS

Descargue desde ollama.com/download o use Homebrew:

brew install ollama

Linux

Script de instalación de una sola línea:

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

Windows

Descargue el instalador desde ollama.com/download y ejecútelo. Ollama se ejecuta como un servicio en segundo plano en Windows.

Verificar instalación

ollama --version

Debería ver ollama version 0.6.x o superior. Si ve un número de versión, Ollama está instalado correctamente.

Fuente: Guía de instalación de Ollama

Paso 2: Descargar un modelo Gemma 4

Elija el modelo que coincida con su hardware:

Para laptops y cargas de trabajo ligeras

# El modelo más pequeño — funciona en cualquier laptop moderna (5 GB RAM)
ollama pull gemma4:e2b

# Modelo pequeño con capacidad más amplia (5-9 GB RAM)
ollama pull gemma4:e4b

Para computadoras de escritorio con una GPU dedicada

# Mejor eficiencia — calidad insignia con 3.8B de parámetros activos (18 GB RAM)
ollama pull gemma4:26b-moe

# Calidad más alta — 31B de parámetros completos (20 GB RAM)
ollama pull gemma4:31b

Especificando la cuantización

Por defecto, Ollama descarga la cuantización recomendada para cada modelo (generalmente Q4_K_M para un buen equilibrio entre calidad y tamaño). Puede especificar diferentes cuantizaciones:

# Calidad superior, tamaño más grande
ollama pull gemma4:31b-q5_K_M

# Tamaño más pequeño, calidad ligeramente inferior
ollama pull gemma4:31b-q3_K_M

# Precisión total (requiere mucha más RAM)
ollama pull gemma4:31b-fp16

La descarga tomará unos minutos dependiendo de su conexión a internet. Los tamaños de los modelos varían desde ~1.5 GB (E2B 4-bit) hasta ~62 GB (31B FP16).

Paso 3: Ejecutar Gemma 4

Chat interactivo

ollama run gemma4:e4b

Esto abre una sesión de chat interactiva. Escriba su prompt y presione Enter:

>>> What are the key differences between REST and GraphQL APIs?

El modelo responderá directamente en su terminal. Escriba /bye para salir.

Prompt único (no interactivo)

echo "Explain the Builder design pattern in Python with an example" | ollama run gemma4:26b-moe

Con modo de pensamiento

Gemma 4 soporta un modo de pensamiento configurable para tareas complejas. Actívelo agregando un system prompt:

ollama run gemma4:31b --system "Think step by step before answering. Show your reasoning process."

Para tareas de matemáticas, lógica y análisis complejo, el modo de pensamiento mejora significativamente la calidad de la respuesta. El modelo generará más de 4,000 tokens de razonamiento interno antes de producir su respuesta final.

Paso 4: Usar la API local

Ollama expone una API REST en localhost:11434 que es compatible con el formato de API de OpenAI. Esto significa que cualquier herramienta o biblioteca que soporte la API de OpenAI puede conectarse a su Gemma 4 local con un simple cambio de URL.

Probar la API con curl

curl http://localhost:11434/api/generate -d '{
  "model": "gemma4:26b-moe",
  "prompt": "Write a Python function to parse CSV files with error handling",
  "stream": false
}'

Endpoint compatible con OpenAI

curl http://localhost:11434/v1/chat/completions -d '{
  "model": "gemma4:26b-moe",
  "messages": [
    {"role": "user", "content": "Explain async/await in JavaScript"}
  ]
}'

Fuente: Documentación de la API de Ollama

Paso 5: Integrar con su aplicación

Python

import requests

def ask_gemma(prompt, model="gemma4:26b-moe"):
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={
            "model": model,
            "prompt": prompt,
            "stream": False
        }
    )
    return response.json()["response"]

# Usage
answer = ask_gemma("What is the time complexity of merge sort?")
print(answer)

Python con SDK de OpenAI

from openai import OpenAI

# Point to local Ollama instead of OpenAI
client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"  # Ollama doesn't require a real API key
)

response = client.chat.completions.create(
    model="gemma4:26b-moe",
    messages=[
        {"role": "system", "content": "You are a helpful coding assistant."},
        {"role": "user", "content": "Write a React hook for debounced search"}
    ]
)
print(response.choices[0].message.content)

Node.js / TypeScript

const response = await fetch("http://localhost:11434/v1/chat/completions", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({
    model: "gemma4:26b-moe",
    messages: [
      { role: "user", content: "Explain the Observer pattern with a TypeScript example" }
    ]
  })
});

const data = await response.json();
console.log(data.choices[0].message.content);

Usando con LangChain

from langchain_community.llms import Ollama

llm = Ollama(model="gemma4:26b-moe")
response = llm.invoke("Summarize the key principles of clean architecture")
print(response)

Usando con LlamaIndex

from llama_index.llms.ollama import Ollama

llm = Ollama(model="gemma4:26b-moe", request_timeout=120.0)
response = llm.complete("What are the SOLID principles in software engineering?")
print(response)

Explicación de las opciones de cuantización

La cuantización reduce el tamaño del modelo y el uso de memoria utilizando números de menor precisión para representar los pesos del modelo. El intercambio es entre calidad y uso de recursos:

Q4_K_M es el punto óptimo para la mayoría de los usuarios. La diferencia de calidad con respecto a FP16 es lo suficientemente pequeña como para que la mayoría de las tareas produzcan resultados indistinguibles, mientras que los ahorros de memoria del 75% marcan la diferencia entre "necesita un servidor" y "funciona en mi laptop".

Eligiendo la cuantización correcta

Para Gemma 4 E2B/E4B: Use el valor predeterminado (Q4_K_M). Estos modelos ya son lo suficientemente pequeños como para que una cuantización más alta no cambie significativamente la experiencia del usuario.

Para Gemma 4 26B MoE: Q4_K_M cabe en 18 GB de RAM, lo cual está dentro de los 24 GB de VRAM de una RTX 4090 con espacio para el KV cache. Si tiene 48 GB+ de VRAM (A6000, GPUs duales), considere Q8_0 para una calidad marginalmente mejor.

Para Gemma 4 31B Dense: Q4_K_M con 20 GB cabe en una RTX 4090 con márgenes estrechos. Q5_K_M produce resultados ligeramente mejores pero requiere ~24 GB, consumiendo toda la VRAM disponible. Si tiene 32 GB+ de VRAM (RTX 5090, A6000), Q6_K o Q8_0 valen la pena la actualización.

Ajuste de rendimiento

GPU Offloading

Ollama descarga automáticamente las capas del modelo a la GPU cuando hay VRAM disponible. Si solo una parte del modelo cabe en la VRAM, Ollama se divide entre GPU y CPU. Puede controlar esto:

# Forzar todas las capas a la GPU (falla si no hay suficiente VRAM)
OLLAMA_NUM_GPU=999 ollama run gemma4:26b-moe

# Forzar solo CPU (útil para pruebas)
OLLAMA_NUM_GPU=0 ollama run gemma4:e4b

Configuración de la ventana de contexto

Por defecto, Ollama utiliza una ventana de contexto de 2048 tokens por eficiencia. Para utilizar las capacidades completas de contexto de Gemma 4:

# Establecer ventana de contexto en 32K tokens
ollama run gemma4:26b-moe --num-ctx 32768

# Establecer ventana de contexto en 128K tokens (requiere más RAM)
ollama run gemma4:26b-moe --num-ctx 131072

Importante: Las ventanas de contexto más grandes consumen más RAM para el KV cache. Una ventana de contexto de 128K en el modelo 31B puede requerir de 8 a 16 GB de RAM adicionales más allá de los pesos del modelo. Comience con 32K y aumente solo si su caso de uso lo requiere.

Solicitudes concurrentes

Ollama soporta atender múltiples solicitudes simultáneamente:

# Permitir hasta 4 solicitudes concurrentes
OLLAMA_NUM_PARALLEL=4 ollama serve

Cada solicitud concurrente añade una sobrecarga de memoria para su KV cache. En una GPU de 24 GB ejecutando el 26B MoE en Q4_K_M (~18 GB), tiene aproximadamente 6 GB de margen, suficiente para 2 o 3 solicitudes concurrentes con contextos cortos.

Configuraciones de Keep-Alive

Por defecto, Ollama mantiene los modelos cargados en memoria durante 5 minutos después de la última solicitud. Ajuste esto para su caso de uso:

# Mantener el modelo cargado por 1 hora
OLLAMA_KEEP_ALIVE=3600 ollama serve

# Mantener el modelo cargado indefinidamente
OLLAMA_KEEP_ALIVE=-1 ollama serve

# Descargar inmediatamente después de cada solicitud (ahorra memoria)
OLLAMA_KEEP_ALIVE=0 ollama serve

Optimización para NVIDIA RTX

NVIDIA ha lanzado versiones optimizadas de Gemma 4 para GPUs RTX. Estas optimizaciones incluyen:

• Kernels de CUDA personalizados para el mecanismo de atención de Gemma 4
• Integración de TensorRT-LLM para una inferencia más rápida
• Soporte de Flash Attention para reducir el uso de memoria durante la inferencia de contexto largo
• Gestión optimizada de KV cache para un mejor rendimiento

Instalando Gemma 4 optimizado para NVIDIA

Si tiene una GPU de la serie RTX 4000 o 5000:

# Check your GPU
nvidia-smi

# Pull the NVIDIA-optimized version (if available in Ollama)
ollama pull gemma4:31b-nvidia

Alternativamente, use NVIDIA's AI Workbench o TensorRT-LLM directamente para el máximo rendimiento. Las versiones optimizadas para NVIDIA pueden proporcionar una inferencia entre un 30% y un 50% más rápida en GPUs RTX en comparación con las compilaciones estándar de Ollama.

Benchmarks de rendimiento en el mundo real

Medidos en configuraciones comunes de hardware:

Tokens por segundo (Velocidad de generación)

Contexto: La velocidad de lectura humana es de aproximadamente 4 a 5 tokens por segundo. Cualquier modelo que genere por encima de 10 tok/s se siente "instantáneo" para el uso interactivo. Los modelos E2B y E4B son lo suficientemente rápidos para la transmisión en tiempo real en casi cualquier hardware.

Tiempo para el primer token (Latencia)

Para aplicaciones interactivas, el tiempo para el primer token importa más que la velocidad de generación. Los modelos E2B y E4B comienzan a generar casi instantáneamente incluso en CPU, lo que los hace ideales para interfaces de chat en tiempo real.

Casos de uso comunes

Asistente de programación local

Use Gemma 4 como un asistente de programación privado que nunca envía su código a servidores externos:

ollama run gemma4:26b-moe --system "You are an expert software engineer. When given code, analyze it for bugs, suggest improvements, and explain your reasoning. Be concise and practical."

Combine esto con extensiones de VS Code como Continue o Twinny que soporten Ollama como backend.

Análisis de documentos

Procese documentos sensibles localmente:

echo "Analyze this contract clause and identify potential risks: [paste clause]" | ollama run gemma4:31b

Con un contexto de 256K, el modelo 31B puede procesar documentos de hasta ~750 páginas, suficiente para la mayoría de los contratos, documentos de investigación y documentación técnica.

RAG local (Generación aumentada por recuperación)

Combine Gemma 4 con una base de datos vectorial local para un sistema RAG completamente privado:

from langchain_community.llms import Ollama
from langchain_community.embeddings import OllamaEmbeddings
from langchain_community.vectorstores import Chroma

# Use Gemma 4 for both embeddings and generation
embeddings = OllamaEmbeddings(model="gemma4:e4b")
llm = Ollama(model="gemma4:26b-moe")

# Create vector store from your documents
vectorstore = Chroma.from_documents(documents, embeddings)

# Query with RAG
retriever = vectorstore.as_retriever()
docs = retriever.get_relevant_documents("What is our refund policy?")
context = "\n".join([doc.page_content for doc in docs])
response = llm.invoke(f"Based on this context:\n{context}\n\nAnswer: What is our refund policy?")

Construyendo funciones de AI en aplicaciones

Para los desarrolladores que construyen aplicaciones con capacidades de AI, ejecutar Gemma 4 localmente a través de la API de Ollama es el camino más rápido hacia un prototipo funcional. La API compatible con OpenAI significa que puede comenzar con Gemma 4 local para el desarrollo y cambiar a las API de la nube para producción sin cambiar el código de la aplicación.

Plataformas como ZBuild pueden manejar la infraestructura de la aplicación — frontend, backend, autenticación, base de datos — mientras usted se enfoca en la capa de integración de AI. Apunte el endpoint de AI de su aplicación a localhost:11434 durante el desarrollo y cámbielo por un endpoint en la nube cuando esté listo para escalar.

Solución de problemas

Errores de "Out of memory"

Si ve errores de memoria:

1. Pruebe una cuantización más pequeña: ollama pull gemma4:31b-q3_K_M
2. Reduzca la ventana de contexto: --num-ctx 4096
3. Cierre otras aplicaciones que consuman GPU de forma intensiva
4. Cambie a un modelo más pequeño: el 26B MoE ofrece una calidad cercana al 31B a un menor costo de memoria

Velocidad de generación lenta

Si la generación es más lenta de lo esperado:

1. Verifique la utilización de la GPU: nvidia-smi (debería mostrar un alto uso de GPU)
2. Asegúrese de que el modelo quepa completamente en la VRAM — la descarga parcial a la CPU es dramáticamente más lenta
3. Reduzca --num-ctx para liberar VRAM para el cómputo
4. Verifique si otros procesos están utilizando la GPU

Modelo no encontrado

Si ollama run gemma4:26b-moe falla:

# List available models
ollama list

# Search for Gemma 4 models
ollama search gemma4

# Pull the specific model
ollama pull gemma4:26b-moe

Conexión de API rechazada

Si las aplicaciones no pueden conectarse a localhost:11434:

# Check if Ollama is running
ollama list

# Start the Ollama server manually
ollama serve

# Check the port
curl http://localhost:11434/api/tags

Árbol de decisión para la selección del modelo

Use esto para elegir rápidamente el modelo adecuado:

¿Tiene una GPU dedicada con 16 GB+ de VRAM?

• Sí → ¿Desea máxima calidad o máxima eficiencia?
  • Máxima calidad → gemma4:31b (Q4_K_M, necesita 20 GB)
  • Máxima eficiencia → gemma4:26b-moe (Q4_K_M, necesita 18 GB)
• No → ¿Tiene 8 GB+ de RAM?
  • Sí → gemma4:e4b (Q4_K_M, mejor calidad)
  • No → gemma4:e2b (Q4_K_M, funciona con 5 GB)

Para la mayoría de los desarrolladores con una computadora de escritorio moderna o una PC para juegos: Comience con gemma4:26b-moe. Ofrece la mejor relación calidad-recursos de toda la familia Gemma 4.

Lo que puede construir

Con Gemma 4 ejecutándose localmente, usted tiene un backend de AI de costo cero para:

• Aplicaciones de chat con total privacidad en la conversación
• Herramientas de análisis de código que funcionan en bases de código propietarias
• Pipelines de procesamiento de documentos para datos sensibles
• Asistentes de AI locales que funcionan sin conexión
• Prototipos de funciones de AI antes de comprometerse con los costos de API en la nube
• Modelos ajustados (fine-tuned) para tareas específicas de un dominio (Apache 2.0 permite esto libremente)

La licencia Apache 2.0 significa que todo lo que construya es suyo: sin restricciones de uso, sin reparto de ingresos, sin necesidad de aprobación. Ejecútelo localmente, despliéguelo en sus servidores, intégrelo en sus productos. Así es como se ve la AI verdaderamente abierta.

Fuentes

• Gemma 4 Announcement - Google Blog
• Gemma 4 on Ollama
• Ollama Installation Guide
• Ollama API Documentation
• NVIDIA Gemma 4 RTX Optimization
• Gemma 4 Technical Report - Google DeepMind
• Gemma 4 Hugging Face Models
• Continue.dev - Local AI Code Assistant
• LangChain Ollama Integration
• Google AI for Developers - Gemma