Interroger et exporter des appels

Cette page vous montre comment interroger et exporter des appels Weave afin d’analyser les données de trace en dehors de Weave. Par exemple, vous pouvez créer des tableaux de bord personnalisés, partager les résultats avec des collaborateurs ou effectuer une analyse hors ligne. Vous pouvez exporter des appels depuis l’interface Weave, les récupérer de manière programmatique avec les SDK Python ou TypeScript, ou les interroger directement à l’aide de l’API de service.

Exporter des appels depuis l’interface Weave

Dans l’interface Weave, vous pouvez exporter vos données dans plusieurs formats. Elle affiche également le code Python et cURL que vous pouvez utiliser pour exporter les lignes de manière programmatique. Pour exporter des appels :

Accédez à wandb.ai et sélectionnez votre projet.
Dans la barre latérale du projet Weave, cliquez sur Traces.
Sélectionnez plusieurs appels à exporter en cochant la ligne correspondante.
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 montrant des appels sélectionnés prêts à être exportés dans la fenêtre modale Export.

Récupérer les appels par programmation

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 qui correspond le mieux à votre flux de travail.

Python
TypeScript
HTTP API

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

import weave

# Initialize the client
client = weave.init("your-project-name")

# Fetch calls
calls = client.get_calls(filter=...)

Pour récupérer des appels avec l’API TypeScript, utilisez la méthode client.getCalls :

import * as weave from 'weave'

// Initialize the client
const client = await weave.init('intro-example')

// Fetch calls
const calls = await client.getCalls(filter=...)

L’API de service expose la couche de requête complète. Pour récupérer des appels avec 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 plus de détails sur les propriétés et les champs des appels, voir la référence du schéma des appels.

Exporter les métriques d’appel

Lorsque vous avez besoin de données agrégées, comme des 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 d’appel elles-mêmes. Vous pouvez récupérer 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 :

Utilisation totale des jetons
Latence moyenne
Nombre maximal de jetons utilisés
Coût total
Nombre minimal de jetons d’entrée

Le point de terminaison propose plusieurs options de filtrage afin de cibler les appels effectués sur des périodes spécifiées, ainsi que selon d’autres propriétés, telles que :

Nom de l’op
ID de trace
ID de thread
ID d’utilisateur

L’exemple suivant montre comment récupérer les appels générés à partir d’une op nommée 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écifiez la taille des buckets, en secondes.
    "granularity": 86400,
    "filter": {
        "trace_roots_only": True,
        "op_names": ["web_app"]
    },
# Spécifiez 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écifiez la taille des buckets, en secondes.
  granularity: 86400,
  filter: {
    trace_roots_only: true,
    op_names: ["web_app"],
  },
// Spécifiez 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 précise é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 montre des métriques sur deux jours. Chaque jour (bucket) apparaît comme un objet distinct dans les tableaux usage_buckets et call_buckets. Chaque tableau répartit 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 plus d’informations sur les options disponibles, voir la référence de l’API de service.

Premiers pas

Guides

Guides pratiques

Référence

Détails et assistance

Exporter des appels depuis l’interface Weave

Récupérer les appels par programmation

Exporter les métriques d’appel

​Exporter des appels depuis l’interface Weave

​Récupérer les appels par programmation

​Exporter les métriques d’appel

Exporter des appels depuis l’interface Weave

Récupérer les appels par programmation

Exporter les métriques d’appel