Intégrations
Arize Phoenix and Zilliz Cloud Integration

Arize Phoenix and Zilliz Cloud Integration

Arize Phoenix and Zilliz Cloud integrate to evaluate and optimize RAG pipelines, combining Phoenix's open-source evaluation and observability framework for hallucination detection, QA accuracy, and LLM tracing with Zilliz Cloud's high-performance vector database for scalable retrieval in production AI systems.

Utilisez cette intégration gratuitement

Qu’est-ce qu’Arize Phoenix
Arize Phoenix est un outil open source pour évaluer les pipelines de génération augmentée par récupération (RAG). Il fournit des métriques et des insights mesurant la qualité de la récupération et la précision des réponses, en se concentrant sur l’évaluation des hallucinations (déterminer si le contenu est factuel ou hallucinatoire) et l’évaluation QA (évaluer la précision des réponses du modèle). Phoenix fournit également un traçage compatible OTEL pour les applications LLM, capturant la latence des applications, l’utilisation des tokens, les exceptions d’exécution et l’analyse des documents récupérés à travers des frameworks tels que LangChain, LlamaIndex et OpenAI.

En s’intégrant à Zilliz Cloud (Milvus entièrement géré), Arize Phoenix permet une évaluation complète des pipelines RAG construits sur des bases de données vectorielles évolutives, aidant les équipes à identifier les requêtes très performantes, à reconnaître les axes d’amélioration et à comprendre comment les modifications du système de récupération affectent les performances globales grâce à une analyse fondée sur les données.
Avantages de l’intégration Arize Phoenix + Zilliz Cloud
- Détection des hallucinations : Phoenix évalue si les réponses des LLM sont ancrées dans le contexte récupéré depuis Zilliz Cloud, en identifiant le contenu factuel par rapport au contenu hallucinatoire avec des explications détaillées.
- Évaluation de la précision des QA : Phoenix mesure la précision des réponses du modèle par rapport à la vérité terrain, permettant aux équipes de quantifier les performances de leur pipeline RAG soutenu par Zilliz Cloud.
- Traçage LLM de bout en bout : Le traçage compatible OTEL de Phoenix capture l’ensemble du flux de requête — de la génération d’embeddings à la récupération Zilliz Cloud jusqu’à la réponse du LLM — fournissant des informations sur la latence, l’utilisation des tokens et les exceptions d’exécution.
- Optimisation axée sur les données : La combinaison des métriques de récupération de Zilliz Cloud et des informations d’évaluation de Phoenix permet aux équipes d’améliorer de manière itérative leurs pipelines RAG avec des données de performance quantifiées.
Fonctionnement de l’intégration
Arize Phoenix sert de couche d’évaluation et d’observabilité, évaluant la qualité des sorties du pipeline RAG au moyen d’évaluateurs d’hallucinations et de QA alimentés par des juges LLM. Il fournit également un traçage qui capture l’intégralité du cycle de vie des requêtes pour l’analyse des performances et le débogage.

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 de similarité rapide. Il gère l’étape de récupération — trouver le contexte le plus pertinent pour les requêtes des utilisateurs — que Phoenix évalue ensuite en termes de qualité.

Ensemble, Arize Phoenix et Zilliz Cloud créent un workflow 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 de similarité vectorielle, un LLM génère des réponses, et Phoenix évalue l’ensemble du pipeline — détectant les hallucinations, mesurant l’exactitude des réponses et traçant les performances sur tous les composants.

Guide étape par étape

1. Installer les packages requis

$ pip install --upgrade pymilvus openai requests tqdm pandas "arize-phoenix>=4.29.0" nest_asyncio

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-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 obtenir les résultats

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

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

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 cela utilise automatiquement Milvus Lite pour stocker toutes les données dans ce fichier. Si vous disposez de données à grande échelle, 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 préparez les questions avec la vérité terrain :

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)

Collectez les résultats du pipeline RAG pour l’évaluation :

from datasets import Dataset
import pandas as pd

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. Lancez Phoenix et exécutez les évaluations

Démarrez le serveur Phoenix et instrumentez OpenAI :

import phoenix as px
from phoenix.trace.openai import OpenAIInstrumentor

session = px.launch_app()

OpenAIInstrumentor().instrument()

Exécutez les évaluateurs d’hallucination et de QA :

import nest_asyncio
from phoenix.evals import HallucinationEvaluator, OpenAIModel, QAEvaluator, run_evals

nest_asyncio.apply()

eval_model = OpenAIModel(model="gpt-4o")

hallucination_evaluator = HallucinationEvaluator(eval_model)
qa_evaluator = QAEvaluator(eval_model)

df["context"] = df["contexts"]
df["reference"] = df["contexts"]
df.rename(columns={"question": "input", "answer": "output"}, inplace=True)

hallucination_eval_df, qa_eval_df = run_evals(
    dataframe=df,
    evaluators=[hallucination_evaluator, qa_evaluator],
    provide_explanation=True,
)

6. Affichez les résultats de l’évaluation

results_df = df.copy()
results_df["hallucination_eval"] = hallucination_eval_df["label"]
results_df["hallucination_explanation"] = hallucination_eval_df["explanation"]
results_df["qa_eval"] = qa_eval_df["label"]
results_df["qa_explanation"] = qa_eval_df["explanation"]
results_df.head()

En savoir plus
- Évaluation avec Arize Phoenix — Tutoriel officiel de Milvus pour l’évaluation RAG avec Phoenix
- The Path to Production: LLM Application Evaluations and Observability — Blog de Zilliz sur l’évaluation et l’observabilité des LLM
- Top 10 RAG & LLM Evaluation Tools for AI Success — Tutoriel de Zilliz sur les outils d’évaluation RAG
- Documentation d’Arize Phoenix — Documentation officielle de Phoenix
- Dépôt GitHub d’Arize Phoenix — Code source de Phoenix et ressources communautaires

Arize Phoenix and Zilliz Cloud Integration

Qu’est-ce qu’Arize Phoenix

Avantages de l’intégration Arize Phoenix + Zilliz Cloud

Fonctionnement de l’intégration

Guide étape par étape

En savoir plus

Ressources connexes

Le chemin vers la production : évaluations et observabilité des applications LLM

Top 10 des outils d’évaluation RAG et LLM pour réussir dans l’IA

Surveillance et observabilité améliorées dans Zilliz Cloud