Christy Bergman: Warum ich zu Zilliz gekommen bin
Mein Name ist Christy Bergman, und ich bin kürzlich als Developer Advocate mit Sitz in San Francisco zu Zilliz gestoßen. Ich werde Veranstaltungen organisieren, daran teilnehmen und dort Vorträge halten, Blogs und Code-Tutorials schreiben, die Dokumentation verbessern und generell Menschen (hoffentlich wie dir!) dabei helfen, den Umgang mit Milvus zu lernen, der weltweit beliebtesten Open-Source-Vektordatenbank (gemessen an GitHub-Sternen).
Vor Zilliz war ich Developer Advocate bei Anyscale, dem Entwickler des Open-Source-Projekts Ray, das verteiltes Rechnen für alle Entwickler einfach macht. Davor war ich AWS AI/ML Specialist Solutions Architect mit Schwerpunkt auf Deep-Learning-Prognosen.
Warum habe ich mich also entschieden, zu Zilliz zu wechseln? Es begann mit meiner Neugier darauf, die Chat-Ausgaben von ChatGPT zu verbessern, indem Kontext in den Prompt eingefügt wird. Dann begann ich damit, mit Embeddings zu experimentieren, und von dort aus suchte ich nach einer einfach zu verwendenden, schnellen Vektordatenbank. In diesem Blogbeitrag führe ich dich durch die Schritte, die mich hierhergebracht haben.
Der Zweifel: Brauche ich wirklich eine Vektordatenbank?
Am Anfang fragte ich mich, ob eine Vektordatenbank überhaupt notwendig sei. Ein paar Versuche, Text in eine Python-Variable einzubetten, ihn zu picklen und wieder zu entpicklen, brachten mich jedoch zu der Überzeugung, dass Embeddings irgendwo besser als in pickle zwischengespeichert oder persistiert werden müssen.
Milvus ist eine vollwertige Datenbank, die von Grund auf speziell für Vektoren entwickelt wurde. Tausende von Entwicklern weltweit nutzen Milvus, das Unterstützung für viele verschiedene Vektorsuchalgorithmen, Distanzmetriken im Vektorraum und weitere Funktionen wie Insert/upsert, TopK und Range Search, GPU-Unterstützung und mehr umfasst. Die kommerzielle Version heißt Zilliz Cloud und bietet eine SLA-Verfügbarkeit von 99,9 %, Auto-Scaling und läuft auf AWS und GCP (Azure folgt bald), und du kannst sie mit vollständiger SOC2-Konformität in deinem Cloud-Konto betreiben.
Die Optionen erkunden: verschiedene Vektordatenbanken ausprobieren
Um Embeddings in eine Vektordatenbank zu bekommen, brauchst du: 1) unstrukturierte Daten, 2) einen Plan, wie diese Daten in Chunks aufgeteilt werden sollen, 3) ein Embedding-Modell und 4) eine Vektordatenbank.
Für die Daten habe ich den IMDB large movie review dataset des Stanford AI Lab verwendet. Es handelt sich um einen praktisch aufbereiteten Datensatz mit 50.000 Einträgen (50:50-Stichprobenverhältnis positiver/negativer Rezensionen). Diese Daten haben die Spalten: movie_index, Rohtext der Rezension und Filmbewertung.
Für das Chunking entschied ich mich dafür, ganze Filmrezensionen intakt zu lassen, es sei denn, sie waren sehr lang. Für sehr lange Rezensionen verwendete ich die typischen Standard-Chunks mit einer Länge von 512. Das bedeutet, lange Rezensionen wurden in mehrere 512-Zeichen-lange Stücke aufgeteilt. In der LLM-Terminologie nennt man das „chunk size“.
Für das Embedding-Modell probierte ich verschiedene Modelle aus, darunter die allgegenwärtigen OpenAI-Embeddings. Bis ich herausfand, dass es am einfachsten ist, einfach das sich ständig verändernde kleinste, auf dem Retriever-Tab am besten bewertete Modell aus dem MTEB HuggingFace leaderboard auszuwählen. Damals entschied ich mich für „e5-base-v2“. Es ist tatsächlich gut, dass die Wahl des Embedding-Modells unabhängig von der Vektordatenbank selbst ist.
Bei den Datenbanken probierte ich FAISS, Qdrant, Chroma, Weaviate, Pinecone und natürlich Milvus aus. Ich ließ sie alle dieselben Aufgaben durchlaufen: 1) Wie einfach und schnell ist es, direkt aus pandas in die Vektordatenbank zu laden? 2) Wie einfach, schnell und anpassbar ist es, gute Abfrageergebnisse aus der Vektordatenbank zu erhalten? 3) Wie einfach und anpassbar ist es, RAG mit LangChain durchzuführen (zukünftiger Blogbeitrag!).
Milvus sticht hervor
Unter allen Datenbanken, die ich untersucht habe, erregte Milvus aus mehreren Gründen meine Aufmerksamkeit. Erstens bot es eine benutzerfreundliche Erfahrung, insbesondere beim direkten Einfügen von Daten aus pandas mit Metadaten, da dies der erste Ansatz ist, den ein Data Scientist ausprobieren könnte.
Milvus fiel mir auch wegen seiner Geschwindigkeit beim Laden von Vektoren und bei Abfragen auf. Milvus war merklich flotter als andere Ansätze, von denen einige selbst in diesem kleinen Maßstab langsam waren. Ich bemerkte auch die Funktionen und wählte die Standardeinstellungen für andere Datenbanken (IVF-flat Exhaustive Search mit L2-Metrik), obwohl Milvus andere Optionen unterstützt.
Unten finden Sie einen Gist zum Einfügen eines pandas-DataFrames in Milvus. Der vollständige Code ist auf meinem GitHub.
# Vollständiger Code unter: https://github.com/christy/ZillizDemos/blob/main/milvus_onboarding/hello_world_milvus.ipynb
###########
# 1. Laden Sie zur lokalen Verwendung einen Sentence Transformer aus dem HuggingFace Hub herunter.
###########
import os
from dotenv import load_dotenv, find_dotenv
from huggingface_hub import login
_ = load_dotenv(find_dotenv())
hub_token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
login(token=hub_token);
from sentence_transformers import SentenceTransformer
model_name = "BAAI/bge-base-en-v1.5"
retriever = SentenceTransformer(model_name, device="cuda")
# Modellparameter abrufen und für später speichern.
MAX_SEQ_LENGTH = retriever.get_max_seq_length()
HF_EOS_TOKEN_LENGTH = 1
EMBEDDING_LENGTH = retriever.get_sentence_embedding_dimension()
###########
# 2. Wählen Sie der Einfachheit halber eine Chunking-Funktion aus LangChain.
###########
from langchain.text_splitter import RecursiveCharacterTextSplitter
chunk_size = MAX_SEQ_LENGTH - HF_TOKEN_EOS_LENGTH
chunk_overlap = np.round(chunk_size * 0.10, 0)
text_splitter = RecursiveCharacterTextSplitter(
chunk_size=chunk_size,
chunk_overlap=chunk_overlap,
length_function=len,
)
def chunk_text(text):
chunks = text_splitter.split_text(text)
return [chunk for chunk in chunks if chunk]
###########
# 3. Ein pandas-DataFrame bearbeiten.
# Download: https://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
###########
# 1. Daten-Batch aus pandas DataFrame.
batch = df.head(100).copy()
# 2. Primärschlüsseltyp in String ändern.
batch["movie_index"] = batch["movie_index"].apply(lambda x: str(x))
# 3. Rezensionen auf 512 Zeichen kürzen.
batch['chunk'] = batch['text'].apply(chunk_text)
batch = batch.explode('chunk', ignore_index=True)
# 4. Embeddings als neue Spalte in df hinzufügen.
review_embeddings = torch.tensor(retriever.encode(batch['chunk']))
# Embeddings auf Einheitslänge normalisieren.
review_embeddings = F.normalize(review_embeddings, p=2, dim=1)
# 5. Embeddings in eine Liste von `numpy.ndarray` konvertieren, die jeweils `numpy.float32`-Zahlen enthalten.
converted_values = list(map(np.float32, review_embeddings))
batch['embeddings'] = converted_values
# 6. Spalten der Einfachheit halber neu anordnen, sodass der Index zuerst und die Labels am Ende stehen.
new_order = ["movie_index", "text", "chunk", "embeddings", "label_int", "label"]
batch = batch[new_order]
###########
# 4. milvus installieren und importieren.
###########
!pip install milvus pymilvus
import milvus, pymilvus
###########
# 5. Schema zum Laden von Daten in Milvus definieren.
###########
# Den Namen der Milvus-Collection festlegen.
COLLECTION_NAME = "movies"
fields = [
FieldSchema(name="pk", dtype=DataType.INT64, is_primary=True, auto_id=True),
FieldSchema(name="movie_index", dtype=DataType.VARCHAR, max_length=8),
FieldSchema(name="chunk", dtype=DataType.VARCHAR, max_length=MAX_SEQ_LENGTH),
FieldSchema(name="embeddings", dtype=DataType.FLOAT_VECTOR, dim=EMBEDDING_LENGTH),
FieldSchema(name="label_int", dtype=DataType.INT64),
FieldSchema(name="label", dtype=DataType.VARCHAR, max_length=8),
]
schema = CollectionSchema(fields, "Search imdb movie reviews")
mc = Collection(COLLECTION_NAME, schema, consistency_level="Eventually")```
###########
6. Starten Sie einen lokalen Milvus-Server (lite).
###########
default_server.start()
connections.connect(host='127.0.0.1',
port=default_server.listen_port,
show_startup_banner=True)
###########
# 7. Daten in Milvus einfügen.
###########
# Zeigt, wie die Indexparameter geändert werden, anstatt die Standardwerte zu verwenden.
index_params = {
"index_type": "HNSW",
"metric_type": "COSINE",
"params": {'M': 16, # int. 4~64, num_layers
"efConstruction": 32} # int. 8~512, num_nearest_neighbors
}
mc.create_index("embeddings", index_params)
insert_result = mc.insert(batch)
# Nachdem die letzte Entität eingefügt wurde, flush aufrufen, um zu verhindern, dass wachsende Segmente im Speicher verbleiben.
mc.flush()
###########
# 8. Die Datenbank abfragen.
###########
# Bevor Sie eine Suche oder Abfrage durchführen, müssen Sie die Daten in den Speicher laden.
mc.load()
# Definieren Sie eine Beispielfrage zu Ihren Daten.
query = "I'm a medical doctor, what movie should I watch?"
# Die Abfrage mit demselben Embedding-Modell einbetten, das zum Erstellen der Milvus-Collection verwendet wurde.
query_embeddings = torch.tensor(retriever.encode([query]))
# Embeddings auf Einheitslänge normalisieren.
query_embeddings = torch.nn.functional.normalize(query_embeddings, p=2, dim=1)
# Die Embeddings in eine Liste von Listen von np.float32 konvertieren.
query_embeddings = list(map(np.float32, query_embeddings))
# Eine Vektorsuche mit HNSW-Index ausführen.
TOP_K = 3
search_params = {
"M": 16,
"ef": 32,
}
results = mc.search(
data=query_embeddings,
anns_field="embeddings",
param=search_params,
output_fields=["movie_index", "chunk", "label"],
limit=TOP_K,
consistency_level="Eventually"
)
Nach meinem (schnellen, inoffiziellen) Test füllte ich ein Online-Formular aus, um mich auf eine Stelle als Developer Advocate bei Zilliz zu bewerben. Nach meinem letzten Interview machte mir das Zilliz-Team schnell ein Angebot. Also nahm ich ohne Zögern an!
Ich habe fabelhafte Kolleginnen und Kollegen. Lesen Sie die Blogs von Yujian Tang und Frank Liu, um zu erfahren, warum sie zu Zilliz gekommen sind. Meine Chefin, Chris Churilo, ist der geheime Klebstoff, der dafür sorgt, dass wir alle so effizient zusammenarbeiten. Sie nutzt ihr Wissen und ihre Erfahrung, um uns alle glänzen zu lassen. Mein Kollege Filip Haltmayer ist außergewöhnlich geduldig und gut darin, mir während meines Onboardings alles rund um Milvus und Zilliz zu erklären. Unser CEO, Charles Xie, hatte 2017 die ursprüngliche Vision, eine Datenbank speziell für unstrukturierte Daten zu entwickeln.
Was kommt als Nächstes
Während ich mit der Evangelism-Arbeit für Milvus beginne, freue ich mich darauf, Sie alle in der AI-Developer-Community kennenzulernen! Ich werde das Unstructured Data Meetup in San Francisco organisieren, wo ich immer nach großartigen Speakern, Veranstaltungsorten und Co-Hosts suche (melden Sie sich bitte bei mir!). Ich werde mehr bloggen und Vorträge halten (bitte melden Sie sich!). Wenn Sie Open-Source-Milvus in Ihrem Projekt mit unstrukturierten Daten ausprobieren möchten, lassen Sie mich bitte wissen, wie ich helfen kann!
Ich engagiere mich bei mehreren Data-Science-for-Good-Organisationen, darunter DataKind, Women in Data Science und Code for Americas San Francisco Civil Hack nights (durch die ich meine lokale Organisation Sonoma Safe Agriculture kennengelernt habe, für die ich eine interaktive Pestizidkarte erstellt habe). Bitte schließen Sie sich mir an, wenn ich meine neuen Erkenntnisse zu Vektordatenbanken auch in die größere Data-Science-for-Good-Community einbringe.
Weiterlesen
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.
How to Improve Retrieval Quality for Japanese Text with Sudachi, Milvus/Zilliz, and AWS Bedrock
Learn how Sudachi normalization and Milvus/Zilliz hybrid search improve Japanese RAG accuracy with BM25 + vector fusion, AWS Bedrock embeddings, and practical code examples.
Zilliz Cloud Introduces Advanced BYOC-I Solution for Ultimate Enterprise Data Sovereignty
Explore Zilliz Cloud BYOC-I, the solution that balances AI innovation with data control, enabling secure deployments in finance, healthcare, and education sectors.