Gemini on KnightLi Blog

En qué se diferencian los mecanismos de memoria de ChatGPT, Claude Code y Gemini

Thu, 07 May 2026 14:47:17 +0800

La “memoria” se está volviendo cada vez más importante en los productos de IA. Marca el paso de conversaciones puntuales a colaboración de largo plazo: ya no necesitas volver a explicar tu contexto, repetir tus preferencias ni pedir al modelo que entienda el mismo proyecto una y otra vez.

Pero memoria no significa lo mismo en todos los productos. ChatGPT, Claude Code y Gemini intentan ayudar a la IA a recordar más tiempo, pero sus objetivos, lugares de almacenamiento, transparencia y casos de uso son muy distintos.

Al 7 de mayo de 2026, se pueden entender aproximadamente como tres tipos:

ChatGPT se parece más a memoria de asistente personal.
Claude Code se parece más a memoria de proyecto de ingeniería.
Gemini se parece más a contexto del ecosistema Google.

ChatGPT: preferencias de largo plazo alrededor de la persona

La memoria de ChatGPT está diseñada principalmente para colaboración personal. Le importa quién eres, qué prefieres y en qué trabajas a lo largo del tiempo.

OpenAI separa actualmente la memoria de ChatGPT en saved memories y chat history.

saved memories son piezas importantes de información que ChatGPT guarda, como tu nombre, preferencias, objetivos, stack tecnológico habitual y hábitos de escritura. Puedes pedirle explícitamente que recuerde algo, y también puede guardar información de una conversación cuando cree que será útil más adelante.

chat history permite a ChatGPT consultar conversaciones anteriores al responder. No significa que cada chat se convierta en una memoria permanente. Más bien, ChatGPT puede buscar en conversaciones pasadas contexto relevante cuando lo necesita.

La lógica central de ChatGPT es: entender al mismo usuario entre sesiones.

Ejemplos típicos:

“Mantén mis ejemplos de código concisos.”
“Uso principalmente Python y TypeScript.”
“Estoy escribiendo un blog Hugo sobre herramientas de IA.”
“Prefiero conclusiones primero y detalles después.”

Estas memorias no están ligadas a un solo proyecto. Siguen a la cuenta y a los hábitos de trabajo del usuario.

Memory Sources: hacer más visible la personalización

OpenAI destacó Memory sources en su actualización de mayo de 2026.

El objetivo no es añadir otro tipo de memoria, sino mostrar al usuario qué fuentes consultó ChatGPT al personalizar una respuesta. Según los documentos de ayuda de OpenAI, Memory Sources puede mostrar:

Chats anteriores.
Memorias guardadas.
Instrucciones personalizadas.
Archivos de la biblioteca de archivos.
Correos de Gmail conectado.

La visibilidad de archivos y Gmail depende del plan, la región y el estado de conexión. OpenAI también dice que Memory sources puede no mostrar todos los factores que influyeron en una respuesta, pero ayuda a entender y gestionar la personalización.

Esto importa. Cuanto más puede la IA “recordarte”, más necesitas saber qué usó para responder. De lo contrario, la personalización se vuelve una caja negra: parece conocerte, pero no sabes por qué.

La ventaja de ChatGPT es su comprensión de preferencias personales entre sesiones y temas. El riesgo es que las memorias se vuelvan obsoletas, o que el usuario olvide que una memoria antigua sigue afectando respuestas. Vale la pena limpiar periódicamente memorias guardadas y chats antiguos.

Claude Code: alrededor de codebases y reglas de ingeniería

La memoria de Claude Code está más orientada a ingeniería. Le importan menos las preferencias cotidianas del usuario y más cómo debe modificarse este codebase.

Claude Code tiene dos mecanismos de memoria que se confunden fácilmente:

Memoria explícita del proyecto: CLAUDE.md.
Memoria automática del proyecto: Auto Memory.

CLAUDE.md es el archivo de memoria de proyecto más básico y estable. Puede vivir en la raíz del proyecto o dentro de subdirectorios. Claude Code lee estos archivos como instrucciones de proyecto y reglas operativas.

Buen contenido para CLAUDE.md:

Comandos comunes de build, test y lint.
Reglas de estilo y nombres.
Notas de arquitectura del proyecto.
Límites de módulos y zonas de riesgo.
Convenciones del equipo y flujo de commits.

Si CLAUDE.md se guarda en el repositorio, puede versionarse con Git y compartirse como guía de agente para el equipo. Esto es completamente distinto de la memoria personal en la nube de ChatGPT.

Claude Code Auto Memory: acumular experiencia de proyecto

Claude Code también tiene Auto Memory. Su objetivo es permitir que Claude acumule conocimiento del proyecto entre sesiones sin obligar al usuario a escribir cada nota manualmente.

Según la documentación de Claude Code, Auto Memory permite a Claude guardar notas mientras trabaja, como comandos de build, descubrimientos de depuración, notas de arquitectura, preferencias de estilo y hábitos de workflow. No guarda cada sesión, sino que decide qué puede ser útil más adelante.

Un malentendido común es creer que Auto Memory escribe por defecto en .claude/memory.md dentro de la raíz del proyecto. La documentación oficial dice que cada proyecto tiene su propio directorio de memoria bajo el home del usuario, con una ruta similar a:

`1`	`~/.claude/projects/<project>/memory/`

MEMORY.md carga las primeras 200 líneas o 25KB al inicio de cada conversación, mientras que el contenido detallado puede dividirse en otros archivos temáticos. Los archivos de Auto Memory son Markdown locales, y el usuario puede verlos, editarlos o borrarlos mediante /memory.

Esto hace que la memoria de Claude Code se parezca más a una base local de conocimiento de proyecto. Está más cerca del codebase que la memoria personal de ChatGPT, y es más dinámica que un simple CLAUDE.md.

