Intégrations
vLLM and Zilliz Cloud Integration

vLLM and Zilliz Cloud Integration

vLLM and Zilliz Cloud integrate to build high-performance Retrieval-Augmented Generation systems, combining vLLM's optimized LLM inference with PagedAttention and up to 24x throughput improvement alongside Zilliz Cloud's scalable vector database for efficient context retrieval.

Utiliser cette intégration gratuitement

Qu’est-ce que vLLM
vLLM est une bibliothèque open source lancée à l’UC Berkeley SkyLab, désormais un projet en phase d’incubation au sein de la LF AI & Data Foundation, axée sur l’optimisation des performances de service des LLM. Elle utilise une gestion efficace de la mémoire avec PagedAttention, le traitement par lots continu et des noyaux CUDA optimisés afin d’améliorer les performances de service jusqu’à 24 fois tout en réduisant de moitié l’utilisation de la mémoire GPU par rapport aux méthodes traditionnelles comme HuggingFace Transformers et Text Generation Inference.

En s’intégrant à Zilliz Cloud (Milvus entièrement géré), l’inférence LLM à haut débit de vLLM est associée à une base de données vectorielle évolutive pour une récupération efficace du contexte pertinent, permettant aux développeurs de créer des systèmes RAG de niveau production qui ancrent les réponses des LLM dans des données effectivement récupérées afin d’atténuer les hallucinations de l’IA.
Avantages de l’intégration vLLM + Zilliz Cloud
- Inférence RAG à haut débit : PagedAttention de vLLM offre un débit jusqu’à 24 fois supérieur pour l’inférence des LLM, tandis que Zilliz Cloud fournit une récupération vectorielle rapide, créant un pipeline RAG haute performance de bout en bout.
- Utilisation efficace de la mémoire GPU : vLLM réduit l’utilisation de la mémoire GPU d’environ 50 % grâce à la gestion de la mémoire virtuelle pour le cache KV, permettant de consacrer davantage de ressources à la gestion de bases de connaissances plus volumineuses stockées dans Zilliz Cloud.
- Réponses ancrées avec hallucinations réduites : Zilliz Cloud récupère le contexte pertinent depuis de grandes bases de connaissances, et vLLM génère des réponses ancrées dans ces données récupérées, atténuant les hallucinations de l’IA.
- Flexibilité open source : vLLM et Milvus sont tous deux des projets open source sous l’égide de la LF AI & Data Foundation, donnant aux développeurs un contrôle total sur leur infrastructure RAG, avec des options gérées disponibles via Zilliz Cloud.
Fonctionnement de l’intégration
vLLM sert de moteur d’inférence LLM, fournissant un service optimisé pour les grands modèles de langage comme Llama 3.1-8B de Meta. Il utilise PagedAttention pour une gestion efficace de la mémoire, le traitement par lots continu pour un débit élevé, et des noyaux CUDA optimisés pour une génération rapide de réponses contextuellement informées.

Zilliz Cloud sert de couche de base de données vectorielle, stockant et indexant les embeddings de documents pour une recherche de similarité rapide. Lorsque les requêtes des utilisateurs arrivent, il récupère les segments de texte les plus pertinents de la base de connaissances afin de fournir du contexte au LLM.

Ensemble, vLLM et Zilliz Cloud créent une solution RAG complète : les documents sont segmentés, convertis en embeddings à l’aide de modèles comme BAAI/bge-large-en-v1.5, puis stockés dans Zilliz Cloud. Lorsqu’un utilisateur pose une question, la requête est convertie en embedding et Zilliz Cloud récupère le contexte pertinent au moyen d’une recherche de similarité. Ce contexte est ensuite transmis à vLLM, qui sert le LLM pour générer des réponses précises et fondées, enrichies par le texte récupéré.

Guide étape par étape

1. Installer les packages requis

$ pip install -U pymilvus

# (Recommended) Create a new conda environment.
conda create -n myenv python=3.11 -y
conda activate myenv

# Install vLLM with CUDA 12.1.
pip install -U vllm transformers torch

2. Préparer votre jeu de données

Utilisez la documentation officielle de Milvus comme jeu de données et chargez les fichiers HTML :

from langchain.document_loaders import DirectoryLoader

path = "../../RAG/rtdocs_new/"
global_pattern = '*.html'
loader = DirectoryLoader(path=path, glob=global_pattern)
docs = loader.load()

print(f"loaded {len(docs)} documents")

3. Télécharger un modèle d'embedding

Téléchargez un modèle d'embedding gratuit et open source depuis HuggingFace :

import torch
from sentence_transformers import SentenceTransformer

N_GPU = torch.cuda.device_count()
DEVICE = torch.device('cuda:N_GPU' if torch.cuda.is_available() else 'cpu')

model_name = "BAAI/bge-large-en-v1.5"
encoder = SentenceTransformer(model_name, device=DEVICE)

EMBEDDING_DIM = encoder.get_sentence_embedding_dimension()
MAX_SEQ_LENGTH_IN_TOKENS = encoder.get_max_seq_length()

4. Découper et encoder vos données sous forme de vecteurs

Utilisez une longueur fixe de 512 caractères avec un chevauchement de 10 % :

from langchain.text_splitter import RecursiveCharacterTextSplitter
import numpy as np

