Intégrations
Ragas and Zilliz Cloud Integration

Ragas and Zilliz Cloud Integration

Ragas and Zilliz Cloud integrate to evaluate and optimize RAG pipelines, combining Ragas' automated evaluation framework for measuring faithfulness, answer relevance, and context precision with Zilliz Cloud's high-performance vector database for scalable retrieval in production RAG systems.

Utilisez cette intégration gratuitement

Qu’est-ce que Ragas
Ragas est un framework conçu pour évaluer les pipelines de génération augmentée par récupération (RAG). Bien que les outils et frameworks existants aident à créer des pipelines RAG, évaluer et quantifier les performances d’un pipeline peut être difficile — c’est là que Ragas (RAG Assessment) intervient. Il fournit des outils d’évaluation axés sur des métriques incluant la fidélité, la pertinence des réponses, le rappel du contexte et la précision du contexte, et prend en charge la génération de jeux de données de test synthétiques, la surveillance en production et les intégrations avec des plateformes comme LangChain, LlamaIndex et Milvus.

En s’intégrant à Zilliz Cloud (Milvus entièrement géré), Ragas permet une évaluation complète des performances des pipelines RAG construits sur des bases de données vectorielles à grande échelle, permettant aux développeurs d’évaluer la qualité de la récupération et la précision de la génération des réponses à l’échelle de la production, d’identifier des problèmes comme les hallucinations dans les réponses, et d’améliorer itérativement leurs applications.
Avantages de l’intégration Ragas + Zilliz Cloud
- Évaluation RAG complète à grande échelle : Zilliz Cloud gère des vecteurs à l’échelle du milliard pour les applications d’entreprise, et Ragas permet une évaluation complète des performances sur ces grands ensembles de données, en maintenant l’efficacité de l’évaluation à mesure que les données évoluent.
- Évaluation multi-métrique : Ragas fournit des métriques pour la fidélité, la pertinence des réponses, le rappel du contexte et la précision du contexte, offrant aux développeurs une vue d’ensemble des performances de leur pipeline RAG lorsqu’ils utilisent Zilliz Cloud comme magasin de vecteurs.
- Cycle de développement rationalisé : L’intégration permet aux développeurs d’évaluer les performances au fil du temps avec un minimum de code, d’identifier les hallucinations dans les réponses et les lacunes de récupération, et d’améliorer itérativement leurs applications RAG.
- Surveillance en production : Ragas prend en charge la surveillance de la qualité du pipeline RAG dans les environnements de production, garantissant que la récupération depuis Zilliz Cloud et la génération par LLM maintiennent des normes élevées au fil du temps.
Fonctionnement de l’intégration
Ragas sert de cadre d’évaluation, en évaluant la qualité des sorties du pipeline RAG selon plusieurs dimensions. Il évalue la précision et le rappel des informations contextuelles récupérées depuis la base de données vectorielle, et mesure la fidélité et la pertinence des réponses générées par le LLM, en calculant un score pondéré pour mesurer la qualité globale de la réponse.

Zilliz Cloud sert de couche de base de données vectorielle dans le pipeline RAG évalué, en stockant et en indexant les embeddings de documents pour une recherche rapide par similarité. Il gère l’étape de récupération — trouver le contexte le plus pertinent pour les requêtes des utilisateurs — que Ragas évalue ensuite en termes de précision et de rappel.

Ensemble, Ragas et Zilliz Cloud créent un workflow complet de développement et d’évaluation RAG : les documents sont embedded et stockés dans Zilliz Cloud, les requêtes des utilisateurs récupèrent le contexte pertinent grâce à la recherche par similarité vectorielle, un LLM génère des réponses basées sur le contexte récupéré, et Ragas évalue l’ensemble du pipeline — en mesurant à quel point le contexte récupéré est précis et complet, et à quel point les réponses générées sont fidèles et pertinentes.

Guide étape par étape

1. Installer les packages requis

$ pip install --upgrade pymilvus openai requests tqdm pandas ragas

2. Configurer la clé API OpenAI

import os

os.environ["OPENAI_API_KEY"] = "sk-***********"

3. Définir la classe RAG

Définissez la classe RAG qui utilise Milvus comme magasin de vecteurs et OpenAI comme LLM :

from typing import List
from tqdm import tqdm
from openai import OpenAI
from pymilvus import MilvusClient

