Cómo conectarse a Milvus Lite usando LangChain y LlamaIndex
Milvus Lite, lanzado hace solo una semana, el 31 de mayo, ahora es el método predeterminado para que conectores de terceros como LangChain y LlamaIndex se conecten a Milvus, la popular base de datos vectorial de código abierto.
| Método | Nivel de control del proceso de recuperación | Tiempo (segundos) |
| LlamaIndex | Sin control | 2156 |
| LangChain | Control total | 8 |
| API de Milvus Lite | Control total | 28 |
Tabla: Tiempos usando el mismo modelo de embeddings de HuggingFace (BAAI/bge-large-en-v1.5) y los mismos archivos de datos HTML.
¿El resultado? Si buscas el mejor equilibrio entre un alto control sobre la configuración de Milvus y una configuración rápida, usar directamente las APIs de Milvus Lite es la opción óptima. El código completo y los tiempos están disponibles en mi GitHub.
En las siguientes secciones, cubriremos:
Conexión a Milvus Lite usando LlamaIndex
Conexión a Milvus Lite usando LangChain
Conexión a Milvus Lite usando APIs de Milvus
Conexión a Milvus Lite usando LlamaIndex
Es fácil empezar a usar LlamaIndex. Tarda unos 2000 segundos en conectarse y crear una colección.
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
)
Conexión a Milvus Lite usando LangChain
Es fácil empezar con LangChain. Tarda unos 8 segundos en conectarse y crear una colección.
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": {}}
)
Conexión a Milvus Lite mediante las API de Milvus Lite
Pero ¿qué está pasando entre bastidores? Desglosemos los pasos reales y hagamos más explícitos los valores predeterminados:
Inicia el servidor Milvus Lite y conéctate.
Selecciona un modelo de embeddings.
Crea una colección de base de datos de Milvus.
Define un esquema.
Elige un índice (estructura de datos para la búsqueda de vecinos más cercanos aproximados).
Elige una métrica de distancia (definición de “cerca” en el espacio vectorial).
Elige el nivel de consistencia para insertar datos.
Selecciona una estrategia de fragmentación.
Transforma fragmentos de datos en vectores usando la inferencia del modelo de embeddings.
Inserta datos vectoriales en Milvus.
Aquí está el código Python usando directamente la API de Milvus Lite. Tarda unos 28 segundos en conectarse y crear una colección.
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)
Elección del método adecuado de Milvus Light
Aunque las diferentes API de Milvus Lite ofrecen comodidades, conllevan compensaciones en términos de control sobre los métodos de recuperación y fragmentación, y de velocidad.
Usar directamente las API de Milvus Lite proporciona el mayor control sobre la configuración de recuperación de Milvus, equilibrado con la mayor velocidad de creación de colecciones.
Recursos y lecturas adicionales
Documentación de Milvus Lite LlamaIndex
Documentación de Milvus Lite LangChain
Documentación de LangChain Milvus
Sigue leyendo
Bringing AI to Legal Tech: The Role of Vector Databases in Enhancing LLM Guardrails
Discover how vector databases enhance AI reliability in legal tech, ensuring accurate, compliant, and trustworthy AI-powered legal solutions.
DeepRAG: Thinking to Retrieval Step by Step for Large Language Models
Discover DeepRAG, an advanced retrieval-augmented generation (RAG) model that improves LLM accuracy by retrieving only essential data through step-by-step reasoning.
Vector Databases vs. Hierarchical Databases
Use a vector database for AI-powered similarity search; use a hierarchical database for organizing data in parent-child relationships with efficient top-down access patterns.