Aprovechamiento de Milvus y Friendli Serverless Endpoints para RAG avanzado y consultas multimodales
FriendliAI se especializa en infraestructura de IA generativa, ofreciendo soluciones que permiten a las organizaciones implementar y gestionar de manera eficiente grandes modelos de lenguaje (LLMs) y otros modelos de IA generativa con rendimiento optimizado y costo reducido. Los usuarios tienen la capacidad de elegir entre LLMs convencionales listos para producción accesibles a través de APIs, o LLMs personalizados ajustados finamente desplegados en el hardware que elija el usuario, ya sea en la nube pública o en clústeres privados locales.
Milvus es una base de datos vectorial de código abierto que almacena, indexa y busca datos no estructurados a escala de miles de millones mediante embeddings vectoriales de alta dimensión. Es perfecta para crear aplicaciones modernas de IA como generación aumentada por recuperación (RAG), búsqueda semántica, búsqueda multimodal y sistemas de recomendación.
En este artículo, exploraremos cómo usar Milvus con Friendli Serverless Endpoints para realizar generación aumentada por recuperación (RAG) en documentos y materiales específicos y ejecutar consultas multimodales que incorporen imágenes y otro contenido visual. Esta potente combinación permite aplicaciones de IA más sofisticadas y conscientes del contexto.
Comprender RAG y los modelos multimodales
Generación aumentada por recuperación (RAG)
RAG es una técnica que mejora los modelos de lenguaje proporcionándoles información relevante, principalmente recuperada de una base de conocimientos impulsada por una base de datos vectorial. Este enfoque permite a los modelos de IA generar respuestas más precisas y contextualmente apropiadas al hacer referencia a fuentes de datos externas designadas.
Modelos multimodales
Los modelos multimodales pueden procesar y comprender múltiples tipos de datos de entrada, como texto, imágenes y audio. Pueden analizar y generar respuestas basadas en diversas fuentes de información, lo que permite interacciones más completas y matizadas.
¿Por qué incorporar RAG y modelos multimodales juntos?
La combinación de RAG y capacidades multimodales mejora significativamente los sistemas de IA al proporcionar las siguientes funciones simultáneamente:
- Permitir tipos de entrada más diversos y ricos según la elección del usuario
- Proporcionar información actualizada
- Mejorar la precisión y relevancia de las respuestas
- Habilitar interacciones conscientes del contexto
Implementación práctica
Profundicemos en la implementación práctica de RAG y consultas multimodales usando la base de datos vectorial Milvus y Friendli Serverless Endpoints.
Paso 1: Instalar requisitos previos y descargar la documentación de Milvus
Primero, instalaremos las bibliotecas necesarias y descargaremos la documentación de Milvus que usaremos para nuestro trabajo de RAG:
!pip install --upgrade pymilvus requests tqdm langchain langchain-community langchain-huggingface langchain-openai friendli-client tiktoken
!wget https://github.com/milvus-io/milvus-docs/releases/download/v2.4.6-preview/milvus_docs_2.4.x_en.zip
!rm -rf milvus_docs
!unzip -q milvus_docs_2.4.x_en.zip -d milvus_docs
Paso 2: Procesar archivos de documentación
A continuación, leeremos los archivos de documentación de Milvus y usaremos una estrategia simple de división de archivos para tratar cada línea de texto como un fragmento individual:
from glob import glob
text_lines = []
for file_path in glob("milvus_docs/en/faq/*.md", recursive=True):
with open(file_path, "r") as file:
file_text = file.read()
text_lines += file_text.split("# ")
Paso 3: Preparar embeddings
Usaremos la biblioteca de embeddings de Hugging Face para utilizar un modelo simple all-MiniLM-L6 para crear representaciones vectoriales de nuestro texto:
from langchain_huggingface import HuggingFaceEmbeddings
embeddings_model_name = "sentence-transformers/all-MiniLM-L6-v2"
embedding = HuggingFaceEmbeddings(model_name=embeddings_model_name)
test_embedding = embedding.embed_query("This is a test")
embedding_dim = len(test_embedding)
print(embedding_dim)
print(test_embedding[:10])
Paso 4: Configurar el cliente de Milvus
Ahora, preparemos el cliente de Milvus para nuestra implementación de RAG. En este ejemplo simple, usamos Milvus Lite, que se ejecuta localmente y materializa un archivo en un archivo local. También puedes considerar otras opciones de despliegue de Milvus:
Si solo necesitas una base de datos vectorial local para datos a pequeña escala o prototipado, establecer el uri como un archivo local, por ejemplo ./milvus.db, es el método más conveniente, ya que utiliza automáticamente Milvus Lite para almacenar todos los datos en este archivo.
Para datos y tráfico a mayor escala en producción, puedes configurar un servidor Milvus en Docker o Kubernetes. En esta configuración, usa la dirección y el puerto del servidor como tu uri, por ejemplo http://localhost:19530. Si habilitas la función de autenticación en Milvus, establece el token como "<your_username>:<your_password>"; de lo contrario, no es necesario establecer el token.
También puedes usar Milvus completamente gestionado en Zilliz Cloud. Simplemente establece el uri y el token en el Public Endpoint and API key de tu instancia de Zilliz Cloud.
from pymilvus import MilvusClient
milvus_client = MilvusClient(uri="./milvus_demo.db")
collection_name = "my_rag_collection"
Paso 5: Crear una colección de Milvus
Crearemos una colección en el cliente de Milvus si aún no existe:
if milvus_client.has_collection(collection_name):
milvus_client.drop_collection(collection_name)
milvus_client.create_collection(
collection_name=collection_name,
dimension=embedding_dim,
metric_type="IP", # Inner product distance
consistency_level="Strong", # Strong consistency level
)
Paso 6: Incrustar e insertar texto en Milvus
Incrustemos nuestro texto e insertémoslo en la colección de Milvus:
from tqdm import tqdm
data = []
for i, line in enumerate(tqdm(text_lines, desc="Creating embeddings")):
data.append({"id": i, "vector": embedding.embed_query(line), "text": line})
milvus_client.insert(collection_name=collection_name, data=data)
Paso 7: Realizar una consulta RAG
Ahora podemos hacer una pregunta y buscar datos relevantes dentro de nuestra base de datos Milvus:
question = "How is data stored in milvus?"
search_res = milvus_client.search(
collection_name=collection_name,
data=[
embedding.embed_query(question)
],
limit=3, # Return top 3 results
search_params={"metric_type": "IP", "params": {}}, # Inner product distance
output_fields=["text"], # Return the text field
)
import json
retrieved_lines_with_distances = [
(res["entity"]["text"], res["distance"]) for res in search_res[0]
]
print(json.dumps(retrieved_lines_with_distances, indent=4))
context = "\n".join(
[line_with_distance[0] for line_with_distance in retrieved_lines_with_distances]
)
Paso 8: Crear prompts para RAG
Creemos los prompts del sistema y del usuario para nuestra consulta RAG:
SYSTEM_PROMPT = """
Human: You are an AI assistant. You are able to find answers to the questions from the contextual passage snippets provided.
"""
USER_PROMPT = f"""
Use the following pieces of information enclosed in <context> tags to provide an answer to the question enclosed in <question> tags.
<context>
{context}
</context>
<question>
{question}
</question>
"""
Paso 9: Configurar el token de Friendli
Obtén tu FRIENDLI_TOKEN desde la Friendli Suite y configúralo como una variable de entorno:
import os
if "FRIENDLI_TOKEN" not in os.environ:
os.environ["FRIENDLI_TOKEN"] = 'flp_FILL_IN_WITH_YOUR_OWN_PERSONAL_ACCESS_TOKEN'
Paso 10: Ejecutar la consulta RAG
Ahora podemos ejecutar nuestra consulta RAG usando los Friendli Serverless Endpoints:
from langchain_openai import ChatOpenAI
llm = ChatOpenAI(
model="meta-llama-3.1-70b-instruct",
base_url="https://api.friendli.ai/serverless/v1",
api_key=os.environ["FRIENDLI_TOKEN"],
)
from langchain_core.prompts import ChatPromptTemplate
from langchain_core.output_parsers import StrOutputParser
prompt = ChatPromptTemplate.from_messages([
("system", SYSTEM_PROMPT),
("user", USER_PROMPT)
])
output_parser = StrOutputParser()
chain = prompt | llm | output_parser
print(chain.invoke({"input": question}))
Esto produce la respuesta basada en los documentos proporcionados:
En Milvus, los datos se almacenan en dos formas: datos insertados y metadatos.
Los datos insertados (datos vectoriales, datos escalares y el esquema específico de la colección) se almacenan en almacenamiento persistente como registros incrementales. Milvus admite múltiples backends de almacenamiento de objetos, incluidos MinIO, AWS S3, Google Cloud Storage (GCS), Azure Blob Storage, Alibaba Cloud OSS y Tencent Cloud Object Storage (COS).
Los metadatos, por otro lado, se generan dentro de Milvus y se almacenan en etcd, y cada módulo de Milvus tiene sus propios metadatos.
Paso 11: Consultas multimodales
Para consultas multimodales, usaremos el modelo Llama-3.2-11b-vision:
multimodalllm = ChatOpenAI(
model="llama-3.2-11b-vision-instruct",
base_url="https://api.friendli.ai/serverless/beta",
api_key=os.environ["FRIENDLI_TOKEN"],
)
image_url = "https://milvus.io/docs/v2.4.x/assets/highly-decoupled-architecture.png"
message = HumanMessage(
content=[
{"type": "text", "text": "describe what is in this image"},
{"type": "image_url", "image_url": {"url": image_url}},
],
)
response = multimodalllm.invoke([message])
print(response.content)
A partir de su respuesta, podemos inferir que el modelo comprende correctamente la imagen:
La imagen muestra un diagrama de flujo de los componentes de un sistema, con los siguientes componentes:
**Servicio coordinador**
* Root
* Query
…
Paso 12: Combinar capacidades RAG y multimodales
Finalmente, combinemos las capacidades RAG y multimodales:
question = "How is data stored in milvus with respect to this picture?"
USER_PROMPT = f"""
Use the following pieces of information enclosed in <context> tags to provide an answer to the question enclosed in <question> tags.
<context>
{context}
</context>
<question>
{question}
</question>
"""
message = HumanMessage(
content=[
{"type": "text", "text": USER_PROMPT},
{"type": "image_url", "image_url": {"url": image_url}},
],
)
response = multimodalllm.invoke([message])
print(response.content)
El modelo genera correctamente una respuesta adecuada basada en la imagen y los documentos:
**Paso 1: Identificar los componentes involucrados en el almacenamiento de datos en Milvus.**
Los componentes involucrados en el almacenamiento de datos en Milvus incluyen:
* Capa de acceso
* Almacenamiento de mensajes
* Nodo de trabajador
**Paso 2: Determinar cómo se almacenan los datos en Milvus.**
Los datos se almacenan en la Capa de acceso y el Almacenamiento de mensajes.
**Paso 3: Determinar dónde se almacenan los datos en Milvus.**
Los datos se almacenan tanto en Access Layer como en Message Storage.
**Respuesta:** Los datos se almacenan tanto en Access Layer como en Message Storage.
Para ver el código completo y más detalles, consulta este notebook de Colab.
Conclusión
Este tutorial ha demostrado cómo aprovechar Milvus y Friendli Serverless Endpoints para implementar RAG avanzado y consultas multimodales. Al combinar estas potentes tecnologías, puedes crear aplicaciones de IA más sofisticadas que puedan comprender y procesar diversos tipos de información, lo que da lugar a respuestas más precisas y conscientes del contexto.
Sigue leyendo
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.
Build for the Boom: Why AI Agent Startups Should Build Scalable Infrastructure Early
Explore strategies for developing AI agents that can handle rapid growth. Don't let inadequate systems undermine your success during critical breakthrough moments.
What is the K-Nearest Neighbors (KNN) Algorithm in Machine Learning?
KNN is a supervised machine learning technique and algorithm for classification and regression. This post is the ultimate guide to KNN.