DEV Community

Cover image for Cómo usar Gemma 4 12B gratis: 6 métodos efectivos en 2026
Roobia
Roobia

Posted on • Originally published at apidog.com

Cómo usar Gemma 4 12B gratis: 6 métodos efectivos en 2026

Gemma 4 12B es de pesos abiertos y tiene licencia Apache 2.0. En la práctica, “gratis” significa que no pagas API ni suscripción: descargas el modelo y lo ejecutas en tu propia máquina, o lo pruebas desde el navegador. El coste real es el hardware donde lo ejecutes.

Prueba Apidog hoy

Antes de empezar, ten en cuenta esto: Gemma 4 12B está pensado para uso local y en dispositivo. Los modelos mayores, 31B y 26B, son los que Google aloja para chat gratuito en AI Studio. El valor del 12B es que puede ejecutarse en un portátil con 16 GB de memoria. Si necesitas contexto técnico del modelo, empieza por qué es Gemma 4 12B.

Gemma 4 12B

A continuación tienes seis formas prácticas de usarlo gratis: desde una demo en navegador hasta una API local compatible con OpenAI.

Resumen rápido

Método Qué obtienes Mejor para
Hugging Face Space Chat en navegador, cero instalación Probarlo en un minuto
Ollama Modelo local + API compatible con OpenAI Desarrolladores, un comando
LM Studio Aplicación de escritorio local con GUI Usarlo sin terminal
llama.cpp Servidor API local ligero Configuraciones avanzadas y baja sobrecarga
HF Transformers Python, control total, GPU Colab gratuita Notebooks y ajuste fino
Google AI Edge Ejecución en dispositivo Teléfonos y hardware perimetral

Método 1: probarlo en el navegador sin instalar nada

La forma más rápida de validar Gemma 4 12B es usar el Space oficial de Hugging Face. No necesitas descargar pesos, crear una cuenta ni tener GPU local.

Demo de Gemma 4 12B en Hugging Face

Pasos:

  1. Abre el Space de demostración de Gemma 4 12B.
  2. Escribe un prompt.
  3. Opcionalmente, sube una imagen o un clip de audio.
  4. Revisa la respuesta generada.

Usa este método para una prueba rápida o para validar las capacidades multimodales. Si quieres integrarlo en una app o llamarlo desde código, pasa a un método local.

Método 2: Ollama para una API local rápida

Ollama es la opción más directa para desarrolladores: instala el runtime, descarga el modelo y expone una API local compatible con OpenAI.

Ollama Gemma 4 12B

1. Instala Ollama

En macOS o Linux:

curl -fsSL https://ollama.com/install.sh | sh
Enter fullscreen mode Exit fullscreen mode

En Windows, descarga el instalador desde ollama.com y ejecútalo.

2. Descarga y ejecuta Gemma 4 12B 

ollama pull gemma4:12b
ollama run gemma4:12b
Enter fullscreen mode Exit fullscreen mode

El primer comando descarga el modelo. Por defecto, Ollama usa una compilación cuantificada de 4 bits Q4_K_M, de alrededor de 8 GB. El segundo comando abre un chat interactivo.

Para salir:

/bye
Enter fullscreen mode Exit fullscreen mode

3. Llama al modelo desde una API local

Ollama expone un endpoint compatible con OpenAI en:

http://localhost:11434/v1
Enter fullscreen mode Exit fullscreen mode

Ejemplo con curl:

curl http://localhost:11434/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gemma4:12b",
    "messages": [
      {
        "role": "user",
        "content": "Explain how transformers work in two sentences."
      }
    ]
  }'
Enter fullscreen mode Exit fullscreen mode

Como el formato coincide con OpenAI, puedes reutilizar SDKs, clientes HTTP, editores, frameworks de agentes o herramientas internas cambiando solo la URL base a:

http://localhost:11434/v1
Enter fullscreen mode Exit fullscreen mode

Si trabajas con Cursor u otro IDE, el patrón es similar al de esta guía de DeepSeek V4 en Cursor: cambia el modelo por gemma4:12b.

Comandos útiles:

ollama list
ollama ps
ollama show gemma4:12b
Enter fullscreen mode Exit fullscreen mode
  • ollama list: muestra modelos descargados.
  • ollama ps: muestra modelos en ejecución.
  • ollama show gemma4:12b: imprime detalles del modelo.

Método 3: LM Studio si no quieres usar terminal

LM Studio es una aplicación de escritorio para Windows, macOS y Linux. Es útil si quieres ejecutar modelos locales desde una interfaz gráfica.

Pasos:

  1. Descarga e instala LM Studio.
  2. Busca Gemma 4 12B en el catálogo de modelos.
  3. Elige una cuantificación que encaje con tu RAM.
  4. Descarga el modelo.
  5. Abre la pestaña de chat y empieza a probar prompts.