CHUNK_SIZE = 512
chunk_overlap = np.round(CHUNK_SIZE * 0.10, 0)

child_splitter = RecursiveCharacterTextSplitter(
   chunk_size=CHUNK_SIZE,
   chunk_overlap=chunk_overlap)

chunks = child_splitter.split_documents(docs)

list_of_strings = [doc.page_content for doc in chunks if hasattr(doc, 'page_content')]

embeddings = torch.tensor(encoder.encode(list_of_strings))
embeddings = np.array(embeddings / np.linalg.norm(embeddings))
converted_values = list(map(np.float32, embeddings))

dict_list = []
for chunk, vector in zip(chunks, converted_values):
   chunk_dict = {
       'chunk': chunk.page_content,
       'source': chunk.metadata.get('source', ""),
       'vector': vector,
   }
   dict_list.append(chunk_dict)

5. Enregistrer les vecteurs dans Milvus

Ingérez les embeddings vectoriels encodés dans la base de données vectorielle Milvus :

from pymilvus import MilvusClient

mc = MilvusClient("milvus_demo.db")

COLLECTION_NAME = "MilvusDocs"
mc.create_collection(COLLECTION_NAME,
       EMBEDDING_DIM,
       consistency_level="Eventually",
       auto_id=True, 
       overwrite=True)

mc.insert(
   COLLECTION_NAME,
   data=dict_list,
   progress_bar=True)

Concernant l'argument de MilvusClient : 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. Si vous avez un grand volume de données, vous pouvez configurer un serveur Milvus plus performant sur Docker ou Kubernetes. Si vous souhaitez utiliser Zilliz Cloud, le service cloud entièrement géré pour Milvus, ajustez l'uri et le token, qui correspondent au Public Endpoint et à l'API Key dans Zilliz Cloud.

6. Effectuer une recherche vectorielle

Posez une question et recherchez les chunks voisins les plus proches :

import torch.nn.functional as F

SAMPLE_QUESTION = "What do the parameters for HNSW mean?"

query_embeddings = torch.tensor(encoder.encode(SAMPLE_QUESTION))
query_embeddings = F.normalize(query_embeddings, p=2, dim=1)
query_embeddings = list(map(np.float32, query_embeddings))

OUTPUT_FIELDS = list(dict_list[0].keys())
OUTPUT_FIELDS.remove('vector')

TOP_K = 2

results = mc.search(
    COLLECTION_NAME,
    data=query_embeddings,
    output_fields=OUTPUT_FIELDS,
    limit=TOP_K,
    consistency_level="Eventually")

7. Exécuter la génération RAG avec vLLM et Llama 3.1

Instanciez une instance de modèle vLLM et générez des réponses augmentées par le texte récupéré :

from vllm import LLM, SamplingParams

MODELTORUN = "meta-llama/Meta-Llama-3.1-8B-Instruct"

torch.cuda.empty_cache()

llm = LLM(model=MODELTORUN,
         enforce_eager=True,
         dtype=torch.bfloat16,
         gpu_memory_utilization=0.5,
         max_model_len=1000,
         seed=415,
         max_num_batched_tokens=3000)

Rédigez un prompt en utilisant les contextes et les sources récupérés depuis Milvus :

contexts_combined = ' '.join(reversed(contexts))
source_combined = ' '.join(reversed(list(dict.fromkeys(sources))))

SYSTEM_PROMPT = f"""First, check if the provided Context is relevant to
the user's question.  Second, only if the provided Context is strongly relevant, answer the question using the Context.  Otherwise, if the Context is not strongly relevant, answer the question without using the Context. 
Be clear, concise, relevant.  Answer clearly, in fewer than 2 sentences.
Grounding sources: {source_combined}
Context: {contexts_combined}
User's question: {SAMPLE_QUESTION}
"""

prompts = [SYSTEM_PROMPT]

sampling_params = SamplingParams(temperature=0.2, top_p=0.95)

outputs = llm.generate(prompts, sampling_params)

for output in outputs:
   generated_text = output.outputs[0].text
   print(f"Question: {SAMPLE_QUESTION!r}")
   print(f"Generated text: {generated_text!r}")

En savoir plus
- Créer un RAG avec Milvus, vLLM et Llama 3.1 — Tutoriel officiel de Milvus pour créer un RAG avec vLLM
- Créer un RAG avec Milvus, vLLM et Llama 3.1 de Meta — Blog de Zilliz sur la création d’un RAG avec vLLM
- Déployer un système RAG multimodal avec vLLM et Milvus — Blog de Zilliz sur le RAG multimodal avec vLLM
- Créer des applications RAG avec Milvus, Qwen et vLLM — Blog de Zilliz sur le RAG avec Qwen et vLLM
- Documentation vLLM — Documentation officielle de vLLM

vLLM and Zilliz Cloud Integration

Qu’est-ce que vLLM

Avantages de l’intégration vLLM + Zilliz Cloud

Fonctionnement de l’intégration

Guide étape par étape

En savoir plus

Ressources connexes

Créer un RAG avec Milvus, vLLM et Llama 3.1 de Meta

Déploiement d’un système RAG multimodal avec vLLM et Milvus

Créer des applications RAG avec Milvus, Qwen et vLLM