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:

1. Verbindung zu Milvus Lite mit LlamaIndex

2. Verbindung zu Milvus Lite mit LangChain

3. 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:

1. Starten Sie den Milvus Lite-Server und stellen Sie eine Verbindung her.

2. Wählen Sie ein Embedding-Modell aus.

3. Erstellen Sie eine Milvus-Datenbank-Collection.

   1. Definieren Sie ein Schema.

   2. Wählen Sie einen Index aus (Datenstruktur für die Approximate-Nearest-Neighbor-Suche).

   3. Wählen Sie eine Distanzmetrik aus (Definition von „nah“ im Vektorraum).

   4. Wählen Sie das Konsistenzlevel für das Einfügen von Daten aus.

4. Wählen Sie eine Chunking-Strategie aus.

5. Wandeln Sie Daten-Chunks mithilfe der Inferenz des Embedding-Modells in Vektoren um.

6. 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-Dokumentation

Milvus Lite LlamaIndex-Dokumentation

Milvus Lite LangChain-Dokumentation

LangChain Milvus-Dokumentation

LlamaIndex Milvus-Dokumentation