DEV Community

Cover image for Cómo Ejecutar Gemma 4 como Backend de API
Roobia
Roobia

Posted on • Originally published at apidog.com

Cómo Ejecutar Gemma 4 como Backend de API

En resumen: Google lanzó Gemma 4 en abril de 2026, una familia de cuatro modelos abiertos licenciados bajo Apache 2.0 que supera a modelos 20 veces su tamaño en benchmarks estándar. Puedes llamar a la API de Gemma 4 a través de Google AI Studio, Vertex AI, o ejecutarla localmente con Ollama y vLLM. Combínala con Smart Mock de Apidog para generar automáticamente respuestas de API realistas a partir de tus esquemas OpenAPI sin escribir una sola regla de mock.

Prueba Apidog hoy

Introducción

La mayoría de los modelos de IA de código abierto te obligan a elegir entre potencia y facilidad de despliegue: o tienes un modelo inmanejable en un portátil, o algo pequeño e insuficiente para tareas complejas. Gemma 4 rompe ese compromiso.

Gemma 4 es la familia de modelos abiertos más capaz de Google DeepMind. El modelo Dense de 31B ocupa el #3 entre todos los modelos abiertos en Arena AI, superando a otros 20 veces más grandes. El MoE de 26B está en el sexto puesto. Ambos funcionan en una sola GPU de 80 GB. Los modelos ligeros E2B y E4B funcionan offline en móviles y dispositivos de borde.

Para desarrolladores de API, esto es clave: Gemma 4 admite llamada a funciones, salida JSON estructurada y ventanas de contexto de 256K. Es práctico para construir herramientas de API impulsadas por IA: generación de datos de prueba, mocks, análisis de respuestas y más.

💡 Tip: Si necesitas validar respuestas generadas por IA contra tu OpenAPI, Smart Mock de Apidog genera mocks automáticamente desde tu definición de API. Sin reglas manuales: Smart Mock lee tu esquema y produce datos contextualmente apropiados al instante. Descarga Apidog gratis y conéctalo a tu flujo de trabajo de API de Gemma 4.

¿Qué es Gemma 4 y qué hay de nuevo?

Gemma 4 es la cuarta generación de modelos de lenguaje abiertos de Google DeepMind. "Gemma" viene del latín "piedra preciosa". Desde 2024, los modelos Gemma han sido descargados más de 400 millones de veces. La comunidad ha generado más de 100,000 variantes: el "Gemmaverse".

Gráfico mostrando la clasificación de modelos de lenguaje en el Gemmaverse, destacando a Gemma 4

Gemma 4 está bajo licencia Apache 2.0, lo que habilita uso comercial, modificación y distribución sin restricciones. Esto es relevante para empresas y startups que requieren control total.

Novedades clave respecto a Gemma 3:

  • Entrada multimodal nativa: Imágenes y video en los cuatro modelos, audio en E2B/E4B.
  • Ventanas de contexto más largas: E2B/E4B soportan 128K tokens; 26B/31B llegan a 256K tokens.
  • Soporte nativo de agentes: Llamada a funciones, salida JSON y system instructions.
  • Razonamiento avanzado: Mejoras en matemáticas y seguimiento de instrucciones multi-step.
  • Soporte multilingüe: Más de 140 idiomas entrenados de forma nativa.
  • Licencia Apache 2.0: Uso comercial claro y sin ambigüedades.

Gráfico de clasificación de Arena AI mostrando el rendimiento de Gemma 4 en comparación con otros modelos

Variantes y capacidades del modelo Gemma 4

Cuatro tamaños, cada uno optimizado para un nivel de hardware:

Modelo Parámetros Parámetros activos Contexto Ideal para
E2B 2B efectivo ~2B 128K Móvil, IoT, borde sin conexión
E4B 4B efectivo ~4B 128K Teléfonos, Raspberry Pi, Jetson
26B MoE 26B total ~3.8B activos 256K Servidor, baja latencia
31B Dense 31B 31B 256K Máxima calidad, ajuste fino

E2B/E4B usan arquitectura MoE para ahorrar recursos y funcionar offline en móviles (AICore). El MoE de 26B es óptimo para despliegue servidor con baja latencia. El Dense de 31B es el de más calidad, ideal para ajuste fino o generación de salidas JSON complejas.

Para uso de API, el MoE 26B es el mejor equilibrio entre velocidad y calidad. El Dense 31B es ideal cuando necesitas precisión máxima y salidas estructuradas.

Todos los modelos soportan llamada a funciones y salida JSON nativa.

Configuración de la API de Gemma 4: paso a paso

Tienes tres opciones principales para usar Gemma 4: Google AI Studio, Vertex AI o despliegue local.

Opción 1: Google AI Studio (rápido para prototipos)

  1. Crea una cuenta en Google AI Studio y genera una API Key.

  2. Instala el SDK:

    pip install google-genai

  3. Llama al modelo:

    import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel("gemma-4-31b-it")
