Interroger et exporter des appels

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 :

Accédez à Forge et sélectionnez votre projet.
Dans la barre latérale du projet Weave, cliquez sur Traces.
Sélectionnez les appels à exporter en cochant les lignes correspondantes.
Dans la barre d’outils du tableau Traces, cliquez sur le bouton d’exportation ou de téléchargement.
Dans la fenêtre modale Export, choisissez Selected rows ou All rows.
Cliquez sur Export.

Page Traces affichant des appels sélectionnés, prêts à être exportés, dans la fenêtre modale 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.

Python
TypeScript
HTTP API

Pour récupérer des appels à l’aide de l’API Python, utilisez la méthode client.get_calls :

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 :

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 :

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.

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 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 :

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))

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.

{
  "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.

​Exporter des appels depuis l’interface Weights & Biases

​Récupérer des appels de manière programmatique

​Exporter les métriques d’appel

Exporter des appels depuis l’interface Weights & Biases

Récupérer des appels de manière programmatique

Exporter les métriques d’appel