Come connettersi a Milvus Lite utilizzando LangChain e LlamaIndex
Milvus Lite, rilasciato appena una settimana fa, il 31 maggio, è ora il metodo predefinito per connettori di terze parti come LangChain e LlamaIndex per connettersi a Milvus, il popolare database vettoriale open-source.
| Metodo | Livello di controllo per il processo di recupero | Tempo (secondi) |
| LlamaIndex | Nessun controllo | 2156 |
| LangChain | Controllo completo | 8 |
| Milvus Lite API | Controllo completo | 28 |
Tabella: Tempi usando lo stesso modello di embedding HuggingFace (BAAI/bge-large-en-v1.5) e gli stessi file di dati HTML.
Il risultato? Se cerchi il miglior equilibrio tra un alto controllo sulle impostazioni di Milvus e una configurazione rapida, usare direttamente le API di Milvus Lite è la scelta ottimale. Il codice completo e i tempi sono disponibili sul mio GitHub.
Nelle sezioni seguenti, tratteremo:
Connessione a Milvus Lite usando LlamaIndex
Connessione a Milvus Lite usando LangChain
Connessione a Milvus Lite usando API Milvus
Connessione a Milvus Lite usando LlamaIndex
È facile iniziare a usare LlamaIndex. Ci vogliono circa 2000 secondi per connettersi e creare una collection.
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
)
Connessione a Milvus Lite usando LangChain
È facile iniziare in LangChain. Ci vogliono circa 8 secondi per connettersi e creare una collection.
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": {}}
)
Connessione a Milvus Lite tramite le API di Milvus Lite
Ma cosa succede dietro le quinte? Analizziamo i passaggi effettivi e rendiamo più espliciti i valori predefiniti:
Avvia il server Milvus Lite e connettiti.
Seleziona un modello di embedding.
Crea una collection di database Milvus.
Definisci uno schema.
Scegli un indice (struttura dati per la ricerca Approximate Nearest Neighbor).
Scegli una metrica di distanza (definizione di “vicino” nello spazio vettoriale).
Scegli il livello di consistenza per l’inserimento dei dati.
Seleziona una strategia di chunking.
Trasforma i chunk di dati in vettori usando l’inferenza del modello di embedding.
Inserisci i dati vettoriali in Milvus.
Ecco il codice Python che utilizza direttamente la Milvus Lite API. Sono necessari circa 28 secondi per connettersi e creare una collection.
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)
Scegliere il metodo Milvus Light giusto
Sebbene le diverse API di Milvus Lite offrano comodità, comportano compromessi in termini di controllo sui metodi di retrieval e chunking e sulla velocità.
L’utilizzo diretto delle API di Milvus Lite offre il massimo controllo sulle impostazioni di retrieval di Milvus, bilanciato con la massima velocità di creazione della collection.
Risorse e ulteriori letture
Documentazione di Milvus Lite LlamaIndex
Documentazione di Milvus Lite LangChain
Documentazione di LangChain Milvus
Continua a leggere
A Few Notes from Databricks Data + AI Summit 2026: Why the Data Layer Matters Again
James Luan shares notes from Databricks Data + AI Summit 2026 on why production AI is pushing the data layer back to the center of infrastructure.
Zilliz Cloud Just Landed in Claude Code
The Zilliz Cloud Plugin brings the full power of Zilliz Cloud directly into your Claude Code terminal as natural-language conversations.
Vector Databases vs. Graph Databases
Use a vector database for AI-powered similarity search; use a graph database for complex relationship-based queries and network analysis.