response = model.generate_content(
    "Generate a JSON object for a user account with id, email, and created_at fields."
)
print(response.text)

  4. Para salida JSON estructurada:

    import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

prompt = """
Generate 3 sample user objects for an e-commerce API. 
Each user should have: id (integer), email (string), username (string), 
created_at (ISO 8601 timestamp), and subscription_tier (free|pro|enterprise).
Return as a JSON array.
"""

response = model.generate_content(prompt)
users = json.loads(response.text)
print(json.dumps(users, indent=2))

Opción 2: Despliegue local con Ollama

  1. Instala Ollama desde ollama.com.

  2. Descarga el modelo:

    ollama pull gemma4

  3. Ejecuta el servidor:

    ollama serve

  4. Haz una llamada:

    import requests
import json

response = requests.post(
    "http://localhost:11434/api/chat",
    json={
        "model": "gemma4",
        "messages": [
            {
                "role": "user",
                "content": "Generate a valid JSON response for a REST API /products endpoint. Include id, name, price, and stock fields."
            }
        ],
        "stream": False
    }
)

result = response.json()
print(result["message"]["content"])

Opción 3: Llamada a funciones para orquestación de API

Define funciones que el modelo puede llamar y orquesta flujos de trabajo automatizados:

import google.generativeai as genai

genai.configure(api_key="YOUR_API_KEY")

tools = [
    {
        "function_declarations": [
            {
                "name": "get_api_schema",
                "description": "Retrieve the OpenAPI schema for a given endpoint path",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "endpoint_path": {
                            "type": "string",
                            "description": "The API endpoint path, e.g. /users/{id}"
                        },
                        "method": {
                            "type": "string",
                            "enum": ["GET", "POST", "PUT", "DELETE", "PATCH"]
                        }
                    },
                    "required": ["endpoint_path", "method"]
                }
            }
        ]
    }
]

model = genai.GenerativeModel("gemma-4-31b-it", tools=tools)
response = model.generate_content(
    "I need to test the GET /users/{id} endpoint. What schema should the response follow?"
)

if response.candidates[0].content.parts[0].function_call:
    fc = response.candidates[0].content.parts[0].function_call
    print(f"Model called function: {fc.name}")
    print(f"With args: {dict(fc.args)}")
Enter fullscreen mode Exit fullscreen mode

Este patrón es clave para pipelines de prueba de API con agentes.

Construyendo mocks de API impulsados por IA con Gemma 4

Gemma 4 permite generar datos mock realistas a partir de esquemas OpenAPI. Ideal cuando el backend aún no existe o para probar casos extremos.

Ejemplo práctico:

import google.generativeai as genai
import json

genai.configure(api_key="YOUR_API_KEY")

model = genai.GenerativeModel(
    "gemma-4-31b-it",
    generation_config={"response_mime_type": "application/json"}
)

schema = {
    "type": "object",
    "properties": {
        "id": {"type": "integer"},
        "order_number": {"type": "string", "pattern": "^ORD-[0-9]{6}$"},
        "status": {"type": "string", "enum": ["pending", "shipped", "delivered", "cancelled"]},
        "total": {"type": "number", "minimum": 0},
        "items": {
            "type": "array",
            "items": {
                "type": "object",
                "properties": {
                    "product_id": {"type": "integer"},
                    "quantity": {"type": "integer", "minimum": 1},
                    "unit_price": {"type": "number"}
                }
            }
        },
        "created_at": {"type": "string", "format": "date-time"}
    }
}

prompt = f"""
Generate 5 realistic mock responses for an order management API.
Each response must conform exactly to this JSON Schema:
{json.dumps(schema, indent=2)}

Make the data realistic: use realistic prices, product IDs, and varied statuses.
Return as a JSON array of 5 order objects.
"""

response = model.generate_content(prompt)
mock_orders = json.loads(response.text)
print(json.dumps(mock_orders, indent=2))
Enter fullscreen mode Exit fullscreen mode

Gemma 4 respeta enums, patrones de string y rangos numéricos de tu esquema. Puedes ampliar este patrón para cualquier endpoint de API.

Para mocking avanzado, incluye lógica condicional según la solicitud, o usa la ventana de contexto de 256K para prompts con toda tu especificación OpenAPI y generar múltiples mocks de endpoints a la vez.

Tip: Exporta tu colección de Apidog como OpenAPI, pégala en el prompt y pide a Gemma 4 que genere 10 casos de prueba por endpoint.

Probando las respuestas de la API de Gemma 4 con Apidog

Para validar que las respuestas cumplen tu esquema, usa los Escenarios de Prueba de Apidog.

Captura de pantalla de la interfaz de Apidog mostrando la validación de respuestas de API

