Home
Blog
Wird Gemini Embedding 2 die Multi-Vektorsuche in Vektordatenbanken beenden?

Wird Gemini Embedding 2 die Multi-Vektorsuche in Vektordatenbanken beenden?

Engineering

March 13, 2026

Jack Li

Google hat Gemini Embedding 2 veröffentlicht - das erste multimodale Einbettungsmodell, das Text, Bilder, Video, Audio und Dokumente in einen einzigen Vektorraum einbettet.

Sie können einen Videoclip, ein Produktfoto und einen Textabsatz mit einem einzigen API-Aufruf einbetten, und sie landen alle in derselben semantischen Umgebung.

Vor dieser Art von Modellen musste man jede Modalität durch ein eigenes spezialisiertes Modell laufen lassen und dann jede Ausgabe in einer separaten Vektorspalte speichern. Multi-Vektor-Spalten in Vektor-Datenbanken wie Milvus wurden genau für solche Szenarien entwickelt.

Da Gemini Embedding 2 mehrere Modalitäten gleichzeitig abbildet, stellt sich die Frage, inwieweit Gemini Embedding 2 Multi-Vektor-Spalten ersetzen kann und wo es versagt. In diesem Beitrag wird erläutert, wo jeder Ansatz passt und wie sie zusammenarbeiten.

Was ist anders an Gemini Embedding 2 im Vergleich zu CLIP/CLAP?

Embedding-Modelle konvertieren unstrukturierte Daten in dichte Vektoren, so dass semantisch ähnliche Elemente im Vektorraum geclustert werden. Das Besondere an Gemini Embedding 2 ist, dass es dies nativ und modalitätsübergreifend tut, ohne separate Modelle und ohne Stitching-Pipelines.

Bis jetzt bedeuteten multimodale Einbettungen Dual-Encoder-Modelle, die mit kontrastivem Lernen trainiert wurden: CLIP für Bild-Text, CLAP für Audio-Text, die jeweils genau zwei Modalitäten verarbeiten. Wenn man alle drei Modalitäten benötigte, führte man mehrere Modelle aus und koordinierte deren Einbettungsräume selbst.

Die Indizierung eines Podcasts mit Titelbild bedeutete beispielsweise, dass man CLIP für das Bild, CLAP für den Ton und einen Textencoder für das Transkript laufen ließ - drei Modelle, drei Vektorräume und eine benutzerdefinierte Fusionslogik, um ihre Ergebnisse bei der Abfrage vergleichbar zu machen.

Im Gegensatz dazu unterstützt Gemini Embedding 2 laut Googles offizieller Ankündigung folgendes:

Text mit bis zu 8.192 Token pro Anfrage
Bilder bis zu 6 pro Anfrage (PNG, JPEG)
Videos bis zu 120 Sekunden (MP4, MOV)
Audio bis zu 80 Sekunden, nativ eingebettet ohne ASR-Transkription
Dokumente PDF-Eingabe, bis zu 6 Seiten

Gemischte Eingabe von Bild und Text in einem einzigen Einbettungsaufruf

Gemini Embedding 2 vs. CLIP/CLAP Ein Modell vs. viele für multimodale Einbettungen

	Zweifach-Encoder (CLIP, CLAP)	Gemini Einbettung 2
Modalitäten pro Modell	2 (z. B. Bild + Text)	5 (Text, Bild, Video, Audio, PDF)
Hinzufügen einer neuen Modalität	Sie bringen ein weiteres Modell ein und richten die Bereiche manuell aus	Bereits enthalten - ein API-Aufruf
Modalitätsübergreifende Eingabe	Separate Kodierer, separate Aufrufe	Verschachtelte Eingabe (z. B. Bild + Text in einer Anfrage)
Architektur	Getrennte Bild- und Textcodierer, die durch Kontrastverluste aufeinander abgestimmt sind	Ein einziges Modell, das das multimodale Verständnis von Gemini übernimmt

Der Vorteil von Gemini Embedding 2: Vereinfachung der Pipeline

Nehmen wir ein gängiges Szenario: Aufbau einer semantischen Suchmaschine über eine kurze Videobibliothek. Jeder Clip hat visuelle Frames, gesprochenes Audio und Untertiteltext - alle beschreiben denselben Inhalt.

Vor Gemini Embedding 2 brauchten Sie drei separate Einbettungsmodelle (Bild, Audio, Text), drei Vektorsäulen und eine Abrufpipeline, die einen mehrseitigen Abruf, eine Ergebnisfusion und eine Deduplizierung durchführt. Das ist eine Menge an beweglichen Teilen, die aufgebaut und gewartet werden müssen.

