Google on KnightLi Blog

Gemini Embedding 2: texto, imagen, video y audio en un mismo espacio vectorial

Mon, 04 May 2026 06:01:10 +0800

Google Developers Blog presento el uso de Gemini Embedding 2 para desarrollo. El modelo ya esta en GA a traves de Gemini API y Gemini Enterprise Agent Platform. Lo importante no es solo que sea “un nuevo modelo de embedding”, sino que puede mapear texto, imagenes, video, audio y documentos al mismo espacio semantico.

Esto amplia los limites de los sistemas de recuperacion. Antes, muchos flujos RAG necesitaban convertir imagenes, videos o audio en texto o metadatos y crear indices separados. Gemini Embedding 2 puede procesar directamente entradas multimodales, haciendo que agents, busqueda y sistemas de clasificacion trabajen mas facilmente con materiales reales de negocio.

Enlace original: Building with Gemini Embedding 2: Agentic multimodal RAG and beyond

Capacidades del modelo

Gemini Embedding 2 admite mas de 100 idiomas. Una sola solicitud puede procesar:

Hasta 8,192 tokens de texto.
Hasta 6 imagenes.
Hasta 120 segundos de video.
Hasta 180 segundos de audio.
Hasta 6 paginas PDF.

La clave es el “espacio semantico unificado”. Los desarrolladores pueden poner contenidos de distintas modalidades en una misma representacion vectorial y aplicar la misma logica de recuperacion, clustering o reranking.

Por ejemplo, una descripcion de texto y una imagen pueden ir en la misma solicitud de embedding:

from google import genai
from google.genai import types

client = genai.Client()

with open('dog.png', 'rb') as f:
    image_bytes = f.read()
result = client.models.embed_content(
    model='gemini-embedding-2',
    contents=[
        "An image of a dog",
        types.Part.from_bytes(
            data=image_bytes,
            mime_type='image/png',
        ),
    ]
)

print(result.embeddings)

Si quieres obtener un embedding separado para cada entrada, en vez de agregarlas en un unico vector, puedes usar Batch API. El articulo tambien menciona que Agent Platform sigue avanzando en este soporte por lotes.

Que significa para RAG

El embedding multimodal es muy util para RAG agentico. Un AI agent puede necesitar revisar al mismo tiempo repositorios de codigo, PDF, capturas, graficos, transcripciones de reuniones y fotos de producto. Si todos los materiales entran en el mismo espacio semantico, la recuperacion no necesita una entrada distinta para cada formato.

Google recomienda usar task prefix segun la tarea para acercar el embedding al objetivo de recuperacion. Por ejemplo, preguntas y respuestas, fact checking, recuperacion de codigo y resultados de busqueda pueden usar prefijos distintos:

# Generate embedding for your task's query:
def prepare_query(query):
    return f"task: question answering | query: {content}"
    # return f"task: fact checking | query: {content}"
    # return f"task: code retrieval | query: {content}"
    # return f"task: search result | query: {content}"
# Generate embedding for document of an asymmetric retrieval task:
def prepare_document(content, title=None):
    if title is None:
        title = "none"
    return f"title: {title} | text: {content}"

Este prefijo encaja con recuperacion asimetrica: las consultas suelen ser cortas y los documentos largos. Preparar query y document con formatos de tarea distintos puede mejorar el emparejamiento entre consulta corta y documento largo.

El articulo da dos resultados reales:

Harvey mejoro un 3% el Recall@20 precision frente a la generacion anterior de embedding en benchmarks legales.
Supermemory mejoro un 40% el Recall@1 en precision de busqueda y lo usa en memoria, indexacion, busqueda y Q&A.

Estos numeros no significan que todos los escenarios mejoren igual, pero muestran que el embedding multimodal ya no es solo una demostracion, sino que produce efecto en productos reales de busqueda.

Busqueda visual