Flujo recomendado:

  1. Importa tu endpoint Gemma 4 en Apidog: Crea el endpoint y define el esquema de respuesta esperado.

  2. Usa Smart Mock: Genera respuestas base realistas desde tu esquema. Smart Mock infiere tipos y valores según nombres de campo y especificación.

    Captura de pantalla de la configuración de Smart Mock de Apidog

  3. Crea un Escenario de Prueba: Añade la llamada a Gemma 4 como primer paso y pasos de aserción para validar la respuesta.

  4. Configura aserciones: Verifica códigos de estado, headers y estructura JSON (por ejemplo, que candidates[0].content.parts[0].text exista y sea parseable).

  5. Pruebas basadas en datos: Usa archivos CSV/JSON para variar prompts y entradas, y ejecuta múltiples pruebas automáticamente.

Todo el flujo, desde definición de esquema hasta ejecución de la prueba, puede estar listo en 15 minutos y automatizarse en CI/CD con Apidog CLI.

Casos de uso reales

  • Generación de datos de prueba de API: Produce cientos de registros realistas rápidamente introduciendo tu esquema OpenAPI.
  • Mocking inteligente: Devuelve resultados contextuales (ej. búsquedas de productos) sin codificar cada caso.
  • Generación de documentación de API: Alimenta tu codebase y deja que Gemma 4 genere especificaciones OpenAPI o documentación de endpoints.
  • Validación de esquema de respuesta: Analiza respuestas y detecta violaciones de esquema más allá de un simple validador JSON.
  • Escritura automatizada de pruebas de regresión: Da tu especificación y reportes de bugs, y genera casos de prueba para cubrir esos escenarios.

Gemma 4 vs. otros modelos abiertos para API

Modelo Parámetros Contexto Salida JSON Llamada a funciones Licencia
Gemma 4 31B 31B 256K Nativo Nativo Apache 2.0
Gemma 4 26B MoE 26B (3.8B act.) 256K Nativo Nativo Apache 2.0
Llama 3.3 70B 70B 128K Vía prompt Vía prompt Llama Comm.
Mistral 7B 7B 32K Vía prompt Limitado Apache 2.0
Qwen 2.5 72B 72B 128K Nativo Nativo Apache 2.0

Las características críticas para API son: salida JSON nativa, llamada a funciones y longitud de contexto. Gemma 4 31B y 26B tienen las tres y menor coste de cómputo que Llama 3.3 70B o Qwen 2.5 72B. Mistral 7B es rápido pero con contexto limitado.

La licencia Apache 2.0 de Gemma 4 es clara y sin restricciones comerciales, a diferencia de Llama Community.

Recomendación: Empieza con Gemma 4 26B MoE para latencia baja, o 31B para máxima calidad.

Conclusión

Gemma 4 ofrece una alternativa abierta y potente para construir herramientas de API, con licencia Apache 2.0 y capacidades nativas de llamada a funciones y salida JSON. Los cuatro tamaños cubren desde móviles hasta servidores.

Combina Gemma 4 con Apidog para un ciclo cerrado entre generación de datos y validación de API: genera mocks, prototipa esquemas y valida salidas con Smart Mock y Escenarios de Prueba. Es un workflow práctico para APIs impulsadas por IA.

FAQ

¿Qué es Gemma 4?

Gemma 4 es la última familia de modelos de lenguaje abiertos de Google DeepMind, lanzada en abril de 2026. Cuatro tamaños (E2B, E4B, 26B MoE, 31B Dense), licencia Apache 2.0. El 31B está actualmente en el top 3 de Arena AI.

¿Es gratis usar Gemma 4?

Los pesos del modelo son gratuitos bajo Apache 2.0. Pagas solo por el cómputo: ejecución local, Google AI Studio (capa gratuita con límites) o Vertex AI (tarifas estándar).

¿Puede Gemma 4 generar JSON estructurado?

Sí. Usa el parámetro response_mime_type: "application/json" en el SDK de Google para obtener siempre JSON válido.

¿Cómo se compara Gemma 4 con GPT-4o para desarrollo de API?

GPT-4o es propietario y solo en la nube. Gemma 4 31B es gratuito para despliegue local y competitivo en benchmarks de razonamiento. Mejor para privacidad o control de costes.

¿Puedo ajustar Gemma 4 con mis propios datos de API?

Sí. Google soporta ajuste fino vía AI Studio, Vertex AI y herramientas como Hugging Face TRL. Esto mejora la calidad en dominios y esquemas específicos.

¿Qué hardware necesito para ejecutar Gemma 4 localmente?

Modelos de 31B y 26B requieren una NVIDIA H100 de 80 GB (bfloat16). Versiones cuantificadas funcionan en GPUs de consumo (16-24 GB VRAM). E4B/E2B funcionan en móviles y dispositivos edge.

¿Gemma 4 soporta llamada a funciones?

Sí, nativo en todos los modelos. Define herramientas como objetos JSON; el modelo decide cuándo llamarlas y pasa argumentos estructurados.

¿Cómo pruebo las respuestas de la API de Gemma 4 automáticamente?

Usa Escenarios de Prueba de Apidog: importa tu endpoint, configura pasos y aserciones, ejecuta localmente, desde CLI o CI/CD.

Top comments (0)