LM Studio también puede levantar un servidor local con endpoint compatible con OpenAI, normalmente en:

http://localhost:1234/v1
Enter fullscreen mode Exit fullscreen mode

Esto te permite probar el modelo desde una GUI y, después, llamarlo desde código sin cambiar demasiado tu flujo de trabajo.

Método 4: llama.cpp para una configuración ligera

llama.cpp ejecuta modelos GGUF con poca sobrecarga y ofrece su propio servidor compatible con OpenAI.

Instalación:

# macOS
brew install llama.cpp

# Windows
winget install llama.cpp
Enter fullscreen mode Exit fullscreen mode

Después, inicia un servidor apuntando a la compilación GGUF oficial. Busca la colección ggml-org/gemma-4 en Hugging Face para confirmar el repositorio exacto del modelo 12B y pásalo a llama-server:

llama-server -hf ggml-org/gemma-4-12B-it-GGUF
Enter fullscreen mode Exit fullscreen mode

El servidor expone una API compatible con OpenAI en:

http://localhost:8080/v1
Enter fullscreen mode Exit fullscreen mode

Usa esta ruta si quieres:

  • Menos dependencias.
  • Más control sobre flags de ejecución.
  • Mejor ajuste para hardware modesto.
  • Un runtime local reutilizable en otras herramientas.

Método 5: Hugging Face Transformers para control total en Python

Si quieres notebooks, scripts, experimentos o ajuste fino, usa Transformers. Si no tienes GPU local, puedes ejecutar el flujo en un notebook gratuito de Google Colab.

Instala dependencias:

pip install transformers torch accelerate torchvision

# Para entrada de audio y vídeo
pip install librosa
Enter fullscreen mode Exit fullscreen mode

Ejemplo básico de generación:

from transformers import AutoProcessor, AutoModelForMultimodalLM

MODEL_ID = "google/gemma-4-12B-it"

processor = AutoProcessor.from_pretrained(MODEL_ID)
model = AutoModelForMultimodalLM.from_pretrained(
    MODEL_ID,
    dtype="auto",
    device_map="auto",
)

messages = [
    {"role": "system", "content": "You are a helpful assistant."},
    {"role": "user", "content": "Write a short joke about saving RAM."},
]

inputs = processor.apply_chat_template(
    messages,
    tokenize=True,
    return_dict=True,
    return_tensors="pt",
    add_generation_prompt=True,
    enable_thinking=False,
).to(model.device)

input_len = inputs["input_ids"].shape[-1]

outputs = model.generate(
    **inputs,
    max_new_tokens=1024
)

response = processor.decode(
    outputs[0][input_len:],
    skip_special_tokens=False
)

print(processor.parse_response(response))
Enter fullscreen mode Exit fullscreen mode

Para activar razonamiento paso a paso:

enable_thinking=True
Enter fullscreen mode Exit fullscreen mode

Para entrada multimodal, añade contenido estructurado:

  • Imagen antes del texto: {"type": "image", ...}
  • Audio después del texto: {"type": "audio", ...}

Los pesos también están disponibles en Kaggle si prefieres esa fuente. Para patrones completos de código, revisa la guía del desarrollador.

Método 6: Google AI Edge para móviles y dispositivos perimetrales

Para ejecutar Gemma 4 12B en teléfonos o hardware perimetral, Google distribuye la pila AI Edge. Tanto Google AI Edge Gallery como la CLI LiteRT-LM permiten ejecutar el 12B en el dispositivo.

Ejemplo con LiteRT-LM:

litert-lm import \
  --from-huggingface-repo=litert-community/gemma-4-12B-it-litert-lm \
  gemma-4-12B-it.litertlm gemma4-12b

litert-lm serve
Enter fullscreen mode Exit fullscreen mode

Este método encaja mejor cuando necesitas:

  • Asistentes móviles sin conexión.
  • Aplicaciones embebidas.
  • Procesamiento local de datos.
  • Evitar que los datos salgan del dispositivo.

Prueba tu API local de Gemma 4 12B con Apidog

Cuando Gemma 4 12B funciona con Ollama o llama.cpp, ya tienes una API HTTP local. Antes de conectarla a una app, conviene validar el contrato de solicitud y respuesta con un cliente API. Apidog sirve para probar, documentar y depurar ese endpoint.

Probar API local de Gemma 4 12B con Apidog

Configuración recomendada:

  1. Descarga Apidog y crea un proyecto HTTP.
  2. Añade una solicitud POST.
  3. Usa la URL de Ollama: 
http://localhost:11434/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode

O la de llama.cpp:

