Intégrations
Arm and Zilliz Cloud Integration

Arm and Zilliz Cloud Integration

Arm and Zilliz Cloud integrate to build cost-effective RAG applications on Arm-based infrastructure, combining Arm's energy-efficient processor architecture with Zilliz Cloud's high-performance vector database for optimized vector search workloads on Arm servers and cloud instances.

Utilisez cette intégration gratuitement

Qu’est-ce qu’Arm
Arm conçoit des architectures de processeurs qui alimentent des milliards d’appareils dans le monde entier. Leurs conceptions écoénergétiques prennent de plus en plus en charge les centres de données et le cloud computing, offrant de solides performances en IA et en apprentissage automatique. Les processeurs Arm de classe serveur, tels qu’AWS Graviton, offrent des alternatives économiques aux architectures x86 traditionnelles, avec une adoption croissante par les fournisseurs de cloud et les entreprises pour l’exécution de charges de travail ML.

En s’intégrant à Zilliz Cloud (Milvus entièrement géré), l’infrastructure basée sur Arm permet aux organisations d’exécuter efficacement des charges de travail de recherche vectorielle et de RAG avec des performances optimisées et des économies de coûts grâce à l’efficacité énergétique d’Arm, tandis que Zilliz Cloud gère le stockage vectoriel, l’indexation et la recherche de similarité nativement sur l’architecture Arm.
Avantages de l’intégration Arm + Zilliz Cloud
- Infrastructure d’IA rentable : Les processeurs économes en énergie d’Arm offrent de solides performances d’IA à moindre coût par rapport aux architectures x86 traditionnelles, et Zilliz Cloud s’exécute nativement sur Arm, maximisant les économies pour les charges de travail de recherche vectorielle.
- Prise en charge native de l’architecture Arm : Zilliz Cloud prend en charge nativement l’architecture Arm, permettant un déploiement fluide sur des serveurs et instances cloud basés sur Arm comme AWS Graviton, sans problèmes de compatibilité.
- Performances de recherche vectorielle optimisées : La plateforme gère automatiquement l’allocation des ressources et optimise les performances des requêtes spécifiquement pour les processeurs Arm, garantissant des opérations efficaces de recherche de similarité vectorielle.
- Inférence LLM locale sur CPU Arm : L’intégration prend en charge l’exécution de LLM comme Llama 3.1 directement sur des CPU basés sur Arm à l’aide de llama.cpp avec des modèles quantifiés, permettant des pipelines RAG complets sans exigences de GPU.
Fonctionnement de l’intégration
Arm fournit l’architecture de processeur et la couche d’infrastructure, alimentant les serveurs et les instances cloud comme AWS Graviton qui exécutent à la fois la base de données vectorielle et les charges de travail d’inférence LLM. Les CPU Arm prennent en charge l’exécution efficace des modèles d’embeddings et des LLM quantifiés grâce à des optimisations comme SVE 256 et MATMUL_INT8.

Zilliz Cloud sert de couche de base de données vectorielle s’exécutant nativement sur l’architecture Arm, stockant et indexant les embeddings de documents pour une recherche rapide par similarité. Il fournit une récupération haute performance à faible latence sur une infrastructure basée sur Arm, permettant des applications RAG efficaces.

Ensemble, Arm et Zilliz Cloud créent une plateforme RAG de bout en bout rentable : les documents sont convertis en embeddings à l’aide de modèles s’exécutant sur des CPU Arm, stockés dans la base de données vectorielle de Zilliz Cloud déployée sur une infrastructure Arm, et lorsque les utilisateurs interrogent le système, le contexte pertinent est récupéré par recherche de similarité vectorielle et transmis à un LLM servi par llama.cpp sur Arm — le tout s’exécutant efficacement sur des processeurs Arm économes en énergie.

Guide étape par étape

1. Configurer l’environnement basé sur Arm

Nous recommandons d’utiliser des instances AWS Graviton (par exemple, c7g.2xlarge avec Ubuntu 22.04 LTS). Vous avez besoin d’au moins quatre cœurs, 8 Go de RAM et 32 Go de stockage disque.

Installez Python et créez un environnement virtuel :

$ sudo apt update
$ sudo apt install python-is-python3 python3-pip python3-venv -y
$ python -m venv venv
$ source venv/bin/activate

Installez les dépendances Python requises :

$ pip install --upgrade pymilvus openai requests langchain-huggingface huggingface_hub tqdm

2. Créer la collection sur Zilliz Cloud

Définissez uri et token comme le point de terminaison public et la clé API dans Zilliz Cloud :

from pymilvus import MilvusClient