Pero Auto Memory es local a la máquina. No sigue naturalmente al repositorio hacia otras máquinas o entornos cloud. Para reglas estables compartidas por el equipo, ponlas en el CLAUDE.md del repositorio.

Gemini: alrededor del contexto del ecosistema Google

La lógica de memoria de Gemini vuelve a ser distinta.

Gemini también soporta información guardada y referencias a chats anteriores. Los documentos de ayuda de Google dicen que los usuarios pueden guardar información sobre vida, trabajo o preferencias, y Gemini puede consultar chats pasados antes de responder. Cuando usa esta información, la respuesta puede mostrar fuentes como Your saved info o Previous chats.

Pero la diferenciación de Gemini no es solo “guardar unas preferencias”. Es la integración con el ecosistema Google.

Con autorización del usuario y disponibilidad de funciones, Gemini puede acceder a contexto de apps conectadas de Google como Gmail, Google Drive, Docs y Sheets. Su ventaja no es hacer que el usuario le enseñe cada dato manualmente, sino convertir los datos existentes de la cuenta Google en contexto de trabajo buscable.

Una diferencia típica:

ChatGPT recuerda: “Últimamente he estado reparando una unidad de cinta LTO.”
Gemini puede encontrar el correo de confirmación de compra en Gmail o leer notas de reparación desde Drive.

Esto no significa que Gemini pueda leer todos los datos de Google sin condiciones. Depende del tipo de cuenta, región, permisos, apps conectadas, ajustes de Keep Activity y disponibilidad del producto. Las cuentas empresariales y escolares también pueden estar controladas por administradores de Google Workspace.

Más exactamente, la memoria de Gemini es una combinación de información guardada, chats anteriores y datos conectados del ecosistema Google.

Diferencias centrales

Dimensión	ChatGPT	Claude Code	Gemini
Objeto central	Persona y preferencias	Proyecto y codebase	Cuenta Google y datos del ecosistema
Memoria típica	Preferencias, contexto personal, objetivos de largo plazo	Arquitectura, comandos, convenciones, experiencia de depuración	Información guardada, chats anteriores, contexto de Gmail/Drive/Docs
Forma de almacenamiento	Memoria y contexto de chat en la cuenta OpenAI	`CLAUDE.md`, `MEMORY.md`, archivos Markdown locales	Actividad de cuenta Google, información guardada, datos de apps conectadas
Transparencia	Memory sources muestra parte de la fuente	Los archivos Markdown se pueden abrir y editar	Se gestiona con indicaciones de fuente, Gemini Apps Activity y ajustes Google
Capacidad entre proyectos	Fuerte, sigue a la cuenta de usuario	Débil, principalmente sigue al proyecto o memoria local	Fuerte, depende de datos y permisos de Google
Compartición en equipo	No adecuada para compartir directamente	`CLAUDE.md` puede compartirse por Git	Depende sobre todo de Workspace y permisos
Mejor para	Preferencias personales y comportamiento de asistente a largo plazo	Proyectos de código largos y colaboración con agentes	Recuperación en Google Workspace y trabajo entre herramientas

Cómo elegir

Si quieres que la IA recuerde quién eres, qué estilo prefieres y cómo sueles trabajar, la memoria de ChatGPT es más adecuada.

Sirve para guardar preferencias personales como estilo de escritura, stack técnico, formato de respuesta, contexto profesional y dirección de proyectos de largo plazo. Su foco es reducir el coste de presentarte de nuevo para que cada conversación empiece más rápido.

Si quieres que la IA recuerde cómo debe cambiarse un codebase, qué comandos funcionan y qué trampas evitar, Claude Code es más adecuado.

Pon reglas estables en CLAUDE.md para compartirlas con el equipo. Deja que Auto Memory ayude con experiencia dinámica. Las decisiones importantes deberían organizarse aún en documentación o CLAUDE.md, no quedar solo en memoria automática local.

Si la mayoría de tus materiales viven en Gmail, Drive, Docs y Sheets, el contexto de ecosistema de Gemini tiene ventaja.

Es útil para encontrar correos antiguos, organizar documentos de Drive y conectar calendario y materiales de oficina. La clave al usar Gemini no es recordarle todo repetidamente en chat, sino asegurarse de que las conexiones de apps, permisos y ajustes de actividad relevantes estén correctos.

Una división práctica del trabajo

Puedes dividirlos así:

ChatGPT recuerda preferencias personales generales.
Claude Code recuerda conocimiento de ingeniería para un repositorio.
Gemini recupera materiales de tu ecosistema Google.

En otras palabras, ChatGPT es como un secretario personal, Claude Code como un ingeniero senior dentro del proyecto, y Gemini como un indexador de tu cuenta Google.

No hay ganador absoluto. Tienen objetivos distintos.

El mayor error es mezclarlos. Las preferencias personales no siempre pertenecen a la memoria de proyecto; la arquitectura del proyecto no siempre pertenece a la memoria personal en la nube; y recuperar datos del ecosistema Google no significa que el modelo te entienda de verdad a largo plazo.

Lectura breve

La siguiente etapa de la memoria en IA no es simplemente “recordar más”. La memoria necesita capas, visibilidad y control.

ChatGPT se centra en personalización entre sesiones. Claude Code se centra en continuidad de proyectos de código. Gemini se centra en contexto del ecosistema Google. Una buena colaboración de largo plazo con IA no pone toda la información en una sola caja negra; mantiene cada tipo de memoria en el lugar correcto.

Pon preferencias personales en memoria personal, reglas de ingeniería en el codebase, y materiales históricos en los sistemas originales de documentos y correo. El trabajo de la IA es llamar el contexto correcto cuando hace falta, no mezclar todo en una sola pila.

Enlaces

