So verbinden Sie sich mit Milvus Lite mithilfe von LangChain und LlamaIndex
Milvus Lite, erst vor einer Woche am 31. Mai veröffentlicht, ist nun die Standardmethode für Drittanbieter-Connectors wie LangChain und LlamaIndex, um eine Verbindung zu Milvus, der beliebten Open-Source-Vektordatenbank, herzustellen.
| Methode | Kontrollniveau für den Abrufprozess | Zeit (Sekunden) |
| LlamaIndex | Keine Kontrolle | 2156 |
| LangChain | Volle Kontrolle | 8 |
| Milvus Lite API | Volle Kontrolle | 28 |
Tabelle: Zeitmessungen mit demselben HuggingFace-Embedding-Modell (BAAI/bge-large-en-v1.5) und denselben HTML-Datendateien.
Das Ergebnis? Wenn Sie nach der besten Balance zwischen hoher Kontrolle über Milvus-Einstellungen und schneller Einrichtung suchen, ist die direkte Verwendung der Milvus Lite APIs die optimale Wahl. Der vollständige Code und die Zeitmessungen sind auf meinem GitHub verfügbar.
In den folgenden Abschnitten behandeln wir:
Verbindung zu Milvus Lite mit LlamaIndex
Verbindung zu Milvus Lite mit LangChain
Verbindung zu Milvus Lite mit Milvus APIs
Verbindung zu Milvus Lite mit LlamaIndex
Der Einstieg mit LlamaIndex ist einfach. Es dauert etwa 2000 Sekunden, eine Verbindung herzustellen und eine Collection zu erstellen.
from pymilvus import MilvusClient
from llama_index.core import (
Settings,
ServiceContext,
StorageContext,
VectorStoreIndex,
)
from llama_index.embeddings.huggingface import HuggingFaceEmbedding
from llama_index.vector_stores.milvus import MilvusVectorStore
# 1. Define the embedding model.
service_context = ServiceContext.from_defaults(
# LlamaIndex local: translates to the same location as default HF cache.
embed_model="local:BAAI/bge-large-en-v1.5")
# LlamaIndex hides this but we need it to create the vector store!
EMBEDDING_DIM = 1024
# 2. Create a Milvus collection from the documents and embeddings.
milvus_client = MilvusClient()
vector_store = MilvusVectorStore(
client=milvus_client,
dim=EMBEDDING_DIM,
overwrite=True
)
storage_context = StorageContext.from_defaults(
vector_store=vector_store
)
llamaindex = VectorStoreIndex.from_documents(
# Chunk, embed, insert too slow! Just use one document.
docs[:1],
storage_context=storage_context,
service_context=service_context
)
Verbindung zu Milvus Lite mit LangChain
Der Einstieg in LangChain ist einfach. Es dauert etwa 8 Sekunden, eine Verbindung herzustellen und eine Collection zu erstellen.
from langchain_milvus import Milvus
from langchain_huggingface import HuggingFaceEmbeddings
from langchain.text_splitter import RecursiveCharacterTextSplitter
# 1. Define the embedding model.
model_name = "BAAI/bge-large-en-v1.5"
model_kwargs = {'device': 'cpu'}
encode_kwargs = {'normalize_embeddings': True}
embed_model = HuggingFaceEmbeddings(
model_name=model_name,
model_kwargs=model_kwargs,
encode_kwargs=encode_kwargs)
EMBEDDING_DIM = embed_model.dict()['client'].get_sentence_embedding_dimension()
# 2. Create a Milvus collection from the documents and embeddings.
start_time = time.time()
vectorstore = Milvus.from_documents(
documents=docs,
embedding=embed_model,
connection_args={
"uri": "./milvus_demo.db",},
# Override LangChain default values for Milvus.
consistency_level="Eventually",
drop_old=True,
index_params = {
"metric_type": "COSINE",
"index_type": "AUTOINDEX",
"params": {}}
)
Verbindung zu Milvus Lite über Milvus Lite APIs herstellen
Aber was passiert im Hintergrund? Schauen wir uns die tatsächlichen Schritte genauer an und machen die Standardwerte expliziter:
Starten Sie den Milvus Lite-Server und stellen Sie eine Verbindung her.
Wählen Sie ein Embedding-Modell aus.
Erstellen Sie eine Milvus-Datenbank-Collection.
Definieren Sie ein Schema.
Wählen Sie einen Index aus (Datenstruktur für die Approximate-Nearest-Neighbor-Suche).
Wählen Sie eine Distanzmetrik aus (Definition von „nah“ im Vektorraum).
Wählen Sie das Konsistenzlevel für das Einfügen von Daten aus.
Wählen Sie eine Chunking-Strategie aus.
Wandeln Sie Daten-Chunks mithilfe der Inferenz des Embedding-Modells in Vektoren um.
Fügen Sie Vektordaten in Milvus ein.
Hier ist der Python-Code, der die Milvus Lite API direkt verwendet. Es dauert etwa 28 Sekunden, eine Verbindung herzustellen und eine Collection zu erstellen.
import pymilvus
# STEP 1. CONNECT A CLIENT TO LIGHT MILVUS PYTHON SERVER.
from pymilvus import MilvusClient
mc = MilvusClient("milvus_demo.db")
# STEP 2. DOWNLOAD AN OPEN SOURCE EMBEDDING MODEL.
from sentence_transformers import SentenceTransformer
model_name = "BAAI/bge-large-en-v1.5"
encoder = SentenceTransformer(model_name, device=’cpu’)
# STEP 3. CREATE A MILVUS COLLECTION AND DEFINE THE DATABASE INDEX.
# Uses Milvus AUTOINDEX, which defaults to HNSW.
COLLECTION_NAME = "MilvusDocs"
mc.create_collection(COLLECTION_NAME,
EMBEDDING_DIM,
consistency_level="Eventually",
auto_id=True,
overwrite=True,)
# STEP 4. CHUNK DATA INTO VECTORS.
from langchain_community.document_transformers import BeautifulSoupTransformer
from langchain.text_splitter import RecursiveCharacterTextSplitter
# Define chunk size and overlap.
chunk_size = 512
chunk_overlap = np.round(chunk_size * 0.10, 0)
# Split the documents into recursive, overlapping chunks.
child_splitter = RecursiveCharacterTextSplitter(
chunk_size = chunk_size,
chunk_overlap = chunk_overlap,
length_function = len, # use built-in Python len function)
chunks = child_splitter.split_documents(docs)
# STEP 5. TRANSFORM CHUNKS INTO VECTORS USING EMBEDDING MODEL INFERENCE.
list_of_strings = [doc.page_content for doc in chunks if hasattr(doc, 'page_content')]
embeddings = torch.tensor(encoder.encode(list_of_strings))
# STEP 6. INSERT CHUNK LIST INTO MILVUS.
# First, create chunk_list and dict_list.
dict_list = []
for chunk, sparse, dense in zip(chunks, embeddings["sparse"], embeddings["dense"]):
chunk_dict = {
'chunk': chunk.page_content,
'source': chunk.metadata.get('source', ""),
'vector': dense
}
dict_list.append(chunk_dict)
mc.insert(
COLLECTION_NAME,
data=dict_list,
progress_bar=True)
Auswahl der richtigen Milvus-Light-Methode
Während die verschiedenen Milvus Lite APIs Komfort bieten, gehen sie mit Kompromissen in Bezug auf die Kontrolle über Retrieval- und Chunking-Methoden sowie Geschwindigkeit einher.
Die direkte Verwendung der Milvus Lite APIs bietet die größte Kontrolle über die Milvus-Retrieval-Einstellungen und zugleich die schnellste Geschwindigkeit bei der Erstellung von Collections.
Ressourcen und weiterführende Lektüre
Milvus Lite LlamaIndex-Dokumentation
Milvus Lite LangChain-Dokumentation
LangChain Milvus-Dokumentation
Weiterlesen
What Is a Vector Lakebase?
A Vector Lakebase is a unified, lake-native data architecture for AI that combines vector-database-grade serving with open lake storage, reusable lake-level indexes, and a shared semantic layer.
Zilliz Cloud On-Demand Compute: Pay Only for What You Use
The customer case behind Zilliz Cloud On-Demand: how a $10K vector search bill came down to under $500, and the engineering changes that made it possible.
Why AI Databases Don't Need SQL
Whether you like it or not, here's the truth: SQL is destined for decline in the era of AI.