http://localhost:8080/v1/chat/completions
Enter fullscreen mode Exit fullscreen mode
  1. Configura el cuerpo como JSON.
  2. Pega esta carga útil: 
{
  "model": "gemma4:12b",
  "messages": [
    {
      "role": "user",
      "content": "Return a JSON object with two fields: city and country."
    }
  ],
  "stream": false
}
Enter fullscreen mode Exit fullscreen mode
  1. Guarda la URL base como variable de entorno para alternar entre Ollama y llama.cpp.
  2. Añade una aserción para comprobar que el campo content contiene JSON válido.
  3. Cambia stream a true para validar streaming antes de construir una interfaz de usuario.

Ejemplo de variable de entorno:

BASE_URL=http://localhost:11434/v1
Enter fullscreen mode Exit fullscreen mode

Después usa:

{{BASE_URL}}/chat/completions
Enter fullscreen mode Exit fullscreen mode

La ventaja es simple: detectas prompts malformados, campos incorrectos o errores de streaming en Apidog antes de depurarlos dentro de tu aplicación.

Si estás comparando herramientas, revisa estas recopilaciones de herramientas gratuitas de prueba de API en línea y alternativas a Postman. El mismo flujo funciona con cualquier endpoint compatible con OpenAI, igual que en una configuración de pruebas de APIs con Postman.

¿Qué cuantificación deberías elegir?

Gemma 4 12B se adapta a distintas máquinas según el nivel de compresión.

Compilación Memoria necesaria Compensación
Precisión completa ~16 GB Mejor calidad
8 bits ~14 GB Calidad casi completa
4 bits Q4_K_M ~8 GB Ligera caída de calidad, mayor compatibilidad

Ollama usa por defecto la versión de 4 bits. Por eso puede funcionar en una GPU de 8 GB o en un MacBook con 16 GB de memoria unificada. Si tienes margen de memoria, prueba la compilación de 8 bits para mejorar calidad.

¿Qué método gratuito deberías usar?

Usa esta regla rápida:

  • Solo quieres probar el modelo: Hugging Face Space.
  • Estás desarrollando software: Ollama.
  • No quieres usar terminal: LM Studio.
  • Quieres baja sobrecarga: llama.cpp.
  • Trabajas en notebooks o fine-tuning: Hugging Face Transformers.
  • Necesitas ejecución en móvil o edge: Google AI Edge.

Para la mayoría de desarrolladores, Ollama es la mejor opción diaria. Transformers queda para experimentos más controlados o trabajos pesados.

Consejos para ejecutar Gemma 4 12B localmente

  • Ajusta la cuantificación a tu RAM. Si el sistema empieza a intercambiar memoria a disco, la generación será lenta. La versión de 4 bits es la opción segura.
  • Activa enable_thinking=True solo cuando haga falta. Úsalo para matemáticas o razonamiento de varios pasos. Déjalo desactivado para respuestas rápidas.
  • Controla el tamaño del contexto. La ventana de 256K es grande, pero transcripciones largas y bases de código pueden llenarla.
  • Valida primero la API en Apidog. Confirma estructura JSON, streaming y nombres de campos antes de integrarlo en tu app.
  • Reutiliza el mismo patrón con otros modelos locales. Puedes aplicar un flujo similar a Qwen 3.7, MiniMax M3 y Claude Opus 4.8.

Preguntas frecuentes

¿Gemma 4 12B es realmente gratis?

Sí. Es de pesos abiertos y tiene licencia Apache 2.0. Puedes descargarlo y ejecutarlo gratis, incluso para uso comercial. Solo pagas el hardware o la nube donde lo ejecutes.

¿Necesito una GPU?

No, pero ayuda. La versión de 4 bits puede ejecutarse en una GPU de 8 GB o en un Mac con 16 GB de memoria unificada. En CPU también puede funcionar, pero será más lento.

¿Puedo usar Gemma 4 12B en Google AI Studio?

Actualmente no. AI Studio aloja los modelos 31B y 26B para chat gratuito en navegador. Gemma 4 12B está diseñado para ejecución local y en dispositivo.

¿La API local necesita clave API?

No. Ollama y llama.cpp sirven el modelo en localhost sin clave. Si una herramienta exige un campo de API key, puedes usar una cadena de marcador de posición; el servidor local la ignorará.

¿Puedo llamarlo desde mi código existente de OpenAI?

Sí. Ollama y llama.cpp exponen endpoints compatibles con OpenAI.

Usa estas URLs base:

# Ollama
http://localhost:11434/v1

# llama.cpp
http://localhost:8080/v1
Enter fullscreen mode Exit fullscreen mode

Después conserva la estructura habitual de chat/completions.

¿Cómo uso imagen y audio?

Usa Transformers, LM Studio o las aplicaciones de AI Edge, que admiten entrada multimodal. Añade contenido de imagen antes del prompt de texto y contenido de audio después.

¿Qué es más rápido: Ollama o llama.cpp?

Ambos usan el mismo motor subyacente. llama.cpp ofrece menos sobrecarga y más flags de ajuste. Ollama es más fácil de instalar y operar. Para la mayoría de usuarios, la diferencia práctica es pequeña.

Top comments (0)