OpenAI Memory FAQ: https://help.openai.com/en/articles/8590148-memory-faq
ChatGPT Release Notes: https://help.openai.com/en/articles/6825453-chatgpt-release-notes
Claude Code Memory: https://code.claude.com/docs/en/memory
Gemini Saved info: https://support.google.com/gemini/answer/15637730
Gemini Apps Privacy Hub: https://support.google.com/gemini/answer/13594961

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 dividir tareas entre ChatGPT, Claude y Gemini: elección de uso diario, codificación y capacidades especiales

Sat, 25 Apr 2026 10:51:19 +0800

Mucha gente ya no confía en un solo modelo. En cambio, alternan entre “ChatGPT”, “Claude” y “Gemini”. Eso hace que la pregunta sea mucho más práctica: ¿qué tipo de tareas deberían asignarse a qué modelo?

Esto resulta confuso no porque los tres sean débiles, sino porque ahora son fuertes de diferentes maneras. Si aún así eliges basándose en un estándar vago como “cuál es más inteligente”, fácilmente puedes terminar eligiendo la herramienta equivocada.

Si simplificamos primero la conclusión, queda más o menos así:

Para conversaciones diarias y tareas de propósito general, muchas personas comienzan con ChatGPT
Para la codificación de línea de comandos, la colaboración de contexto prolongado y la ejecución sostenida de tareas, “Claude” a menudo se siente más fluido.
Cuando necesita integración del ecosistema de Google, búsqueda, puntos de entrada multimodales o ciertas capacidades a nivel de producto, “Gemini” tiende a destacar más.

Dividámoslo en tres partes.

1. Conversaciones diarias: por qué muchas personas todavía abren `ChatGPT` primero

Para la mayoría de los escenarios cotidianos, “ChatGPT” todavía se siente como el “punto de entrada predeterminado”.

No se trata de un único punto de referencia. Se trata de la experiencia general:
cuando desea hacer una pregunta rápida, organizar sus pensamientos, redactar un borrador, crear una primera versión o resumir un material, “ChatGPT” generalmente se siente bastante equilibrado.

Sus puntos fuertes suelen aparecer en algunos lugares:

Su estilo de respuesta es relativamente estable.
La curva de aprendizaje es baja para los usuarios generales.
La mayoría de las tareas amplias no requieren muchos ajustes adicionales
El producto se siente pulido y funciona bien para el uso diario frecuente

Entonces, si tu tarea es algo como esto:

Ayúdame a organizar un tema.
Convertir una idea en contenido estructurado.
Resumir un artículo extenso.
Lluvia de ideas sobre varios enfoques
Reescribir algo más claramente

Entonces, “ChatGPT” suele ser un lugar muy natural para empezar.

Eso no significa que sea siempre la opción más sólida para cada tarea profesional. Esto significa que, para un uso amplio y de propósito general, a menudo se siente más como el espacio de trabajo predeterminado.

2. Codificación de línea de comandos y tareas largas: por qué mucha gente se inclina por `Claude`

Una vez que una tarea pasa de “charlemos” a “seguiremos trabajando hasta terminar esto”, muchas personas empiezan a preferir “Claude”.

Esto es especialmente cierto en escenarios como:

Programación de línea de comandos
Comprender el contexto de un gran proyecto.
Coordinar ediciones en múltiples archivos.
Depuración de largas cadenas de tareas.
Leer código mientras se avanza constantemente una tarea

En este tipo de trabajo, la clave no suele ser si una respuesta es especialmente impresionante. Se trata de si el modelo puede permanecer estable a lo largo de una cadena de trabajo más larga.

La razón por la que a menudo se prefiere “Claude” no es que “diga una frase mejor que las demás”, sino que:

Se mantiene mejor en tareas de contexto prolongado.
Se siente más estable al leer archivos, registros y reglas continuamente
Es más adecuado para avanzar gradualmente en trabajos de codificación complejos.
En los flujos de trabajo de agentes y de línea de comandos, a menudo se lo trata como el modelo de trabajo principal.

Si está haciendo “codificación de vibración”, corrigiendo errores en la terminal, entendiendo la estructura del proyecto o cambiando características en varios archivos, las fortalezas de “Claude” tienden a mostrarse más claramente. En pocas palabras, “Claude” se siente más como un modelo con el que trabajas para hacer las cosas, no simplemente como uno al que haces una pregunta y obtienes una respuesta.

3. “Géminis” a menudo gana no “compitiendo frontalmente en todo”

Cuando la gente habla de “Géminis”, a menudo formulan la pregunta de la siguiente manera: ¿es el más fuerte de los tres?

Pero en el uso real, la pregunta más útil no suele ser esa. Es: ¿en qué escenarios vale especialmente la pena sacarlo y usarlo a propósito?

El valor de “Géminis” a menudo se muestra más claramente en estas direcciones:

Integración con el ecosistema de Google.
Búsqueda y recopilación de información.
Puntos de entrada multimodales
Ciertos vínculos de características del lado del producto.

Si su flujo de trabajo ya está cerca de la cadena de herramientas de Google, por ejemplo:

Buscar
Documentos
Correo electrónico
Uso del lado del navegador
Puntos de entrada móviles

Entonces la conveniencia práctica de “Gemini” puede importar más que una simple comparación entre modelo y puntuación.

En otras palabras, “Gemini” suele ser útil porque se integra en su flujo de trabajo de manera más natural, no solo porque puede o no vencer a otra persona en una sola respuesta.

4. La forma útil de elegir no es preguntar quién es más fuerte, sino qué tipo de tarea tienes

Cuando la gente compara los tres modelos uno al lado del otro, la trampa más fácil es tratar de encontrar el “mejor” modelo.

Pero las tareas reales varían demasiado:

Algunas son preguntas y respuestas únicas
Algunas son conversaciones de larga duración.
Algunos son proyectos de software.
Algunos son recuperación de información.
Algunos son procesamiento multimodal
Algunos son colaboración en cadena de herramientas.

Por lo tanto, el enfoque más eficaz suele ser ordenar por tipo de tarea:

Si desea un asistente amplio y de alta frecuencia que funcione de inmediato, comience con ChatGPT
Si necesita contexto extenso, trabajo en la línea de comandos, colaboración en codificación y progreso constante en tareas complejas, pruebe primero con “Claude”.
Si necesita ayuda del ecosistema de Google, búsqueda, puntos de entrada multimodal o ciertas integraciones de productos, preste especial atención a “Gemini”.

Ese tipo de división del trabajo está mucho más cerca del uso en el mundo real que obligar a un único campeón general.

5. Por qué muchos usuarios habituales se suscriben a los tres

Desde la perspectiva de un usuario ligero, pagar por los tres puede parecer redundante.
Desde la perspectiva de un usuario intensivo, es más como asignar diferentes herramientas a diferentes trabajos.

La razón es sencilla:
Si las fortalezas de los tres modelos ya han comenzado a divergir claramente, entonces usarlos juntos no constituye realmente un gasto duplicado. Es una forma de reducir los costos de cambio y los costos de prueba y error.

Por ejemplo:

Utilice ChatGPT para la organización diaria y preguntas y respuestas generales
Utilice Claude para el trabajo de codificación principal.
Utilice Gemini para ciertos flujos de trabajo de búsqueda, multimodales o relacionados con Google

La lógica de esta configuración no es fundamentalmente diferente de la de los diseñadores que instalan múltiples herramientas creativas o los desarrolladores que usan múltiples IDE.

6. Cuándo no debes cambiar de modelo con demasiada frecuencia

Eso sí, tener más modelos no siempre es mejor.

Si todavía estás creando un flujo de trabajo estable, saltar demasiado pronto y con demasiada frecuencia entre tres modelos puede complicar aún más las cosas. Los problemas comunes incluyen:

Volver a explicar la misma tarea tres veces.
Recibir diferentes sugerencias de diferentes modelos y luchar más para juzgarlas.
Perder contexto y aumentar los costos de colaboración.
Estancarse en la elección de herramientas antes de establecer sus propios límites de trabajo.

Entonces, una forma más estable suele ser esta:

Asigne primero a cada modelo un escenario principal
Úselo continuamente en ese escenario por un tiempo.
Construya gradualmente sus propios hábitos de división del trabajo.

Eso hace que sea más fácil obtener experiencia reutilizable en lugar de quedarse para siempre en la etapa de “déjame probar esta hoy”.

7. Una forma sencilla de recordarlo

Si solo desea una versión práctica para recordar, puede utilizar esta división en lenguaje sencillo:

ChatGPT: más parecido al asistente de uso general predeterminado
Claude: más bien la opción principal para tareas largas y colaboración en codificación
Gemini: más bien la herramienta con mayores ventajas en la búsqueda, el trabajo multimodal y el ecosistema de Google

Esta no es una regla absoluta y no significa que los tres no puedan reemplazarse entre sí. Es simplemente un punto de partida más realista.

Lo que realmente importa no es elegir el “modelo más fuerte del universo”, sino averiguarlo lo antes posible:
Para el tipo de tarea que tienes por delante, ¿qué modelo ahorra más tiempo, cuesta menos esfuerzo mental y facilita la obtención de resultados?

Aplicación de Google para escritorio: llevando la búsqueda con IA a Windows

Sat, 18 Apr 2026 11:08:00 +0800

Google ha añadido un punto de entrada de búsqueda más ligero al escritorio de Windows. En lugar de abrir primero un navegador, puede presionar un acceso directo, abrir un cuadro de búsqueda, hacer preguntas, cargar imágenes, analizar archivos, seleccionar contenido en su pantalla y seguir haciendo preguntas de seguimiento.

El nombre oficial es Aplicación de Google para escritorio. No pretende reemplazar un navegador tradicional. Su propósito es reunir la búsqueda de Google, el modo AI, Google Lens, compartir pantalla, búsqueda de archivos de computadora y búsqueda de Google Drive en un cuadro de búsqueda de escritorio.

Si busca información con frecuencia, resume documentos, identifica contenido de capturas de pantalla o desea una forma más rápida de buscar en su computadora, vale la pena probar esta aplicación de escritorio de Google.

Requisitos

Según la página oficial de Google, los requisitos actuales son:

Los usuarios deben tener 13 años o más.
El dispositivo debe ejecutar Windows 10 o posterior.
Actualmente, la aplicación solo está disponible en inglés.
El modo AI en la Búsqueda de Google no es compatible con todas las cuentas, países e idiomas.

En otras palabras, los usuarios de Windows 10 y Windows 11 pueden instalarlo primero y probarlo. La página oficial actualmente dice Ahora disponible en Windows, por lo que este artículo se centra en la versión de Windows.

Características principales

1. Abrir búsqueda con un acceso directo

Después de la instalación, presione:

`1`	`Alt + Space`

Esto abre el cuadro de búsqueda de escritorio de Google. Presiónelo nuevamente para ocultar el cuadro.

La experiencia es un poco como un iniciador de sistema. Ya sea que esté escribiendo un documento, leyendo una página web, organizando archivos o usando otra aplicación, puede acceder a la Búsqueda sin tener que volver al navegador.

2. Modo IA y preguntas de seguimiento

La búsqueda tradicional suele proporcionar una lista de enlaces. El modo AI se acerca más a una respuesta resumida creada a partir de los resultados de búsqueda. Puede hacer una pregunta directamente, obtener una respuesta más completa y seguir abriendo enlaces útiles cuando sea necesario.