Gemini Embedding 2 tambien encaja con busqueda por imagen, busqueda mixta imagen-texto e identificacion de productos. El articulo menciona que Nuuly, una empresa de alquiler de ropa, lo uso para emparejar fotos de ropa sin etiquetar en almacen: Match@20 subio de 60% a casi 87%, y el exito total de identificacion paso de 74% a mas de 90%.

La clave de estos escenarios no es generar contenido, sino entender “a que inventario, documento o registro de producto se parece mas esta imagen”. Si tu negocio tiene muchas imagenes, clips de video o documentos escaneados, el embedding multimodal es mas natural que un indice puramente textual.

Reranking de recuperacion

El embedding tambien puede usarse para rerank. Una practica comun es recuperar primero un grupo de candidatos y luego calcular la similitud entre cada candidato y la consulta del usuario, subiendo los resultados mas relevantes:

# 1. Define a function to calculate the dot product (cosine similarity)
def dot_product(a: np.ndarray, b: np.ndarray):
  return (np.array(a) @ np.array(b).T)
# 2. Retrieve your embeddings
# (Assuming 'summaries' is your list of search results)
search_res = get_embeddings(summaries)
embedded_query = get_embeddings([query])

# 3. Calculate similarity scores
sim_value = dot_product(search_res, embedded_query)

# 4. Select the most relevant result
best_match_index = np.argmax(sim_value)

El articulo tambien menciona otra idea: pedir primero al modelo que genere una respuesta hipotetica con su conocimiento interno, hacer embedding de esa respuesta y compararla con los candidatos. Esto ayuda a elegir resultados semanticamente mas cercanos, especialmente en RAG de preguntas y respuestas.

Clustering, clasificacion y deteccion de anomalias

Ademas de recuperacion, los embeddings sirven para clustering, clasificacion y deteccion de anomalias. A diferencia de la recuperacion de preguntas y respuestas, estas son tareas simetricas: query y document pueden usar el mismo prefijo de tarea.

# Generate embedding for query & document of your task.
def prepare_query_and_document(content):
    # return f'task: clustering | query: {content}'
    # return f'task: sentence similarity | query: {content}'
    # return f'task: classification | query: {content}'

Estas tareas pueden aplicarse a clasificacion de opinion publica, moderacion de contenido, agrupacion de activos similares y deteccion de muestras anomalas. Tambien pueden ayudar a un agent a ordenar mucho contexto antes de entrar en razonamiento posterior.

Almacenamiento y coste

Gemini Embedding 2 devuelve por defecto vectores de 3,072 dimensiones. Usa Matryoshka Representation Learning, por lo que puedes truncar el vector a una dimension menor con output_dimensionality. Google recomienda 1,536 o 768 dimensiones cuando la eficiencia es prioritaria:

result = client.models.embed_content(
    model="gemini-embedding-2",
    contents="What is the meaning of life?",
    config={"output_dimensionality": 768}
)

Los vectores pueden almacenarse en Agent Platform Vector Search, Pinecone, Weaviate, Qdrant, ChromaDB y sistemas similares. En coste, el articulo menciona que Batch API ofrece mayor throughput y puede llegar al 50% del precio por defecto de embeddings.

Como usarlo como desarrollador

Si ya tienes RAG textual, puedes empezar con dos mejoras incrementales:

Poner PDF, capturas, descripciones de imagen y documentos de texto en un mismo indice, y comprobar si la recuperacion se vuelve mas estable.
Agregar task prefix para distintas tareas, como Q&A, fact checking, recuperacion de codigo y busqueda de productos. No proceses todo con el mismo formato de embedding.

Si estas creando un producto nuevo, considera primero estas direcciones:

Base de conocimiento empresarial: recuperar documentos, graficos, capturas de presentaciones y material de reuniones al mismo tiempo.
Busqueda visual: encontrar productos, activos, disenos y archivos usando imagen, texto o entradas mixtas.
Toolchain de Agent: permitir que coding agents, research agents o agentes de soporte recuperen materiales de negocio en varios formatos.
Gobernanza de contenido: clasificar, agrupar y detectar anomalias en texto, imagenes y clips de video.

