Intégrations
BentoML and Zilliz Cloud Integration

BentoML and Zilliz Cloud Integration

BentoML and Zilliz Cloud integrate to build end-to-end AI applications, combining BentoML's open-source AI inference platform for serving and deploying machine learning models with Zilliz Cloud's high-performance vector database for scalable embedding storage and retrieval in RAG systems.

Utilisez cette intégration gratuitement

Qu’est-ce que BentoML
BentoML est une plateforme d’inférence IA open-source pour servir et déployer des modèles de machine learning. Elle fait le lien entre le développement et les opérations en rationalisant le déploiement en production, en encapsulant les modèles, les dépendances et la logique d’inférence dans des unités standardisées appelées « Bentos ». La plateforme offre un service d’API haute performance prenant en charge les protocoles HTTP, gRPC et CLI, avec un déploiement vers des conteneurs Docker, Kubernetes et des plateformes cloud. BentoCloud, son service managé, fournit des modèles préconstruits, notamment Llama 3, Stable Diffusion, CLIP et Sentence Transformers, avec un déploiement en un clic.

En s’intégrant à Zilliz Cloud (Milvus entièrement managé), BentoML permet aux développeurs de convertir des données non structurées en embeddings vectoriels à l’aide de modèles servis et de les stocker dans une base de données vectorielle évolutive pour une récupération efficace, alimentant des applications RAG de bout en bout, la recherche sémantique et les systèmes de recommandation avec une charge d’infrastructure minimale.
Avantages de l’intégration BentoML + Zilliz Cloud
- Déploiement de modèles en un clic avec stockage évolutif : BentoCloud offre un déploiement instantané de modèles d’embeddings et de LLM à la pointe de la technologie, tandis que Zilliz Cloud gère le stockage et la récupération de vecteurs à grande échelle.
- Accès à des modèles avancés : BentoCloud offre une disponibilité immédiate de modèles d’IA de pointe comme Llama 3 et Sentence Transformers sans exigences d’entraînement, avec des embeddings stockés et recherchés efficacement dans Zilliz Cloud.
- Charge d’infrastructure réduite : Les deux services managés minimisent les frais de configuration et de maintenance, permettant aux équipes de se concentrer sur la création d’applications d’IA plutôt que sur la gestion de l’infrastructure.
- Options de déploiement flexibles : BentoML prend en charge l’auto-hébergement via son framework open source aux côtés du service managé de BentoCloud, avec Zilliz Cloud fournissant la couche de base de données vectorielle dans l’un ou l’autre modèle de déploiement.
- Service de modèles standardisé : BentoML standardise le déploiement de modèles à travers les frameworks de ML (PyTorch, TensorFlow, scikit-learn), tandis que Zilliz Cloud fournit une interface de stockage vectoriel cohérente quel que soit le framework de modèle utilisé.
Fonctionnement de l’intégration
BentoML sert de plateforme d’inférence IA, hébergeant et servant des modèles d’embedding et des LLM via BentoCloud ou des déploiements auto-hébergés. Il gère le service de modèles via des endpoints HTTP, permettant aux applications de générer des embeddings à partir de données textuelles à l’aide de modèles comme Sentence Transformers et de générer des réponses LLM à l’aide de modèles comme Llama 3.

Zilliz Cloud sert de couche de base de données vectorielle, stockant et indexant les embeddings générés par les modèles servis par BentoML. Il fournit une recherche de similarité haute performance avec une faible latence, permettant une récupération efficace du contexte le plus pertinent à partir de grandes collections.

Ensemble, BentoML et Zilliz Cloud créent une solution RAG complète : BentoML sert des modèles d’embedding qui convertissent les données textuelles en vecteurs, lesquels sont stockés dans Zilliz Cloud. Lorsqu’un utilisateur pose une question, BentoML intègre la requête, Zilliz Cloud récupère les documents les plus pertinents grâce à la recherche de similarité, et le service LLM de BentoML génère une réponse contextuellement informée basée sur le contexte récupéré.

Guide étape par étape

1. Installer les packages requis

$ pip install -U pymilvus bentoml

2. Servir les embeddings avec BentoML/BentoCloud

Importez bentoml et configurez un client HTTP à l’aide de SyncHTTPClient en spécifiant l’endpoint et, éventuellement, le token :

import bentoml

BENTO_EMBEDDING_MODEL_END_POINT = "BENTO_EMBEDDING_MODEL_END_POINT"
BENTO_API_TOKEN = "BENTO_API_TOKEN"

embedding_client = bentoml.SyncHTTPClient(
    BENTO_EMBEDDING_MODEL_END_POINT, token=BENTO_API_TOKEN
)

3. Préparer et traiter les données

Lisez les fichiers et prétraitez le texte, puis téléchargez les données des villes :

def chunk_text(filename: str) -> list:
    with open(filename, "r") as f:
        text = f.read()
    sentences = text.split("\n")
    return sentences

import os
import requests
import urllib.request

