Agent Skills on KnightLi Blog

Scientific Agent Skills: una biblioteca de skills para dar flujos de investigación a AI Agents

Sun, 17 May 2026 17:52:04 +0800

K-Dense-AI/scientific-agent-skills es una colección de Agent Skills para trabajo científico y de investigación.

Su objetivo no es crear otro chatbot. Convierte tareas frecuentes de investigación, como consultar documentación, conectar bases de datos, escribir scripts de análisis, procesar archivos, generar gráficos y preparar informes, en skills que un AI Agent puede descubrir y llamar.

Proyecto: https://github.com/K-Dense-AI/scientific-agent-skills

A fecha de 2026-05-17, la API de GitHub mostraba unos 23.4k stars, 2.5k forks, licencia MIT y último push el 2026-05-11. El README habla de 135 ready-to-use scientific and research skills, pero el directorio scientific-skills muestra 137 entradas vía API de GitHub. La diferencia puede venir del criterio de conteo, entradas recientes o retraso en actualizar el README.

Conclusión rápida

Scientific Agent Skills encaja con quienes ya usan Codex, Claude Code, Cursor, Gemini CLI u otra herramienta compatible con el estándar Agent Skills.

Su valor principal está en tres puntos:

Escribe el uso de herramientas científicas en SKILL.md, para que el agent no tenga que adivinar cada vez cómo se usa una librería.
Organiza bases de datos científicas, paquetes Python, procesamiento de documentos, escritura científica y visualización en una misma colección.
Hace que un AI Agent se parezca más a un asistente capaz de ejecutar flujos de investigación, no solo a un bot que responde conceptos.

Pero no es un botón mágico que “hace ciencia” al instalarlo. Las skills pueden ayudar al agent a elegir herramientas correctas y generar código y flujos más fiables, pero la calidad de datos, el diseño experimental, las hipótesis estadísticas, las decisiones clínicas y las conclusiones de investigación siguen requiriendo juicio humano.

Qué incluye

El README describe el proyecto como una colección de skills para investigación, computación científica, ingeniería, análisis, finanzas y escritura. Las áreas principales incluyen:

Bioinformática y genómica.
Quimioinformática y descubrimiento de fármacos.
Proteómica y espectrometría de masas.
Investigación clínica y medicina de precisión.
Healthcare AI y machine learning clínico.
Imagen médica y patología digital.
Machine learning y AI.
Ciencia de materiales y química.
Física y astronomía.
Simulación y optimización de ingeniería.
Análisis y visualización de datos.
Ciencia geoespacial y teledetección.
Automatización de laboratorio.
Escritura científica, revisión bibliográfica, peer review y gestión de citas.

Estas skills no buscan limitar al agent a ciertas librerías. El README también deja claro que el agent puede escribir Python y llamar cualquier API o paquete disponible. Las skills aportan documentación curada, ejemplos, buenas prácticas y rutas de integración.

En otras palabras, son una mezcla de manuales de herramientas científicas, plantillas de workflow y convenciones de llamada para agents.

Bases de datos y paquetes Python

La parte más atractiva para usuarios científicos es la cobertura de bases de datos y del ecosistema Python.

El README menciona:

Acceso unificado a 78 bases públicas mediante database-lookup.
Cobertura de PubChem, ChEMBL, UniProt, COSMIC, ClinicalTrials.gov, FRED, USPTO y más.
Skills dedicadas para DepMap, Imaging Data Commons, PrimeKG, U.S. Treasury Fiscal Data, Hugging Science y otras fuentes.
Más de 70 Python Package Skills optimizadas.

En el directorio aparecen muchos nombres conocidos:

rdkit
scanpy
biopython
bioservices
pydeseq2
scvelo
scvi-tools
pymatgen
qiskit
pennylane
openmm
mdanalysis
scikit-learn
statsmodels
matplotlib
seaborn
networkx
sympy
pytorch-lightning
transformers
timesfm-forecasting

Para un desarrollador, esas librerías no sorprenden por sí mismas. Lo útil es que el agent puede leer restricciones, ejemplos de código, flujos comunes y advertencias específicas mientras trabaja. Eso es más estable que depender solo de memoria antigua del modelo.

Escenarios típicos

Scientific Agent Skills sirve mejor para tareas de investigación con varios pasos que para preguntas de una sola vuelta.

En descubrimiento de fármacos, un agent podría consultar ChEMBL para inhibidores de EGFR, analizar relaciones estructura-actividad con RDKit, hacer screening virtual con DiffDock, buscar literatura y generar un informe.

En análisis single-cell, podría cargar datos 10X en Scanpy, hacer QC, integrar datasets, identificar tipos celulares, ejecutar expresión diferencial y enriquecimiento de vías.

En multi-omics, podría conectar RNA-seq, espectrometría de masas, metabolitos, interacciones de proteínas, ensayos clínicos y modelado estadístico.

Sin skills, estas tareas se convierten fácilmente en “el agent entiende la dirección general, pero hay que recordarle cada paso”. La biblioteca de skills guarda rutas frecuentes para reducir desvíos.

Instalación

El README recomienda la herramienta estándar de Agent Skills:

`1`	`npx skills add K-Dense-AI/scientific-agent-skills`

Si usas GitHub CLI v2.90.0+, también puedes instalar con gh skill:

`1`	`gh skill install K-Dense-AI/scientific-agent-skills`

Instalar una skill concreta:

`1`	`gh skill install K-Dense-AI/scientific-agent-skills scanpy`

Indicar un agent destino:

