Exploiter Milvus et les points de terminaison serverless de Friendli pour des requêtes RAG avancées et multimodales
FriendliAI est spécialisé dans l’infrastructure d’IA générative, offrant des solutions qui permettent aux organisations de déployer et de gérer efficacement de grands modèles de langage (LLM) et d’autres modèles d’IA générative avec des performances optimisées et des coûts réduits. Les utilisateurs ont la possibilité de choisir parmi des LLM conventionnels prêts pour la production accessibles via des API, ou des LLM personnalisés affinés déployés sur le matériel de leur choix, que ce soit sur le cloud public ou sur des clusters privés sur site.
Milvus est une base de données vectorielle open-source qui stocke, indexe et recherche des données non structurées à l’échelle du milliard au moyen d’embeddings vectoriels de grande dimension. Elle est parfaite pour créer des applications d’IA modernes telles que la génération augmentée par récupération (RAG), la recherche sémantique, la recherche multimodale et les systèmes de recommandation.
Dans cet article, nous explorerons comment utiliser Milvus avec Friendli Serverless Endpoints pour effectuer de la génération augmentée par récupération (RAG) sur des documents et supports particuliers, et exécuter des requêtes multimodales intégrant des images et d’autres contenus visuels. Cette combinaison puissante permet de créer des applications d’IA plus sophistiquées et sensibles au contexte.
Comprendre la RAG et les modèles multimodaux
Génération augmentée par récupération (RAG)
La RAG est une technique qui améliore les modèles de langage en leur fournissant des informations pertinentes, principalement récupérées à partir d’une base de connaissances alimentée par une base de données vectorielle. Cette approche permet aux modèles d’IA de générer des réponses plus précises et contextuellement appropriées en se référant à des sources de données externes désignées.
Modèles multimodaux
Les modèles multimodaux peuvent traiter et comprendre plusieurs types de données d’entrée, comme du texte, des images et de l’audio. Ils peuvent analyser et générer des réponses à partir de sources d’information diverses, permettant des interactions plus complètes et nuancées.
Pourquoi intégrer la RAG et les modèles multimodaux ensemble ?
La combinaison de la RAG et des capacités multimodales améliore considérablement les systèmes d’IA en fournissant simultanément les fonctionnalités suivantes :
- Permettre des types d’entrées plus diversifiés et riches selon le choix de l’utilisateur
- Fournir des informations à jour
- Améliorer la précision et la pertinence des réponses
- Permettre des interactions sensibles au contexte
Mise en œuvre pratique
Plongeons dans la mise en œuvre pratique de la RAG et des requêtes multimodales à l’aide de la base de données vectorielle Milvus et de Friendli Serverless Endpoints.
Étape 1 : Installer les prérequis et télécharger la documentation Milvus
Tout d’abord, nous allons installer les bibliothèques nécessaires et télécharger la documentation Milvus que nous utiliserons pour notre tâche 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
Étape 2 : Traiter les fichiers de documentation
Ensuite, nous lirons les fichiers de documentation Milvus et utiliserons une stratégie simple de découpage de fichiers pour traiter chaque ligne de texte comme un segment individuel :
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("# ")
Étape 3 : Préparer les embeddings
Nous utiliserons la bibliothèque d’embeddings Hugging Face pour utiliser un modèle simple all-MiniLM-L6 afin de créer des représentations vectorielles de notre texte :
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])
Étape 4 : Configurer le client Milvus
Maintenant, préparons le client Milvus pour notre implémentation RAG. Dans cet exemple simple, nous utilisons Milvus Lite, qui s’exécute localement et matérialise un fichier dans un fichier local. Vous pouvez également envisager d’autres options de déploiement de Milvus :
Si vous avez seulement besoin d’une base de données vectorielle locale pour des données à petite échelle ou du prototypage, définir l’uri comme un fichier local, par exemple ./milvus.db, est la méthode la plus pratique, car elle utilise automatiquement Milvus Lite pour stocker toutes les données dans ce fichier.
Pour des données et un trafic à plus grande échelle en production, vous pouvez configurer un serveur Milvus sur Docker ou Kubernetes. Dans cette configuration, veuillez utiliser l’adresse et le port du serveur comme votre uri, par exemple http://localhost:19530. Si vous activez la fonctionnalité d’authentification sur Milvus, définissez le token comme "<your_username>:<your_password>", sinon il n’est pas nécessaire de définir le token.
Vous pouvez également utiliser Milvus entièrement géré sur Zilliz Cloud. Définissez simplement l’uri et le token sur le point de terminaison public et la clé API de votre instance Zilliz Cloud.
from pymilvus import MilvusClient
milvus_client = MilvusClient(uri="./milvus_demo.db")
collection_name = "my_rag_collection"
Étape 5 : Créer une collection Milvus
Nous créerons une collection dans le client Milvus si elle n’existe pas déjà :
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
)
Étape 6 : Intégrer et insérer du texte dans Milvus
Intégrons notre texte et insérons-le dans la collection 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)
Étape 7 : Effectuer une requête RAG
Nous pouvons maintenant poser une question et rechercher des données pertinentes dans notre base de données 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]
)
Étape 8 : Créer des prompts pour RAG
Créons les prompts système et utilisateur pour notre requête 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>
"""
Étape 9 : Configurer le jeton Friendli
Obtenez votre FRIENDLI_TOKEN depuis la Friendli Suite et définissez-le comme variable d’environnement :
import os
if "FRIENDLI_TOKEN" not in os.environ:
os.environ["FRIENDLI_TOKEN"] = 'flp_FILL_IN_WITH_YOUR_OWN_PERSONAL_ACCESS_TOKEN'
Étape 10 : Exécuter la requête RAG
Nous pouvons maintenant exécuter notre requête RAG à l’aide des 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}))
Cela produit la réponse basée sur les documents fournis :
Dans Milvus, les données sont stockées sous deux formes : les données insérées et les métadonnées.
Les données insérées (données vectorielles, données scalaires et schéma propre à la collection) sont stockées dans un stockage persistant sous forme de journaux incrémentiels. Milvus prend en charge plusieurs backends de stockage d’objets, notamment MinIO, AWS S3, Google Cloud Storage (GCS), Azure Blob Storage, Alibaba Cloud OSS et Tencent Cloud Object Storage (COS).
Les métadonnées, quant à elles, sont générées au sein de Milvus et sont stockées dans etcd, chaque module Milvus ayant ses propres métadonnées.
Étape 11 : Requêtes multimodales
Pour les requêtes multimodales, nous utiliserons le modèle 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)
D’après sa réponse, nous pouvons déduire que le modèle comprend correctement l’image :
L’image représente un organigramme des composants d’un système, avec les composants suivants :
**Coordinator Service**
* Root
* Query
…
Étape 12 : Combiner les capacités RAG et multimodales
Enfin, combinons les capacités RAG et 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)
Le modèle génère correctement une réponse appropriée basée sur l’image et les documents :
**Étape 1 : Identifier les composants impliqués dans le stockage des données dans Milvus.**
Les composants impliqués dans le stockage des données dans Milvus comprennent :
* Access Layer
* Message Storage
* Worker Node
**Étape 2 : Déterminer comment les données sont stockées dans Milvus.**
Les données sont stockées dans l’Access Layer et le Message Storage.
Étape 3 : Déterminer où les données sont stockées dans Milvus. Les données sont stockées à la fois dans Access Layer et Message Storage.
Réponse : Les données sont stockées à la fois dans Access Layer et Message Storage.
Pour le code complet et plus de détails, consultez ce [notebook Colab](https://colab.research.google.com/drive/17AbtVa5lrWrn-daF4D7hu3JYfFQBGJXy?usp=sharing).
## Conclusion
Ce tutoriel a démontré comment exploiter *Milvus* et *Friendli Serverless Endpoints* pour mettre en œuvre des requêtes RAG avancées et multi-modales. En combinant ces technologies puissantes, vous pouvez créer des applications d’IA plus sophistiquées, capables de comprendre et de traiter divers types d’informations, ce qui conduit à des réponses plus précises et tenant compte du contexte.
Continuer à lire
Announcing the General Availability of Single Sign-On (SSO) on Zilliz Cloud
SSO is GA on Zilliz Cloud, delivering the enterprise-grade identity management capabilities your teams need to deploy vectorDB with confidence.
Introducing Zilliz MCP Server: Natural Language Access to Your Vector Database
Developers can easily manage and query vector databases with natural language via Zilliz MCP Server in AI-native environments.
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.