> ## Documentation Index
> Fetch the complete documentation index at: https://docs.wandb.ai/llms.txt
> Use this file to discover all available pages before exploring further.
# Monitoring en ligne
> Configurer le monitoring en ligne des applications LLM en production avec W&B Weave pour suivre les performances et les métriques de qualité.
Il s'agit d'un notebook interactif. Vous pouvez l'exécuter localement ou utiliser les liens ci-dessous :
* [Ouvrir dans Google Colab](https://colab.research.google.com/github/wandb/docs/blob/main/weave/cookbooks/source/online_monitoring.ipynb)
* [Voir le code source sur GitHub](https://github.com/wandb/docs/blob/main/weave/cookbooks/source/online_monitoring.ipynb)
## Intégrer Weave : tableau de bord de production
Ce notebook montre comment utiliser les API et les fonctions de Weave pour créer un tableau de bord personnalisé de monitoring en production, en extension de la vue Traces dans Weave. Ce guide s’adresse aux développeurs et aux ingénieurs ML qui exécutent des applications LLM en production et souhaitent une visibilité sur mesure sur les performances, les coûts et les retours des utilisateurs, au-delà de ce que fournit la vue Traces par défaut. Ce notebook se concentre sur :
* La récupération des traces, des coûts, du feedback et d’autres métriques depuis Weave.
* La création de vues agrégées pour le feedback des utilisateurs et la répartition des coûts.
* La création de visualisations de l’utilisation des jetons et de la latence au fil du temps.
À la fin de ce notebook, vous disposerez d’un tableau de bord personnalisé opérationnel qui agrège les données de trace, les coûts et le feedback de votre projet Weave dans une seule vue. Vous pouvez essayer le tableau de bord avec votre propre projet Weave en installant `streamlit` et en exécutant le [script du tableau de bord de production](https://github.com/NiWaRe/agent-dev-collection).
## Configuration
Pour commencer, installez les packages suivants :
```python lines theme={null}
!pip install streamlit pandas plotly weave
```
## Implémentation
Les sections suivantes expliquent comment initialiser le client Weave, récupérer les données d’appel et générer des visualisations pour le tableau de bord.
### Initialiser le client Weave et définir les coûts
Commencez par configurer une fonction pour initialiser le client Weave et ajouter des coûts pour chaque modèle. Cette étape est requise pour que les requêtes de coût en aval puissent attribuer une tarification par jeton à chaque appel.
W\&B inclut les coûts standard pour de nombreux modèles et vous permet également d'ajouter vos propres coûts personnalisés ainsi que des modèles personnalisés. L'exemple suivant montre comment ajouter des coûts personnalisés pour quelques modèles et utiliser les coûts standard pour les autres.
Les coûts sont calculés à partir des jetons suivis pour chaque appel dans Weave. Pour de nombreuses bibliothèques de fournisseurs de LLM, Weave suit automatiquement l'utilisation des jetons, mais vous pouvez aussi renvoyer un nombre de jetons personnalisé pour n'importe quel appel. Pour en savoir plus sur la définition du nombre de jetons et le calcul des coûts pour un modèle personnalisé, voir le [cookbook sur les coûts personnalisés](/fr/weave/cookbooks/custom_model_cost#setting-up-a-model-with-weave).
```python lines theme={null}
PROJECT_NAME = "wandb-smle/weave-cookboook-demo"
python
import weave
MODEL_NAMES = [
# nom du modèle, coût du prompt, coût de la complétion
("gpt-4o-2024-05-13", 0.03, 0.06),
("gpt-4o-mini-2024-07-18", 0.03, 0.06),
("gemini/gemini-1.5-flash", 0.00025, 0.0005),
("gpt-4o-mini", 0.03, 0.06),
("gpt-4-turbo", 0.03, 0.06),
("claude-3-haiku-20240307", 0.01, 0.03),
("gpt-4o", 0.03, 0.06),
]
def init_weave_client(project_name):
try:
client = weave.init(project_name)
for model, prompt_cost, completion_cost in MODEL_NAMES:
client.add_cost(
llm_id=model,
prompt_token_cost=prompt_cost,
completion_token_cost=completion_cost,
)
except Exception as e:
print(f"Failed to initialize Weave client for project '{project_name}': {e}")
return None
else:
return client
client = init_weave_client(PROJECT_NAME)
```
### Récupérer les données d'appels dans Weave
Le client étant initialisé et les coûts configurés, l’étape suivante consiste à récupérer les données d’appels dans Weave. Deux options s’offrent à vous pour récupérer ces données :
* Récupérer les données appel par appel.
* Utiliser des API de haut niveau.
Les sections suivantes décrivent chaque option.
#### Récupérer les données par appel
La première option pour accéder aux données dans Weave consiste à récupérer une liste d’appels filtrés et à extraire les données souhaitées appel par appel. Pour ce faire, utilisez l’API `calls_query_stream` pour récupérer les données d’appels depuis Weave :
* API `calls_query_stream` : cette API récupère les données d’appels depuis Weave.
* dictionnaire `filter` : ce dictionnaire contient les paramètres de filtre pour récupérer les données d’appels. Voir la [référence CallSchema](/fr/weave/reference/python-sdk/trace_server/trace_server_interface#class-callschema) pour plus de détails.
* liste `expand_columns` : cette liste contient les colonnes à étendre dans les données d’appels.
* liste `sort_by` : cette liste contient les paramètres de tri des données d’appels.
* booléen `include_costs` : ce booléen indique s’il faut inclure les coûts dans les données d’appels.
* booléen `include_feedback` : ce booléen indique s’il faut inclure le feedback dans les données d’appels.
```python lines theme={null}
import itertools
from datetime import datetime, timedelta
import pandas as pd
def fetch_calls(client, project_id, start_time, trace_roots_only, limit):
filter_params = {
"project_id": project_id,
"filter": {"started_at": start_time, "trace_roots_only": trace_roots_only},
"expand_columns": ["inputs.example", "inputs.model"],
"sort_by": [{"field": "started_at", "direction": "desc"}],
"include_costs": True,
"include_feedback": True,
}
try:
calls_stream = client.server.calls_query_stream(filter_params)
calls = list(
itertools.islice(calls_stream, limit)
) # limiter le nombre d'appels à récupérer si trop nombreux
print(f"Fetched {len(calls)} calls.")
except Exception as e:
print(f"Error fetching calls: {e}")
return []
else:
return calls
calls = fetch_calls(client, PROJECT_NAME, datetime.now() - timedelta(days=1), True, 100)
python
# les données brutes sont une liste d'objets Call
pd.DataFrame([call.dict() for call in calls]).head(3)
```
Traitez les appels à partir du résultat renvoyé par Weave. Extrayez les informations pertinentes et stockez-les dans une liste de dictionnaires. Convertissez ensuite cette liste de dictionnaires en DataFrame pandas et renvoyez-la.
```python lines theme={null}
import json
from datetime import datetime
import pandas as pd
def process_calls(calls):
records = []
for call in calls:
feedback = call.summary.get("weave", {}).get("feedback", [])
thumbs_up = sum(
1
for item in feedback
if isinstance(item, dict) and item.get("payload", {}).get("emoji") == "👍"
)
thumbs_down = sum(
1
for item in feedback
if isinstance(item, dict) and item.get("payload", {}).get("emoji") == "👎"
)
latency = call.summary.get("weave", {}).get("latency_ms", 0)
records.append(
{
"Call ID": call.id,
"Trace ID": call.trace_id, # ID unique de la trace, utilisable pour la récupérer
"Display Name": call.display_name, # nom facultatif que vous pouvez définir dans l'interface utilisateur ou par programmation
"Latency (ms)": latency,
"Thumbs Up": thumbs_up,
"Thumbs Down": thumbs_down,
"Started At": pd.to_datetime(getattr(call, "started_at", datetime.min)),
"Inputs": json.dumps(call.inputs, default=str),
"Outputs": json.dumps(call.output, default=str),
}
)
return pd.DataFrame(records)
python
df_calls = process_calls(calls)
df_calls.head(3)
```
#### Utilisez des API de haut niveau
Au lieu de passer en revue chaque appel, Weave fournit aussi des API de haut niveau pour accéder directement aux coûts des modèles, au feedback et à d’autres métriques.
Par exemple, pour le coût, utilisez l’API `query_costs` pour récupérer les coûts de tous les LLM utilisés dans le projet :
```python lines theme={null}
# Utiliser l'API de coût pour obtenir les coûts
costs = client.query_costs()
df_costs = pd.DataFrame([cost.dict() for cost in costs])
df_costs["total_cost"] = (
df_costs["prompt_token_cost"] + df_costs["completion_token_cost"]
)
# afficher uniquement la première ligne pour chaque llm_id unique
df_costs
```
### Rassemblez les données d’entrée et générez des visualisations
Avec les données d’appel et les coûts disponibles sous forme de DataFrames, vous pouvez générer des visualisations à l’aide de plotly. Il s’agit d’un tableau de bord de base que vous pouvez personnaliser à votre guise. Pour un exemple plus avancé, consultez l’[exemple Streamlit du dépôt knowledge-worker-weave](https://github.com/NiWaRe/knowledge-worker-weave/blob/master/prod_dashboard.py).
```python lines theme={null}
import plotly.express as px
import plotly.graph_objects as go
def plot_feedback_pie_chart(thumbs_up, thumbs_down):
fig = go.Figure(
data=[
go.Pie(
labels=["Thumbs Up", "Thumbs Down"],
values=[thumbs_up, thumbs_down],
marker={"colors": ["#66b3ff", "#ff9999"]},
hole=0.3,
)
]
)
fig.update_traces(textinfo="percent+label", hoverinfo="label+percent")
fig.update_layout(showlegend=False, title="Feedback Summary")
return fig
def plot_model_cost_distribution(df):
fig = px.bar(
df,
x="llm_id",
y="total_cost",
color="llm_id",
title="Cost Distribution by Model",
)
fig.update_layout(xaxis_title="Model", yaxis_title="Cost (USD)")
return fig
# Voir le code source pour tous les graphiques
python
plot_feedback_pie_chart(df_calls["Thumbs Up"].sum(), df_calls["Thumbs Down"].sum())
python
plot_model_cost_distribution(df_costs)
```
## Conclusion
Ce cookbook a montré comment créer un tableau de bord de monitoring en production personnalisé à l'aide des API et des fonctions de Weave. Weave met l'accent sur des intégrations rapides afin de simplifier à la fois l'ingestion des données et leur extraction pour des processus personnalisés.
* **Entrée des données :**
* Tracing indépendant du framework avec le décorateur [`@weave-op()`](/fr/weave/quickstart#2-log-a-trace-to-a-new-project) et la possibilité d'importer des appels depuis un fichier CSV (voir le [cookbook d'import associé](/fr/weave/cookbooks/import_from_csv)).
* Points de terminaison de l'API de service pour enregistrer dans Weave depuis différents frameworks et langages de programmation. Voir la [référence de l'API de service](https://docs.wandb.ai/weave/reference/service-api/calls/call-start) pour plus de détails.
* **Sortie des données :**
* Téléchargez les données aux formats CSV, TSV, JSONL ou JSON. Voir la [référence de l'API de service](/fr/weave/reference/service-api) pour plus de détails.
* Exportez-les via un accès programmatique aux données. Voir la section « Use Python » dans le panneau d'export, comme décrit dans ce cookbook. Voir [Interroger et exporter des appels](/fr/weave/guides/tracking/tracing#querying-and-exporting-calls) pour plus de détails.
Ce tableau de bord personnalisé étend la vue Traces intégrée de Weave pour permettre un monitoring sur mesure des applications LLM en production. Pour voir un tableau de bord plus complexe, consultez l'[exemple Streamlit dans le dépôt agent-dev-collection](https://github.com/NiWaRe/agent-dev-collection), où vous pouvez ajouter l'URL de votre propre projet Weave.