repo = "ytang07/bento_octo_milvus_RAG"
directory = "data"
save_dir = "./city_data"
api_url = f"https://api.github.com/repos/{repo}/contents/{directory}"

response = requests.get(api_url)
data = response.json()

if not os.path.exists(save_dir):
    os.makedirs(save_dir)

for item in data:
    if item["type"] == "file":
        file_url = item["download_url"]
        file_path = os.path.join(save_dir, item["name"])
        urllib.request.urlretrieve(file_url, file_path)

Traitez chaque fichier et générez des embeddings :

cities = os.listdir("city_data")
city_chunks = []
for city in cities:
    chunked = chunk_text(f"city_data/{city}")
    cleaned = []
    for chunk in chunked:
        if len(chunk) > 7:
            cleaned.append(chunk)
    mapped = {"city_name": city.split(".")[0], "chunks": cleaned}
    city_chunks.append(mapped)

def get_embeddings(texts: list) -> list:
    if len(texts) > 25:
        splits = [texts[x : x + 25] for x in range(0, len(texts), 25)]
        embeddings = []
        for split in splits:
            embedding_split = embedding_client.encode(sentences=split)
            embeddings += embedding_split
        return embeddings
    return embedding_client.encode(
        sentences=texts,
    )

entries = []
for city_dict in city_chunks:
    embedding_list = get_embeddings(city_dict["chunks"])
    for i, embedding in enumerate(embedding_list):
        entry = {
            "embedding": embedding,
            "sentence": city_dict["chunks"][i],
            "city": city_dict["city_name"],
        }
        entries.append(entry)

4. Insérer les données dans Milvus

Initialisez un client Milvus Lite, créez une collection avec un schéma et un index, puis insérez les données :

from pymilvus import MilvusClient, DataType

COLLECTION_NAME = "Bento_Milvus_RAG"
DIMENSION = 384

milvus_client = MilvusClient("milvus_demo.db")

schema = MilvusClient.create_schema(
    auto_id=True,
    enable_dynamic_field=True,
)
schema.add_field(field_name="id", datatype=DataType.INT64, is_primary=True)
schema.add_field(field_name="embedding", datatype=DataType.FLOAT_VECTOR, dim=DIMENSION)

index_params = milvus_client.prepare_index_params()
index_params.add_index(
    field_name="embedding",
    index_type="AUTOINDEX",
    metric_type="COSINE",
)

if milvus_client.has_collection(collection_name=COLLECTION_NAME):
    milvus_client.drop_collection(collection_name=COLLECTION_NAME)
milvus_client.create_collection(
    collection_name=COLLECTION_NAME, schema=schema, index_params=index_params
)

milvus_client.insert(collection_name=COLLECTION_NAME, data=entries)

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 mettre en place 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.

5. Configurer le LLM et construire le RAG

Déployez un LLM sur BentoCloud et configurez la fonction RAG :

BENTO_LLM_END_POINT = "BENTO_LLM_END_POINT"

llm_client = bentoml.SyncHTTPClient(BENTO_LLM_END_POINT, token=BENTO_API_TOKEN)

def dorag(question: str, context: str):
    prompt = (
        f"You are a helpful assistant. The user has a question. Answer the user question based only on the context: {context}. \n"
        f"The user question is {question}"
    )

    results = llm_client.generate(
        max_tokens=1024,
        prompt=prompt,
    )

    res = ""
    for result in results:
        res += result

    return res

6. Poser une question avec RAG

Recherchez dans Milvus le contexte pertinent et générez une réponse :

question = "What state is Cambridge in?"

def ask_a_question(question):
    embeddings = get_embeddings([question])
    res = milvus_client.search(
        collection_name=COLLECTION_NAME,
        data=embeddings,
        anns_field="embedding",
        limit=5,
        output_fields=["sentence"],
    )

    sentences = []
    for hits in res:
        for hit in hits:
            sentences.append(hit["entity"]["sentence"])
    context = ". ".join(sentences)
    return context

context = ask_a_question(question=question)
print(dorag(question=question, context=context))

En savoir plus
- Génération augmentée par récupération (RAG) avec Milvus et BentoML — Tutoriel officiel de Milvus pour créer un RAG avec BentoML
- RAG sans OpenAI : BentoML, OctoAI et Milvus — Blog de Zilliz sur la création d’un RAG sans OpenAI
- Défis d’infrastructure dans le passage à l’échelle du RAG avec des modèles d’IA personnalisés — Blog de Zilliz sur le passage à l’échelle du RAG avec BentoML et Milvus
- Documentation BentoML — Documentation officielle de BentoML
- Documentation BentoCloud — Documentation du service géré BentoCloud

BentoML and Zilliz Cloud Integration

Qu’est-ce que BentoML

Avantages de l’intégration BentoML + Zilliz Cloud

Fonctionnement de l’intégration

Guide étape par étape

En savoir plus

Ressources connexes

RAG sans OpenAI : BentoML, OctoAI et Milvus

Défis d’infrastructure liés à la mise à l’échelle du RAG avec des modèles d’IA personnalisés

Guide de l’auto-hébergement de systèmes LLM