El valor de Gemini Embedding 2 esta en convertir materiales multimodales en un mismo conjunto de activos recuperables. Para desarrolladores, reduce la capa intermedia de “convertir primero a texto y luego buscar”, y acerca los sistemas RAG a la forma real de los datos del mundo.

Cómo llamar a Google Nano Banana para recortar fondos de imágenes

Thu, 09 Apr 2026 20:10:48 +0800

Este artículo usa un script Python realmente ejecutable para demostrar cómo llamar a la capacidad de edición de imágenes Nano Banana de Google y recortar fondos de imágenes de producto.

El objetivo de esta implementación es muy claro:

Leer imágenes de producto desde un directorio
Llamar al modelo de imagen de Google para eliminar el fondo
Hacer una limpieza local adicional del fondo transparente sobre la imagen devuelta
Exportar finalmente como PNG con fondo transparente

Si ya tienes un lote de imágenes de producto con fondo blanco, fotos de auriculares o cables, y quieres generar rápidamente imágenes de fondo transparente aptas para e-commerce, esta forma es bastante directa.

Qué hace este código

Este script se divide principalmente en 4 partes:

Definir el prompt para que el modelo sepa que debe “quitar fondo, conservar sujeto, no añadir sombras”
Llamar a la interfaz de generación de imágenes de google-genai
Extraer el resultado de imagen desde la respuesta del modelo
Usar lógica local para convertir fondos claros de los bordes en transparencia, reduciendo restos de borde

Es decir, no se limita a enviar una imagen al modelo y terminar, sino que encadena “edición con modelo + posprocesamiento local”.

Preparación antes de ejecutar

Primero instala dependencias:

`1`	`.\.venv\Scripts\python.exe -m pip install google-genai pillow`

Cómo obtener GEMINI_API_KEY

GEMINI_API_KEY es la clave usada para llamar a Gemini API. Según el quickstart oficial de Google, si todavía no tienes una key, puedes crearla directamente en Google AI Studio.

Pasos:

Abre Google AI Studio.
Inicia sesión con tu cuenta de Google.
Busca la página Get API key o API keys.
Crea una nueva API key.
Copia la key generada.
Configúrala como variable de entorno local para que el script pueda leerla.

Si la página todavía no tiene un proyecto disponible, normalmente hay que completar primero la inicialización del proyecto y después volver a la página de API Key para crear la clave.

Después de obtener la key, configura la variable de entorno:

`1`	`$env:GEMINI_API_KEY="your_api_key"`

Si usas cmd, puedes escribir:

`1`	`set GEMINI_API_KEY=your_api_key`

Si configuras a la vez GEMINI_API_KEY y GOOGLE_API_KEY, en ejecución normalmente se leerá primero GOOGLE_API_KEY, así que se recomienda conservar solo una para evitar confusión.

Ejemplo de estructura de directorios

El script recibe dos parámetros:

input_dir: directorio de imágenes de entrada
output_dir: directorio de imágenes de salida

Por ejemplo:

images/
  product1.jpg
  product2.png

output/

Cómo ejecutarlo

Suponiendo que el script se llame cutout.py, se ejecuta así:

`1`	`.\.venv\Scripts\python.exe .\cutout.py .\images .\output`

Si quieres cambiar de modelo, también puedes pasar el parámetro explícitamente:

`1`	`.\.venv\Scripts\python.exe .\cutout.py .\images .\output --model gemini-2.5-flash-image`

El script recorrerá estos formatos dentro del directorio de entrada:

.jpg
.jpeg
.png
.webp

Al terminar, generará archivos PNG con fondo transparente y el mismo nombre en el directorio de salida.

Flujo principal de llamada

La llamada clave a Google Nano Banana está aquí:

response = client.models.generate_content(
    model=model,
    contents=[PROMPT, image],
)

