> ## Documentation Index
> Fetch the complete documentation index at: https://docs.coreweave.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Interroger et exporter des appels
> Filtrez, triez et exportez les données d’appels Weave à l’aide du SDK Python, de l’API REST ou de l’interface utilisateur de Weights & Biases pour vos analyses personnalisées.
Cette page explique comment interroger et exporter des appels Weave afin d’analyser les données de trace en dehors de Weave. Vous pouvez par exemple créer des tableaux de bord personnalisés, partager des résultats avec vos collaborateurs ou effectuer des analyses hors ligne. Vous pouvez exporter des appels depuis l’interface utilisateur de Weights & Biases, les récupérer par programmation avec les SDK Python ou TypeScript, ou les interroger directement à l’aide de l’API de service.
Exporter des appels depuis l’interface Weights & Biases
Dans l’interface Weights & Biases, vous pouvez exporter vos données dans plusieurs formats. L’interface affiche également le code Python et cURL à utiliser pour exporter les lignes par programmation.
Pour exporter des appels :
1. Accédez à [Forge](https://forge.coreweave.com/wandb) et sélectionnez votre projet.
2. Dans la barre latérale du projet Weave, cliquez sur **Traces**.
3. Sélectionnez les appels à exporter en cochant les lignes correspondantes.
4. Dans la barre d’outils du tableau **Traces**, cliquez sur le bouton d’exportation ou de téléchargement.
5. Dans la fenêtre modale **Export**, choisissez **Selected rows** ou **All rows**.
6. Cliquez sur **Export**.
Récupérer des appels de manière programmatique
Pour filtrer, trier ou traiter des appels en dehors de l’interface utilisateur, récupérez-les avec l’un des SDK Weave ou l’API de service. Choisissez l’interface la mieux adaptée à votre flux de travail.
Pour récupérer des appels à l’aide de l’API Python, utilisez la méthode [`client.get_calls`](/fr/products/wandb/weave/reference/python-sdk/trace/weave_client#method-get_calls) :
```python lines theme={"system"}
import weave
# Initialiser le client
client = weave.init("your-project-name")
# Récupérer les appels
calls = client.get_calls(filter=...)
```
Pour récupérer des appels à l’aide de l’API TypeScript, utilisez la méthode [`client.getCalls`](/fr/products/wandb/weave/reference/typescript-sdk/interfaces/weaveclient#getcalls) :
```typescript lines theme={"system"}
import * as weave from 'weave'
// Initialiser le client
const client = await weave.init('intro-example')
// Récupérer les appels
const calls = await client.getCalls(filter=...)
```
L’API de service expose l’intégralité de la couche de requête. Pour récupérer des appels à l’aide de l’API de service, envoyez une requête au point de terminaison [`/calls/stream_query`](/fr/products/wandb/weave/reference/service-api/calls/calls-query-stream) :
```bash theme={"system"}
curl -L 'https://trace.wandb.ai/calls/stream_query' \
-H 'Content-Type: application/json' \
-H 'Accept: application/json' \
-d '{
"project_id": "string",
"filter": {
"op_names": [
"string"
],
"input_refs": [
"string"
],
"output_refs": [
"string"
],
"parent_ids": [
"string"
],
"trace_ids": [
"string"
],
"call_ids": [
"string"
],
"trace_roots_only": true,
"wb_user_ids": [
"string"
],
"wb_run_ids": [
"string"
]
},
"limit": 100,
"offset": 0,
"sort_by": [
{
"field": "string",
"direction": "asc"
}
],
"query": {
"$expr": {}
},
"include_costs": true,
"include_feedback": true,
"columns": [
"string"
],
"expand_columns": [
"string"
]
}'
```
Pour tout savoir sur les propriétés et les champs des appels, consultez la [référence du schéma des appels](/fr/products/wandb/weave/guides/tracking/call-schema-reference).
Exporter les métriques d’appel
Lorsque vous avez besoin d’informations agrégées, comme les tendances de coût ou de latence, plutôt que des enregistrements d’appels sous-jacents, utilisez le point de terminaison de métriques décrit dans cette section.
Vous pouvez également utiliser le [point de terminaison POST `/calls/stats`](/fr/products/wandb/weave/reference/service-api/calls/call-stats) de l’API de service Weave pour récupérer des métriques sur vos appels sans récupérer les données des appels elles-mêmes. Vous pouvez obtenir des informations sur vos appels, comme la latence et le coût, et les agréger par somme, moyenne, minimum, maximum et nombre. Par exemple, vous pouvez récupérer :
* L’utilisation totale des jetons
* La latence moyenne
* Le nombre maximum de jetons utilisés
* Le coût total
* Le nombre minimum de jetons en entrée
Le point de terminaison propose plusieurs options de filtrage pour cibler les appels effectués sur une période donnée ou selon d’autres propriétés, telles que :
* Le nom de l’op
* L’ID de trace
* L’ID de thread
* L’ID utilisateur
L’exemple suivant montre comment récupérer les appels générés par un op nommé `web_app` sur deux jours. Remplacez `[YOUR-TEAM-NAME/YOUR-PROJECT-NAME]` par les noms de votre équipe et de votre projet :
```python Python lines {10-11,16-24} theme={"system"}
import requests
import json
import os
url = "https://trace.wandb.ai/calls/stats"
payload = {
"project_id": "[YOUR-TEAM-NAME/YOUR-PROJECT-NAME]",
"start": "2026-03-01T00:00:00Z",
# Spécifier la taille des buckets, en secondes.
"granularity": 86400,
"filter": {
"trace_roots_only": True,
"op_names": ["web_app"]
},
# Spécifier les métriques et leur fonction d'agrégation
"usage_metrics": [
{"metric": "total_tokens", "aggregations": ["sum"]},
{"metric": "total_cost", "aggregations": ["sum"]}
],
"call_metrics": [
{"metric": "call_count", "aggregations": ["sum"]},
{"metric": "error_count", "aggregations": ["sum"]},
{"metric": "latency_ms", "aggregations": ["avg", "min", "max"], "percentiles": [50, 95, 99]}
]
}
API_KEY = os.getenv("WANDB_API_KEY")
response = requests.post(url, json=payload, auth=("api", API_KEY))
print(json.dumps(response.json(), indent=2))
```
```typescript TypeScript lines {6-7,13-20} theme={"system"}
const url = "https://trace.wandb.ai/calls/stats";
const payload = {
project_id: "[YOUR-TEAM-NAME/YOUR-PROJECT-NAME]",
start: "2026-03-01T00:00:00Z",
// Spécifier la taille des buckets, en secondes.
granularity: 86400,
filter: {
trace_roots_only: true,
op_names: ["web_app"],
},
// Spécifier les métriques et leur fonction d'agrégation
usage_metrics: [
{ metric: "total_tokens", aggregations: ["sum"] },
{ metric: "total_cost", aggregations: ["sum"] },
],
call_metrics: [
{ metric: "call_count", aggregations: ["sum"] },
{ metric: "error_count", aggregations: ["sum"] },
{ metric: "latency_ms", aggregations: ["avg", "min", "max"], percentiles: [50, 95, 99] },
],
};
const API_KEY = process.env.WANDB_API_KEY!;
const response = await fetch(url, {
method: "POST",
headers: {
"Content-Type": "application/json",
Authorization: "Basic " + btoa(`api:${API_KEY}`),
},
body: JSON.stringify(payload),
});
const data = await response.json();
console.log(JSON.stringify(data, null, 2));
```
La requête indique également comment agréger les métriques. Vous pouvez agréger les métriques par `sum`, `count`, `avg`, `min`, `max` et `count`.
Le point de terminaison renvoie un objet JSON. L’exemple de réponse suivant présente deux jours de métriques. Chaque jour (bucket) correspond à un objet distinct dans les tableaux `usage_buckets` et `call_buckets`. Chaque tableau ventile les métriques différemment :
* `usage_buckets` : regroupe les métriques d’appel de chaque jour par modèle utilisé.
* `call_buckets` : regroupe les métriques d’appel de chaque jour, quel que soit le modèle utilisé.
Définissez le champ granularity (en secondes) dans la requête pour modifier la taille des buckets.
```json lines theme={"system"}
{
"start": "2026-03-03T00:00:00Z",
"end": "2026-03-04T21:34:39.746539Z",
"granularity": 86400,
"timezone": "UTC",
"usage_buckets": [
{
"timestamp": "2026-03-03T00:00:00",
"model": "gpt-4o-2024-08-06",
"sum_total_tokens": 498.0,
"sum_input_tokens": 219.0,
"sum_output_tokens": 279.0,
"count": 5,
"sum_total_cost": 0.0033374999156876584
},
{
"timestamp": "2026-03-03T00:00:00",
"model": "gpt-5-2025-08-07",
"sum_total_tokens": 0.0,
"sum_input_tokens": 0.0,
"sum_output_tokens": 0.0,
"count": 0,
"sum_total_cost": 0.0
},
{
"timestamp": "2026-03-04T00:00:00",
"model": "gpt-4o-2024-08-06",
"sum_total_tokens": 58.0,
"sum_input_tokens": 27.0,
"sum_output_tokens": 31.0,
"count": 1,
"sum_total_cost": 0.0003774999904635479
},
{
"timestamp": "2026-03-04T00:00:00",
"model": "gpt-5-2025-08-07",
"sum_total_tokens": 427.0,
"sum_input_tokens": 26.0,
"sum_output_tokens": 401.0,
"count": 1,
"sum_total_cost": 0.00404249989787786
}
],
"call_buckets": [
{
"timestamp": "2026-03-03T00:00:00",
"sum_call_count": 6,
"sum_error_count": 1,
"avg_latency_ms": 1505.6666666666667,
"min_latency_ms": 525,
"max_latency_ms": 2524,
"p50_latency_ms": 1534.0,
"p95_latency_ms": 2328.5,
"p99_latency_ms": 2484.9000000000005,
"count": 6
},
{
"timestamp": "2026-03-04T00:00:00",
"sum_call_count": 2,
"sum_error_count": 0,
"avg_latency_ms": 3645.0,
"min_latency_ms": 1739,
"max_latency_ms": 5551,
"p50_latency_ms": 3645.0,
"p95_latency_ms": 5360.4,
"p99_latency_ms": 5512.88,
"count": 2
}
]
}
```
Vous pouvez interroger les métriques sur une période maximale de 31 jours. Pour en savoir plus sur les options disponibles, consultez la [référence de l’API de service](/fr/products/wandb/weave/reference/service-api/calls/call-stats).