Jetzt können Sie die Einzelbilder, den Ton und die Untertitel des Videos in einen einzigen API-Aufruf eingeben und erhalten einen einheitlichen Vektor, der das gesamte semantische Bild erfasst.

Natürlich ist die Versuchung groß, daraus zu schließen, dass Spalten mit mehreren Vektoren tot sind. Aber diese Schlussfolgerung verwechselt "multimodale einheitliche Darstellung" mit "multidimensionalem Vektorabruf". Sie lösen unterschiedliche Probleme, und es ist wichtig, den Unterschied zu verstehen, um den richtigen Ansatz zu wählen.

Was ist die Multivektorsuche in Milvus?

In Milvus bedeutet Multi-Vektorsuche, dass ein und dasselbe Objekt in mehreren Vektorfeldern gleichzeitig gesucht wird und diese Ergebnisse dann mit einem Reranking kombiniert werden.

Der Kerngedanke: Ein einzelnes Objekt hat oft mehr als eine Bedeutung. Ein Produkt hat einen Titel und eine Beschreibung. Ein Beitrag in sozialen Medien hat eine Überschrift und ein Bild. Jeder Blickwinkel sagt etwas anderes aus, also erhält jeder sein eigenes Vektorfeld.

Milvus durchsucht jedes Vektorfeld unabhängig und führt dann die Kandidatengruppen mithilfe eines Rerankers zusammen. In der API wird jede Anfrage einem anderen Feld und einer anderen Suchkonfiguration zugeordnet, und hybrid_search() gibt das kombinierte Ergebnis zurück.

Zwei gängige Muster hängen davon ab:

Sparse+Dense Vector Search. Sie haben einen Produktkatalog, in den Benutzer Suchanfragen wie "rote Nike Air Max Größe 10" eingeben. Dichte Vektoren erfassen die semantische Absicht ("Laufschuhe, rot, Nike"), aber nicht die genaue Größe. Spärliche Vektoren über BM25 oder Modelle wie BGE-M3 treffen die Schlüsselwortübereinstimmung. Sie müssen beide parallel laufen lassen und dann neu ranken - denn keine der beiden Methoden allein liefert gute Ergebnisse für Abfragen, die natürliche Sprache mit spezifischen Identifikatoren wie SKUs, Dateinamen oder Fehlercodes kombinieren.
Multimodale Vektorsuche. Ein Benutzer lädt ein Foto eines Kleides hoch und gibt ein: "So ähnlich, aber in blau". Sie suchen gleichzeitig in der Spalte für die Bildeinbettung nach visueller Ähnlichkeit und in der Spalte für die Texteinbettung nach der Farbbeschränkung. Jede Spalte hat ihren eigenen Index und ihr eigenes Modell - CLIP für das Bild, ein Text-Encoder für die Beschreibung - und die Ergebnisse werden zusammengeführt.

Milvus führt beide Muster als parallele ANN-Suchen mit nativem Reranking über RRFRanker aus. Die Schemadefinition, die Multi-Index-Konfiguration und das integrierte BM25 werden alle in einem System abgewickelt.

Nehmen wir zum Beispiel einen Produktkatalog, bei dem jeder Artikel eine Textbeschreibung und ein Bild enthält. Sie können drei Suchvorgänge für diese Daten parallel durchführen:

Semantische Textsuche. Abfrage der Textbeschreibung mit dichten Vektoren, die von Modellen wie BERT, Transformers oder der OpenAI Embeddings API generiert wurden.
Volltextsuche. Abfrage der Textbeschreibung mit spärlichen Vektoren mit BM25 oder spärlichen Einbettungsmodellen wie BGE-M3 oder SPLADE.
Modalübergreifende Bildsuche. Abfrage von Produktbildern anhand einer Textabfrage mit dichten Vektoren aus einem Modell wie CLIP.

Ist die Multi-Vektorsuche mit Gemini Embedding 2 noch von Bedeutung?

Gemini Embedding 2 verarbeitet mehr Modalitäten in einem einzigen Aufruf, was die Pipelines erheblich vereinfacht. Aber eine einheitliche multimodale Einbettung ist nicht dasselbe wie eine Multi-Vektor-Suche. Mit anderen Worten: Ja, die Multi-Vektor-Suche ist nach wie vor wichtig.

Gemini Embedding 2 bildet Text, Bilder, Video, Audio und Dokumente in einem gemeinsamen Vektorraum ab. Google positioniert es für die multimodale semantische Suche, die Dokumentensuche und Empfehlungen - Szenarien, in denen alle Modalitäten denselben Inhalt beschreiben und eine hohe cross-modale Überlappung einen einzigen Vektor sinnvoll macht.