Aquí se pasan dos contenidos:

Un prompt de texto PROMPT
Una imagen PIL.Image

El prompt le pide al modelo eliminar el fondo completo de la imagen de producto, conservar solo el sujeto y enfatiza varios puntos:

Conservar el producto completo
Conservar detalles de cables y líneas finas
Limpiar huecos internos y zonas anulares
No añadir objetos nuevos
No añadir sombras

Este tipo de prompt influye mucho en la calidad del recorte, especialmente en detalles como cables de auriculares, bordes transparentes y zonas huecas.

Por qué hacer otro posprocesamiento local

Después de que el modelo devuelve el resultado, el script no lo guarda directamente, sino que ejecuta make_transparent_from_borders(image).

La idea de este paso es:

Buscar píxeles de fondo claros desde los bordes de la imagen
Usar búsqueda en anchura para marcar todas las zonas claras conectadas
Convertir finalmente esas zonas en transparentes

La ventaja es que puede limpiar mejor algunos bordes blancos residuales, fondos gris claro y zonas de borde poco limpias.

La condición para decidir “si es fondo” está aquí:

def is_light_background_pixel(r: int, g: int, b: int) -> bool:
    brightness = (r + g + b) / 3
    spread = max(r, g, b) - min(r, g, b)
    return brightness >= 170 and spread <= 35

En términos simples:

El color debe ser suficientemente claro
La diferencia entre los tres canales RGB no debe ser grande

Esto encaja bien con fondos blancos, gris claro o casi de color sólido en imágenes de producto.

Código fuente completo

Abajo se conserva el código fuente completo actual, para que puedas reutilizarlo o modificarlo directamente:

from __future__ import annotations

import argparse
import os
from pathlib import Path
from collections import deque

from PIL import Image

try:
    from google import genai
except ImportError as exc:  # pragma: no cover
    raise SystemExit(
        "Missing dependency: google-genai. Install it with "
        r"'.\.venv\Scripts\python.exe -m pip install google-genai'."
    ) from exc


PROMPT = (
    "Remove the entire background from this product photo and return only the product "
    "on a fully transparent background as a PNG. Keep the full product intact, preserve "
    "thin cable details, clean the inner loops and holes, and do not add any new objects "
    "or shadows."
)


def is_light_background_pixel(r: int, g: int, b: int) -> bool:
    brightness = (r + g + b) / 3
    spread = max(r, g, b) - min(r, g, b)
    return brightness >= 170 and spread <= 35


def to_pil_image(image_obj) -> Image.Image:
    if isinstance(image_obj, Image.Image):
        return image_obj
    pil_image = getattr(image_obj, "_pil_image", None)
    if isinstance(pil_image, Image.Image):
        return pil_image
    as_pil = getattr(image_obj, "pil_image", None)
    if isinstance(as_pil, Image.Image):
        return as_pil
    raise TypeError(f"Unsupported image object type: {type(image_obj)!r}")


def make_transparent_from_borders(image: Image.Image) -> Image.Image:
    rgba = image.convert("RGBA")
    width, height = rgba.size
    pixels = rgba.load()

    visited: set[tuple[int, int]] = set()
    queue: deque[tuple[int, int]] = deque()

    def push_if_bg(x: int, y: int) -> None:
        if (x, y) in visited:
            return
        r, g, b, _ = pixels[x, y]
        if is_light_background_pixel(r, g, b):
            visited.add((x, y))
            queue.append((x, y))

    for x in range(width):
        push_if_bg(x, 0)
        push_if_bg(x, height - 1)
    for y in range(height):
        push_if_bg(0, y)
        push_if_bg(width - 1, y)

    while queue:
        x, y = queue.popleft()
        for nx, ny in ((x - 1, y), (x + 1, y), (x, y - 1), (x, y + 1)):
            if 0 <= nx < width and 0 <= ny < height:
                push_if_bg(nx, ny)

    for x, y in visited:
        pixels[x, y] = (0, 0, 0, 0)

    return rgba