La parte útil es que puedes seguir haciendo preguntas de seguimiento. Por ejemplo, comience con:

`1`	`What is this tool best used for?`

Luego continúa con:

`1`	`If I create written content, how can I use it to improve my workflow?`

Esto evita reescribir repetidamente palabras clave o saltar entre varias páginas.

3. Cargar imágenes para reconocimiento y búsqueda

La aplicación de escritorio de Google permite cargar una imagen y hacer preguntas sobre ella. Los usos comunes incluyen:

Identificar personas, lugares, productos u objetos en una imagen.
Encontrar imágenes similares e información relacionada.
Extraer una descripción del contenido de la imagen.
Pedirle a la IA que genere indicaciones creativas basadas en la imagen.

Por ejemplo, después de subir un retrato, podrías preguntar:

`1`	`Who is the person in this image? Please provide an introduction and related references.`

Para la búsqueda diaria de imágenes, la búsqueda de fuentes y el reconocimiento de objetos, esto es más conveniente que abrir manualmente una página web y cargar la imagen allí.

4. Seleccione el contenido de la pantalla con Google Lens

Google Lens es una de las partes más útiles de la aplicación de escritorio. Puede seleccionar un área en su pantalla y dejar que reconozca y busque ese contenido.

Es útil para:

Seleccionar un producto en una página web para encontrar artículos similares o información relacionada.
Seleccionar texto en una captura de pantalla y pedir una explicación.
Seleccionar una interfaz de software y preguntar qué herramienta es.
Seleccionar un mensaje de error y solicitar ideas para solucionar problemas.

La idea central es simple: busca lo que ves. Anteriormente, es posible que hayas necesitado tomar una captura de pantalla, guardarla y cargarla. Ahora puedes seleccionar el objetivo directamente en la pantalla.

5. Búsqueda de pantalla compartida

Además de seleccionar una parte de la pantalla, la aplicación también admite compartir pantalla. Una vez habilitada, la IA puede ver la ventana actual o la pantalla completa, y usted puede hacer preguntas sobre lo que está visible.

Por ejemplo, mientras lees un artículo, puedes preguntar:

`1`	`Please summarize the key points on the current page.`

`1`	`What parts of this page could be improved?`

Esto puede ahorrar tiempo al leer páginas web, revisar diseños, analizar fragmentos de código o resumir páginas largas. Cuando se habilita el uso compartido de pantalla, el sistema generalmente muestra un borde claro para que pueda confirmar lo que se está compartiendo.

6. Buscar archivos de computadora y Google Drive

La página oficial de Google también dice que la aplicación puede encontrar aplicaciones y archivos en su computadora y en Google Drive desde el mismo cuadro de búsqueda.

Esto combina la búsqueda en el escritorio y la búsqueda en la nube. Si recuerda parte del nombre de un archivo, una palabra clave del contenido o desea encontrar algo rápidamente en Google Drive, no necesita abrir el Explorador de archivos y Drive por separado.

Al usarla por primera vez, es posible que la aplicación le pregunte si desea habilitar la búsqueda en Google Drive o la búsqueda de archivos locales. Autorice solo las áreas que realmente necesita, especialmente cuando se trata de archivos locales y datos de la nube.

Instalación y uso

1. Abra la página de descarga oficial

Visita:

https://search.google/google-app/desktop/

Haga clic en Descargar aplicación para descargar el instalador.

2. Instale la aplicación de escritorio

Una vez finalizada la descarga, ejecute el instalador y siga las instrucciones.

Puede optar por iniciar sesión con una cuenta de Google. Iniciar sesión es más útil si desea realizar búsquedas en Google Drive, búsquedas personalizadas y algunas funciones de inteligencia artificial. Si solo desea probar la búsqueda básica, también puede comenzar con las indicaciones predeterminadas.

3. Abra el cuadro de búsqueda

Prensa:

`1`	`Alt + Space`

Aparece un cuadro de búsqueda de Google en el escritorio. Puede escribir una pregunta directamente, cargar archivos, usar Lens o comenzar a compartir pantalla.

4. Habilite el ámbito de búsqueda que necesita

Si desea buscar en Google Drive o archivos locales, siga las instrucciones para habilitar los permisos relevantes.

Un enfoque práctico:

Habilite primero la búsqueda de Google Drive y pruebe la búsqueda de documentos en la nube.
Habilite la búsqueda de archivos locales solo si la necesita.
Dejar ámbitos innecesarios desactivados.

Esto le brinda acceso a las partes útiles mientras mantiene los permisos claros.

Casos de uso comunes

Analizar archivos PDF y documentos

Puede arrastrar un PDF, una tabla o un documento y pedirle que resuma los puntos clave.

Por ejemplo:

`1`	`Please summarize the key points of this PDF and list anything I should pay attention to.`

Para archivos densos como formularios, declaraciones, materiales de solicitud o manuales, continúe con:

`1`	`Please organize the key information by category.`

Esto suele ser más rápido que leer un documento largo página por página.

Resumir páginas web

Después de habilitar el uso compartido de pantalla, puede pedirle que resuma la página actual.

Por ejemplo:

`1`	`Extract the main ideas from this page and summarize them in five bullet points.`

Esto es útil para artículos extensos, páginas de productos, documentación y páginas de noticias.

Identificar capturas de pantalla e interfaces

Utilice Google Lens para seleccionar una interfaz de software, un fragmento de código, un mensaje de error o un contenido de imagen en la pantalla y luego pídale que le explique lo que está viendo.

Por ejemplo:

`1`	`Please explain what this error means and suggest a troubleshooting path.`

`1`	`What tool is shown in this screenshot, and what scenarios is it likely used for?`

Ayuda con la creación de contenido

También puede ayudar a escribir títulos, generar esquemas y organizar puntos de venta.

