Créez une recherche multimodale pour des ressources 3D avec Tripo et Zilliz Cloud
La génération 3D par IA a rendu la création d’assets beaucoup plus rapide. Avec Tripo, un générateur de modèles 3D par IA, les équipes peuvent générer des modèles 3D à partir de prompts textuels, d’images ou de croquis, puis les utiliser dans le développement de jeux, l’e-commerce, le marketing, la conception de concepts et les pipelines créatifs internes.
Cette rapidité crée un nouveau problème : les assets s’accumulent vite.
Quelques modèles générés sont faciles à gérer manuellement. Quelques milliers ne le sont pas. Les designers peuvent régénérer des objets qui existent déjà. Les équipes de jeu peuvent perdre le fil des variations de personnages, d’accessoires et d’environnements. Les équipes marketing peuvent passer plus de temps à chercher un asset utilisable qu’à l’adapter pour une campagne.
Ce tutoriel montre comment transformer ces assets générés en un catalogue consultable. Tripo constitue la couche de création 3D, tandis que Zilliz Cloud est la couche de récupération : un service de base de données vectorielle entièrement géré, créé par les concepteurs de Milvus, qui stocke les embeddings et les métadonnées, prend en charge la recherche de similarité à faible latence et vous permet de combiner la recherche vectorielle avec des filtres structurés.
Dans ce workflow, chaque enregistrement d’asset contient un aperçu de rendu, des métadonnées structurées et un embedding multimodal. Une fois les assets indexés, les utilisateurs peuvent effectuer une recherche par texte, par image, ou par texte et image ensemble.
Ce que vous allez créer
La bibliothèque de ce tutoriel traite chaque asset 3D comme un élément de catalogue consultable. Le maillage 3D reste là où votre pipeline d’assets le stocke. L’enregistrement consultable contient l’aperçu de rendu de l’asset, les métadonnées, les références de stockage et l’embedding.
Cette démo utilise trois types de données locales :
| Données locales | Ce qu’elles contiennent |
|---|---|
| milvus_dataset.csv | Métadonnées par asset : catégorie, style, type d’objet, couleur, cas d’utilisation, nom de fichier, informations de projet |
| milvus_render_images/ | Aperçus rendus des assets Tripo. C’est ce que vous recherchez et ce qui vous est renvoyé |
| milvus_input_images/ | Images de référence utilisées pour la génération d’image vers 3D. Stockées comme métadonnées et références de requête facultatives |
Le workflow de base est :
Asset 3D généré par Tripo
↓
Image d’aperçu de rendu + métadonnées
↓
Embedding multimodal
↓
Collection Zilliz Cloud
↓
Recherche par texte, image, ou texte + image
↓
Renvoyer les images de rendu et métadonnées correspondantes
Cette configuration prend en charge des schémas de recherche créative courants :
- Rechercher par concept, comme épée fantastique bleue.
- Rechercher par type d’objet, style, couleur ou cas d’utilisation.
- Utiliser une image de référence lorsque les mots sont trop vagues.
- Combiner une image de référence avec du texte pour orienter le résultat.
- Filtrer par champs structurés tels que catégorie, projet, opérateur, style ou mode de génération.
Le résultat n’est pas seulement un dossier avec de meilleurs noms de fichiers. C’est un catalogue d’assets interrogeable.
Pourquoi les aperçus de rendu et les métadonnées sont importants
Un modèle 3D n’est pas facile à rechercher directement. Dans un pipeline de production, le modèle s’accompagne généralement de plusieurs éléments d’information associés :
- le maillage généré ou le fichier source ;
- une ou plusieurs images d’aperçu de rendu ;
- une image d’entrée ou de référence facultative ;
- une légende ou un prompt ;
- des tags générés ;
- des champs de projet, de propriétaire ou d’opérateur ;
- des métadonnées de style, de catégorie, de couleur, de type d’objet et de cas d’utilisation ;
- des URLs ou des clés de stockage qui renvoient à l’asset.
Pour ce tutoriel, l’aperçu de rendu est l’objet visuel que nous intégrons. Cela fonctionne bien, car les aperçus de rendu capturent la forme, le matériau, la couleur et le style visuel sous une forme qu’un modèle d’embedding multimodal peut comprendre.
L’aperçu de rendu est l’objet que voit le modèle d’embedding ; la qualité de l’asset affecte donc directement la qualité de la recherche. La fidélité géométrique — formes, arêtes et décorations préservées — fournit au modèle un signal structurel. Les textures haute résolution — matériaux distincts, couleur fidèle, détail de surface — lui fournissent un signal de matériau et de couleur. Sans les deux, les embeddings s’aplatissent : un sac en cuir et un sac en toile se ressemblent pour le modèle, et la recherche cesse d’être utile.
Les métadonnées vous offrent une deuxième couche de contrôle : vous pouvez effectuer une recherche sémantique tout en appliquant des filtres exacts. Un enregistrement d’asset pourrait ressembler à ceci :
caption: épée fantastique avec pierre précieuse bleue
llm_object: épée
llm_category: arme
llm_style: fantasy
llm_color: bleu, argent
llm_use_case: asset de jeu
generation_mode: image-to-3D
render_image_file: fantasy_sword.webp
input_image_file: sword_reference.webp
Cette combinaison rend la bibliothèque utile dans de vrais workflows. Par exemple, un artiste de jeu peut rechercher un personnage féminin et restreindre l’ensemble des résultats à asset de jeu. Un marketeur peut chercher sac en cuir réaliste et filtrer par projet. Une équipe e-commerce peut rechercher par catégorie et matériau sans dépendre de noms de fichiers exacts.
Note sur le format d’image
Dans cette démo, les images de rendu et de référence sont stockées en .webp pour économiser de l’espace. L’API d’embedding peut être plus fiable avec des entrées PNG ou JPEG, selon le modèle et la route du fournisseur. Si vous voyez des erreurs d’entrée d’image, convertissez les aperçus WebP en PNG ou JPEG avant l’embedding.
Outils dans ce pipeline
Ce tutoriel connecte deux systèmes : l’un qui crée les assets 3D, et l’autre qui les rend recherchables.
Tripo : la couche de création
Tripo est un générateur de modèles 3D par IA construit sur un modèle de plus de 20 milliards de paramètres. Son produit principal, Tripo Studio, couvre tout le flux de création d’assets dans un seul espace de travail — depuis une entrée texte, image ou croquis jusqu’au raffinement du maillage, à la génération de textures, au rigging, à l’animation et à l’export. Un maillage standard se génère en deux à cinq secondes, ce qui explique en partie pourquoi les bibliothèques d’assets grossissent assez vite pour nécessiter le pipeline de recherche que ce tutoriel construit.
Trois capacités sont particulièrement pertinentes ici :
- La génération de modèles Image-to-3D préserve la structure géométrique — formes complexes, arêtes nettes, décorations, détails de surface — afin que les modèles générés restent fidèles à la référence d’entrée.
- HD Model pousse cette fidélité encore plus loin, avec la prise en charge de jusqu’à deux millions de faces pour des assets qui tiennent la route en rendu rapproché, en visualisation de produit ou en impression 3D.
- La Génération de textures jusqu’à une résolution 8K ajoute une reproduction fidèle des couleurs, une distinction claire des matériaux (métal, cuir, tissu, bois) et des détails de surface fins tels que marques d’usure, grain et micro-textures.
Ensemble, ces éléments donnent à chaque asset suffisamment de signal géométrique et matériel pour produire un embedding multimodal significatif — et c’est là que le volet retrieval intervient.
Zilliz Cloud : la couche de retrieval
Zilliz Cloud est une plateforme Vector Lakebase entièrement managée, conçue par les créateurs de Milvus, la base de données vectorielle open-source la plus largement adoptée (45 000+ étoiles GitHub, 100 M+ de téléchargements Docker, 10 000+ organisations en production). En son cœur se trouve une base de données vectorielle de niveau production offrant une recherche en moins d’une milliseconde à l’échelle de 100 milliards. Dans ce tutoriel, elle gère trois choses :
- Stockage des embeddings — le vecteur multimodal de chaque asset réside aux côtés de ses métadonnées structurées dans une collection unique.
- Recherche par similarité — les requêtes texte, image ou combinées sont transformées en embeddings dans le même espace vectoriel et mises en correspondance avec les aperçus de rendu stockés.
- Retrieval filtré — des filtres exacts par catégorie, style, cas d’usage ou projet se superposent à la recherche sémantique en une seule requête, ce qui transforme un tas de vecteurs en un catalogue interrogeable.
Prérequis
Avant de commencer, préparez les éléments suivants :
- Un compte et un cluster Zilliz Cloud. Le cluster gratuit suffit pour ce tutoriel. Inscrivez-vous, créez un cluster, puis copiez son endpoint et son token.
- Une clé API OpenRouter pour le modèle d’embedding multimodal utilisé ci-dessous.
- Python 3.10 ou version ultérieure.
- Le SDK Python Milvus. Consultez le guide d’installation de PyMilvus si vous débutez avec celui-ci.
- Un ensemble d’assets générés par Tripo, comprenant des images d’aperçu de rendu et des métadonnées.
- Des images de référence facultatives utilisées pour la génération image-to-3D.
Le code d’exemple ci-dessous suppose un script nommé tripo_rag.py, mais la même logique peut être déplacée dans votre propre service d’ingestion, backend de gestion d’assets ou outil interne.
Étape 1 : Préparer les données d’assets générés par Tripo
Commencez avec les assets générés dans Tripo. Pour chaque asset, exportez ou stockez au moins une image d’aperçu de rendu. Si l’asset a été créé à partir d’une image de référence, conservez également cette image de référence. Elle peut être utile pour le débogage, la prévisualisation des résultats de recherche ou la création de futurs modes de recherche.
Chaque ligne de votre CSV de métadonnées doit représenter un asset. Au minimum, incluez :
- un ID d’asset unique ;
- un nom de fichier d’image d’aperçu de rendu ou une clé de stockage ;
- une légende ou un prompt de génération ;
- des champs de catégorie, d’objet, de style, de couleur et de cas d’utilisation lorsqu’ils sont disponibles ;
- des champs de projet ou de propriétaire si votre équipe a besoin d’un contrôle d’accès ou d’un filtrage au niveau de l’espace de travail ;
- l’URL ou l’emplacement de stockage de l’asset d’origine.
Des métadonnées plus riches vous offrent de meilleurs filtres par la suite. Le vecteur vous aide à trouver des assets visuellement et sémantiquement similaires. Les métadonnées vous aident à restreindre l’ensemble des résultats aux assets réellement utilisables pour le projet en cours.
Étape 2 : Créer une collection Zilliz Cloud
Chaque enregistrement de la collection représente un asset Tripo. Les champs structurés stockent les métadonnées. Le champ multimodal_vector stocke l’embedding de l’aperçu de rendu.
Les exemples ci-dessous utilisent un vecteur de 3072 dimensions et la similarité COSINE. Gardez la dimension alignée avec le modèle d’embedding que vous utilisez.
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)
Créez ensuite l’index vectoriel :
index_params = MilvusClient.prepare_index_params()
index_params.add_index(
field_name=VECTOR_FIELD,
index_type="AUTOINDEX",
metric_type="COSINE",
)
Si votre script encapsule la configuration dans une commande, exécutez :
python3 tripo_rag.py create-collection
Une fois la commande terminée, ouvrez la console Zilliz Cloud et vérifiez la liste des collections.
Cliquez sur la collection pour vérifier le statut, le schéma, les entités chargées et la configuration du champ vectoriel.
Petite remarque sur l’index : AUTOINDEX garde le tutoriel simple, car vous n’avez pas besoin d’ajuster manuellement les paramètres d’index avant d’importer les données. Le type de métrique COSINE correspond aux embeddings normalisés utilisés à l’étape suivante.
Étape 3 : Générer des embeddings multimodaux pour les images de rendu
Ensuite, générez un embedding pour chaque aperçu de rendu.
La démo envoie l’image d’aperçu à un modèle d’embedding via OpenRouter. L’image est encodée sous forme d’URL de données base64, et le vecteur renvoyé est normalisé L2 avant d’être inséré dans 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)
},
}
]
)
Pour un véritable pipeline d’ingestion, mettez les embeddings en cache. Appeler une API d’embedding externe pour chaque importation est lent, et les nouvelles tentatives peuvent rendre coûteuses les exécutions de test répétées.
python3 tripo_rag.py build-cache
Un cache rend également le comportement d’importation déterministe. Vous pouvez reconstruire la collection, tester des modifications de schéma ou relancer des importations sans ré-encoder chaque aperçu de rendu.
Étape 4 : Importer les enregistrements d’actifs dans Zilliz Cloud
Une fois le cache prêt, convertissez chaque ligne CSV en une entité pour Zilliz Cloud.
Chaque entité doit inclure les champs structurés et le vecteur multimodal mis en cache :
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],
}
Importez ensuite le jeu de données et vérifiez les statistiques de la collection :
python3 tripo_rag.py import-data
python3 tripo_rag.py stats
Ouvrez l’onglet Data dans la console Zilliz Cloud pour confirmer que les enregistrements d’actifs ont été insérés. Vous devriez voir les champs de métadonnées, les références aux images de rendu et le champ vectoriel pour chaque entité.
Les actifs Tripo sont désormais des entités recherchables dans une base de données vectorielle, et non des fichiers locaux épars.
Étape 5 : Rechercher par texte, image ou les deux
La recherche fonctionne selon trois modes, tous via le même modèle multimodal et sur le même champ multimodal_vector.
| Mode | Utilisez-le lorsque | Exemple |
|---|---|---|
| Texte | Vous pouvez décrire ce que vous voulez | épée fantastique bleue |
| Image | Vous avez une référence et voulez des ressources similaires | téléversez un rendu de bouclier stylisé |
| Texte + image | Vous voulez une intention et un ancrage visuel | image d’épée + épée fantastique avec gemme bleue |
La requête est intégrée dans le même espace vectoriel que les aperçus de rendu des ressources. Zilliz Cloud recherche ensuite le champ vectoriel et renvoie les ressources les plus proches avec leurs métadonnées.
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,
)
)
Comme chaque résultat inclut à la fois un score de similarité et des métadonnées, votre front-end peut afficher l’image d’aperçu, la légende, la catégorie, le style, le cas d’utilisation et l’URL de la ressource originale dans la même carte de résultat.
La recherche ne se limite pas à la similarité vectorielle pure. Comme chaque ressource comporte des métadonnées structurées, vous pouvez ajouter des filtres à une requête sémantique en une seule demande. Par exemple, recherchez female mais limitez l’ensemble des résultats à llm_use_case == "game asset". C’est ce qui fait de la collection un véritable catalogue plutôt qu’un tas de vecteurs.
Exemple 1 : Recherche textuelle avec un filtre de cas d’utilisation
Supposons qu’une équipe de jeu ait besoin de ressources de type personnage. Vous pouvez rechercher female et limiter les résultats au cas d’utilisation game asset :
python3 tripo_rag.py search \
--text "female" \
--use-case "game asset" \
--top-k 12
Cela renvoie les ressources correspondantes les plus proches du sous-ensemble des game assets, ce qui est plus utile que de rechercher dans toute la bibliothèque et d’ignorer manuellement les ressources de produit, d’environnement ou de marketing non pertinentes.
Exemple 2 : Recherche texte plus image de référence
Le texte seul est souvent trop large pour le travail visuel. Une requête comme fantasy sword with blue gemstone indique au système ce que vous voulez, mais une image de référence ancre la forme, la composition et la direction visuelle.
python3 tripo_rag.py search \
--text "fantasy sword with blue gemstone" \
--image ./examples/sword_reference.png \
--top-k 12
Ce mode est utile lorsqu’un créateur part d’une référence visuelle mais souhaite orienter la recherche avec quelques mots. L’image de référence apporte la similarité visuelle. Le texte précise l’intention.
Ce que cela permet dans un véritable pipeline d’actifs
Une fois la bibliothèque consultable, les équipes peuvent utiliser les ressources 3D générées davantage comme un inventaire de production réutilisable.
Une équipe de jeu peut suivre les variations d’accessoires et de personnages entre les projets. Une équipe e-commerce peut organiser des ressources de type produit par catégorie, matériau et style. Une équipe marketing peut conserver une bibliothèque approuvée de visuels réutilisables. Une équipe creative-ops peut construire des workflows de révision autour de la propriété, des ID de projet et des URL d’actifs au lieu de s’appuyer sur des noms de dossiers.
Le changement important est simple : la génération crée l’actif, mais la recherche rend l’actif réutilisable.
Conclusion
La génération 3D par IA facilite la production de plus de ressources qu’une structure de dossiers manuelle ne peut en gérer. Le prochain goulot d’étranglement est la récupération : trouver le bon actif, comprendre d’où il vient et le réutiliser dans le bon projet.
Ce tutoriel a montré une façon de résoudre ce problème. Générez des ressources avec Tripo, stockez les aperçus de rendu et les métadonnées dans Zilliz Cloud, intégrez chaque aperçu avec un modèle multimodal, et recherchez dans la collection par texte, image, ou les deux. Le même schéma peut commencer modestement avec un jeu de données local et évoluer vers un catalogue d’actifs de production à mesure que votre bibliothèque s’étend.
C’est également l’orientation derrière Zilliz Vector Lakebase : conserver les données d’IA multimodales, les embeddings, les métadonnées et les chemins de service dans une seule fondation consultable, afin que les équipes puissent passer de la génération à la récupération puis à la réutilisation sans reconstruire la couche de données à chaque fois.
Pour l’essayer vous-même, inscrivez-vous à Zilliz Cloud, créez un cluster gratuit, générez un petit lot de ressources avec Tripo, et exécutez le pipeline de bout en bout. Une fois que les premiers résultats de recherche semblent corrects, connectez la sortie à votre navigateur d’actifs interne ou à votre outil créatif.
Exemples d’actifs Tripo
Les actifs ci-dessous ont été générés dans Tripo Studio à l’aide des fonctionnalités décrites dans ce tutoriel.
Génération de textures 8K
La génération de textures 8K préserve la fidélité des couleurs et distingue les matériaux de surface tels que le métal, le cuir, le tissu et le bois, jusqu’aux marques d’usure et aux micro-textures.
Modèle HD
Le modèle HD prend en charge jusqu’à deux millions de faces, préservant les formes complexes, les arêtes nettes et les détails fins de surface pour le rendu, la visualisation et l’impression 3D.
Continuer à lire
Zilliz Cloud Just Landed in Claude Code
The Zilliz Cloud Plugin brings the full power of Zilliz Cloud directly into your Claude Code terminal as natural-language conversations.
Introducing Zilliz Cloud Global Cluster: Region-Level Resilience for Mission-Critical AI
Zilliz Cloud Global Cluster delivers multi-region resilience, automatic failover, and fast global AI search with built-in security and compliance.
Why Context Engineering Is Becoming the Full Stack of AI Agents
Discover how context engineering unifies prompts, RAG, and tools to build smarter, production-ready AI agents powered by Milvus.