def save_first_image_part(response, dst: Path) -> None:
    parts = getattr(response, "parts", None)
    if parts is None and getattr(response, "candidates", None):
        parts = response.candidates[0].content.parts

    if not parts:
        raise RuntimeError("Model returned no content parts.")

    for part in parts:
        inline_data = getattr(part, "inline_data", None)
        if inline_data is None and isinstance(part, dict):
            inline_data = part.get("inline_data")

        if inline_data is None:
            continue

        if hasattr(part, "as_image"):
            image = to_pil_image(part.as_image())
            dst.parent.mkdir(parents=True, exist_ok=True)
            make_transparent_from_borders(image).save(dst)
            return

        data = getattr(inline_data, "data", None)
        mime_type = getattr(inline_data, "mime_type", "")
        if data:
            dst.parent.mkdir(parents=True, exist_ok=True)
            with open(dst, "wb") as handle:
                handle.write(data)
            with Image.open(dst) as img:
                processed = make_transparent_from_borders(img)
                processed.save(dst.with_suffix(".png"))
            if dst.suffix.lower() != ".png":
                dst.unlink(missing_ok=True)
            return

    raise RuntimeError("Model returned text only and no edited image.")


def process_image(src: Path, dst: Path, client, model: str) -> None:
    with Image.open(src).convert("RGBA") as image:
        response = client.models.generate_content(
            model=model,
            contents=[PROMPT, image],
        )
    save_first_image_part(response, dst)


def main() -> None:
    parser = argparse.ArgumentParser(description="Use Nano Banana / Gemini image editing to cut out product images.")
    parser.add_argument("input_dir", type=Path)
    parser.add_argument("output_dir", type=Path)
    parser.add_argument("--model", default="gemini-2.5-flash-image")
    args = parser.parse_args()

    api_key = os.environ.get("GEMINI_API_KEY")
    if not api_key:
        raise SystemExit("Missing GEMINI_API_KEY environment variable.")

    client = genai.Client(api_key=api_key)
    exts = {".jpg", ".jpeg", ".png", ".webp"}

    for src in sorted(args.input_dir.iterdir()):
        if not src.is_file() or src.suffix.lower() not in exts:
            continue
        dst = args.output_dir / f"{src.stem}.png"
        process_image(src, dst, client, args.model)
        print(dst)


if __name__ == "__main__":
    main()

Qué conviene optimizar después

Si quieres seguir usando este script para producción por lotes, después puedes añadir:

Reintentos ante fallos, para evitar que una sola imagen rompa todo el lote
Registro de logs, para localizar qué imagen falló
Umbrales configurables para distintos fondos
Escaneo recursivo de subdirectorios
Vista previa comparativa entre imagen original y resultado

Resumen

Si solo quieres entender rápido “cómo llamar a Google Nano Banana para recortar fondos”, el núcleo son tres pasos:

Instalar google-genai y Pillow
Configurar GEMINI_API_KEY
Usar client.models.generate_content() pasando prompt e imagen

El valor de este código está en que no solo llama al modelo, sino que añade posprocesamiento de fondo transparente, por lo que sirve mejor para tareas reales de recorte de imágenes de producto.

Comparación de modelos Google Gemma 4: cómo elegir entre 2B/4B/26B/31B

Sun, 05 Apr 2026 08:30:00 +0800

Gemma 4 se centra en la “multimodalidad” y la “inferencia local fuera de línea”, con una gama completa desde modelos livianos hasta modelos de alto rendimiento. Para la mayoría de los usuarios de implementación local, la clave no es elegir el modelo más grande, sino el que mejor se adapte a las necesidades de hardware y tareas.

Comparación de modelos Gemma 4

La siguiente tabla es para una selección rápida del modelo. El rendimiento real y el uso de recursos deben validarse en su propio entorno.

