Crea una búsqueda multimodal para activos 3D con Tripo y Zilliz Cloud
La generación 3D con IA ha hecho que la creación de recursos sea mucho más rápida. Con Tripo, un generador de modelos 3D con IA, los equipos pueden generar modelos 3D a partir de indicaciones de texto, imágenes o bocetos, y luego usarlos en desarrollo de videojuegos, comercio electrónico, marketing, diseño conceptual y flujos creativos internos.
Esa velocidad crea un nuevo problema: los recursos se acumulan rápidamente.
Unos pocos modelos generados son fáciles de gestionar manualmente. Unos cuantos miles no lo son. Los diseñadores pueden regenerar objetos que ya existen. Los equipos de videojuegos pueden perder el seguimiento de variaciones de personajes, props y entornos. Los equipos de marketing pueden dedicar más tiempo a buscar un recurso utilizable que a adaptarlo para una campaña.
Este tutorial muestra cómo convertir esos recursos generados en un catálogo consultable. Tripo es la capa de creación 3D, mientras que Zilliz Cloud es la capa de recuperación: un servicio de base de datos vectorial totalmente gestionado de los creadores de Milvus que almacena embeddings y metadatos, admite búsqueda de similitud de baja latencia y permite combinar la búsqueda vectorial con filtros estructurados.
En este flujo de trabajo, cada registro de recurso contiene una vista previa renderizada, metadatos estructurados y un embedding multimodal. Una vez indexados los recursos, los usuarios pueden buscar por texto, por imagen o por texto e imagen juntos.
Lo que crearás
La biblioteca de este tutorial trata cada recurso 3D como un elemento de catálogo consultable. La malla 3D permanece dondequiera que tu pipeline de recursos la almacene. El registro consultable contiene la vista previa renderizada del recurso, metadatos, referencias de almacenamiento y embedding.
Esta demo utiliza tres tipos de datos locales:
| Datos locales | Qué contiene |
|---|---|
| milvus_dataset.csv | Metadatos por recurso: categoría, estilo, tipo de objeto, color, caso de uso, nombre de archivo, información del proyecto |
| milvus_render_images/ | Vistas previas renderizadas de los recursos de Tripo. Estas son las que buscas y recibes como resultado |
| milvus_input_images/ | Imágenes de referencia usadas para la generación de imagen a 3D. Almacenadas como metadatos y referencias de consulta opcionales |
El flujo de trabajo básico es:
Recurso 3D generado por Tripo
↓
Imagen de vista previa renderizada + metadatos
↓
Embedding multimodal
↓
Colección de Zilliz Cloud
↓
Buscar por texto, imagen o texto + imagen
↓
Devolver imágenes renderizadas coincidentes y metadatos
Esta configuración admite patrones comunes de búsqueda creativa:
- Buscar por concepto, como espada de fantasía azul.
- Buscar por tipo de objeto, estilo, color o caso de uso.
- Usar una imagen de referencia cuando las palabras son demasiado vagas.
- Combinar una imagen de referencia con texto para orientar el resultado.
- Filtrar por campos estructurados como categoría, proyecto, operador, estilo o modo de generación.
El resultado no es solo una carpeta con mejores nombres de archivo. Es un catálogo de recursos consultable.
Por qué importan las vistas previas renderizadas y los metadatos
Un modelo 3D no es fácil de buscar directamente. En un pipeline de producción, el modelo suele venir con varias piezas de información relacionadas:
- la malla generada o archivo fuente;
- una o más imágenes de vista previa renderizadas;
- una imagen de entrada o referencia opcional;
- un pie de foto o prompt;
- etiquetas generadas;
- campos de proyecto, propietario u operador;
- metadatos de estilo, categoría, color, tipo de objeto y caso de uso;
- URLs o claves de almacenamiento que apuntan al recurso.
Para este tutorial, la vista previa renderizada es el objeto visual que incrustamos. Eso funciona bien porque las vistas previas renderizadas capturan forma, material, color y estilo visual en una forma que un modelo de embeddings multimodal puede entender.
La vista previa renderizada es el objeto que ve el modelo de embeddings, por lo que la calidad del recurso afecta directamente la calidad de la búsqueda. La fidelidad geométrica —formas, bordes y decoraciones conservados— le da al modelo señal estructural. Las texturas de alta resolución —materiales distintivos, color fiel, detalle de superficie— le dan señal de material y color. Sin ambas, los embeddings se aplanan: una bolsa de cuero y una bolsa de lona se ven iguales para el modelo, y la búsqueda deja de ser útil.
Los metadatos te dan una segunda capa de control: puedes ejecutar búsqueda semántica y aun así aplicar filtros exactos. Un registro de recurso podría verse así:
caption: espada de fantasía con gema azul
llm_object: espada
llm_category: arma
llm_style: fantasía
llm_color: azul, plateado
llm_use_case: recurso de juego
generation_mode: imagen a 3D
render_image_file: fantasy_sword.webp
input_image_file: sword_reference.webp
Esta combinación hace que la biblioteca sea útil en flujos de trabajo reales. Por ejemplo, un artista de juegos puede buscar un personaje femenino y restringir el conjunto de resultados a recurso de juego. Un profesional de marketing puede buscar bolso de cuero realista y filtrar por proyecto. Un equipo de comercio electrónico puede buscar por categoría y material sin depender de nombres de archivo exactos.
Nota sobre el formato de imagen
En esta demostración, las imágenes renderizadas y de referencia se almacenan como .webp para ahorrar espacio. La API de embeddings puede ser más fiable con entradas PNG o JPEG, según el modelo y la ruta del proveedor. Si ves errores de entrada de imagen, convierte las vistas previas WebP a PNG o JPEG antes de generar embeddings.
Herramientas en este pipeline
Este tutorial conecta dos sistemas: uno que crea los recursos 3D y otro que los hace buscables.
Tripo: la capa de creación
Tripo es un generador de modelos 3D con IA construido sobre un modelo con más de 20 mil millones de parámetros. Su producto principal, Tripo Studio, cubre todo el flujo de creación de recursos en un solo espacio de trabajo — desde entradas de texto, imagen o boceto hasta refinamiento de malla, generación de texturas, rigging, animación y exportación. Una malla estándar se genera en dos a cinco segundos, lo que es parte de la razón por la que las bibliotecas de recursos crecen lo suficientemente rápido como para necesitar el pipeline de búsqueda que construye este tutorial.
Tres capacidades son especialmente relevantes aquí:
- La generación de modelos de imagen a 3D preserva la estructura geométrica — formas complejas, bordes afilados, decoraciones, detalles de superficie — para que los modelos generados se mantengan fieles a la referencia de entrada.
- HD Model lleva esa fidelidad más lejos, admitiendo hasta dos millones de caras para recursos que resisten renderizados en primer plano, visualización de productos o impresión 3D.
- La Generación de texturas con una resolución de hasta 8K añade reproducción fiel del color, distinción clara de materiales (metal, cuero, tela, madera) y detalles de superficie de grano fino como marcas de desgaste, vetas y microtexturas.
En conjunto, estas capacidades dan a cada recurso suficiente señal geométrica y material para producir un embedding multimodal significativo — que es donde entra el lado de recuperación.
Zilliz Cloud: la capa de recuperación
Zilliz Cloud es una plataforma Vector Lakebase totalmente gestionada, creada por los creadores de Milvus, la base de datos vectorial de código abierto más adoptada (45,000+ estrellas en GitHub, 100M+ descargas de Docker, 10,000+ organizaciones en producción). En su núcleo hay una base de datos vectorial de nivel de producción que ofrece búsqueda en menos de un milisegundo a escala de 100 mil millones. En este tutorial, maneja tres cosas:
- Almacenamiento de embeddings — el vector multimodal de cada recurso vive junto a sus metadatos estructurados en una sola colección.
- Búsqueda por similitud — las consultas de texto, imagen o combinadas se convierten en embeddings en el mismo espacio vectorial y se comparan con las vistas previas renderizadas almacenadas.
- Recuperación filtrada — filtros exactos por categoría, estilo, caso de uso o proyecto se superponen a la búsqueda semántica en una sola solicitud, que es lo que convierte una pila de vectores en un catálogo consultable.
Requisitos previos
Antes de comenzar, prepara lo siguiente:
- Una cuenta y un clúster de Zilliz Cloud. El clúster gratuito es suficiente para este tutorial. Regístrate, crea un clúster y copia su endpoint y token.
- Una clave de API de OpenRouter para el modelo de embeddings multimodal usado a continuación.
- Python 3.10 o posterior.
- El SDK de Python de Milvus. Consulta la guía de instalación de PyMilvus si eres nuevo en esto.
- Un conjunto de assets generados por Tripo, incluidas imágenes de vista previa de renderizado y metadatos.
- Imágenes de referencia opcionales usadas para la generación de imagen a 3D.
El código de ejemplo a continuación asume un script llamado tripo_rag.py, pero la misma lógica puede trasladarse a tu propio servicio de ingesta, backend de gestión de assets o herramienta interna.
Paso 1: Prepara los datos de assets generados por Tripo
Comienza con los assets generados en Tripo. Para cada asset, exporta o almacena al menos una imagen de vista previa de renderizado. Si el asset se creó a partir de una imagen de referencia, conserva también esa imagen de referencia. Puede ser útil para depurar, previsualizar resultados de búsqueda o crear futuros modos de búsqueda.
Cada fila en tu CSV de metadatos debe representar un asset. Como mínimo, incluye:
- un ID de asset único;
- un nombre de archivo o clave de almacenamiento de la imagen de vista previa de renderizado;
- un pie de foto o prompt de generación;
- campos de categoría, objeto, estilo, color y caso de uso cuando estén disponibles;
- campos de proyecto o propietario si tu equipo necesita control de acceso o filtrado a nivel de workspace;
- la URL o ubicación de almacenamiento del asset original.
Unos metadatos más ricos te ofrecen mejores filtros más adelante. El vector te ayuda a encontrar assets visual y semánticamente similares. Los metadatos te ayudan a reducir el conjunto de resultados a los assets que realmente son utilizables para el proyecto actual.
Paso 2: Crea una colección de Zilliz Cloud
Cada registro en la colección representa un asset de Tripo. Los campos estructurados almacenan metadatos. El campo multimodal_vector almacena el embedding de la vista previa de renderizado.
Los ejemplos siguientes usan un vector de 3072 dimensiones y similitud COSINE. Mantén la dimensión alineada con el modelo de embeddings que uses.
schema = MilvusClient.create_schema(
auto_id=False,
enable_dynamic_field=False
)
schema.add_field("id", DataType.INT64, is_primary=True)
schema.add_field("project_id", DataType.VARCHAR, max_length=64)
schema.add_field("operator_id", DataType.VARCHAR, max_length=64)
schema.add_field("caption", DataType.VARCHAR, max_length=2048)
schema.add_field("llm_keyword", DataType.VARCHAR, max_length=512)
schema.add_field("llm_object", DataType.VARCHAR, max_length=512)
schema.add_field("llm_category", DataType.VARCHAR, max_length=128)
schema.add_field("llm_style", DataType.VARCHAR, max_length=128)
schema.add_field("llm_color", DataType.VARCHAR, max_length=256)
schema.add_field("llm_use_case", DataType.VARCHAR, max_length=128)
schema.add_field("generation_mode", DataType.VARCHAR, max_length=32)
schema.add_field("url", DataType.VARCHAR, max_length=512)
schema.add_field("input_image_file", DataType.VARCHAR, max_length=256)
schema.add_field("input_image_key", DataType.VARCHAR, max_length=512)
schema.add_field("render_image_file", DataType.VARCHAR, max_length=256)
schema.add_field("render_image_key", DataType.VARCHAR, max_length=512)
schema.add_field(VECTOR_FIELD, DataType.FLOAT_VECTOR, dim=VECTOR_DIM)
Luego crea el índice vectorial:
index_params = MilvusClient.prepare_index_params()
index_params.add_index(
field_name=VECTOR_FIELD,
index_type="AUTOINDEX",
metric_type="COSINE",
)
Si tu script encapsula la configuración en un comando, ejecuta:
python3 tripo_rag.py create-collection
Después de que el comando termine, abre la consola de Zilliz Cloud y revisa la lista de colecciones.
Haz clic en la colección para revisar el estado, el esquema, las entidades cargadas y la configuración del campo vectorial.
Una nota rápida sobre el índice: AUTOINDEX mantiene el tutorial simple porque no necesitas ajustar manualmente los parámetros del índice antes de importar datos. El tipo de métrica COSINE coincide con los embeddings normalizados utilizados en el siguiente paso.
Paso 3: Generar embeddings multimodales para imágenes renderizadas
A continuación, genera un embedding para cada vista previa renderizada.
La demostración envía la imagen de vista previa a un modelo de embeddings a través de OpenRouter. La imagen se codifica como una URL de datos en base64, y el vector devuelto se normaliza con L2 antes de insertarse en Zilliz Cloud.
def data_url_for_image(path: Path) -> str:
mime_type = mimetypes.guess_type(path.name)[0] or "image/webp"
data = base64.b64encode(path.read_bytes()).decode("ascii")
return f"data:{mime_type};base64,{data}"
def embed_content(self, content: list[dict]) -> list[float]:
body = {
"model": "google/gemini-embedding-2-preview",
"input": [{"content": content}],
"encoding_format": "float",
}
response = requests.post(
"https://openrouter.ai/api/v1/embeddings",
headers=self._headers(),
json=body,
timeout=120,
)
vector = response.json()["data"][0]["embedding"]
return l2_normalize(vector)
def embed_image(self, image_path: Path) -> list[float]:
return self.embed_content(
[
{
"type": "image_url",
"image_url": {
"url": data_url_for_image(image_path)
},
}
]
)
Para una canalización de ingesta real, almacena en caché los embeddings. Llamar a una API externa de embeddings para cada importación es lento, y los reintentos pueden hacer que las ejecuciones de prueba repetidas sean costosas.
python3 tripo_rag.py build-cache
Una caché también hace que el comportamiento de importación sea determinista. Puedes reconstruir la colección, probar cambios de esquema o volver a ejecutar importaciones sin volver a generar embeddings para cada vista previa renderizada.
Paso 4: Importar registros de activos en Zilliz Cloud
Una vez que la caché esté lista, convierte cada fila del CSV en una entidad para Zilliz Cloud.
Cada entidad debe incluir los campos estructurados y el vector multimodal en caché:
def row_to_entity(row_index: int, row: dict, cached_item: dict) -> dict:
return {
"id": row_index,
"project_id": row.get("project_id", ""),
"operator_id": row.get("operator_id", ""),
"caption": row.get("caption", ""),
"llm_keyword": row.get("llm_keyword", ""),
"llm_object": row.get("llm_object", ""),
"llm_category": row.get("llm_category", ""),
"llm_style": row.get("llm_style", ""),
"llm_color": row.get("llm_color", ""),
"llm_use_case": row.get("llm_use_case", ""),
"generation_mode": generation_mode(row),
"url": row.get("url", ""),
"input_image_file": row.get("input_image_file", ""),
"input_image_key": row.get("input_image_key", ""),
"render_image_file": row.get("render_image_file", ""),
"render_image_key": row.get("render_image_key", ""),
VECTOR_FIELD: cached_item[VECTOR_FIELD],
}
Luego importa el conjunto de datos y comprueba las estadísticas de la colección:
python3 tripo_rag.py import-data
python3 tripo_rag.py stats
Abre la pestaña Data en la consola de Zilliz Cloud para confirmar que los registros de activos se insertaron. Deberías ver los campos de metadatos, las referencias a imágenes renderizadas y el campo vectorial de cada entidad.
Los activos de Tripo ahora son entidades buscables en una base de datos vectorial, no archivos locales sueltos.
Paso 5: Buscar por texto, imagen o ambos
La búsqueda se ejecuta en tres modos, todos a través del mismo modelo multimodal y contra el mismo campo multimodal_vector.
| Modo | Úsalo cuando | Ejemplo |
|---|---|---|
| Texto | Puedes describir lo que quieres | espada fantástica azul |
| Imagen | Tienes una referencia y quieres recursos similares | sube un render de escudo estilizado |
| Texto + imagen | Quieres intención y un ancla visual | imagen de espada + espada fantástica con gema azul |
La consulta se incrusta en el mismo espacio vectorial que las previsualizaciones renderizadas de los recursos. Luego, Zilliz Cloud busca en el campo vectorial y devuelve los recursos más cercanos con sus metadatos.
def search(args) -> None:
if not args.text and not args.image:
raise SystemExit("Provide --text, --image, or both.")
embedding_client = OpenRouterEmbeddingClient(
require_env("OPENROUTER_API_KEY")
)
client = connect_client()
if args.text and args.image:
vector = embedding_client.embed_text_image(
args.text,
Path(args.image)
)
elif args.image:
vector = embedding_client.embed_image(Path(args.image))
else:
vector = embedding_client.embed_text(args.text)
results = client.search(
collection_name=args.collection,
data=[vector],
anns_field=VECTOR_FIELD,
filter=filter_expr(args),
limit=args.top_k,
output_fields=[
"project_id",
"caption",
"llm_keyword",
"llm_object",
"llm_category",
"llm_style",
"llm_color",
"llm_use_case",
"generation_mode",
"render_image_file",
"render_image_key",
"input_image_file",
"url",
],
search_params={"metric_type": "COSINE"},
)
for rank, hit in enumerate(results[0], start=1):
entity = hit["entity"]
print(
json.dumps(
{
"rank": rank,
"score": hit["distance"],
**entity,
},
ensure_ascii=False,
indent=2,
)
)
Como cada resultado incluye tanto una puntuación de similitud como metadatos, tu front end puede renderizar la imagen de previsualización, el pie de imagen, la categoría, el estilo, el caso de uso y la URL del recurso original en la misma tarjeta de resultado.
La búsqueda no se limita a la similitud vectorial pura. Como cada recurso contiene metadatos estructurados, puedes añadir filtros a una consulta semántica en una sola solicitud. Por ejemplo, buscar female pero restringir el conjunto de resultados a llm_use_case == "game asset". Eso es lo que convierte la colección en un catálogo real en lugar de una pila de vectores.
Ejemplo 1: Búsqueda de texto con un filtro de caso de uso
Supongamos que un equipo de juego necesita recursos similares a personajes. Puedes buscar female y restringir los resultados al caso de uso de game asset:
python3 tripo_rag.py search \
--text "female" \
--use-case "game asset" \
--top-k 12
Esto devuelve los recursos coincidentes más cercanos del subconjunto de game asset, lo cual es más útil que buscar en toda la biblioteca e ignorar manualmente recursos irrelevantes de producto, entorno o marketing.
Ejemplo 2: Búsqueda de texto más imagen de referencia
El texto por sí solo suele ser demasiado amplio para el trabajo visual. Una consulta como fantasy sword with blue gemstone le dice al sistema lo que quieres, pero una imagen de referencia ancla la forma, la composición y la dirección visual.
python3 tripo_rag.py search \
--text "fantasy sword with blue gemstone" \
--image ./examples/sword_reference.png \
--top-k 12
Este modo es útil cuando un creador parte de una referencia visual pero quiere orientar la búsqueda con unas pocas palabras. La imagen de referencia aporta similitud visual. El texto reduce la intención.
Qué permite esto en un pipeline real de activos
Una vez que la biblioteca es buscable, los equipos pueden usar los activos 3D generados más como un inventario de producción reutilizable.
Un equipo de juegos puede hacer un seguimiento de las variaciones de objetos y personajes entre proyectos. Un equipo de comercio electrónico puede organizar activos similares a productos por categoría, material y estilo. Un equipo de marketing puede mantener una biblioteca aprobada de elementos visuales reutilizables. Un equipo de creative-ops puede crear flujos de trabajo de revisión en torno a la propiedad, los ID de proyecto y las URL de activos en lugar de depender de nombres de carpetas.
El cambio importante es simple: la generación crea el activo, pero la búsqueda hace que el activo sea reutilizable.
Conclusión
La generación 3D con IA facilita producir más activos de los que una estructura manual de carpetas puede gestionar. El siguiente cuello de botella es la recuperación: encontrar el activo adecuado, entender de dónde vino y reutilizarlo en el proyecto correcto.
Este tutorial mostró una forma de resolver ese problema. Generar activos con Tripo, almacenar vistas previas renderizadas y metadatos en Zilliz Cloud, incrustar cada vista previa con un modelo multimodal y buscar en la colección por texto, imagen o ambos. El mismo patrón puede empezar poco a poco con un conjunto de datos local y crecer hasta convertirse en un catálogo de activos de producción a medida que se expande tu biblioteca.
Esa también es la dirección detrás de Zilliz Vector Lakebase: mantener los datos de IA multimodales, las incrustaciones, los metadatos y las rutas de servicio en una base buscable, para que los equipos puedan pasar de la generación a la recuperación y a la reutilización sin reconstruir la capa de datos cada vez.
Para probarlo tú mismo, regístrate en Zilliz Cloud, crea un clúster gratuito, genera un pequeño lote de activos con Tripo y ejecuta el pipeline de principio a fin. Una vez que los primeros resultados de búsqueda se vean correctos, conecta la salida a tu navegador interno de activos o herramienta creativa.
Ejemplos de activos de Tripo
Los activos que aparecen a continuación se generaron en Tripo Studio usando las funciones descritas en este tutorial.
Generación de texturas 8K
La generación de texturas 8K preserva la fidelidad del color y distingue materiales de superficie como metal, cuero, tela y madera, hasta marcas de desgaste y microtexturas.
Modelo HD
El Modelo HD admite hasta dos millones de caras, preservando formas complejas, bordes definidos y detalles finos de superficie para renderizado, visualización e impresión 3D.
Sigue leyendo
Zilliz Cloud Now Available in Azure North Europe: Bringing AI-Powered Vector Search Closer to European Customers
The addition of the Azure North Europe (Ireland) region further expands our global footprint to better serve our European customers.
Zilliz Cloud Delivers Better Performance and Lower Costs with Arm Neoverse-based AWS Graviton
Zilliz Cloud adopts Arm-based AWS Graviton3 CPUs to cut costs, speed up AI vector search, and power billion-scale RAG and semantic search workloads.
Legal Document Analysis: Harnessing Zilliz Cloud's Semantic Search and RAG for Legal Insights
Enhance legal document analysis with Zilliz Cloud’s Semantic Search and RAG. Improve accuracy, efficiency, and scalability for contracts, case law, and compliance.