Erstellen Sie eine multimodale Suche für 3D-Assets mit Tripo und Zilliz Cloud
Die KI-3D-Generierung hat die Erstellung von Assets deutlich beschleunigt. Mit Tripo, einem KI-3D-Modellgenerator, können Teams 3D-Modelle aus Text-Prompts, Bildern oder Skizzen generieren und sie anschließend in der Spieleentwicklung, im E-Commerce, im Marketing, im Konzeptdesign und in internen kreativen Pipelines einsetzen.
Diese Geschwindigkeit schafft ein neues Problem: Assets häufen sich schnell an.
Einige generierte Modelle lassen sich leicht manuell verwalten. Einige Tausend nicht. Designer generieren möglicherweise Objekte erneut, die bereits existieren. Game-Teams verlieren möglicherweise den Überblick über Varianten von Charakteren, Props und Umgebungen. Marketing-Teams verbringen möglicherweise mehr Zeit damit, nach einem brauchbaren Asset zu suchen, als es für eine Kampagne anzupassen.
Dieses Tutorial zeigt, wie diese generierten Assets in einen durchsuchbaren Katalog umgewandelt werden. Tripo ist die 3D-Erstellungsebene, während Zilliz Cloud die Retrieval-Ebene ist: ein vollständig verwalteter Vektordatenbank-Service von den Entwicklern von Milvus, der Embeddings und Metadaten speichert, Ähnlichkeitssuche mit niedriger Latenz unterstützt und es ermöglicht, Vektorsuche mit strukturierten Filtern zu kombinieren.
In diesem Workflow enthält jeder Asset-Datensatz eine Render-Vorschau, strukturierte Metadaten und ein multimodales Embedding. Sobald die Assets indiziert sind, können Benutzer per Text, per Bild oder mit Text und Bild zusammen suchen.
Was Sie erstellen werden
Die Bibliothek in diesem Tutorial behandelt jedes 3D-Asset als durchsuchbaren Katalogeintrag. Das 3D-Mesh verbleibt dort, wo Ihre Asset-Pipeline es speichert. Der durchsuchbare Datensatz enthält die Render-Vorschau des Assets, Metadaten, Speicherreferenzen und das Embedding.
Diese Demo verwendet drei Arten lokaler Daten:
| Lokale Daten | Was sie enthalten |
|---|---|
| milvus_dataset.csv | Metadaten pro Asset: Kategorie, Stil, Objekttyp, Farbe, Anwendungsfall, Dateiname, Projektinformationen |
| milvus_render_images/ | Gerenderte Vorschauen der Tripo-Assets. Nach diesen suchen Sie und diese erhalten Sie zurück |
| milvus_input_images/ | Referenzbilder, die für die Bild-zu-3D-Generierung verwendet wurden. Gespeichert als Metadaten und optionale Abfragereferenzen |
Der grundlegende Workflow lautet:
Von Tripo generiertes 3D-Asset
↓
Render-Vorschaubild + Metadaten
↓
Multimodales Embedding
↓
Zilliz Cloud Collection
↓
Suche per Text, Bild oder Text + Bild
↓
Passende Render-Bilder und Metadaten zurückgeben
Dieses Setup unterstützt gängige kreative Suchmuster:
- Suche nach Konzept, zum Beispiel blaues Fantasy-Schwert.
- Suche nach Objekttyp, Stil, Farbe oder Anwendungsfall.
- Ein Referenzbild verwenden, wenn Worte zu vage sind.
- Ein Referenzbild mit Text kombinieren, um das Ergebnis zu steuern.
- Nach strukturierten Feldern wie Kategorie, Projekt, Operator, Stil oder Generierungsmodus filtern.
Das Ergebnis ist nicht nur ein Ordner mit besseren Dateinamen. Es ist ein abfragbarer Asset-Katalog.
Warum Render-Vorschauen und Metadaten wichtig sind
Ein 3D-Modell lässt sich nicht einfach direkt durchsuchen. In einer Produktionspipeline wird das Modell in der Regel von mehreren zugehörigen Informationen begleitet:
- das generierte Mesh oder die Quelldatei;
- ein oder mehrere Render-Vorschaubilder;
- ein optionales Eingabe- oder Referenzbild;
- eine Caption oder ein Prompt;
- generierte Tags;
- Projekt-, Owner- oder Operator-Felder;
- Metadaten zu Stil, Kategorie, Farbe, Objekttyp und Anwendungsfall;
- URLs oder Speicherschlüssel, die zurück auf das Asset verweisen.
Für dieses Tutorial ist die Render-Vorschau das visuelle Objekt, das wir einbetten. Das funktioniert gut, weil Render-Vorschauen Form, Material, Farbe und visuellen Stil in einer Form erfassen, die ein multimodales Embedding-Modell verstehen kann.
Die Render-Vorschau ist das Objekt, das das Embedding-Modell sieht, daher wirkt sich die Asset-Qualität direkt auf die Suchqualität aus. Geometrische Genauigkeit — erhaltene Formen, Kanten und Verzierungen — liefert dem Modell strukturelle Signale. Hochauflösende Texturen — unterscheidbare Materialien, originalgetreue Farben, Oberflächendetails — liefern ihm Material- und Farbsignale. Ohne beides verflachen Embeddings: Eine Ledertasche und eine Canvas-Tasche sehen für das Modell gleich aus, und die Suche ist nicht mehr nützlich.
Metadaten geben Ihnen eine zweite Kontrollebene: Sie können semantische Suche ausführen und dennoch exakte Filter anwenden. Ein Asset-Datensatz könnte so aussehen:
caption: Fantasy-Schwert mit blauem Edelstein
llm_object: Schwert
llm_category: Waffe
llm_style: Fantasy
llm_color: blau, silber
llm_use_case: Game-Asset
generation_mode: image-to-3D
render_image_file: fantasy_sword.webp
input_image_file: sword_reference.webp
Diese Kombination macht die Bibliothek in echten Workflows nützlich. Zum Beispiel kann ein Game Artist nach einer weiblichen Figur suchen und die Ergebnismenge auf Game-Asset beschränken. Ein Marketer kann nach realistischer Ledertasche suchen und nach Projekt filtern. Ein E-Commerce-Team kann nach Kategorie und Material suchen, ohne sich auf exakte Dateinamen zu verlassen.
Hinweis zum Bildformat
In dieser Demo werden Render- und Referenzbilder aus Gründen der Speicherplatzeffizienz als .webp gespeichert. Die Embedding-API kann je nach Modell und Provider-Route mit PNG- oder JPEG-Eingaben zuverlässiger sein. Wenn Sie Fehler bei der Bildeingabe sehen, konvertieren Sie WebP-Vorschauen vor dem Embedding in PNG oder JPEG.
Tools in dieser Pipeline
Dieses Tutorial verbindet zwei Systeme: eines, das die 3D-Assets erstellt, und eines, das sie durchsuchbar macht.
Tripo: die Erstellungsebene
Tripo ist ein KI-3D-Modellgenerator, der auf einem Modell mit über 20 Milliarden Parametern basiert. Sein Hauptprodukt, Tripo Studio, deckt den gesamten Asset-Erstellungsfluss in einem Arbeitsbereich ab — von Text-, Bild- oder Skizzeneingabe über Mesh-Verfeinerung, Texturgenerierung, Rigging, Animation und Export. Ein Standard-Mesh wird in zwei bis fünf Sekunden generiert, was mit dazu beiträgt, dass Asset-Bibliotheken schnell genug wachsen, um die Suchpipeline zu benötigen, die dieses Tutorial aufbaut.
Drei Fähigkeiten sind hier besonders relevant:
- Image-to-3D model generation bewahrt die geometrische Struktur — komplexe Formen, scharfe Kanten, Verzierungen, Oberflächendetails — sodass generierte Modelle der Eingabereferenz treu bleiben.
- HD Model treibt diese Wiedergabetreue weiter voran und unterstützt bis zu zwei Millionen Faces für Assets, die bei Nahaufnahmen, Produktvisualisierung oder 3D-Druck bestehen.
- Texture Generation mit bis zu 8K-Auflösung fügt originalgetreue Farbwiedergabe, klare Materialunterscheidung (Metall, Leder, Stoff, Holz) und fein abgestufte Oberflächendetails wie Abnutzungsspuren, Maserung und Mikrotexturen hinzu.
Zusammen geben diese jedem Asset genügend geometrische und materielle Signale, um ein aussagekräftiges multimodales Embedding zu erzeugen — und hier kommt die Retrieval-Seite ins Spiel.
Zilliz Cloud: die Retrieval-Ebene
Zilliz Cloud ist eine vollständig verwaltete Vector Lakebase-Plattform, entwickelt von den Machern von Milvus, der am weitesten verbreiteten Open-Source-Vektordatenbank (45.000+ GitHub-Sterne, 100M+ Docker-Pulls, 10.000+ Organisationen in Produktion). Im Kern steht eine produktionsreife Vektordatenbank, die Suche im Sub-Millisekundenbereich im Maßstab von 100 Milliarden ermöglicht. In diesem Tutorial übernimmt sie drei Dinge:
- Embedding-Speicherung — der multimodale Vektor jedes Assets befindet sich zusammen mit seinen strukturierten Metadaten in einer einzigen Collection.
- Ähnlichkeitssuche — Text-, Bild- oder kombinierte Abfragen werden in denselben Vektorraum eingebettet und mit den gespeicherten Render-Vorschauen abgeglichen.
- Gefiltertes Retrieval — exakte Filter nach Kategorie, Stil, Anwendungsfall oder Projekt werden in einer Anfrage über die semantische Suche gelegt, und genau das verwandelt einen Haufen Vektoren in einen abfragbaren Katalog.
Voraussetzungen
Bevor Sie beginnen, bereiten Sie Folgendes vor:
- Ein Zilliz Cloud-Konto und -Cluster. Der kostenlose Cluster reicht für dieses Tutorial aus. Registrieren Sie sich, erstellen Sie einen Cluster und kopieren Sie dessen Endpoint und Token.
- Ein OpenRouter-API-Schlüssel für das unten verwendete multimodale Embedding-Modell.
- Python 3.10 oder höher.
- Das Milvus Python SDK. Siehe die PyMilvus-Installationsanleitung, falls Sie neu damit sind.
- Ein Satz von mit Tripo generierten Assets, einschließlich Render-Vorschaubildern und Metadaten.
- Optionale Referenzbilder, die für die Image-to-3D-Generierung verwendet werden.
Der untenstehende Beispielcode geht von einem Skript namens tripo_rag.py aus, aber dieselbe Logik kann in Ihren eigenen Ingestion-Service, Ihr Asset-Management-Backend oder Ihr internes Tool verschoben werden.
Schritt 1: Mit Tripo generierte Asset-Daten vorbereiten
Beginnen Sie mit den in Tripo generierten Assets. Exportieren oder speichern Sie für jedes Asset mindestens ein Render-Vorschaubild. Wenn das Asset aus einem Referenzbild erstellt wurde, bewahren Sie auch dieses Referenzbild auf. Es kann nützlich sein, um Debugging durchzuführen, Suchergebnisse in der Vorschau anzuzeigen oder zukünftige Suchmodi zu entwickeln.
Jede Zeile in Ihrer Metadaten-CSV sollte ein Asset darstellen. Fügen Sie mindestens Folgendes hinzu:
- eine eindeutige Asset-ID;
- einen Dateinamen oder Storage-Key für ein Render-Vorschaubild;
- eine Beschriftung oder einen Generierungs-Prompt;
- Felder für Kategorie, Objekt, Stil, Farbe und Anwendungsfall, sofern verfügbar;
- Projekt- oder Besitzerfelder, wenn Ihr Team Zugriffskontrolle oder Filterung auf Workspace-Ebene benötigt;
- die URL oder den Speicherort des ursprünglichen Assets.
Umfangreichere Metadaten ermöglichen Ihnen später bessere Filter. Der Vektor hilft Ihnen, visuell und semantisch ähnliche Assets zu finden. Die Metadaten helfen Ihnen, die Ergebnismenge auf die Assets einzugrenzen, die für das aktuelle Projekt tatsächlich nutzbar sind.
Schritt 2: Eine Zilliz Cloud Collection erstellen
Jeder Datensatz in der Collection repräsentiert ein Tripo-Asset. Die strukturierten Felder speichern Metadaten. Das Feld multimodal_vector speichert das Embedding für die Render-Vorschau.
Die folgenden Beispiele verwenden einen 3072-dimensionalen Vektor und COSINE-Ähnlichkeit. Halten Sie die Dimension mit dem von Ihnen verwendeten Embedding-Modell abgestimmt.
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)
Erstellen Sie anschließend den Vektorindex:
index_params = MilvusClient.prepare_index_params()
index_params.add_index(
field_name=VECTOR_FIELD,
index_type="AUTOINDEX",
metric_type="COSINE",
)
Wenn Ihr Skript die Einrichtung in einen Befehl kapselt, führen Sie Folgendes aus:
python3 tripo_rag.py create-collection
Nachdem der Befehl abgeschlossen ist, öffnen Sie die Zilliz Cloud-Konsole und überprüfen Sie die Collection-Liste.
Klicken Sie auf die Collection, um den Status, das Schema, die geladenen Entitäten und die Konfiguration des Vektorfelds zu überprüfen.
Ein kurzer Hinweis zum Index: AUTOINDEX hält das Tutorial einfach, da Sie vor dem Importieren von Daten keine Indexparameter manuell feinabstimmen müssen. Der COSINE-Metriktyp passt zu den normalisierten Embeddings, die im nächsten Schritt verwendet werden.
Schritt 3: Multimodale Embeddings für Renderbilder generieren
Generieren Sie als Nächstes ein Embedding für jede Rendervorschau.
Die Demo sendet das Vorschaubild über OpenRouter an ein Embedding-Modell. Das Bild wird als Base64-Daten-URL kodiert, und der zurückgegebene Vektor wird L2-normalisiert, bevor er in Zilliz Cloud eingefügt wird.
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)
},
}
]
)
Zwischenspeichern Sie für eine echte Ingestion-Pipeline die Embeddings. Das Aufrufen einer externen Embedding-API für jeden Import ist langsam, und Wiederholungsversuche können wiederholte Testläufe teuer machen.
python3 tripo_rag.py build-cache
Ein Cache macht das Importverhalten außerdem deterministisch. Sie können die Collection neu erstellen, Schemaänderungen testen oder Importe erneut ausführen, ohne jede Rendervorschau neu einzubetten.
Schritt 4: Asset-Datensätze in Zilliz Cloud importieren
Nachdem der Cache bereit ist, wandeln Sie jede CSV-Zeile in eine Entität für Zilliz Cloud um.
Jede Entität sollte die strukturierten Felder und den zwischengespeicherten multimodalen Vektor enthalten:
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],
}
Importieren Sie dann den Datensatz und prüfen Sie die Collection-Statistiken:
python3 tripo_rag.py import-data
python3 tripo_rag.py stats
Öffnen Sie den Data-Tab in der Zilliz Cloud-Konsole, um zu bestätigen, dass die Asset-Datensätze eingefügt wurden. Sie sollten die Metadatenfelder, Renderbild-Referenzen und das Vektorfeld für jede Entität sehen.
Die Tripo-Assets sind jetzt durchsuchbare Entitäten in einer Vektordatenbank, keine losen lokalen Dateien.
Schritt 5: Nach Text, Bild oder beidem suchen
Die Suche läuft in drei Modi, alle über dasselbe multimodale Modell und gegen dasselbe Feld multimodal_vector.
| Modus | Verwenden, wenn | Beispiel |
|---|---|---|
| Text | Du beschreiben kannst, was du möchtest | blaues Fantasy-Schwert |
| Bild | Du eine Referenz hast und ähnliche Assets möchtest | ein stilisiertes Schild-Rendering hochladen |
| Text + Bild | Du Absicht und einen visuellen Anker möchtest | Schwertbild + Fantasy-Schwert mit blauem Edelstein |
Die Abfrage wird in denselben Vektorraum eingebettet wie die Asset-Rendering-Vorschauen. Zilliz Cloud durchsucht dann das Vektorfeld und gibt die ähnlichsten Assets mit ihren Metadaten zurück.
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,
)
)
Da jedes Ergebnis sowohl einen Ähnlichkeitswert als auch Metadaten enthält, kann dein Frontend das Vorschaubild, die Beschriftung, die Kategorie, den Stil, den Anwendungsfall und die ursprüngliche Asset-URL in derselben Ergebniskarte anzeigen.
Die Suche ist nicht auf reine Vektorähnlichkeit beschränkt. Da jedes Asset strukturierte Metadaten trägt, kannst du einer semantischen Abfrage in einer einzigen Anfrage Filter hinzufügen. Suche zum Beispiel nach female, beschränke die Ergebnismenge aber auf llm_use_case == "game asset". Genau das macht die Sammlung zu einem echten Katalog statt zu einem Haufen Vektoren.
Beispiel 1: Textsuche mit einem Anwendungsfall-Filter
Angenommen, ein Game-Team benötigt charakterähnliche Assets. Du kannst nach female suchen und die Ergebnisse auf den Anwendungsfall game asset beschränken:
python3 tripo_rag.py search \
--text "female" \
--use-case "game asset" \
--top-k 12
Dies gibt die am besten passenden Assets aus der Game-Asset-Teilmenge zurück, was nützlicher ist, als die gesamte Bibliothek zu durchsuchen und irrelevante Produkt-, Umgebungs- oder Marketing-Assets manuell zu ignorieren.
Beispiel 2: Textsuche plus Referenzbild
Text allein ist für visuelle Arbeit oft zu breit gefasst. Eine Abfrage wie Fantasy-Schwert mit blauem Edelstein sagt dem System, was du möchtest, aber ein Referenzbild verankert Form, Komposition und visuelle Richtung.
python3 tripo_rag.py search \
--text "fantasy sword with blue gemstone" \
--image ./examples/sword_reference.png \
--top-k 12
Dieser Modus ist nützlich, wenn ein Creator mit einer visuellen Referenz beginnt, die Suche aber mit ein paar Worten steuern möchte. Das Referenzbild liefert visuelle Ähnlichkeit. Der Text grenzt die Absicht ein.
Was dies in einer realen Asset-Pipeline ermöglicht
Sobald die Bibliothek durchsuchbar ist, können Teams generierte 3D-Assets eher wie wiederverwendbaren Produktionsbestand nutzen.
Ein Game-Team kann Prop- und Charaktervarianten projektübergreifend verfolgen. Ein E-Commerce-Team kann produktähnliche Assets nach Kategorie, Material und Stil organisieren. Ein Marketing-Team kann eine freigegebene Bibliothek wiederverwendbarer Visuals pflegen. Ein Creative-Ops-Team kann Review-Workflows rund um Eigentümerschaft, Projekt-IDs und Asset-URLs aufbauen, anstatt sich auf Ordnernamen zu verlassen.
Die wichtige Verschiebung ist einfach: Generierung erstellt das Asset, aber Suche macht das Asset wiederverwendbar.
Fazit
KI-3D-Generierung macht es einfach, mehr Assets zu produzieren, als eine manuelle Ordnerstruktur verwalten kann. Der nächste Engpass ist die Abfrage: das richtige Asset zu finden, zu verstehen, woher es stammt, und es im richtigen Projekt wiederzuverwenden.
Dieses Tutorial zeigte einen Weg, dieses Problem zu lösen. Generieren Sie Assets mit Tripo, speichern Sie Render-Vorschauen und Metadaten in Zilliz Cloud, betten Sie jede Vorschau mit einem multimodalen Modell ein und durchsuchen Sie die Sammlung per Text, Bild oder beidem. Dasselbe Muster kann klein mit einem lokalen Datensatz beginnen und mit dem Wachstum Ihrer Bibliothek zu einem Produktions-Asset-Katalog heranwachsen.
Das ist auch die Richtung hinter Zilliz Vector Lakebase: multimodale KI-Daten, Embeddings, Metadaten und Bereitstellungspfade in einer durchsuchbaren Grundlage zu halten, damit Teams von der Generierung über die Abfrage bis zur Wiederverwendung gelangen können, ohne die Datenschicht jedes Mal neu aufzubauen.
Um es selbst auszuprobieren, registrieren Sie sich für Zilliz Cloud, erstellen Sie einen kostenlosen Cluster, generieren Sie einen kleinen Batch von Assets mit Tripo und führen Sie die Pipeline End-to-End aus. Sobald die ersten Suchergebnisse passend aussehen, verbinden Sie die Ausgabe mit Ihrem internen Asset-Browser oder Kreativtool.
Tripo-Asset-Beispiele
Die folgenden Assets wurden in Tripo Studio mit den in diesem Tutorial beschriebenen Funktionen generiert.
8K-Texturgenerierung
Die 8K-Texturgenerierung bewahrt die Farbtreue und unterscheidet Oberflächenmaterialien wie Metall, Leder, Stoff und Holz bis hin zu Gebrauchsspuren und Mikrotexturen.
HD Model
HD Model unterstützt bis zu zwei Millionen Flächen und bewahrt komplexe Formen, scharfe Kanten und feine Oberflächenmerkmale für Rendering, Visualisierung und 3D-Druck.
Weiterlesen
Smarter Autoscaling in Zilliz Cloud: Always Optimized for Every Workload
With the latest upgrade, Zilliz Cloud introduces smarter autoscaling—a fully automated, more streamlined, elastic resource management system.
Zilliz Cloud Launches in AWS Australia, Expanding Global Reach to Australia and Neighboring Markets
We're thrilled to announce that Zilliz Cloud is now available in the AWS Sydney, Australia region (ap-southeast-2).
8 Latest RAG Advancements Every Developer Should Know
Explore eight advanced RAG variants that can solve real problems you might be facing: slow retrieval, poor context understanding, multimodal data handling, and resource optimization.