Modelo	Tamaño del parámetro	Posicionamiento	Fortalezas clave	Principales limitaciones	Escenarios recomendados
Gema 4 2B	2B	Ultraligero	Baja latencia, bajo uso de recursos, barrera de implementación más baja	Rendimiento limitado en razonamientos complejos y largas cadenas de tareas	Móvil, IoT, preguntas y respuestas ligeras, automatización sencilla
Gema 4 4B	4B	Ligero mejorado	Mayor comprensión y generación que 2B, aún fácil de implementar localmente	Límite limitado para codificación pesada y tareas complejas de agentes	Asistente local, trabajo documental básico, tareas diarias multilingües
Gema 4 26B	26B	Alto rendimiento (MoE)	Mejor razonamiento y uso de herramientas, adecuado para flujos de trabajo de producción	Requisito de VRAM y umbral de hardware significativamente mayores	Asistente de codificación, flujos de trabajo complejos, agentes internos empresariales
Gema 4 31B	31B	Alto rendimiento (denso)	Mejor capacidad general y mayor estabilidad en tareas complejas	Mayor coste de recursos y complejidad de ajuste	Razonamiento avanzado, tareas de codificación complejas, automatización intensa

Cómo elegir: comenzar desde hardware y tareas

Si su principal preocupación es si funciona sin problemas, utilice esta guía:

VRAM 8GB: prioriza 2B/4B.
VRAM 12GB: prioriza 4B o variantes cuantificadas de modelos más grandes.
VRAM 24GB: céntrese en 26B y evalúe 31B cuantificados según la carga de trabajo.
Mayor VRAM o multi-GPU: considere configuraciones 31B de alta precisión.

Primero, priorice la estabilidad y la velocidad de inferencia y luego aumente gradualmente el tamaño del modelo.

Cuatro casos de uso típicos

1) Asistente General Local

Modelo preferido: 4B
Por qué: fuerte equilibrio entre coste y calidad, adecuado para un uso local a largo plazo.

2) Codificación y automatización

Modelo preferido: 26B
Por qué: más estable en tareas de varios pasos, llamadas a herramientas y generación de scripts.

3) Razonamiento avanzado y agentes complejos

Modelo preferido: 31B
Por qué: mayor solidez en un contexto complejo.

4) Dispositivos perimetrales y uso ligero sin conexión

Modelo preferido: 2B
Por qué: es más fácil de implementar en dispositivos con recursos limitados.

Sugerencias de implementación (Ollama)

Un enfoque práctico es iterar en pequeños pasos:

Comience con 4B para establecer una línea de base (latencia, memoria, calidad).
Cree un conjunto de pruebas fijo a partir de tareas reales (por ejemplo, 20 preguntas comunes + 10 tareas de automatización).
Compare 26B/31B con el conjunto en cuanto a precisión, latencia y costo de VRAM.
Actualice sólo cuando la ganancia sea clara.

Esto evita saltar a un modelo grande demasiado pronto y sufrir retrasos, bajo rendimiento y gastos generales de mantenimiento.

Conclusión

El valor real de Gemma 4 no es sólo un mayor número de parámetros, sino también un modelo práctico que permite pasar de ser liviano a uno de alto rendimiento:

Para una implementación rápida y de bajo costo: comience con “2B/4B”.
Para flujos de trabajo de IA locales de nivel de producción: priorice “26B”.
Para razonamiento avanzado y automatización intensa: pase a 31B.

En la mayoría de los casos, la mejor opción de Gemma 4 no es el modelo más grande, sino el que mejor se adapta a su hardware y objetivos de tareas.

Publicaciones relacionadas

Guía de Cuantización LLM (FP16/Q8/Q5/Q4/Q2)
Desinstalar completamente Ollama en Linux
Ruta de almacenamiento y migración del modelo Ollama
Cómo comprobar si Ollama usa GPU
Cómo instalar y ejecutar Gemma 4 en Android
Cómo ejecutar Gemma 4 en una computadora portátil: guía de configuración local de 5 minutos