> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/gemma4.md). # Gemma 4 (26B MoE, 4B activo) Despliega Gemma 4 (26B MoE, 4B activo) de Google en Clore.ai: el modelo de pesos abiertos lanzado en abril de 2026 que subió hasta {% hint style="info" %} **Estado (abril de 2026):** Gemma 4 se lanzó el **2 de abril de 2026** por Google como la siguiente generación de la familia Gemma de pesos abiertos. Se publican dos variantes: una **densa de 31B** modelo (`google/gemma-4-31b-it`) y una **MoE de 26B con \~4B parámetros activos** (`google/gemma-4-26b-it`). Ambos se publican bajo los términos estándar de **Términos de uso de Gemma** en [huggingface.co/google/gemma-4-26b-it](https://huggingface.co/google/gemma-4-26b-it) y [huggingface.co/google/gemma-4-31b-it](https://huggingface.co/google/gemma-4-31b-it). {% endhint %} Gemma 4 es la primera entrada MoE de Google en la línea Gemma y la primera versión de Gemma que llegó a lo más alto del LMSYS Arena (informes del proveedor **#3 en general en el lanzamiento**, superando por poco a varios modelos cerrados en veracidad y seguimiento de instrucciones). La cifra principal es la variante MoE: **26B de parámetros totales, \~4B activos por token**, lo que te da un seguimiento de instrucciones casi de vanguardia al coste de inferencia de un modelo denso pequeño. Para los usuarios de Clore.ai, la conclusión práctica es simple: el MoE de 26B funciona cómodamente en una sola **RTX 4090 (24GB)** con cuantización FP8 o de 4 bits (\~10 tok/s) y alcanza un rendimiento de nivel de producción en una sola **H100 80GB** (\~40+ tok/s), poniendo el seguimiento de instrucciones de calidad Gemma al alcance por aproximadamente \~$1.04/h en el marketplace. La variante densa de 31B es la hermana más capaz pero también más cara, y necesita 2× RTX 4090 o 1× H100 para servir. ## Características clave * **Arquitectura MoE (variante de 26B)** — 26B de parámetros totales, \~4B activados por token; pagas un coste de inferencia de clase 4B por calidad de clase 26B * **Alternativa densa (variante de 31B)** — para equipos que prefieren la previsibilidad y la madurez de las herramientas de la inferencia densa * **Ventana de contexto de 128K** — preguntas y respuestas sobre documentos largos, RAG sobre bases de código medianas, bucles de agentes de múltiples turnos * **Seguimiento de instrucciones sólido** — Gemma 4 está ajustado explícitamente para uso de herramientas, salida estructurada y seguimiento fiel de restricciones * **Multilingüe** — se mantiene la cobertura multilingüe completa heredada de Gemma 3, además de una suite de benchmarks ampliada en otros idiomas * **Pesos abiertos, términos de Gemma** — gratis para la mayoría de los usos comerciales; revisa la [Política de uso prohibido de Gemma](https://ai.google.dev/gemma/prohibited_use_policy) antes de publicarlo * **Herramientas de primera clase** — compatible desde el primer momento con vLLM, SGLang, Ollama y Hugging Face Transformers ## Elige tu variante | Variante | Parámetros totales | Activo | Contexto | Cuantización recomendada | GPU de Clore recomendada | | ---------------------------------------- | ------------------ | -------------- | -------- | ------------------------ | ------------------------------------------------------------------------------------------------------------------------- | | **Gemma 4 26B MoE** (`gemma-4-26b-it`) | 26B | \~4B por token | 128K | FP8 o GPTQ de 4 bits | 1× [RTX 4090](https://clore.ai/rent-4090.html?utm_source=docs\&utm_medium=guide\&utm_campaign=gemma4) (24 GB, cuantizado) | | **Gemma 4 31B denso** (`gemma-4-31b-it`) | 31B | 31B (todos) | 128K | FP8 o BF16 | 1× [H100](https://clore.ai/rent-h100.html?utm_source=docs\&utm_medium=guide\&utm_campaign=gemma4) (80 GB, BF16) | {% hint style="success" %} **Elección práctica:** Para el 90% de las implementaciones de una sola GPU, elige **Gemma 4 26B MoE en FP8**. Obtienes la calidad destacada del Arena a \~10–15 tok/s en una 4090 y \~40+ tok/s en una H100, sin el coste de latencia de la inferencia densa de 31B. {% endhint %} *** ## Requisitos del servidor | Componente | 26B MoE (4 bits, 4090) | 26B MoE (FP8, H100) | 31B denso (BF16, H100) | | --------------- | ---------------------------------- | ------------------- | ---------------------- | | VRAM de GPU | 24GB | 80 GB | 80 GB | | RAM del sistema | 32GB | 64GB | 64GB | | Disco | 60GB NVMe | 80GB NVMe | 90GB NVMe | | Red | 100 Mbps para la descarga desde HF | Se prefiere 1 Gbps | Se prefiere 1 Gbps | | CUDA | 12.8+ | 12.8+ | 12.8+ | | Controlador | 550+ | 555+ | 555+ | Planifica un \~20% adicional de margen de VRAM sobre la huella fija de los pesos para cubrir la caché KV en contextos largos. La configuración `--gpu-memory-utilization 0.90` en vLLM es un buen valor predeterminado. *** ## Despliegue rápido en CLORE.AI La vía más rápida: alquila una sola GPU, descarga la imagen estándar `vllm/vllm-openai` y sirve el modelo con una API compatible con OpenAI. A continuación se muestra la configuración de docker-compose usada por el resto de estas guías: ajusta el nombre del modelo y el tamaño de paralelismo tensorial según la variante que elegiste arriba. ### Opción A — Gemma 4 26B MoE en una sola GPU (vLLM, FP8) ```yaml version: "3.8" services: vllm: image: vllm/vllm-openai:latest ports: - "8000:8000" environment: - HUGGING_FACE_HUB_TOKEN=${HF_TOKEN} volumes: - hf_cache:/root/.cache/huggingface command: > --model google/gemma-4-26b-it --quantization fp8 --max-model-len 32768 --gpu-memory-utilization 0.90 --served-model-name gemma-4-26b --trust-remote-code deploy: resources: reservations: devices: - driver: nvidia count: 1 capabilities: [gpu] shm_size: "8gb" volumes: hf_cache: ``` ```bash # Levántalo HF_TOKEN=hf_xxx docker compose up -d # Sigue los registros mientras se descargan los pesos docker compose logs -f vllm ``` {% hint style="info" %} **Validación de licencia:** Los modelos Gemma en Hugging Face requieren aceptar los términos de Google una vez por cuenta. Visita la página del modelo en un navegador, haz clic en "Aceptar licencia", luego exporta `HF_TOKEN` para que el contenedor pueda descargar los pesos. {% endhint %} ### Opción B — Gemma 4 31B denso en H100 (vLLM, BF16) ```bash docker run --gpus all -p 8000:8000 \\ -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \\ -v ~/.cache/huggingface:/root/.cache/huggingface \\ --ipc=host \ vllm/vllm-openai:latest \ --model google/gemma-4-31b-it \\ --dtype bfloat16 \\ --max-model-len 32768 \ --gpu-memory-utilization 0.90 \ --served-model-name gemma-4-31b ``` ### Opción C — Gemma 4 31B denso en 2× RTX 4090 (FP8, paralelismo tensorial) ```bash docker run --gpus all -p 8000:8000 \\ -e HUGGING_FACE_HUB_TOKEN=$HF_TOKEN \\ -v ~/.cache/huggingface:/root/.cache/huggingface \\ --ipc=host \ vllm/vllm-openai:latest \ --model google/gemma-4-31b-it \\ --quantization fp8 \\ --tensor-parallel-size 2 \\ --max-model-len 16384 \ --gpu-memory-utilization 0.90 \ --served-model-name gemma-4-31b ``` ### Opción D — Pruebas locales rápidas con Ollama Para experimentación de nivel portátil, Ollama envuelve las compilaciones comunitarias GGUF. Espera que las cuantizaciones lleguen unos días después del lanzamiento oficial. ```bash # Una vez que se publique un GGUF comunitario ollama pull gemma4:26b-moe-q4_k_m ollama run gemma4:26b-moe-q4_k_m # API compatible con OpenAI en :11434 curl http://localhost:11434/v1/chat/completions \ -H "Content-Type: application/json" \\ -d '{ "model": "gemma4:26b-moe-q4_k_m", "messages": [{"role":"user","content":"Resume el enfoque de enrutamiento MoE en dos oraciones."}] }' ``` Consulta la [guía de Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) para configuración general, gestión del modelo y consejos de persistencia. *** ## Ejemplos de uso El contenedor de vLLM expone una API compatible con OpenAI en `:8000`. Cualquier cosa que hable el esquema de completions de chat de OpenAI funciona directamente. ### Completion de chat con curl ```bash curl http://localhost:8000/v1/chat/completions \\ -H "Content-Type: application/json" \\ -d '{ "model": "gemma-4-26b", "messages": [ {"role": "system", "content": "Eres un redactor técnico cuidadoso."}, {"role": "user", "content": "Explica el enrutamiento MoE en tres oraciones sin usar analogías."} ], "max_tokens": 512, "temperature": 0.7 }' ``` ### Python (cliente de OpenAI) ```python from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY") resp = client.chat.completions.create( model="gemma-4-26b", messages=[ {"role": "system", "content": "Respondes en texto plano, sin markdown."}, {"role": "user", "content": "Dame una lista de verificación de revisión de código de 5 puntos para un manejador HTTP en Go."}, ], temperature=0.7, max_tokens=1024, ) print(resp.choices[0].message.content) ``` ### Respuestas en streaming ```python from openai import OpenAI client = OpenAI(base_url="http://localhost:8000/v1", api_key="EMPTY") stream = client.chat.completions.create( model="gemma-4-26b", messages=[{"role": "user", "content": "Escribe un haiku sobre la inferencia distribuida."}], stream=True, max_tokens=128, ) for chunk in stream: delta = chunk.choices[0].delta.content if delta: print(delta, end="", flush=True) print() ``` ### Hugging Face Transformers (uso sin conexión) ```python import torch from transformers import AutoModelForCausalLM, AutoTokenizer model_name = "google/gemma-4-26b-it" tokenizer = AutoTokenizer.from_pretrained(model_name) model = AutoModelForCausalLM.from_pretrained( model_name, torch_dtype=torch.bfloat16, device_map="auto", load_in_4bit=True, # Cabe el MoE en una sola tarjeta de 24 GB ) messages = [ {"role": "user", "content": "Refactoriza esta función de Python para que sea más legible:\n\ndef f(x): return [i for i in x if i%2==0 and i>10]"}, ] input_ids = tokenizer.apply_chat_template(messages, return_tensors="pt").to(model.device) output = model.generate(input_ids, max_new_tokens=512, do_sample=True, temperature=0.7) print(tokenizer.decode(output[0][input_ids.shape[-1]:], skip_special_tokens=True)) ``` *** ## Consejos de rendimiento * **Usa FP8 en Hopper.** En H100, el checkpoint FP8 ocupa aproximadamente la mitad de memoria que BF16 sin pérdida medible de calidad en tareas de seguimiento de instrucciones. Pasa `--quantization fp8` a vLLM. * **Usa GPTQ de 4 bits en Ada (RTX 4090).** Para la variante MoE en una sola 4090, una compilación comunitaria GPTQ de 4 bits es el punto óptimo práctico: espera \~10–15 tok/s. Las compilaciones GGUF Q4\_K\_M de Ollama ofrecen una calidad similar con operaciones más sencillas. * **Paralelismo tensorial para 31B denso.** A través de 2× RTX 4090, pasa `--tensor-parallel-size 2`. Fija el contexto a lo que realmente necesitas (`--max-model-len 16384`) — cada duplicación del contexto aproximadamente duplica la huella de la caché KV. * **Paralelismo de expertos para el MoE.** En configuraciones multigPU para el MoE de 26B, el paralelismo experto de vLLM `--enable-expert-parallel` puede dar un aumento notable del rendimiento con tamaños de lote altos. Es excesivo para una sola GPU. * **Prefill por fragmentos para contextos largos.** Al superar los 32K, añade `--enable-chunked-prefill` a vLLM. Esto mantiene manejable la latencia del prefill y evita bloqueos en la ruta de decodificación. * **Descarga los pesos de antemano.** Para alquileres efímeros de Clore, monta un volumen persistente en `/root/.cache/huggingface` para que las ejecuciones posteriores se salten la descarga de 50–60 GB. * **Elige el backend de servicio adecuado.** vLLM es la opción predeterminada segura. SGLang suele ganar en Hopper para cargas de trabajo de alta concurrencia; consulta la [guía de vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) para una comparación más amplia. *** ## Pruebas comparativas {% hint style="warning" %} **Cifras publicadas por el proveedor — verificación independiente pendiente.** Las cifras siguientes provienen del material de lanzamiento de Google del 2 de abril de 2026. Todavía están llegando reproducciones independientes en evaluaciones privadas. Toma la clasificación del Arena y las puntuaciones de veracidad como orientativas, no absolutas. {% endhint %} | Benchmark | Gemma 4 26B MoE | Gemma 4 31B denso | Referencia | | ------------------------------------- | ------------------------------------------------------------- | -------------------------------------------------------- | ------------------ | | LMSYS Arena (global) | #3 en el lanzamiento | \~#5 en el lanzamiento | según el proveedor | | Seguimiento de instrucciones (IFEval) | el proveedor informa de fuertes mejoras frente a Gemma 3 | el proveedor informa de fuertes mejoras frente a Gemma 3 | según el proveedor | | Veracidad (SimpleQA / similar) | supera a varios modelos cerrados según Google | comparable | según el proveedor | | Multilingüe (Global-MMLU) | el proveedor informa de paridad con modelos mucho más grandes | la mejor puntuación de Gemma hasta la fecha | según el proveedor | El argumento de posicionamiento de Gemma 4 es "más útil por parámetro activo", no "rey absoluto de HumanEval". Si necesitas generación de código pura, compáralo con [GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md) (codificación de vanguardia) o [Qwen3.5](/guides/guides_v2-es/modelos-de-lenguaje/qwen35.md) (el mejor denso de clase 35B). Si necesitas bucles agentivos de largo plazo, GLM-5.1 sigue siendo la herramienta más precisa. *** ## Solución de problemas | Problema | Solución | | -------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `OutOfMemoryError` cargando el MoE de 26B en 24 GB | Cambia a FP8 (`--quantization fp8`) o 4 bits (`load_in_4bit=True` en Transformers). Reduce `--max-model-len` a 16384 para reducir la caché KV. | | `OutOfMemoryError` cargando el 31B denso en H100 | BF16 con contexto de 32K está justo al límite en 80 GB. Baja `--max-model-len` a 16384 o cambia a FP8. | | La descarga de Hugging Face falla con 403 | No has aceptado la licencia de Gemma en la página del modelo. Abre la URL en un navegador, acepta los términos y luego vuelve a descargar con un token que tenga `lectura` alcance. | | Primer token muy lento | Carga fría de los pesos (\~30–60 s en la primera solicitud) más prefill en entradas largas. Ejecuta una solicitud ficticia de calentamiento después de que arranque el servidor. Añade `--enable-chunked-prefill` para cargas de trabajo de contexto largo. | | Salida confusa / bucles de repetición | Comprueba la plantilla de chat — `tokenizer.apply_chat_template` es obligatorio; no concatenes `system`+`user` las cadenas manualmente. Configura `temperature=0.7` y `top_p=0.95` para uso general. | | Salida de herramientas / JSON poco fiable | Usa la `--guided-decoding-backend` o pasa un esquema JSON mediante `response_format`. El modelo sigue bien las restricciones, pero las indicaciones no estructuradas seguirán desviándose. | | `cuantización no compatible` error en vLLM | Actualiza a una versión de vLLM publicada después de abril de 2026 (`pip install -U vllm --pre`). La arquitectura de Gemma 4 necesita los analizadores de configuración más recientes. | *** ## Preguntas frecuentes **¿Gemma 4 vs Llama 4?** Distintas formas para distintos trabajos. [Llama 4 Scout](/guides/guides_v2-es/modelos-de-lenguaje/llama4.md) es 109B/17B-activo con un contexto destacado de 10M — estupendo cuando necesitas volcar entradas enormes en el modelo. Gemma 4 26B MoE es mucho más pequeño en parámetros totales (26B frente a 109B), activa menos parámetros por token (4B frente a 17B) y está más afinado para el seguimiento de instrucciones y la veracidad. Para presupuestos de VRAM ajustados y calidad por parámetro, gana Gemma 4. Para longitudes de contexto absurdas, gana Llama 4 Scout. **¿Cuánta VRAM necesita Gemma 4 26B MoE?** * GGUF / GPTQ de 4 bits: cabe en **24GB** (una sola RTX 4090), \~10–15 tok/s. * FP8: cómodo en **40 GB**, rápido en **80 GB** (H100) a \~40+ tok/s. * BF16 completo: \~55 GB de pesos más la caché KV — planifica una **80 GB** tarjeta. **¿Puedo usar Gemma 4 comercialmente?** Sí, bajo los términos de uso estándar de Gemma. Revisa la [Política de uso prohibido de Gemma](https://ai.google.dev/gemma/prohibited_use_policy) antes de desplegarlo — hay restricciones sobre casos de uso específicos (engaño, generación de CSAM, actividad ilegal) y debes pasar los avisos de licencia aguas abajo a tus usuarios. No es un modelo Apache 2.0 / MIT — es de pesos abiertos bajo una política de uso. Si necesitas una licencia completamente sin restricciones, [Qwen3.5](/guides/guides_v2-es/modelos-de-lenguaje/qwen35.md) (Apache 2.0) o [GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md) (MIT) son alternativas. **¿Gemma 4 vs DeepSeek-V4?** [DeepSeek-V4](/guides/guides_v2-es/modelos-de-lenguaje/deepseek-v4.md) es una clase de pesos distinta — \~1T de parámetros, multimodal, 1M de contexto. Usa DeepSeek-V4 cuando necesites capacidad bruta y dispongas de un serio rack de GPU. Usa Gemma 4 26B MoE cuando quieras un fuerte seguimiento de instrucciones en una **sola GPU** y te importen las [bare metal](https://clore.ai/bare-metal) alquileres en Clore. Gemma 4 es el candidato a "mejor modelo que cabe en una 4090"; DeepSeek-V4 es el candidato a "pagaré por 8× H200". **¿Gemma 4 admite entradas de visión / multimodales?** El lanzamiento principal de Gemma 4 está ajustado solo para texto (`*-it`). Google históricamente ha seguido los lanzamientos de texto con variantes de visión PaliGemma — sigue [huggingface.co/google](https://huggingface.co/google) para actualizaciones. Para un modelo abierto con capacidad de imagen hoy, mira [Kimi K2.5](/guides/guides_v2-es/modelos-de-lenguaje/kimi-k2.md) o [Llama 4 Scout](/guides/guides_v2-es/modelos-de-lenguaje/llama4.md). *** ## Guías relacionadas * [vLLM](/guides/guides_v2-es/modelos-de-lenguaje/vllm.md) — backend de servicio de producción usado en esta guía * [Ollama](/guides/guides_v2-es/modelos-de-lenguaje/ollama.md) — la forma más rápida de probar localmente con compilaciones GGUF * [Llama 4](/guides/guides_v2-es/modelos-de-lenguaje/llama4.md) — la alternativa MoE de Meta con 10M de contexto * [GLM-5.1](/guides/guides_v2-es/modelos-de-lenguaje/glm-5-1.md) — MoE de codificación de clase de vanguardia (744B/40B-activo) cuando la clase de tamaño de Gemma no es suficiente * [Qwen3.5](/guides/guides_v2-es/modelos-de-lenguaje/qwen35.md) — denso de 35B con Apache 2.0, la otra opción fuerte de una sola GPU * [Gemma 3](/guides/guides_v2-es/modelos-de-lenguaje/gemma3.md) — la generación anterior, una línea base útil para la migración ### Enlaces * [Gemma 4 26B MoE en Hugging Face](https://huggingface.co/google/gemma-4-26b-it) * [Gemma 4 31B denso en Hugging Face](https://huggingface.co/google/gemma-4-31b-it) * [Términos de uso de Gemma](https://ai.google.dev/gemma/terms) * [Política de uso prohibido de Gemma](https://ai.google.dev/gemma/prohibited_use_policy) * [documentación de vLLM](https://docs.vllm.ai) * [repositorio SGLang](https://github.com/sgl-project/sglang) --- # Agent Instructions This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com. ## Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter: ``` GET https://docs.clore.ai/guides/guides_v2-es/modelos-de-lenguaje/gemma4.md?ask=&goal= ``` `ask` is the immediate question: it should be specific, self-contained, and written in natural language. `goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.