Die Multivektorsuchevon Milvus löst ein anderes Problem. Es handelt sich um eine Möglichkeit, ein und dasselbe Objekt über mehrere Vektorfelderzu durchsuchen -z. B. einen Titel plus Beschreibung oder Text plus Bild - und diese Signale dann bei der Suche zu kombinieren. Mit anderen Worten: Es geht darum, mehrere semantische Ansichten desselben Objekts zu erhalten und abzufragen, und nicht darum, alles in eine einzige Darstellung zu komprimieren.

Daten aus der realen Welt lassen sich jedoch nur selten in eine einzige Darstellung einbetten. Biometrische Systeme, agentengestützte Werkzeugsuche und E-Commerce mit gemischten Absichten hängen alle von Vektoren ab, die in völlig unterschiedlichen semantischen Räumen leben. Genau an dieser Stelle hört eine einheitliche Einbettung auf zu funktionieren.

Warum eine Einbettung nicht ausreicht: Multi-Vektor-Retrieval in der Praxis

Gemini Embedding 2 ist für den Fall gedacht, dass alle Modalitäten dieselbe Sache beschreiben. Die Multi-Vektor-Suche behandelt alles andere - und "alles andere" deckt die meisten Produktions-Retrievalsysteme ab.

Biometrische Daten. Ein einzelner Benutzer hat Vektoren für Gesicht, Stimme, Fingerabdruck und Iris. Diese beschreiben völlig unabhängige biologische Merkmale mit keinerlei semantischen Überschneidungen. Sie lassen sich nicht in einem Vektor zusammenfassen - jeder benötigt eine eigene Spalte, einen eigenen Index und eine eigene Ähnlichkeitsmetrik.

Agentische Werkzeuge. Ein Programmierassistent wie OpenClaw speichert dichte semantische Vektoren für die Konversationshistorie ("das Bereitstellungsproblem von letzter Woche") neben spärlichen BM25-Vektoren für den genauen Abgleich von Dateinamen, CLI-Befehlen und Konfigurationsparametern. Unterschiedliche Abrufziele, unterschiedliche Vektortypen, unabhängige Suchpfade, dann Neueinstufung.

E-Commerce mit gemischten Absichten. Das Promovideo und die Detailbilder eines Produkts funktionieren gut als einheitliche Gemini-Einbettung. Wenn ein Benutzer jedoch nach "Kleidern, die so aussehen" und "gleicher Stoff, Größe M" sucht, benötigen Sie eine Spalte für visuelle Ähnlichkeit und eine Spalte für strukturierte Attribute mit separaten Indizes und einer hybriden Abrufschicht.

Wann sollte man Gemini Embedding 2 vs. Multi-Vektor-Spalten verwenden?

Szenario	Was ist zu verwenden?	Warum
Alle Modalitäten beschreiben denselben Inhalt (Videobilder + Audio + Untertitel)	Gemini Embedding 2 einheitlicher Vektor	Hohe semantische Überlappung bedeutet, dass ein Vektor das gesamte Bild erfasst - keine Fusion erforderlich
Sie benötigen neben dem semantischen Recall auch die Präzision der Schlüsselwörter (BM25 + Dense)	Spalten mit mehreren Vektoren mit hybrid_search()	Sparsame und dichte Vektoren dienen unterschiedlichen Suchzielen, die nicht in einer Einbettung zusammengefasst werden können
Cross-modale Suche ist der primäre Anwendungsfall (Textabfrage → Bildergebnisse)	Gemini Embedding 2 einheitlicher Vektor	Ein einziger gemeinsamer Raum macht cross-modale Ähnlichkeit nativ
Vektoren leben in grundlegend unterschiedlichen semantischen Räumen (Biometrie, strukturierte Attribute)	Spalten mit mehreren Vektoren mit Indizes pro Feld	Unabhängige Ähnlichkeitsmetriken und Indextypen pro Vektorfeld
Sie wollen eine einfache Pipeline und einen feinkörnigen Abruf	Beides - vereinheitlichter Gemini-Vektor + zusätzliche Sparse- oder Attributspalten in derselben Sammlung	Gemini handhabt die multimodale Spalte; Milvus handhabt die hybride Abrufschicht um sie herum

Diese beiden Ansätze schließen sich nicht gegenseitig aus. Sie können Gemini Embedding 2 für die einheitliche multimodale Spalte verwenden und dennoch zusätzliche sparse oder attributspezifische Vektoren in separaten Spalten innerhalb derselben Milvus-Sammlung speichern.

