Intégrations
DeepEval and Zilliz Cloud Integration

DeepEval and Zilliz Cloud Integration

DeepEval and Zilliz Cloud integrate to test and evaluate RAG pipeline performance, combining DeepEval's evaluation framework with metrics for contextual precision, recall, relevancy, faithfulness, and answer relevancy alongside Zilliz Cloud's high-performance vector database for scalable retrieval in production RAG systems.

Utilisez cette intégration gratuitement

Qu’est-ce que DeepEval
DeepEval est un framework d’évaluation conçu pour tester les pipelines de génération augmentée par récupération (RAG). Il aide les développeurs à évaluer et à quantifier les performances des pipelines grâce à des métriques complètes couvrant à la fois la qualité de la récupération (précision contextuelle, rappel et pertinence) et la qualité de la génération (pertinence et fidélité des réponses). DeepEval permet aux développeurs d’identifier les problèmes, de garantir des normes de qualité et d’améliorer de manière itérative leurs systèmes RAG.

En s’intégrant à Zilliz Cloud (Milvus entièrement géré), DeepEval fournit une boîte à outils complète pour créer et tester des systèmes RAG de production, en mesurant la pertinence et l’exactitude des résultats de récupération issus de la recherche vectorielle de Zilliz Cloud et en évaluant la fidélité et la pertinence des réponses générées par les LLM.
Avantages de l’intégration DeepEval + Zilliz Cloud
- Évaluation complète de la récupération : DeepEval mesure la précision contextuelle, le rappel et la pertinence des documents récupérés depuis Zilliz Cloud, fournissant des informations détaillées sur la capacité de la recherche vectorielle à faire remonter les informations pertinentes.
- Évaluation de la qualité de la génération : DeepEval évalue la pertinence des réponses et la fidélité des réponses des LLM, garantissant que les sorties sont à la fois pertinentes par rapport à la question et factuellement ancrées dans le contexte récupéré depuis Zilliz Cloud.
- Tests automatisés avec des juges LLM : DeepEval utilise une évaluation basée sur des LLM (par exemple, GPT-4o) pour noter et expliquer automatiquement la qualité de la récupération et de la génération, réduisant ainsi l’effort d’évaluation manuelle.
- Tests prêts pour la production : Cette combinaison offre aux développeurs une boîte à outils complète pour créer et tester des systèmes RAG de production, l’infrastructure gérée de Zilliz Cloud réduisant la complexité opérationnelle tandis que DeepEval garantit le respect des standards de qualité.
Fonctionnement de l’intégration
DeepEval sert de cadre d’évaluation, fournissant des métriques et des cas de test pour évaluer la qualité du pipeline RAG. Il évalue le récupérateur au moyen de métriques de précision contextuelle, de rappel et de pertinence, et évalue le générateur au moyen de métriques de pertinence et de fidélité des réponses — le tout en utilisant des juges basés sur des LLM pour une notation et des explications automatisées.

Zilliz Cloud sert de couche de base de données vectorielle dans le pipeline RAG évalué, stockant et 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 — dont DeepEval évalue ensuite la qualité.

Ensemble, DeepEval et Zilliz Cloud créent un flux de travail complet de développement et d’évaluation RAG : les documents sont convertis en embeddings 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, et DeepEval évalue l’ensemble du pipeline — en mesurant la qualité du classement de la récupération, la pertinence contextuelle, l’exactitude des réponses et la fidélité factuelle.

Guide étape par étape

1. Installer les packages requis

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

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 vectoriel 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-4o-mini",
    ):
        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("demo"))
        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, charger les données et collecter les résultats

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 cela utilise automatiquement Milvus Lite pour stocker toutes les données dans ce fichier. Si vous disposez d’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.

Téléchargez et chargez les données, puis collectez les résultats RAG :

import urllib.request
import pandas as pd

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)

question_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?",
]
ground_truth_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.",
]
contexts_list = []
answer_list = []
for question in tqdm(question_list, desc="Answering questions"):
    answer, contexts = my_rag.answer(question, return_retrieved_text=True)
    contexts_list.append(contexts)
    answer_list.append(answer)

df = pd.DataFrame(
    {
        "question": question_list,
        "contexts": contexts_list,
        "answer": answer_list,
        "ground_truth": ground_truth_list,
    }
)

5. Évaluer le récupérateur avec DeepEval

Évaluez la qualité de la récupération à l’aide des métriques de précision contextuelle, de rappel et de pertinence :

from deepeval.metrics import (
    ContextualPrecisionMetric,
    ContextualRecallMetric,
    ContextualRelevancyMetric,
)
from deepeval.test_case import LLMTestCase
from deepeval import evaluate

contextual_precision = ContextualPrecisionMetric()
contextual_recall = ContextualRecallMetric()
contextual_relevancy = ContextualRelevancyMetric()

test_cases = []

for index, row in df.iterrows():
    test_case = LLMTestCase(
        input=row["question"],
        actual_output=row["answer"],
        expected_output=row["ground_truth"],
        retrieval_context=row["contexts"],
    )
    test_cases.append(test_case)

result = evaluate(
    test_cases=test_cases,
    metrics=[contextual_precision, contextual_recall, contextual_relevancy],
    print_results=False,
)

6. Évaluer la génération avec DeepEval

Évaluez la qualité de la génération à l’aide des métriques de pertinence de la réponse et de fidélité :

from deepeval.metrics import AnswerRelevancyMetric, FaithfulnessMetric

answer_relevancy = AnswerRelevancyMetric()
faithfulness = FaithfulnessMetric()

test_cases = []

for index, row in df.iterrows():
    test_case = LLMTestCase(
        input=row["question"],
        actual_output=row["answer"],
        expected_output=row["ground_truth"],
        retrieval_context=row["contexts"],
    )
    test_cases.append(test_case)

result = evaluate(
    test_cases=test_cases,
    metrics=[answer_relevancy, faithfulness],
    print_results=False,
)

En savoir plus
- Évaluation avec DeepEval — Tutoriel officiel de Milvus pour l’évaluation RAG avec DeepEval
- Évaluer RAG : tout ce que vous devez savoir — Blog de Zilliz sur les bonnes pratiques d’évaluation 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 DeepEval — Documentation officielle de DeepEval
- Dépôt GitHub de DeepEval — Code source de DeepEval et ressources communautaires

DeepEval and Zilliz Cloud Integration

Qu’est-ce que DeepEval

Avantages de l’intégration DeepEval + Zilliz Cloud

Fonctionnement de l’intégration

Guide étape par étape

En savoir plus

Ressources connexes

Évaluer le RAG : tout ce que vous devez savoir

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

Évaluation RAG avec Ragas