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