Schnellstart: Einrichten von Gemini Embedding 2 + Milvus

Hier ist eine funktionierende Demo. Sie benötigen eine laufende Milvus- oder Zilliz-Cloud-Instanz und einen GOOGLE_API_KEY.

Einrichtung

pip install google-genai pymilvus
export GOOGLE_API_KEY="your-api-key"

Vollständiges Beispiel

"""
Prerequisites:
    pip install google-genai pymilvus
Set environment variable:
export GOOGLE_API_KEY="your-api-key"
“"”
import os
import struct
import numpy as np
from google import genai
from google.genai import types
from pymilvus import MilvusClient, DataType
# ── Config ───────────────────────────────────────────────────────────────
COLLECTION_NAME = “gemini_multimodal_demo”
MILVUS_URI = “http://localhost:19530”  # Change to your Milvus address
DIM = 3072  # gemini-embedding-2-preview output dimension
GEMINI_MODEL = “gemini-embedding-2-preview”
# ── Initialize clients ──────────────────────────────────────────────────
gemini_client = genai.Client()  # Uses GOOGLE_API_KEY env var
milvus_client = MilvusClient(MILVUS_URI)
# ── Helper: generate embedding ──────────────────────────────────────────
def embed_texts(texts: list[str], task_type: str = “SEMANTIC_SIMILARITY”) -> list[list[float]]:
“""Embed a list of text strings.""”
result = gemini_client.models.embed_content(
model=GEMINI_MODEL,
contents=texts,
config=types.EmbedContentConfig(task_type=task_type),
)
return [e.values for e in result.embeddings]
def embed_image(image_path: str) -> list[float]:
“""Embed an image file.""”
with open(image_path, “rb”) as f:
image_bytes = f.read()
mime = “image/png” if image_path.endswith(“.png”) else “image/jpeg”
result = gemini_client.models.embed_content(
model=GEMINI_MODEL,
contents=types.Part.from_bytes(data=image_bytes, mime_type=mime),
)
return result.embeddings[0].values
def embed_audio(audio_path: str) -> list[float]:
“""Embed an audio file.""”
with open(audio_path, “rb”) as f:
audio_bytes = f.read()
mime_map = {“.mp3”: “audio/mpeg”, “.wav”: “audio/wav”, “.flac”: “audio/flac”}
ext = os.path.splitext(audio_path)[1].lower()
mime = mime_map.get(ext, “audio/mpeg”)
result = gemini_client.models.embed_content(
model=GEMINI_MODEL,
contents=types.Part.from_bytes(data=audio_bytes, mime_type=mime),
)
return result.embeddings[0].values
# ── 1. Create Milvus collection ─────────────────────────────────────────
print(“=== Creating collection ===”)
if milvus_client.has_collection(COLLECTION_NAME):
milvus_client.drop_collection(COLLECTION_NAME)
schema = milvus_client.create_schema()
schema.add_field(“id”, DataType.INT64, is_primary=True, auto_id=True)
schema.add_field(“content”, DataType.VARCHAR, max_length=2000)   # description of the content
schema.add_field(“modality”, DataType.VARCHAR, max_length=20)    # "text", "image", “audio”
schema.add_field(“vector”, DataType.FLOAT_VECTOR, dim=DIM)
index_params = milvus_client.prepare_index_params()
index_params.add_index(
field_name=“vector”,
index_type=“AUTOINDEX”,
metric_type=“COSINE”,
)
milvus_client.create_collection(
COLLECTION_NAME,
schema=schema,
index_params=index_params,
consistency_level=“Strong”,
)
print(f"Collection '{COLLECTION_NAME}' created (dim={DIM}, metric=COSINE)")
# ── 2. Insert text embeddings ───────────────────────────────────────────
print(“\n=== Inserting text embeddings ===”)
documents = [
“Artificial intelligence was founded as an academic discipline in 1956.”,
“The Mona Lisa is a half-length portrait painting by Leonardo da Vinci.”,
“Beethoven’s Symphony No. 9 premiered in Vienna on May 7, 1824.”,
“The Great Wall of China stretches over 13,000 miles across northern China.”,
“Jazz music originated in the African-American communities of New Orleans.”,
“The Hubble Space Telescope was launched into orbit on April 24, 1990.”,
“Vincent van Gogh painted The Starry Night while in an asylum in Saint-Rémy.”,
“Machine learning is a subset of AI focused on learning from data.”,
]
text_vectors = embed_texts(documents)
text_rows = [
{“content”: doc, “modality”: “text”, “vector”: vec}
for doc, vec in zip(documents, text_vectors)
]
milvus_client.insert(COLLECTION_NAME, text_rows)
print(f"Inserted {len(text_rows)} text documents")
# ── 3. (Optional) Insert image embeddings ───────────────────────────────
# Uncomment and provide real image paths to test multimodal search
#
# image_files = [
#     ("photo of the Mona Lisa painting", “mona_lisa.jpg”),
#     ("satellite photo of the Great Wall of China", “great_wall.png”),
# ]
# for desc, path in image_files:
#     if os.path.exists(path):
#         vec = embed_image(path)
#         milvus_client.insert(COLLECTION_NAME, [
#             {"content": desc, "modality": "image", “vector": vec}
#         ])
#         print(f"Inserted image: {desc}”)
# ── 4. (Optional) Insert audio embeddings ───────────────────────────────
# Uncomment and provide real audio paths to test multimodal search
#
# audio_files = [
#     ("Beethoven Symphony No.9 excerpt", “beethoven_9.mp3”),
#     ("jazz piano improvisation", “jazz_piano.mp3”),
# ]
# for desc, path in audio_files:
#     if os.path.exists(path):
#         vec = embed_audio(path)
#         milvus_client.insert(COLLECTION_NAME, [
#             {"content": desc, "modality": "audio", “vector": vec}
#         ])
#         print(f"Inserted audio: {desc}”)
# ── 5. Search ────────────────────────────────────────────────────────────
print(“\n=== Searching ===”)
queries = [
“history of artificial intelligence”,
“famous Renaissance paintings”,
“classical music concerts”,
]
query_vectors = embed_texts(queries, task_type=“SEMANTIC_SIMILARITY”)
for query_text, query_vec in zip(queries, query_vectors):
results = milvus_client.search(
COLLECTION_NAME,
data=[query_vec],
limit=3,
output_fields=[“content”, “modality”],
search_params={“metric_type”: “COSINE”},
)
print(f"\nQuery: '{query_text}'")
for hits in results:
for rank, hit in enumerate(hits, 1):
print(f"  [{rank}] (score={hit[‘distance’]:.4f}, modality={hit[‘entity’][‘modality’]}) "
f"{hit[‘entity’][‘content’][:80]}")
# ── 6. Cross-modal search example (image query -> text results) ─────────
# Uncomment to search text collection using an image as query
#
# print(“\n=== Cross-modal search: image -> text ===”)
# query_image_vec = embed_image(“query_image.jpg”)
# results = milvus_client.search(
#     COLLECTION_NAME,
#     data=[query_image_vec],
#     limit=3,
#     output_fields=[“content", “modality”],
#     search_params={"metric_type": “COSINE"},
# )
# for hits in results:
#     for rank, hit in enumerate(hits, 1):
#         print(f”  [{rank}] (score={hit[‘distance’]:.4f}) {hit[‘entity’][‘content’][:80]}”)
# ── Cleanup ──────────────────────────────────────────────────────────────
# milvus_client.drop_collection(COLLECTION_NAME)
# print(f"\nCollection ‘{COLLECTION_NAME}’ dropped")
print(“\nDone!”)

Für Bild- und Audioeinbettungen verwenden Sie embed_image() und embed_audio() auf die gleiche Weise - die Vektoren landen in der gleichen Sammlung und im gleichen Vektorraum, was eine echte cross-modale Suche ermöglicht.

Gemini Embedding 2 wird bald in der Milvus/Zilliz Cloud verfügbar sein

Milvus liefert eine tiefe Integration mit Gemini Embedding 2 durch seine Einbettungsfunktion. Sobald die Funktion verfügbar ist, müssen Sie die Einbettungs-APIs nicht mehr manuell aufrufen. Milvus wird das Modell (das OpenAI, AWS Bedrock, Google Vertex AI und andere unterstützt) automatisch aufrufen, um Rohdaten beim Einfügen und Abfragen bei der Suche zu vektorisieren.

Das bedeutet, dass Sie eine einheitliche multimodale Einbettung von Gemini erhalten, wo es passt, und das vollständige Multi-Vektor-Toolkit von Milvus - sparse-dense hybride Suche, Multi-Index-Schemata, Reranking - wo Sie eine feinkörnige Kontrolle benötigen.

Möchten Sie es ausprobieren? Beginnen Sie mit dem Milvus-Schnellstart und führen Sie die obige Demo aus, oder sehen Sie sich den Leitfaden zur hybriden Suche an, um das vollständige Multi-Vektor-Setup mit BGE-M3 zu erhalten. Stellen Sie Ihre Fragen auf Discord oder in den Milvus-Sprechstunden.