milvus_client = MilvusClient(
    uri="<your_zilliz_public_endpoint>", token="<your_zilliz_api_key>"
)

collection_name = "my_rag_collection"

if milvus_client.has_collection(collection_name):
    milvus_client.drop_collection(collection_name)

milvus_client.create_collection(
    collection_name=collection_name,
    dimension=384,
    metric_type="IP",
    consistency_level="Strong",
)

3. Préparer les données et insérer les embeddings

Téléchargez la documentation FAQ de Milvus et chargez-la :

$ wget https://github.com/milvus-io/milvus-docs/releases/download/v2.4.6-preview/milvus_docs_2.4.x_en.zip
$ unzip -q milvus_docs_2.4.x_en.zip -d milvus_docs

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("# ")

Préparez le modèle d’embedding et insérez les données :

from langchain_huggingface import HuggingFaceEmbeddings
from tqdm import tqdm

embedding_model = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")

data = []
text_embeddings = embedding_model.embed_documents(text_lines)

for i, (line, embedding) in enumerate(
    tqdm(zip(text_lines, text_embeddings), desc="Creating embeddings")
):
    data.append({"id": i, "vector": embedding, "text": line})

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

4. Compiler et lancer llama.cpp sur Arm

Installez les outils de compilation, clonez et compilez llama.cpp :

$ sudo apt install make cmake -y
$ sudo apt install gcc g++ -y
$ sudo apt install build-essential -y

$ git clone https://github.com/ggerganov/llama.cpp
$ cd llama.cpp
$ make GGML_NO_LLAMAFILE=1 -j$(nproc)

Téléchargez et requantifiez le modèle pour des performances optimales sur Arm :

$ huggingface-cli download cognitivecomputations/dolphin-2.9.4-llama3.1-8b-gguf dolphin-2.9.4-llama3.1-8b-Q4_0.gguf --local-dir . --local-dir-use-symlinks False

$ ./llama-quantize --allow-requantize dolphin-2.9.4-llama3.1-8b-Q4_0.gguf dolphin-2.9.4-llama3.1-8b-Q4_0_8_8.gguf Q4_0_8_8

Cette requantification est optimale spécifiquement pour Graviton3. Pour Graviton2, utilisez le format Q4_0_4_4, et pour Graviton4, utilisez le format Q4_0_4_8.

Démarrez le serveur LLM :

$ ./llama-server -m dolphin-2.9.4-llama3.1-8b-Q4_0_8_8.gguf -n 2048 -t 64 -c 65536 --port 8080

5. Effectuer une requête RAG

Initialisez le client LLM, recherchez le contexte pertinent et générez une réponse :

from openai import OpenAI

llm_client = OpenAI(base_url="http://localhost:8080/v1", api_key="no-key")

question = "How is data stored in milvus?"

search_res = milvus_client.search(
    collection_name=collection_name,
    data=[embedding_model.embed_query(question)],
    limit=3,
    search_params={"metric_type": "IP", "params": {}},
    output_fields=["text"],
)

retrieved_lines_with_distances = [
    (res["entity"]["text"], res["distance"]) for res in search_res[0]
]

context = "\n".join(
    [line_with_distance[0] for line_with_distance in retrieved_lines_with_distances]
)

SYSTEM_PROMPT = """
Human: Vous êtes un assistant IA. Vous êtes capable de trouver les réponses aux questions à partir des extraits de passages contextuels fournis.
"""
USER_PROMPT = f"""
Utilisez les éléments d'information suivants encadrés par des balises <context> pour fournir une réponse à la question encadrée par des balises <question>.
<context>
{context}
</context>
<question>
{question}
</question>
"""

response = llm_client.chat.completions.create(
    model="not-used",
    messages=[
        {"role": "system", "content": SYSTEM_PROMPT},
        {"role": "user", "content": USER_PROMPT},
    ],
)
print(response.choices[0].message.content)

En savoir plus
- Créer un RAG sur l’architecture Arm — Tutoriel officiel de Milvus pour créer un RAG sur Arm
- Parcours d’apprentissage Arm : serveurs et cloud computing avec Milvus — Parcours d’apprentissage officiel d’Arm pour Milvus
- Créer un RAG avec Milvus, vLLM et Llama 3.1 de Meta — Blog de Zilliz sur la création d’un RAG avec Llama 3.1
- Dépôt GitHub llama.cpp — Code source de llama.cpp pour l’inférence LLM
- Documentation d’installation de Milvus — Guide d’installation de Milvus incluant la prise en charge d’Arm

Arm and Zilliz Cloud Integration

Qu’est-ce qu’Arm

Avantages de l’intégration Arm + 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

Comment créer un RAG avec Milvus Lite, Llama3 et LlamaIndex