class RAG:
    """
    RAG (Retrieval-Augmented Generation) class built upon OpenAI and Milvus.
    """

    def __init__(self, openai_client: OpenAI, milvus_client: MilvusClient):
        self._prepare_openai(openai_client)
        self._prepare_milvus(milvus_client)

    def _emb_text(self, text: str) -> List[float]:
        return (
            self.openai_client.embeddings.create(input=text, model=self.embedding_model)
            .data[0]
            .embedding
        )

    def _prepare_openai(
        self,
        openai_client: OpenAI,
        embedding_model: str = "text-embedding-3-small",
        llm_model: str = "gpt-3.5-turbo",
    ):
        self.openai_client = openai_client
        self.embedding_model = embedding_model
        self.llm_model = llm_model
        self.SYSTEM_PROMPT = """
Human: You are an AI assistant. You are able to find answers to the questions from the contextual passage snippets provided.
"""
        self.USER_PROMPT = """
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>
"""

    def _prepare_milvus(
        self, milvus_client: MilvusClient, collection_name: str = "rag_collection"
    ):
        self.milvus_client = milvus_client
        self.collection_name = collection_name
        if self.milvus_client.has_collection(self.collection_name):
            self.milvus_client.drop_collection(self.collection_name)
        embedding_dim = len(self._emb_text("foo"))
        self.milvus_client.create_collection(
            collection_name=self.collection_name,
            dimension=embedding_dim,
            metric_type="IP",
            consistency_level="Strong",
        )

    def load(self, texts: List[str]):
        data = []
        for i, line in enumerate(tqdm(texts, desc="Creating embeddings")):
            data.append({"id": i, "vector": self._emb_text(line), "text": line})
        self.milvus_client.insert(collection_name=self.collection_name, data=data)

    def retrieve(self, question: str, top_k: int = 3) -> List[str]:
        search_res = self.milvus_client.search(
            collection_name=self.collection_name,
            data=[self._emb_text(question)],
            limit=top_k,
            search_params={"metric_type": "IP", "params": {}},
            output_fields=["text"],
        )
        retrieved_texts = [res["entity"]["text"] for res in search_res[0]]
        return retrieved_texts[:top_k]

    def answer(
        self,
        question: str,
        retrieval_top_k: int = 3,
        return_retrieved_text: bool = False,
    ):
        retrieved_texts = self.retrieve(question, top_k=retrieval_top_k)
        user_prompt = self.USER_PROMPT.format(
            context="\n".join(retrieved_texts), question=question
        )
        response = self.openai_client.chat.completions.create(
            model=self.llm_model,
            messages=[
                {"role": "system", "content": self.SYSTEM_PROMPT},
                {"role": "user", "content": user_prompt},
            ],
        )
        if not return_retrieved_text:
            return response.choices[0].message.content
        else:
            return response.choices[0].message.content, retrieved_texts

4. Initialiser le pipeline RAG et charger les données

Initialisez RAG avec les clients OpenAI et Milvus, téléchargez et chargez les données :

openai_client = OpenAI()
milvus_client = MilvusClient(uri="./milvus_demo.db")

my_rag = RAG(openai_client=openai_client, milvus_client=milvus_client)

Quant à 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.

import urllib.request

url = "https://raw.githubusercontent.com/milvus-io/milvus/master/DEVELOPMENT.md"
file_path = "./Milvus_DEVELOPMENT.md"

if not os.path.exists(file_path):
    urllib.request.urlretrieve(url, file_path)
with open(file_path, "r") as file:
    file_text = file.read()

text_lines = file_text.split("# ")
my_rag.load(text_lines)

5. Préparer les questions, obtenir les réponses et collecter les résultats

Préparez des questions avec les réponses de référence et collectez les résultats du pipeline RAG :

from ragas import EvaluationDataset
import pandas as pd

user_input_list = [
    "what is the hardware requirements specification if I want to build Milvus and run from source code?",
    "What is the programming language used to write Knowhere?",
    "What should be ensured before running code coverage?",
]
reference_list = [
    "If you want to build Milvus and run from source code, the recommended hardware requirements specification is:\n\n- 8GB of RAM\n- 50GB of free disk space.",
    "The programming language used to write Knowhere is C++.",
    "Before running code coverage, you should make sure that your code changes are covered by unit tests.",
]
retrieved_contexts_list = []
response_list = []

for user_input in tqdm(user_input_list, desc="Answering questions"):
    response, retrieved_context = my_rag.answer(user_input, return_retrieved_text=True)
    retrieved_contexts_list.append(retrieved_context)
    response_list.append(response)

df = pd.DataFrame(
    {
        "user_input": user_input_list,
        "retrieved_contexts": retrieved_contexts_list,
        "response": response_list,
        "reference": reference_list,
    }
)
rag_results = EvaluationDataset.from_pandas(df)

6. Évaluer avec Ragas

Utilisez Ragas pour évaluer le pipeline RAG avec plusieurs métriques :

from ragas import evaluate
from ragas.metrics import AnswerRelevancy, Faithfulness, ContextRecall, ContextPrecision

from ragas.llms import LangchainLLMWrapper
from langchain_openai import ChatOpenAI

llm = ChatOpenAI(model="gpt-4o-mini")
evaluator_llm = LangchainLLMWrapper(llm)

results = evaluate(
    dataset=rag_results,
    metrics=[
        AnswerRelevancy(llm=evaluator_llm),
        Faithfulness(llm=evaluator_llm),
        ContextRecall(llm=evaluator_llm),
        ContextPrecision(llm=evaluator_llm),
    ],
)
results

En savoir plus
- Évaluation avec Ragas — Tutoriel officiel de Milvus pour l’évaluation de RAG avec Ragas
- Évaluation de RAG avec Ragas — Blog de Zilliz sur les métriques et la mise en œuvre de l’évaluation de RAG
- Comment évaluer les applications de génération augmentée par récupération (RAG) — Blog de Zilliz sur l’évaluation des applications RAG
- Documentation de Ragas — Documentation officielle de Ragas
- RAGAS : Évaluation automatisée de la génération augmentée par récupération — Article académique de Ragas

Ragas and Zilliz Cloud Integration

Qu’est-ce que Ragas

Avantages de l’intégration Ragas + Zilliz Cloud

Fonctionnement de l’intégration

Guide étape par étape

En savoir plus

Ressources connexes

Évaluation RAG avec Ragas

Comment évaluer les applications de génération augmentée par récupération (RAG)

Développement de RAG piloté par les métriques