gh skill install K-Dense-AI/scientific-agent-skills --agent codex
gh skill install K-Dense-AI/scientific-agent-skills --agent cursor
gh skill install K-Dense-AI/scientific-agent-skills --agent claude-code
gh skill install K-Dense-AI/scientific-agent-skills --agent gemini

Para reproducibilidad, puedes fijar release tag o commit SHA:

1
2

gh skill install K-Dense-AI/scientific-agent-skills --pin v1.0.0
gh skill install K-Dense-AI/scientific-agent-skills --pin abc123def

Esto importa en investigación. Lo peor es “la semana pasada corría, esta semana cambió el resultado y nadie sabe por qué”. Si una skill participa en un análisis, registra skill, dependencias y versión de datos.

Requisitos de ejecución

El README lista:

Python 3.11+, recomendado 3.12+.
uv para instalar dependencias Python.
Un cliente compatible con Agent Skills.
macOS, Linux o Windows with WSL2.

Los usuarios de Windows deben fijarse en WSL2. Muchas librerías científicas pueden correr en Windows nativo, pero cadenas de dependencias, compiladores, paquetes binarios y rutas dan más problemas. La mención “Windows with WSL2” sugiere un entorno tipo Unix para computación científica.

Diferencia frente a una colección de prompts

Una colección de prompts suele decir al modelo cómo responder. Scientific Agent Skills va más allá: describe herramientas, librerías, bases de datos y workflows como skills descubribles.

Diferencias prácticas:

Una skill puede incluir instrucciones estructuradas y ejemplos de código.
Puede mantenerse alrededor de una librería o base de datos concreta.
El agent puede elegir skills según la tarea, en vez de cargar todas las reglas en el system prompt.
Un equipo puede instalar solo lo que necesita y reducir ruido de contexto.
Las skills pueden versionarse, revisarse y actualizarse con el repositorio.

Para investigación compleja, esto se mantiene mejor que copiar un prompt universal enorme. Modelos, bases de datos y paquetes Python cambian. Capturar esos cambios en skills es más controlable que dejarlos en documentos personales de prompts.

Seguridad y límites de confianza

La advertencia de seguridad del README es directa: las Skills pueden ejecutar código e influir en el comportamiento del coding agent.

Eso importa. Una skill científica puede instalar dependencias Python, acceder a bases de datos en red, leer y escribir archivos locales, ejecutar scripts de análisis, procesar datos experimentales o clínicos sensibles y generar informes que luego se citen.

No conviene instalar todo a ciegas. Una ruta más segura:

Instala solo las skills necesarias para la tarea.
Lee el SKILL.md correspondiente antes.
Revisa paquetes, API, archivos y servicios externos que puede llamar.
Ten más cuidado con skills aportadas por la comunidad.
Ejecuta tareas con datos y código en un entorno aislado.
Mantén revisión humana para conclusiones, sugerencias clínicas y resultados estadísticos.

El README también menciona Cisco AI Defense Skill Scanner y sugiere escanear skills de terceros localmente. El escaneo no sustituye la revisión humana, pero muestra conciencia del riesgo de supply chain de skills.

Para quién es

Este proyecto es más útil para quienes:

Ya usan AI coding agents a diario.
Procesan a menudo datos científicos, papers, gráficos e informes.
Cambian frecuentemente entre herramientas del ecosistema Python científico.
Quieren que un agent ejecute análisis de varios pasos, no solo explique conceptos.
Quieren convertir flujos de investigación del equipo en skills reutilizables.
Quieren estudiar cómo aplicar Agent Skills a dominios profesionales.

No encaja tanto si solo quieres que AI explique un paper de vez en cuando, no tienes entorno Python local, no quieres gestionar dependencias, no has definido límites de privacidad, red y ejecución de código, o necesitas un sistema clínico/productivo regulado sin revisión humana.

Para análisis ocasionales, pedir al agent que escriba un script puede ser más ligero. Si repites flujos parecidos, la biblioteca gana valor.

Consejos de uso

No empieces instalando todo el repositorio y entregando todas las tareas al agent.

Una ruta más práctica:

Elige una tarea de bajo riesgo, como organizar literatura, generar gráficos o explorar datos públicos.
Instala solo skills relevantes, como literature-review, scientific-writing, scanpy o rdkit.
Pide al agent que explique el plan antes de ejecutar código.
Conserva datos de entrada, scripts, entorno y versiones de skills.
Revisa manualmente los resultados.
Si el flujo se estabiliza, conviértelo en SOP o skill propia del equipo.

La clave de un agent científico no es automatizarlo todo. Es dar a las herramientas las partes repetitivas, tediosas y dependientes de documentación, y dejar juicio, hipótesis y conclusiones a las personas.

Resumen

Scientific Agent Skills importa porque lleva Agent Skills desde programación general hacia investigación.

El trabajo científico es naturalmente multi-herramienta, multi-base de datos, multi-archivo y multi-paso. Los prompts de chat por sí solos rara vez cubren esos detalles con estabilidad. Este proyecto convierte librerías, fuentes de datos y flujos de investigación comunes en skills, facilitando que un AI Agent entre en workflows reales.

Pero cuanto más potente es, más límites necesita. Las skills pueden cambiar el comportamiento del agent, ejecutar código, acceder a red y procesar archivos. Lee antes de instalar, aísla la ejecución y no saltes la validación humana de conclusiones científicas.

Si ya usas Codex, Claude Code, Cursor o Gemini CLI para investigación y análisis de datos, Scientific Agent Skills merece una mirada seria. Aunque no lo instales completo, su forma de dividir skills sirve como referencia para organizar workflows de AI científica en equipo.

Referencias:

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