Por ejemplo:

`1`	`Write 10 article titles about AI tool recommendations, with angles for practical tips, productivity tools, and office workflows.`

Después de recibir un borrador, puedes continuar:

`1`	`Make these titles more suitable for a tech blog.`

Este estilo de seguimiento parece más natural que pedirle todo a un motor de búsqueda de una sola vez.

Consejos de uso

Si solo necesita una búsqueda diaria de información, trátela como un punto de entrada más rápido a la Búsqueda de Google. Si trabaja a menudo con imágenes, archivos PDF, páginas web y capturas de pantalla, concéntrese en Lens, la carga de archivos y el uso compartido de pantalla.

Tenga en cuenta tres puntos:

La página oficial dice que la aplicación actualmente solo está disponible en inglés. Las indicaciones en chino pueden comportarse de manera diferente según su cuenta y región.
El modo AI no está disponible para todas las cuentas. Si no puede verlo, verifique la configuración de su cuenta, región e idioma.
La búsqueda de archivos locales, la búsqueda en Google Drive y el uso compartido de pantalla implican permisos de privacidad. Confirme a qué contenido desea que acceda la aplicación antes de habilitarlos.

Resumen rápido

El principal valor de la aplicación de Google para escritorio es que saca la búsqueda del navegador y la convierte en un cuadro de búsqueda de IA al que puedes acceder en cualquier momento.

En resumen, puede:

Abra la búsqueda rápidamente con Alt + Espacio.
Utilice el modo AI para obtener respuestas organizadas.
Subir imágenes o archivos para su análisis.
Seleccionar contenido de la pantalla con Google Lens.
Comprenda la ventana actual o la pantalla completa compartiendo pantalla.
Busque archivos locales, aplicaciones y contenido de Google Drive.

Si ya confías en la Búsqueda de Google y quieres que la experiencia se parezca más a pedirle a un asistente, vale la pena probar la aplicación de Google para escritorio.

Referencia

Página oficial de la aplicación de Google para escritorio: https://search.google/google-app/desktop/

Compartir un Agent Skill para recortar y normalizar imágenes de producto de e-commerce

Thu, 09 Apr 2026 21:43:50 +0800

product-cutout-normalize es un Agent Skill para imágenes de producto.

Procesa imágenes originales y las convierte en imágenes cuadradas con fondo transparente y especificaciones uniformes. Sus reglas predeterminadas son:

Lienzo 1024x1024
Fondo transparente
Conservar el sujeto lo más completo posible
Convertir automáticamente sujetos verticales a orientación horizontal
Centrar el sujeto
Normalizar el ancho visible del sujeto a 820px

Es adecuado para materiales de e-commerce, bibliotecas de producto y preprocesamiento de imágenes para páginas de detalle.

Qué problema resuelve este skill

Después de un recorte básico, muchas imágenes de producto todavía tienen estos problemas:

Restos de borde blanco o fondo gris claro
Orientación horizontal/vertical del sujeto inconsistente
Tamaño de lienzo inconsistente
Tamaño del sujeto muy variable
Pequeños puntos de ruido en áreas transparentes

Este skill procesa con un flujo fijo:

Recorte con Gemini
Limpieza de fondo claro en los bordes
Eliminación de pequeños fragmentos de ruido
Rotación de imágenes verticales a horizontales
Escalado según ancho objetivo
Colocación en el centro de un lienzo transparente uniforme

Las imágenes exportadas quedan más ordenadas y son más adecuadas para uso por lotes.

Escenarios adecuados

Encaja con estas necesidades:

Procesar fotos de producto por lotes
Exportar PNG con fondo transparente de forma uniforme
Unificar el tamaño visual principal
Necesitar un flujo estable y repetible

Si solo procesas pocas imágenes, o si cada imagen necesita ajustar manualmente la composición, quizá no sea la herramienta más adecuada.

Inicio rápido

La forma más directa de ejecución:

`1`	`& ".\.venv\Scripts\python.exe" ".codex\skills\product-cutout-normalize\scripts\run_pipeline.py" "input_dir" "output_dir" --overwrite`

Antes de ejecutar necesitas:

GEMINI_API_KEY
google-genai
Pillow

Instalar dependencias:

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

Configurar variable de entorno:

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

Reglas de salida

Salida predeterminada:

PNG con fondo transparente
Lienzo 1024x1024
Ancho del sujeto 820px
Sujeto centrado
Se limpian pequeños puntos de ruido

Así que no es solo un script de quitar fondo, sino más bien un script de organización de imágenes de producto.

Parámetros principales

Parámetros habituales:

--model Predeterminado: gemini-2.5-flash-image
--canvas-size Tamaño del lienzo cuadrado de salida, predeterminado 1024
--target-width Ancho visible del sujeto, predeterminado 820
--min-component-pixels Fragmentos transparentes con menos píxeles que este valor se eliminan, predeterminado 500
--overwrite Sobrescribe directamente si el archivo de salida ya existe

Por ejemplo:

`1`	`& ".\.venv\Scripts\python.exe" ".codex\skills\product-cutout-normalize\scripts\run_pipeline.py" ".\input" ".\output" --canvas-size 1280 --target-width 960 --overwrite`

Flujo de procesamiento

El flujo es simple:

Recorte con Gemini
Limpieza de fondo claro en los bordes
Eliminación de pequeños fragmentos de ruido
Rotación de imágenes verticales a horizontales
Escalado según ancho objetivo
Colocación en el centro de un lienzo transparente uniforme

Diferencia frente a scripts comunes de recorte

Comparado con un script común de eliminación de fondo, también trata:

Orientación uniforme del sujeto
Tamaño uniforme del sujeto
Tamaño uniforme del lienzo
Limpieza de pequeños fragmentos de ruido
Resultados más adecuados para colocarse directamente en una biblioteca de materiales

