Arize Phoenix enregistre le déroulement de chaque appel dans une application construite sur un modèle de langage : le prompt, la réponse, les outils invoqués, les morceaux de documents récupérés, les temps et les tokens consommés. En plus de cela, il ajoute un ensemble d'évaluateurs qui notent la qualité des réponses sans intervention humaine.
Le problème qu'il résout apparaît dès le premier retour d'utilisateur. Quelqu'un écrit que le système a donné une information fausse, et tu as une phrase et aucun moyen de reconstituer ce qui s'est passé. Sur trois étapes avec des outils et de la recherche de documents, deviner ne fonctionne plus.
La licence, la chose à vérifier en premier
L'outil est décrit comme open source, et c'est une simplification qui mérite d'être détaillée avant de l'inscrire dans un produit.
Le code est public et tu peux le faire tourner toi-même gratuitement, mais la licence est Elastic License 2.0 et non une licence approuvée comme ouverte selon les définitions admises. La différence pratique se résume à une interdiction : tu ne peux pas proposer ce logiciel à d'autres comme un service managé.
Pour la plupart des équipes, cela ne change rien. Tu l'exécutes sur ton propre serveur, tu observes ta propre application, et c'est tout. Cela commence à compter quand tu construis une plateforme dans laquelle tes clients recevraient une console d'observabilité dans le cadre de ton offre. C'est précisément le cas que la licence exclut.
Règle la question dès le départ, car remplacer une couche d'observabilité après un an de travail coûte cher, et une discussion avec le service juridique après la signature d'un contrat client peut coûter plus cher encore.
Installation et premier lancement
pip install arize-phoenix
phoenix serveTu peux aussi l'exécuter sans rien installer durablement :
uvx arize-phoenix serveLes versions sortent plusieurs fois par semaine, donc le numéro de version avance plus vite que n'importe quel texte ne peut le suivre : à la mi-août 2026, il en était à 19.21. Python de 3.10 à 3.14 est requis. L'interface démarre en local et accepte des données immédiatement, donc tu vois les premières traces quelques minutes après l'installation.
Pour un déploiement permanent, il existe des images de conteneur et des charts pour l'exécuter dans un cluster, ainsi que des boutons de déploiement en un clic pour plusieurs fournisseurs cloud. Le choix dépend de la nécessité que les données restent chez toi : l'exécution en local ou dans ta propre infrastructure règle cette exigence sans négociation.
L'instrumentation via OpenTelemetry
C'est le plus grand avantage de l'outil et il vaut la peine d'être compris, car il concerne une décision qui dure des années.
La collecte de données repose sur OpenTelemetry, le standard utilisé bien au-delà du monde des modèles de langage, étendu par une description de concepts propres à ce domaine : le prompt, la réponse, l'appel d'outil, le document récupéré.
La conséquence est pratique. Tu instrumentes l'application une seule fois, puis tu peux changer l'outil qui reçoit les traces sans toucher au code, puisqu'ils parlent le même langage. Cela distingue cette approche des bibliothèques avec leur propre format fermé, où changer de fournisseur oblige à repasser par tous les points d'appel.
from phoenix.otel import register
from openinference.instrumentation.langchain import LangChainInstrumentor
register(project_name="assistant")
LangChainInstrumentor().instrument()Des instrumentations prêtes à l'emploi couvrent des bibliothèques populaires, dont LangChain, LlamaIndex et Haystack, ainsi que les appels directs aux grands fournisseurs de modèles. Avec ton propre code, tu ajoutes les spans à la main, ce qui, sur des fonctions bien découpées, demande une douzaine de lignes.
Parmi ces trois, la dernière donne la trace la plus lisible, car l'application y est un graphe de composants aux entrées et sorties déclarées, donc l'arbre de spans correspond au schéma du pipeline plutôt qu'à un emboîtement accidentel de fonctions. Avec ton propre code, tu dois le mériter toi-même, en nommant les spans de façon à ce qu'ils restent lisibles six mois plus tard.
Décide d'avance ce qui entre dans les traces. Par défaut, le texte complet des prompts et des réponses est enregistré, donc si des données personnelles y transitent, les traces deviennent un lieu de plus qui demande une politique de rétention et un contrôle d'accès.
Les évaluateurs, ou noter sans humain
Le tracing dit ce qui s'est passé. L'évaluation dit si c'était bien, et c'est la seconde moitié de l'outil.
Les évaluateurs intégrés couvrent l'ancrage des réponses dans les sources fournies, la pertinence des morceaux récupérés, la détection de contenu inventé, la mesure de toxicité et des critères que tu écris toi-même. Chacun d'eux est en pratique un prompt envoyé à un modèle juge, avec un format de réponse défini.
Les trois premiers recoupent ce que TruLens appelle la triade RAG : la pertinence des morceaux récupérés, l'ancrage de la réponse dans ceux-ci et la pertinence de la réponse elle-même. Tu te tournes vers cette bibliothèque quand ce qui compte le plus, ce sont des mesures pour la récupération de documents et une licence MIT sans interdiction de revente en tant que service, et le prix à payer est une interface bien plus simple que celle-ci.
Cela soulève la question qui revient toujours, et à raison : si un modèle fait le jugement, qui juge le juge ? La réponse, c'est toi, sur un ensemble d'exemples étiquetés à la main. Une centaine de cas avec étiquettes manuelles suffit pour vérifier à quelle fréquence l'évaluateur est d'accord avec une personne, et c'est le seul moyen de savoir ce que valent ses résultats.
Les prompts des évaluateurs sont visibles et modifiables, ce qui distingue cet outil d'un scoring fermé qui renvoie un nombre sans justification. Dans un domaine qui s'écarte du général, le juridique ou le médical par exemple, cette capacité est décisive, car un évaluateur généraliste se trompera systématiquement.
L'évaluation s'exécute sur un ensemble de traces enregistrées, donc un cycle typique ressemble à ceci : collecter le trafic de production pendant une semaine, choisir quelques centaines de cas, lancer les évaluateurs, inspecter les pires résultats. Cette dernière étape est la plus importante et la plus souvent sautée, car c'est là que tu vois ce qui casse réellement dans l'application.
Expériences et versionnement des prompts
La troisième couche concerne les changements que tu fais délibérément.
Les datasets sont des ensembles d'entrées avec un résultat attendu, stockés et versionnés. Une expérience consiste à exécuter l'application sur un tel ensemble et à comparer les résultats avec une exécution précédente.
La valeur se voit au moment de modifier un prompt système. Sans jeu de test, modifier un prompt est un pas dans le noir : tu corriges un cas, tu en casses trois autres, et tu l'apprends par les retours. Avec un jeu, tu vois les deux chiffres avant le déploiement.
Les prompts peuvent être stockés dans l'outil lui-même, avec l'historique des versions, ce qui est pratique, mais il vaut la peine de se demander si tu le veux. Un prompt fait partie du comportement de l'application, donc le garder dans le dépôt avec le code donne une revue des changements, un lien avec le déploiement et un retour arrière en une étape. Un endroit séparé avec son propre historique est plus commode pour les personnes non techniques et moins bon pour la cohérence du déploiement.
Ce qu'une trace montre réellement
Il vaut la peine de savoir quoi chercher, car un premier coup d'œil à un arbre d'appels peut submerger, alors que la plupart des réponses se trouvent à trois endroits.
Le premier est la répartition du temps. Une trace montre séparément combien de temps chaque étape a pris, et cela démolit généralement l'hypothèse de l'équipe sur ce qui est lent. Dans les applications qui cherchent dans des documents, le modèle est souvent l'élément le plus rapide, le temps étant consommé par la requête à la base vectorielle, le calcul de l'embedding de la requête et des appels d'outils séquentiels qui auraient pu s'exécuter en parallèle.
Le deuxième est celui des morceaux récupérés. Face à une réponse qui contredit les faits, la première question est de savoir si le bon morceau est arrivé dans le contexte. Si non, le problème se situe dans la récupération et aucun changement de prompt ne le corrigera. Si oui et que le modèle a quand même répondu autre chose, le problème se situe dans le prompt ou dans le modèle. Cette distinction retourne complètement le travail, et sans trace tu ne peux pas la faire.
Le troisième est celui des arguments d'appel d'outil. Un agent qui a appelé la bonne fonction avec de mauvais arguments renvoie une réponse qui paraît sensée et qui est entièrement fausse. Tu ne le vois que dans l'enregistrement de l'appel, car la réponse elle-même ne porte aucune trace de ce qui est parti vers l'outil.
Le quatrième, moins souvent utilisé, est la consommation de tokens détaillée par étape. Avec un agent qui fait plusieurs tours, le total est souvent plusieurs fois supérieur à ce que la longueur de la conversation laisse penser, car chaque tour transporte tout le contexte accumulé. C'est là que les économies sont les plus faciles à trouver.
Des traces aux corrections
Collecter des données est facile ; en tirer des conclusions demande une routine que personne n'imposera à ta place.
Un cycle raisonnable ressemble à ceci. Une fois par semaine, tu prends les vingt conversations les moins bien notées, tu les lis et tu leur attribues une cause : mauvaise récupération, mauvais prompt, outil manquant, erreur de données. Au bout de quatre semaines, tu as une distribution des causes et tu sais où travailler, au lieu de corriger ce qui t'a sauté aux yeux.
La deuxième routine concerne les changements. Chaque modification d'un prompt système ou des paramètres de récupération devrait passer par le même jeu de test, avec l'avant et l'après consignés. Sans cela, une équipe six mois plus tard ne peut pas dire si les choses se sont améliorées depuis le début, car chacun ne se souvient que du dernier changement.
La troisième concerne les cas limites. Une conversation qui s'est mal passée et qui a été corrigée a sa place dans le jeu de test comme cas. C'est le moyen le moins coûteux de construire un jeu qui reflète la réalité, car les exemples viennent des utilisateurs plutôt que de l'imagination de l'équipe.
Enregistre aussi la note que donnent les utilisateurs, si l'interface en collecte une. Un pouce vers le bas lié à une trace donne une étiquette qu'aucun évaluateur ne remplace, et après quelques centaines de tels cas tu as de la matière pour vérifier à quel point les scores automatiques correspondent à ce que les gens ont ressenti.
Phoenix face aux alternatives
| Option | Mode d'exécution | Licence | À choisir quand |
|---|---|---|---|
| Arize Phoenix | En local ou dans ta propre infrastructure | Elastic License 2.0 | Les données doivent rester chez toi |
| Langfuse | En local ou dans le cloud de l'éditeur | Ouverte avec des extensions payantes | Tu veux choisir entre les deux |
| LangSmith | Service de l'éditeur | Fermée | Tu travailles dans l'écosystème LangChain |
| Tes propres logs et dashboards | Ton infrastructure | La tienne | Tu as déjà une observabilité mature |
La dernière ligne mérite un examen honnête et est souvent sautée. Si l'équipe exploite déjà un système fonctionnel de collecte de traces et de dashboards, y ajouter quelques attributs décrivant les appels au modèle coûte moins cher que d'introduire un autre outil avec une interface séparée et un entretien séparé. Tu perds les évaluateurs prêts à l'emploi et tu gagnes un seul endroit au lieu de deux.
La différence entre les trois premières lignes tient surtout à l'endroit où se trouvent les données et à la licence qui te lie. Leurs capacités de tracing sont comparables, et celui qui mène sur une fonctionnalité précise change d'un trimestre à l'autre.
Le déploiement en pratique
Quelques points font gagner du temps si l'outil doit rester au-delà d'une semaine d'exploration.
Commence en local. L'exécuter sur ta propre machine et y pointer l'environnement de développement prend quinze minutes et montre tout de suite si les traces contiennent ce dont tu as besoin. C'est seulement ensuite qu'une discussion sur un déploiement permanent a du sens.
Définis la rétention tôt. Les traces qui contiennent le texte complet des prompts grossissent plus vite qu'on ne le suppose, en particulier dans les applications qui cherchent dans des documents, où chaque requête traîne plusieurs morceaux de texte derrière elle. Sans politique de suppression, la base grossit linéairement pour toujours.
Sépare les projets par environnement. Des traces de développement mélangées à celles de la production ruinent toutes les statistiques, car les expériences ressemblent à des erreurs d'utilisateurs.
Le dernier point est une habitude. Un outil d'observabilité que personne n'ouvre est un coût sans retour. Une revue hebdomadaire où quelqu'un inspecte les dix conversations les moins bien notées apporte plus que le plus riche ensemble de graphiques.
Erreurs courantes
La première est de traiter la licence comme ouverte. Elastic License 2.0 interdit de proposer ce logiciel à d'autres comme un service managé, donc un projet d'intégrer la console dans une offre client doit être vérifié avant de commencer le travail.
La deuxième est de faire confiance aux évaluateurs sans vérification. Un score émis par un modèle peut se tromper de façon systématique, et sans jeu étiqueté à la main tu ne sais pas à quelle fréquence.
La troisième est d'enregistrer le contenu complet sans politique de rétention. Les traces deviennent alors une copie des données de production, avec les mêmes exigences mais sans la même protection.
La quatrième est d'instrumenter seulement l'appel au modèle. Les plus grands retards et les erreurs les plus fréquentes se situent généralement dans la récupération de documents et les appels d'outils plutôt que dans le modèle lui-même.
La cinquième est de mélanger les environnements dans un seul projet. Les statistiques perdent tout sens dès que la moitié des traces vient des tests.
La sixième est de collecter des données sans revue régulière. Si personne n'inspecte régulièrement les pires cas, tout le déploiement devient une archive.
FAQ
Arize Phoenix est-il gratuit ?
Pour l'exécuter toi-même, oui, sans frais et sans fonctionnalités verrouillées. La licence, cependant, est Elastic License 2.0 plutôt qu'une licence ouverte au sens admis, et elle interdit de proposer ce logiciel à d'autres comme un service managé.
Les données quittent-elles mon infrastructure ?
En exécution locale ou dans ton propre conteneur, non, et c'est la principale raison de choisir cet outil. Il existe aussi une variante hébergée par l'éditeur, où les traces arrivent sur ses serveurs.
En quoi diffère-t-il de Langfuse et de LangSmith ?
Principalement par la licence et par l'endroit où se trouvent les données. Langfuse offre le choix entre l'auto-hébergement et le cloud de l'éditeur, LangSmith est un service fermé lié à l'écosystème LangChain, et Phoenix s'appuie sur l'auto-hébergement avec une instrumentation basée sur OpenTelemetry.
Dois-je utiliser LangChain pour que cela fonctionne ?
Non. Des instrumentations prêtes à l'emploi couvrent des bibliothèques populaires, mais la collecte de données repose sur OpenTelemetry, donc ton propre code qui appelle directement un modèle peut aussi être décrit, en ajoutant des spans manuellement.
Peut-on faire confiance aux évaluateurs ?
Seulement après vérification sur tes propres données. Un évaluateur est un prompt envoyé à un modèle juge, donc ses résultats doivent être comparés à des étiquettes manuelles sur quelques centaines de cas avant que quiconque ne décide quoi que ce soit à partir d'un graphique.
La documentation se trouve sur le site du projet, et les versions et le code dans le dépôt GitHub.