Crea una ricerca multimodale per asset 3D con Tripo e Zilliz Cloud
La generazione 3D con l’AI ha reso la creazione di asset molto più veloce. Con Tripo, un generatore di modelli 3D AI, i team possono generare modelli 3D da prompt testuali, immagini o schizzi, quindi usarli nello sviluppo di giochi, nell’e-commerce, nel marketing, nel concept design e nelle pipeline creative interne.
Questa velocità crea un nuovo problema: gli asset si accumulano rapidamente.
Alcuni modelli generati sono facili da gestire manualmente. Qualche migliaio no. I designer possono rigenerare oggetti che esistono già. I team di gioco possono perdere traccia delle variazioni di personaggi, prop e ambienti. I team di marketing possono passare più tempo a cercare un asset utilizzabile che ad adattarlo per una campagna.
Questo tutorial mostra come trasformare quegli asset generati in un catalogo ricercabile. Tripo è il livello di creazione 3D, mentre Zilliz Cloud è il livello di recupero: un servizio di database vettoriale completamente gestito dai creatori di Milvus che archivia embedding e metadati, supporta la ricerca per similarità a bassa latenza e consente di combinare la ricerca vettoriale con filtri strutturati.
In questo workflow, ogni record di asset contiene un’anteprima renderizzata, metadati strutturati e un embedding multimodale. Una volta indicizzati gli asset, gli utenti possono cercare per testo, per immagine o combinando testo e immagine.
Cosa costruirai
La libreria in questo tutorial tratta ogni asset 3D come un elemento di catalogo ricercabile. La mesh 3D rimane ovunque la tua pipeline di asset la archivi. Il record ricercabile contiene l’anteprima renderizzata dell’asset, i metadati, i riferimenti di archiviazione e l’embedding.
Questa demo usa tre tipi di dati locali:
| Dati locali | Cosa contengono |
|---|---|
| milvus_dataset.csv | Metadati per asset: categoria, stile, tipo di oggetto, colore, caso d’uso, nome file, info progetto |
| milvus_render_images/ | Anteprime renderizzate degli asset Tripo. Sono ciò che cerchi e che ricevi come risultato |
| milvus_input_images/ | Immagini di riferimento usate per la generazione image-to-3D. Archiviate come metadati e riferimenti di query opzionali |
Il workflow di base è:
Asset 3D generato da Tripo
↓
Immagine di anteprima renderizzata + metadati
↓
Embedding multimodale
↓
Collection Zilliz Cloud
↓
Ricerca per testo, immagine o testo + immagine
↓
Restituzione di immagini renderizzate corrispondenti e metadati
Questa configurazione supporta pattern di ricerca creativa comuni:
- Cerca per concetto, ad esempio spada fantasy blu.
- Cerca per tipo di oggetto, stile, colore o caso d’uso.
- Usa un’immagine di riferimento quando le parole sono troppo vaghe.
- Combina un’immagine di riferimento con il testo per orientare il risultato.
- Filtra per campi strutturati come categoria, progetto, operatore, stile o modalità di generazione.
Il risultato non è solo una cartella con nomi file migliori. È un catalogo di asset interrogabile.
Perché le anteprime renderizzate e i metadati sono importanti
Un modello 3D non è facile da cercare direttamente. In una pipeline di produzione, il modello di solito viene fornito con diverse informazioni correlate:
- la mesh generata o il file sorgente;
- una o più immagini di anteprima renderizzate;
- un’immagine di input o di riferimento opzionale;
- una caption o un prompt;
- tag generati;
- campi relativi a progetto, proprietario o operatore;
- metadati di stile, categoria, colore, tipo di oggetto e caso d’uso;
- URL o chiavi di archiviazione che rimandano all’asset.
Per questo tutorial, l’anteprima renderizzata è l’oggetto visivo di cui creiamo l’embedding. Funziona bene perché le anteprime renderizzate catturano forma, materiale, colore e stile visivo in una forma che un modello di embedding multimodale può comprendere.
L’anteprima renderizzata è l’oggetto che il modello di embedding vede, quindi la qualità dell’asset influisce direttamente sulla qualità della ricerca. La fedeltà geometrica — forme, bordi e decorazioni preservati — fornisce al modello un segnale strutturale. Le texture ad alta risoluzione — materiali distinti, colore fedele, dettaglio della superficie — gli forniscono un segnale di materiale e colore. Senza entrambe, gli embedding si appiattiscono: una borsa in pelle e una borsa in tela appaiono uguali al modello, e la ricerca smette di essere utile.
I metadati ti offrono un secondo livello di controllo: puoi eseguire una ricerca semantica e applicare comunque filtri esatti. Un record di asset potrebbe apparire così:
caption: spada fantasy con gemma blu
llm_object: spada
llm_category: arma
llm_style: fantasy
llm_color: blu, argento
llm_use_case: asset di gioco
generation_mode: image-to-3D
render_image_file: fantasy_sword.webp
input_image_file: sword_reference.webp
Questa combinazione rende la libreria utile nei flussi di lavoro reali. Per esempio, un artista di videogiochi può cercare un personaggio femminile e restringere l’insieme dei risultati ad asset di gioco. Un marketer può cercare borsa in pelle realistica e filtrare per progetto. Un team e-commerce può cercare per categoria e materiale senza dipendere da nomi di file esatti.
Nota sul formato immagine
In questa demo, le immagini di render e di riferimento sono archiviate come .webp per efficienza di spazio. L’API di embedding può essere più affidabile con input PNG o JPEG, a seconda del modello e del percorso del provider. Se riscontri errori di input immagine, converti le anteprime WebP in PNG o JPEG prima dell’embedding.
Strumenti in questa pipeline
Questo tutorial collega due sistemi: uno che crea gli asset 3D e uno che li rende ricercabili.
Tripo: il livello di creazione
Tripo è un generatore di modelli 3D AI basato su un modello con oltre 20 miliardi di parametri. Il suo prodotto principale, Tripo Studio, copre l’intero flusso di creazione degli asset in un unico workspace — dall’input di testo, immagine o schizzo fino al perfezionamento della mesh, generazione di texture, rigging, animazione ed esportazione. Una mesh standard viene generata in due-cinque secondi, e questo è uno dei motivi per cui le librerie di asset crescono abbastanza rapidamente da richiedere la pipeline di ricerca che questo tutorial costruisce.
Tre funzionalità sono particolarmente rilevanti qui:
- La generazione di modelli Image-to-3D preserva la struttura geometrica — forme complesse, bordi netti, decorazioni, dettagli di superficie — così i modelli generati restano fedeli al riferimento di input.
- HD Model spinge ulteriormente questa fedeltà, supportando fino a due milioni di facce per asset che reggono rendering ravvicinati, visualizzazione di prodotti o stampa 3D.
- La Generazione di Texture fino a risoluzione 8K aggiunge riproduzione fedele dei colori, chiara distinzione dei materiali (metallo, pelle, tessuto, legno) e dettagli di superficie a grana fine come segni di usura, venature e micro-texture.
Insieme, questi elementi danno a ogni asset abbastanza segnale geometrico e materiale da produrre un embedding multimodale significativo — ed è qui che entra in gioco il lato del recupero.
Zilliz Cloud: il livello di recupero
Zilliz Cloud è una piattaforma Vector Lakebase completamente gestita, costruita dai creatori di Milvus, il database vettoriale open-source più ampiamente adottato (45.000+ stelle GitHub, 100M+ download Docker, 10.000+ organizzazioni in produzione). Al suo centro c’è un database vettoriale di livello produzione che offre ricerca sotto il millisecondo su scala di 100 miliardi. In questo tutorial, gestisce tre aspetti:
- Archiviazione degli embedding — il vettore multimodale di ogni asset vive accanto ai suoi metadati strutturati in un’unica collection.
- Ricerca per similarità — query testuali, visive o combinate vengono incorporate nello stesso spazio vettoriale e confrontate con le anteprime renderizzate archiviate.
- Recupero filtrato — filtri esatti per categoria, stile, caso d’uso o progetto si sovrappongono alla ricerca semantica in un’unica richiesta, ed è questo che trasforma una pila di vettori in un catalogo interrogabile.
Prerequisiti
Prima di iniziare, prepara quanto segue:
- Un account e un cluster Zilliz Cloud. Il cluster gratuito è sufficiente per questo tutorial. Registrati, crea un cluster e copia il relativo endpoint e token.
- Una chiave API OpenRouter per il modello di embedding multimodale usato di seguito.
- Python 3.10 o versione successiva.
- L’SDK Python di Milvus. Consulta la guida all’installazione di PyMilvus se non lo conosci.
- Un set di asset generati con Tripo, incluse immagini di anteprima del rendering e metadati.
- Immagini di riferimento opzionali usate per la generazione da immagine a 3D.
Il codice di esempio qui sotto presuppone uno script chiamato tripo_rag.py, ma la stessa logica può essere spostata nel tuo servizio di ingestione, backend di gestione degli asset o strumento interno.
Passaggio 1: Preparare i dati degli asset generati con Tripo
Inizia con gli asset generati in Tripo. Per ogni asset, esporta o archivia almeno un’immagine di anteprima del rendering. Se l’asset è stato creato da un’immagine di riferimento, conserva anche quell’immagine di riferimento. Può essere utile per il debug, per visualizzare in anteprima i risultati di ricerca o per creare modalità di ricerca future.
Ogni riga nel tuo CSV di metadati dovrebbe rappresentare un asset. Come minimo, includi:
- un ID asset univoco;
- un nome file o una chiave di archiviazione dell’immagine di anteprima del rendering;
- una didascalia o un prompt di generazione;
- campi categoria, oggetto, stile, colore e caso d’uso quando disponibili;
- campi progetto o proprietario se il tuo team necessita di controllo degli accessi o filtraggio a livello di workspace;
- l’URL o la posizione di archiviazione dell’asset originale.
Metadati più ricchi offrono filtri migliori in seguito. Il vettore ti aiuta a trovare asset visivamente e semanticamente simili. I metadati ti aiutano a restringere l’insieme dei risultati agli asset effettivamente utilizzabili per il progetto corrente.
Passaggio 2: Creare una collection Zilliz Cloud
Ogni record nella collection rappresenta un asset Tripo. I campi strutturati memorizzano i metadati. Il campo multimodal_vector memorizza l’embedding per l’anteprima del rendering.
Gli esempi seguenti usano un vettore a 3072 dimensioni e la similarità COSINE. Mantieni la dimensione allineata al modello di embedding che usi.
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)
Quindi crea l’indice vettoriale:
index_params = MilvusClient.prepare_index_params()
index_params.add_index(
field_name=VECTOR_FIELD,
index_type="AUTOINDEX",
metric_type="COSINE",
)
Se il tuo script incapsula la configurazione in un comando, esegui:
python3 tripo_rag.py create-collection
Al termine del comando, apri la console di Zilliz Cloud e controlla l’elenco delle collection.
Fai clic sulla collection per controllare lo stato, lo schema, le entità caricate e la configurazione del campo vettoriale.
Una breve nota sull'indice: AUTOINDEX mantiene il tutorial semplice perché non è necessario ottimizzare manualmente i parametri dell'indice prima di importare i dati. Il tipo di metrica COSINE corrisponde agli embedding normalizzati utilizzati nel passaggio successivo.
Passaggio 3: Generare embedding multimodali per le immagini di rendering
Successivamente, genera un embedding per ogni anteprima di rendering.
La demo invia l'immagine di anteprima a un modello di embedding tramite OpenRouter. L'immagine viene codificata come URL dati base64 e il vettore restituito viene normalizzato L2 prima di essere inserito in 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)
},
}
]
)
Per una pipeline di ingestione reale, memorizza gli embedding nella cache. Chiamare un'API di embedding esterna per ogni importazione è lento, e i nuovi tentativi possono rendere costose le esecuzioni di test ripetute.
python3 tripo_rag.py build-cache
Una cache rende inoltre deterministico il comportamento dell'importazione. Puoi ricostruire la collection, testare modifiche allo schema o rieseguire importazioni senza rieseguire l'embedding di ogni anteprima di rendering.
Passaggio 4: Importare i record degli asset in Zilliz Cloud
Dopo che la cache è pronta, converti ogni riga CSV in un'entità per Zilliz Cloud.
Ogni entità dovrebbe includere i campi strutturati e il vettore multimodale memorizzato nella 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],
}
Quindi importa il dataset e controlla le statistiche della collection:
python3 tripo_rag.py import-data
python3 tripo_rag.py stats
Apri la scheda Data nella console di Zilliz Cloud per confermare che i record degli asset siano stati inseriti. Dovresti vedere i campi di metadati, i riferimenti alle immagini di rendering e il campo vettoriale per ogni entità.
Gli asset Tripo sono ora entità ricercabili in un database vettoriale, non file locali sparsi.
Passaggio 5: Cercare per testo, immagine o entrambi
La ricerca viene eseguita in tre modalità, tutte tramite lo stesso modello multimodale e sullo stesso campo multimodal_vector.
| Modalità | Usala quando | Esempio |
|---|---|---|
| Testo | Puoi descrivere ciò che vuoi | spada fantasy blu |
| Immagine | Hai un riferimento e vuoi asset simili | carica un render di uno scudo stilizzato |
| Testo + immagine | Vuoi un intento e un ancoraggio visivo | immagine di spada + spada fantasy con gemma blu |
La query viene incorporata nello stesso spazio vettoriale delle anteprime di rendering degli asset. Zilliz Cloud cerca quindi nel campo vettoriale e restituisce gli asset più vicini con i relativi metadati.
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,
)
)
Poiché ogni risultato include sia un punteggio di somiglianza sia metadati, il tuo front end può visualizzare l’immagine di anteprima, la didascalia, la categoria, lo stile, il caso d’uso e l’URL dell’asset originale nella stessa scheda risultato.
La ricerca non è limitata alla pura somiglianza vettoriale. Poiché ogni asset contiene metadati strutturati, puoi aggiungere filtri a una query semantica in un’unica richiesta. Ad esempio, cerca female ma limita l’insieme dei risultati a llm_use_case == "game asset". Questo è ciò che rende la raccolta un vero catalogo invece di un mucchio di vettori.
Esempio 1: Ricerca testuale con un filtro per caso d’uso
Supponiamo che un team di gioco abbia bisogno di asset simili a personaggi. Puoi cercare female e limitare i risultati al caso d’uso game asset:
python3 tripo_rag.py search \
--text "female" \
--use-case "game asset" \
--top-k 12
Questo restituisce gli asset più pertinenti dal sottoinsieme game-asset, il che è più utile che cercare nell’intera libreria e ignorare manualmente asset irrilevanti di prodotto, ambiente o marketing.
Esempio 2: Ricerca con testo più immagine di riferimento
Il solo testo è spesso troppo generico per il lavoro visivo. Una query come fantasy sword with blue gemstone dice al sistema ciò che vuoi, ma un’immagine di riferimento ancora la forma, la composizione e la direzione visiva.
python3 tripo_rag.py search \
--text "fantasy sword with blue gemstone" \
--image ./examples/sword_reference.png \
--top-k 12
Questa modalità è utile quando un creator parte da un riferimento visivo ma vuole orientare la ricerca con poche parole. L’immagine di riferimento porta somiglianza visiva. Il testo restringe l’intento.
Cosa rende possibile in una vera pipeline di asset
Una volta che la libreria è ricercabile, i team possono usare gli asset 3D generati più come un inventario di produzione riutilizzabile.
Un team di sviluppo di giochi può tracciare variazioni di props e personaggi tra i progetti. Un team e-commerce può organizzare asset simili a prodotti per categoria, materiale e stile. Un team marketing può mantenere una libreria approvata di visual riutilizzabili. Un team creative-ops può creare workflow di revisione basati su proprietà, ID di progetto e URL degli asset invece di fare affidamento sui nomi delle cartelle.
Il cambiamento importante è semplice: la generazione crea l'asset, ma la ricerca rende l'asset riutilizzabile.
Conclusione
La generazione 3D con AI rende facile produrre più asset di quanti una struttura manuale di cartelle possa gestire. Il prossimo collo di bottiglia è il recupero: trovare l'asset giusto, capire da dove proviene e riutilizzarlo nel progetto corretto.
Questo tutorial ha mostrato un modo per risolvere questo problema. Genera asset con Tripo, archivia anteprime di rendering e metadati in Zilliz Cloud, incorpora ogni anteprima con un modello multimodale e cerca nella raccolta per testo, immagine o entrambi. Lo stesso schema può partire in piccolo con un dataset locale e crescere fino a diventare un catalogo di asset di produzione man mano che la tua libreria si espande.
Questa è anche la direzione alla base di Zilliz Vector Lakebase: mantenere dati AI multimodali, embeddings, metadati e percorsi di serving in un'unica base ricercabile, così i team possono passare dalla generazione al recupero e al riutilizzo senza ricostruire ogni volta il livello dati.
Per provarlo tu stesso, registrati a Zilliz Cloud, crea un cluster gratuito, genera un piccolo batch di asset con Tripo ed esegui la pipeline dall'inizio alla fine. Quando i primi risultati di ricerca sembrano corretti, collega l'output al tuo browser di asset interno o al tuo strumento creativo.
Esempi di asset Tripo
Gli asset qui sotto sono stati generati in Tripo Studio usando le funzionalità descritte in questo tutorial.
Generazione di texture 8K
La generazione di texture 8K preserva la fedeltà cromatica e distingue materiali di superficie come metallo, pelle, tessuto e legno, fino ai segni di usura e alle micro-texture.
Modello HD
HD Model supporta fino a due milioni di facce, preservando forme complesse, spigoli netti e dettagli fini della superficie per rendering, visualizzazione e stampa 3D.
Continua a leggere
How Zilliz Ended Up at the Center of NVIDIA’s Unstructured Data Story at GTC 2026
If unstructured data is the context of AI, then the ceiling of AI applications will be set not just by models, but by how mature the infrastructure for unstructured data becomes.
Will Amazon S3 Vectors Kill Vector Databases—or Save Them?
AWS S3 Vectors aims for 90% cost savings for vector storage. But will it kill vectordbs like Milvus? A deep dive into costs, limits, and the future of tiered storage.
DeepSeek-VL2: Mixture-of-Experts Vision-Language Models for Advanced Multimodal Understanding
Explore DeepSeek-VL2, the open-source MoE vision-language model. Discover its architecture, efficient training pipeline, and top-tier performance.