Código fuente de SKILL.md

Abajo se conserva el código fuente completo de SKILL.md, sin cambios:

---
name: product-cutout-normalize
description: Run a reusable Gemini product-image pipeline that removes backgrounds, preserves the full subject, rotates tall products to a horizontal orientation, centers them on a 1024x1024 transparent canvas, and normalizes the visible subject width to 820px. Use when the user wants a repeatable cutout-and-normalize workflow for product photos or asks to batch-process product images into standardized square PNG assets.
---

# Product Cutout Normalize

Use this skill when product photos need the same deterministic finishing pipeline:

- Gemini cutout from the original photo
- border cleanup to transparent
- preserve the full subject
- rotate to horizontal when the subject is taller than it is wide
- center on a `1024x1024` transparent canvas
- normalize the visible subject width to `820px`

## Quick Start

Run the bundled script:

```powershell
& ".\.venv\Scripts\python.exe" ".codex\skills\product-cutout-normalize\scripts\run_pipeline.py" "input_dir" "output_dir" --overwrite
```

Required environment:

- `GEMINI_API_KEY`
- `google-genai`
- `Pillow`

## Workflow

1. Confirm the request matches this standard pipeline. If the user asks for a different canvas size, subject width, or layout rule, pass explicit flags instead of changing the script.
2. Run the bundled script on the input directory.
3. If a result looks misaligned, inspect the alpha bounding box and small detached artifacts first; this pipeline already removes tiny alpha components by default.
4. Report the exact input and output directories used, plus any non-default flags.

## Script

Primary entry point:

- `scripts/run_pipeline.py`

Key flags:

- `--model`: Gemini image model, default `gemini-2.5-flash-image`
- `--canvas-size`: output square size, default `1024`
- `--target-width`: visible subject width after normalization, default `820`
- `--min-component-pixels`: remove detached alpha specks smaller than this, default `500`
- `--overwrite`: replace existing outputs in the destination directory

## Repo Integration

If the current project already has [`scripts/nano_banana_cutout.py`](/c:/Work/my_shop/scripts/nano_banana_cutout.py), prefer that repo script when the user wants the same pipeline inside this repository. Use the bundled skill script when the task is cross-project reuse or when you want the workflow to stay self-contained inside the skill.

Código fuente de scripts/run_pipeline.py

Abajo se conserva el código fuente completo de scripts/run_pipeline.py, sin cambios:

from __future__ import annotations

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

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."
)
DEFAULT_CANVAS_SIZE = 1024
DEFAULT_TARGET_WIDTH = 820
DEFAULT_MIN_COMPONENT_PIXELS = 500
SUPPORTED_EXTENSIONS = {".jpg", ".jpeg", ".png", ".webp"}


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 remove_small_components(image: Image.Image, min_component_pixels: int) -> Image.Image:
    if min_component_pixels <= 0:
        return image

    rgba = image.convert("RGBA")
    alpha = rgba.getchannel("A")
    width, height = rgba.size
    alpha_pixels = alpha.load()
    rgba_pixels = rgba.load()
    visited: set[tuple[int, int]] = set()

    for y in range(height):
        for x in range(width):
            if alpha_pixels[x, y] == 0 or (x, y) in visited:
                continue

            queue: deque[tuple[int, int]] = deque([(x, y)])
            visited.add((x, y))
            component: list[tuple[int, int]] = []

            while queue:
                cx, cy = queue.popleft()
                component.append((cx, cy))
                for nx, ny in ((cx - 1, cy), (cx + 1, cy), (cx, cy - 1), (cx, cy + 1)):
                    if 0 <= nx < width and 0 <= ny < height:
                        if alpha_pixels[nx, ny] == 0 or (nx, ny) in visited:
                            continue
                        visited.add((nx, ny))
                        queue.append((nx, ny))

            if len(component) < min_component_pixels:
                for px, py in component:
                    r, g, b, _ = rgba_pixels[px, py]
                    rgba_pixels[px, py] = (r, g, b, 0)

    return rgba


def normalize_product_image(
    image: Image.Image,
    canvas_size: int,
    target_width: int,
) -> Image.Image:
    rgba = image.convert("RGBA")
    bbox = rgba.getchannel("A").getbbox()
    if bbox is None:
        return Image.new("RGBA", (canvas_size, canvas_size), (0, 0, 0, 0))

    subject = rgba.crop(bbox)
    if subject.height > subject.width:
        subject = subject.rotate(-90, expand=True, resample=Image.Resampling.BICUBIC)
        rotated_bbox = subject.getchannel("A").getbbox()
        if rotated_bbox is not None:
            subject = subject.crop(rotated_bbox)

    scale = target_width / subject.width
    subject = subject.resize(
        (target_width, max(1, int(round(subject.height * scale)))),
        Image.Resampling.LANCZOS,
    )

    canvas = Image.new("RGBA", (canvas_size, canvas_size), (0, 0, 0, 0))
    offset_x = (canvas_size - subject.width) // 2
    offset_y = (canvas_size - subject.height) // 2
    canvas.alpha_composite(subject, (offset_x, offset_y))
    return canvas


def finalize_product_image(
    image: Image.Image,
    canvas_size: int,
    target_width: int,
    min_component_pixels: int,
) -> Image.Image:
    transparent = make_transparent_from_borders(image)
    cleaned = remove_small_components(transparent, min_component_pixels)
    return normalize_product_image(cleaned, canvas_size=canvas_size, target_width=target_width)


