Crie uma busca multimodal para ativos 3D com Tripo e Zilliz Cloud
A geração 3D com IA tornou a criação de ativos muito mais rápida. Com o Tripo, um gerador de modelos 3D com IA, as equipes podem gerar modelos 3D a partir de prompts de texto, imagens ou esboços e, em seguida, usá-los no desenvolvimento de jogos, e-commerce, marketing, design conceitual e pipelines criativos internos.
Essa velocidade cria um novo problema: os ativos se acumulam rapidamente.
Alguns modelos gerados são fáceis de gerenciar manualmente. Alguns milhares, não. Designers podem regenerar objetos que já existem. Equipes de jogos podem perder o controle de variações de personagens, props e ambientes. Equipes de marketing podem passar mais tempo procurando um ativo utilizável do que adaptando-o para uma campanha.
Este tutorial mostra como transformar esses ativos gerados em um catálogo pesquisável. O Tripo é a camada de criação 3D, enquanto o Zilliz Cloud é a camada de recuperação: um serviço de banco de dados vetorial totalmente gerenciado dos criadores do Milvus que armazena embeddings e metadados, oferece suporte a buscas por similaridade de baixa latência e permite combinar busca vetorial com filtros estruturados.
Neste fluxo de trabalho, cada registro de ativo contém uma prévia renderizada, metadados estruturados e um embedding multimodal. Depois que os ativos são indexados, os usuários podem pesquisar por texto, por imagem ou por texto e imagem juntos.
O Que Você Vai Construir
A biblioteca neste tutorial trata cada ativo 3D como um item de catálogo pesquisável. A malha 3D permanece onde quer que seu pipeline de ativos a armazene. O registro pesquisável contém a prévia renderizada do ativo, metadados, referências de armazenamento e embedding.
Esta demonstração usa três tipos de dados locais:
| Dados locais | O que contêm |
|---|---|
| milvus_dataset.csv | Metadados por ativo: categoria, estilo, tipo de objeto, cor, caso de uso, nome do arquivo, informações do projeto |
| milvus_render_images/ | Prévias renderizadas dos ativos do Tripo. São elas que você pesquisa e recebe de volta |
| milvus_input_images/ | Imagens de referência usadas para geração de imagem para 3D. Armazenadas como metadados e referências de consulta opcionais |
O fluxo de trabalho básico é:
Ativo 3D gerado pelo Tripo
↓
Imagem de prévia renderizada + metadados
↓
Embedding multimodal
↓
Coleção do Zilliz Cloud
↓
Busca por texto, imagem ou texto + imagem
↓
Retorna imagens renderizadas correspondentes e metadados
Esta configuração oferece suporte a padrões comuns de busca criativa:
- Pesquisar por conceito, como espada azul de fantasia.
- Pesquisar por tipo de objeto, estilo, cor ou caso de uso.
- Usar uma imagem de referência quando as palavras forem vagas demais.
- Combinar uma imagem de referência com texto para orientar o resultado.
- Filtrar por campos estruturados, como categoria, projeto, operador, estilo ou modo de geração.
O resultado não é apenas uma pasta com nomes de arquivos melhores. É um catálogo de ativos consultável.
Por Que Prévias Renderizadas e Metadados São Importantes
Um modelo 3D não é fácil de pesquisar diretamente. Em um pipeline de produção, o modelo geralmente vem com várias informações relacionadas:
- a malha gerada ou arquivo-fonte;
- uma ou mais imagens de prévia renderizadas;
- uma imagem de entrada ou referência opcional;
- uma legenda ou prompt;
- tags geradas;
- campos de projeto, proprietário ou operador;
- metadados de estilo, categoria, cor, tipo de objeto e caso de uso;
- URLs ou chaves de armazenamento que apontam de volta para o ativo.
Para este tutorial, a prévia renderizada é o objeto visual que incorporamos. Isso funciona bem porque as prévias renderizadas capturam forma, material, cor e estilo visual em um formato que um modelo de embedding multimodal consegue entender.
A prévia renderizada é o objeto que o modelo de embedding vê, portanto a qualidade do ativo afeta diretamente a qualidade da busca. A fidelidade geométrica — formas, bordas e decorações preservadas — fornece sinal estrutural ao modelo. Texturas de alta resolução — materiais distintos, cor fiel, detalhes de superfície — fornecem sinal de material e cor. Sem ambos, os embeddings se achatam: uma bolsa de couro e uma bolsa de lona parecem iguais para o modelo, e a busca deixa de ser útil.
Os metadados oferecem uma segunda camada de controle: você pode executar busca semântica e ainda aplicar filtros exatos. Um registro de ativo pode ser assim:
caption: fantasy sword with blue gemstone
llm_object: sword
llm_category: weapon
llm_style: fantasy
llm_color: blue, silver
llm_use_case: game asset
generation_mode: image-to-3D
render_image_file: fantasy_sword.webp
input_image_file: sword_reference.webp
Essa combinação torna a biblioteca útil em fluxos de trabalho reais. Por exemplo, um artista de jogos pode buscar uma personagem feminina e restringir o conjunto de resultados a ativos de jogo. Um profissional de marketing pode procurar uma bolsa de couro realista e filtrar por projeto. Uma equipe de e-commerce pode pesquisar por categoria e material sem depender de nomes de arquivos exatos.
Observação sobre formato de imagem
Nesta demonstração, imagens de renderização e referência são armazenadas como .webp para eficiência de espaço. A API de embeddings pode ser mais confiável com entradas PNG ou JPEG, dependendo do modelo e da rota do provedor. Se você vir erros de entrada de imagem, converta pré-visualizações WebP para PNG ou JPEG antes de gerar embeddings.
Ferramentas neste pipeline
Este tutorial conecta dois sistemas: um que cria os ativos 3D e outro que os torna pesquisáveis.
Tripo: a camada de criação
Tripo é um gerador de modelos 3D com IA desenvolvido com base em um modelo com mais de 20 bilhões de parâmetros. Seu principal produto, Tripo Studio, cobre todo o fluxo de criação de ativos em um único workspace — desde entrada por texto, imagem ou esboço até refinamento de malha, geração de textura, rigging, animação e exportação. Uma malha padrão é gerada em dois a cinco segundos, o que é parte do motivo pelo qual bibliotecas de ativos crescem rápido o suficiente para precisar do pipeline de busca que este tutorial constrói.
Três recursos são especialmente relevantes aqui:
- A geração de modelo de imagem para 3D preserva a estrutura geométrica — formas complexas, bordas nítidas, decorações, detalhes de superfície — para que os modelos gerados permaneçam fiéis à referência de entrada.
- HD Model leva essa fidelidade ainda mais longe, oferecendo suporte a até dois milhões de faces para ativos que se mantêm em renderizações em close-up, visualização de produtos ou impressão 3D.
- A Geração de Textura em resolução de até 8K adiciona reprodução de cores fiel, distinção clara de materiais (metal, couro, tecido, madeira) e detalhes de superfície refinados, como marcas de desgaste, grãos e microtexturas.
Juntos, esses recursos dão a cada ativo sinal geométrico e material suficiente para produzir um embedding multimodal significativo — que é onde entra o lado da recuperação.
Zilliz Cloud: a camada de recuperação
Zilliz Cloud é uma plataforma Vector Lakebase totalmente gerenciada, criada pelos desenvolvedores do Milvus, o banco de dados vetorial open-source mais amplamente adotado (45.000+ estrelas no GitHub, 100M+ pulls no Docker, 10.000+ organizações em produção). Em seu núcleo está um banco de dados vetorial de nível de produção que entrega busca em menos de um milissegundo em escala de 100 bilhões. Neste tutorial, ele lida com três coisas:
- Armazenamento de embeddings — o vetor multimodal de cada ativo fica junto com seus metadados estruturados em uma única coleção.
- Busca por similaridade — consultas de texto, imagem ou combinadas são convertidas em embeddings no mesmo espaço vetorial e comparadas às pré-visualizações de renderização armazenadas.
- Recuperação filtrada — filtros exatos por categoria, estilo, caso de uso ou camada de projeto são aplicados sobre a busca semântica em uma única solicitação, que é o que transforma uma pilha de vetores em um catálogo consultável.
Pré-requisitos
Antes de começar, prepare o seguinte:
- Uma conta e um cluster do Zilliz Cloud. O cluster gratuito é suficiente para este tutorial. Cadastre-se, crie um cluster e copie seu endpoint e token.
- Uma chave de API do OpenRouter para o modelo de embedding multimodal usado abaixo.
- Python 3.10 ou posterior.
- O SDK Python do Milvus. Consulte o guia de instalação do PyMilvus se você for novo nele.
- Um conjunto de assets gerados pelo Tripo, incluindo imagens de pré-visualização de renderização e metadados.
- Imagens de referência opcionais usadas para geração de imagem para 3D.
O código de exemplo abaixo assume um script chamado tripo_rag.py, mas a mesma lógica pode ser movida para seu próprio serviço de ingestão, backend de gerenciamento de assets ou ferramenta interna.
Etapa 1: Prepare os Dados de Assets Gerados pelo Tripo
Comece com os assets gerados no Tripo. Para cada asset, exporte ou armazene pelo menos uma imagem de pré-visualização de renderização. Se o asset foi criado a partir de uma imagem de referência, mantenha essa imagem de referência também. Ela pode ser útil para depuração, pré-visualização de resultados de pesquisa ou criação de modos de pesquisa futuros.
Cada linha no seu CSV de metadados deve representar um asset. No mínimo, inclua:
- um ID de asset exclusivo;
- um nome de arquivo ou chave de armazenamento da imagem de pré-visualização de renderização;
- uma legenda ou prompt de geração;
- campos de categoria, objeto, estilo, cor e caso de uso quando disponíveis;
- campos de projeto ou proprietário se sua equipe precisar de controle de acesso ou filtragem em nível de workspace;
- a URL ou local de armazenamento do asset original.
Metadados mais ricos fornecem filtros melhores posteriormente. O vetor ajuda você a encontrar assets visualmente e semanticamente semelhantes. Os metadados ajudam a restringir o conjunto de resultados aos assets que são realmente utilizáveis para o projeto atual.
Etapa 2: Crie uma Coleção no Zilliz Cloud
Cada registro na coleção representa um asset do Tripo. Os campos estruturados armazenam metadados. O campo multimodal_vector armazena o embedding da pré-visualização de renderização.
Os exemplos abaixo usam um vetor de 3072 dimensões e similaridade COSINE. Mantenha a dimensão alinhada com o modelo de embedding que você usa.
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)
Em seguida, crie o índice vetorial:
index_params = MilvusClient.prepare_index_params()
index_params.add_index(
field_name=VECTOR_FIELD,
index_type="AUTOINDEX",
metric_type="COSINE",
)
Se seu script encapsular a configuração em um comando, execute:
python3 tripo_rag.py create-collection
Depois que o comando terminar, abra o console do Zilliz Cloud e verifique a lista de coleções.
Clique na coleção para verificar o status, o schema, as entidades carregadas e a configuração do campo vetorial.
Uma observação rápida sobre o índice: AUTOINDEX mantém o tutorial simples porque você não precisa ajustar manualmente os parâmetros do índice antes de importar dados. O tipo de métrica COSINE corresponde aos embeddings normalizados usados na próxima etapa.
Etapa 3: Gerar embeddings multimodais para imagens de renderização
Em seguida, gere um embedding para cada pré-visualização de renderização.
A demonstração envia a imagem de pré-visualização para um modelo de embedding por meio do OpenRouter. A imagem é codificada como uma URL de dados em base64, e o vetor retornado é normalizado por L2 antes de ser inserido no 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 um pipeline de ingestão real, armazene os embeddings em cache. Chamar uma API externa de embedding para cada importação é lento, e novas tentativas podem tornar execuções de teste repetidas caras.
python3 tripo_rag.py build-cache
Um cache também torna o comportamento da importação determinístico. Você pode recriar a coleção, testar alterações de esquema ou executar novamente importações sem gerar novamente embeddings para cada pré-visualização de renderização.
Etapa 4: Importar registros de ativos para o Zilliz Cloud
Depois que o cache estiver pronto, converta cada linha CSV em uma entidade para o Zilliz Cloud.
Cada entidade deve incluir os campos estruturados e o vetor multimodal em 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],
}
Em seguida, importe o conjunto de dados e verifique as estatísticas da coleção:
python3 tripo_rag.py import-data
python3 tripo_rag.py stats
Abra a guia Data no console do Zilliz Cloud para confirmar que os registros de ativos foram inseridos. Você deve ver os campos de metadados, as referências de imagem de renderização e o campo vetorial de cada entidade.
Os ativos do Tripo agora são entidades pesquisáveis em um banco de dados vetorial, não arquivos locais soltos.
Etapa 5: Pesquisar por texto, imagem ou ambos
A pesquisa é executada em três modos, todos por meio do mesmo modelo multimodal e no mesmo campo multimodal_vector.
| Modo | Use quando | Exemplo |
|---|---|---|
| Texto | Você pode descrever o que deseja | espada azul de fantasia |
| Imagem | Você tem uma referência e quer ativos semelhantes | envie uma renderização estilizada de escudo |
| Texto + imagem | Você quer intenção e uma âncora visual | imagem de espada + espada de fantasia com pedra preciosa azul |
A consulta é incorporada no mesmo espaço vetorial que as prévias de renderização dos ativos. O Zilliz Cloud então pesquisa o campo vetorial e retorna os ativos mais próximos com seus metadados.
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 inclui tanto uma pontuação de similaridade quanto metadados, seu front-end pode renderizar a imagem de prévia, legenda, categoria, estilo, caso de uso e URL do ativo original no mesmo cartão de resultado.
A pesquisa não se limita à similaridade vetorial pura. Como cada ativo carrega metadados estruturados, você pode adicionar filtros a uma consulta semântica em uma única solicitação. Por exemplo, pesquise female, mas restrinja o conjunto de resultados a llm_use_case == "game asset". É isso que torna a coleção um catálogo real em vez de uma pilha de vetores.
Exemplo 1: Pesquisa de texto com um filtro de caso de uso
Suponha que uma equipe de jogos precise de ativos semelhantes a personagens. Você pode pesquisar female e restringir os resultados ao caso de uso game asset:
python3 tripo_rag.py search \
--text "female" \
--use-case "game asset" \
--top-k 12
Isso retorna os ativos correspondentes mais próximos do subconjunto de game assets, o que é mais útil do que pesquisar em toda a biblioteca e ignorar manualmente ativos irrelevantes de produto, ambiente ou marketing.
Exemplo 2: Pesquisa de texto mais imagem de referência
Texto sozinho muitas vezes é amplo demais para trabalho visual. Uma consulta como espada de fantasia com pedra preciosa azul diz ao sistema o que você quer, mas uma imagem de referência ancora a forma, a composição e a direção visual.
python3 tripo_rag.py search \
--text "fantasy sword with blue gemstone" \
--image ./examples/sword_reference.png \
--top-k 12
Este modo é útil quando um criador começa a partir de uma referência visual, mas quer orientar a pesquisa com algumas palavras. A imagem de referência traz similaridade visual. O texto estreita a intenção.
O Que Isso Possibilita em um Pipeline Real de Ativos
Depois que a biblioteca se torna pesquisável, as equipes podem usar ativos 3D gerados mais como um inventário de produção reutilizável.
Uma equipe de jogos pode acompanhar variações de props e personagens entre projetos. Uma equipe de e-commerce pode organizar ativos semelhantes a produtos por categoria, material e estilo. Uma equipe de marketing pode manter uma biblioteca aprovada de visuais reutilizáveis. Uma equipe de operações criativas pode criar fluxos de trabalho de revisão em torno de propriedade, IDs de projeto e URLs de ativos, em vez de depender de nomes de pastas.
A mudança importante é simples: a geração cria o ativo, mas a busca torna o ativo reutilizável.
Conclusão
A geração 3D por IA facilita produzir mais ativos do que uma estrutura manual de pastas consegue gerenciar. O próximo gargalo é a recuperação: encontrar o ativo certo, entender de onde ele veio e reutilizá-lo no projeto certo.
Este tutorial mostrou uma maneira de resolver esse problema. Gere ativos com o Tripo, armazene pré-visualizações de renderização e metadados no Zilliz Cloud, incorpore cada pré-visualização com um modelo multimodal e pesquise a coleção por texto, imagem ou ambos. O mesmo padrão pode começar pequeno com um conjunto de dados local e crescer para um catálogo de ativos de produção à medida que sua biblioteca se expande.
Essa também é a direção por trás do Zilliz Vector Lakebase: manter dados multimodais de IA, embeddings, metadados e caminhos de serviço em uma única base pesquisável, para que as equipes possam passar da geração à recuperação e à reutilização sem reconstruir a camada de dados a cada vez.
Para experimentar você mesmo, cadastre-se no Zilliz Cloud, crie um cluster gratuito, gere um pequeno lote de ativos com o Tripo e execute o pipeline de ponta a ponta. Quando os primeiros resultados de busca parecerem corretos, conecte a saída ao seu navegador interno de ativos ou ferramenta criativa.
Exemplos de Ativos do Tripo
Os ativos abaixo foram gerados no Tripo Studio usando os recursos descritos neste tutorial.
Geração de Texturas em 8K
A geração de texturas em 8K preserva a fidelidade das cores e distingue materiais de superfície como metal, couro, tecido e madeira, até marcas de desgaste e microtexturas.
Modelo HD
O Modelo HD suporta até dois milhões de faces, preservando formas complexas, bordas nítidas e recursos finos de superfície para renderização, visualização e impressão 3D.
Continue lendo
Introducing Zilliz MCP Server: Natural Language Access to Your Vector Database
Developers can easily manage and query vector databases with natural language via Zilliz MCP Server in AI-native environments.
Balancing Precision and Performance: How Zilliz Cloud's New Parameters Help You Optimize Vector Search
Optimize vector search with Zilliz Cloud’s level and recall features to tune accuracy, balance performance, and power AI applications.
1 Table = 1000 Words? Foundation Models for Tabular Data
TableGPT2 automates tabular data insights, overcoming schema variability, while Milvus accelerates vector search for efficient, scalable decision-making.