def save_first_image_part(
    response,
    dst: Path,
    canvas_size: int,
    target_width: int,
    min_component_pixels: int,
) -> 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)
            finalize_product_image(
                image,
                canvas_size=canvas_size,
                target_width=target_width,
                min_component_pixels=min_component_pixels,
            ).save(dst)
            return

        data = getattr(inline_data, "data", None)
        if data:
            dst.parent.mkdir(parents=True, exist_ok=True)
            with open(dst, "wb") as handle:
                handle.write(data)
            with Image.open(dst) as image:
                processed = finalize_product_image(
                    image,
                    canvas_size=canvas_size,
                    target_width=target_width,
                    min_component_pixels=min_component_pixels,
                )
                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,
    canvas_size: int,
    target_width: int,
    min_component_pixels: int,
) -> 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,
        canvas_size=canvas_size,
        target_width=target_width,
        min_component_pixels=min_component_pixels,
    )


def parse_args() -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        description="Cut out product images with Gemini and normalize them to square transparent PNGs."
    )
    parser.add_argument("input_dir", type=Path)
    parser.add_argument("output_dir", type=Path)
    parser.add_argument("--model", default="gemini-2.5-flash-image")
    parser.add_argument("--canvas-size", type=int, default=DEFAULT_CANVAS_SIZE)
    parser.add_argument("--target-width", type=int, default=DEFAULT_TARGET_WIDTH)
    parser.add_argument("--min-component-pixels", type=int, default=DEFAULT_MIN_COMPONENT_PIXELS)
    parser.add_argument("--overwrite", action="store_true")
    return parser.parse_args()


def main() -> None:
    args = parse_args()
    api_key = os.environ.get("GEMINI_API_KEY")
    if not api_key:
        raise SystemExit("Missing GEMINI_API_KEY environment variable.")
    if not args.input_dir.is_dir():
        raise SystemExit(f"Input directory does not exist: {args.input_dir}")
    if args.canvas_size <= 0:
        raise SystemExit("--canvas-size must be positive.")
    if args.target_width <= 0 or args.target_width > args.canvas_size:
        raise SystemExit("--target-width must be positive and no larger than --canvas-size.")
    if args.min_component_pixels < 0:
        raise SystemExit("--min-component-pixels must be >= 0.")

    args.output_dir.mkdir(parents=True, exist_ok=True)
    client = genai.Client(api_key=api_key)

    for src in sorted(args.input_dir.iterdir()):
        if not src.is_file() or src.suffix.lower() not in SUPPORTED_EXTENSIONS:
            continue
        dst = args.output_dir / f"{src.stem}.png"
        if dst.exists() and not args.overwrite:
            print(f"skip {dst}")
            continue
        process_image(
            src,
            dst,
            client,
            args.model,
            canvas_size=args.canvas_size,
            target_width=args.target_width,
            min_component_pixels=args.min_component_pixels,
        )
        print(dst)


if __name__ == "__main__":
    main()

Descargar adjunto: product-cutout-normalize.7z

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.

Gemini on KnightLi Blog

En qué se diferencian los mecanismos de memoria de ChatGPT, Claude Code y Gemini

ChatGPT: preferencias de largo plazo alrededor de la persona

Memory Sources: hacer más visible la personalización

Claude Code: alrededor de codebases y reglas de ingeniería

Claude Code Auto Memory: acumular experiencia de proyecto

Gemini: alrededor del contexto del ecosistema Google

Diferencias centrales

Cómo elegir

Una división práctica del trabajo

Lectura breve

Enlaces

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

Capacidades del modelo

Que significa para RAG

Busqueda visual

Reranking de recuperacion

Clustering, clasificacion y deteccion de anomalias

Almacenamiento y coste

Como usarlo como desarrollador

Cómo dividir tareas entre ChatGPT, Claude y Gemini: elección de uso diario, codificación y capacidades especiales

1. Conversaciones diarias: por qué muchas personas todavía abren ChatGPT primero

2. Codificación de línea de comandos y tareas largas: por qué mucha gente se inclina por Claude

3. “Géminis” a menudo gana no “compitiendo frontalmente en todo”

4. La forma útil de elegir no es preguntar quién es más fuerte, sino qué tipo de tarea tienes

5. Por qué muchos usuarios habituales se suscriben a los tres

6. Cuándo no debes cambiar de modelo con demasiada frecuencia

7. Una forma sencilla de recordarlo

Aplicación de Google para escritorio: llevando la búsqueda con IA a Windows

Requisitos

Características principales

1. Abrir búsqueda con un acceso directo

2. Modo IA y preguntas de seguimiento

3. Cargar imágenes para reconocimiento y búsqueda

4. Seleccione el contenido de la pantalla con Google Lens

5. Búsqueda de pantalla compartida

6. Buscar archivos de computadora y Google Drive

Instalación y uso

1. Abra la página de descarga oficial

2. Instale la aplicación de escritorio

3. Abra el cuadro de búsqueda

4. Habilite el ámbito de búsqueda que necesita

Casos de uso comunes

Analizar archivos PDF y documentos

Resumir páginas web

Identificar capturas de pantalla e interfaces

Ayuda con la creación de contenido

Consejos de uso

Resumen rápido

Referencia

Compartir un Agent Skill para recortar y normalizar imágenes de producto de e-commerce

Qué problema resuelve este skill

Escenarios adecuados

Inicio rápido

Reglas de salida

Parámetros principales

Flujo de procesamiento

Diferencia frente a scripts comunes de recorte

Código fuente de SKILL.md

Código fuente de scripts/run_pipeline.py

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

Qué hace este código

Preparación antes de ejecutar

Cómo obtener GEMINI_API_KEY

Ejemplo de estructura de directorios

Cómo ejecutarlo

Flujo principal de llamada

Por qué hacer otro posprocesamiento local

Código fuente completo

Qué conviene optimizar después

Resumen

1. Conversaciones diarias: por qué muchas personas todavía abren `ChatGPT` primero

2. Codificación de línea de comandos y tareas largas: por qué mucha gente se inclina por `Claude`