> ## 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.

# Suivre les coûts

> Comprendre le suivi automatique et le suivi personnalisé des coûts des opérations LLM dans Weave

Weave assure le suivi du coût des appels LLM de deux manières :

* **Suivi automatique des coûts** : pour les [intégrations prises en charge](/fr/products/wandb/weave/guides/integrations), Weave capture l’utilisation des jetons à partir de la réponse de l’API et applique la tarification intégrée du modèle, sans aucun code supplémentaire.
* **Suivi personnalisé des coûts** : pour les modèles affinés, les modèles auto-hébergés ou les modèles pour lesquels Weave ne propose pas d’intégration automatique, configurez Weave afin de suivre des coûts personnalisés à l’aide des méthodes d’API disponibles.

<Note>
  Le SDK TypeScript de Weave ne prend pas en charge le suivi des coûts.
</Note>

<h2 id="use-automatic-cost-tracking">
  Utiliser le suivi automatique des coûts
</h2>

Lorsque vous appelez `weave.init()` et utilisez une [intégration LLM prise en charge](/fr/products/wandb/weave/guides/integrations) telle qu’OpenAI, Anthropic, Cohere ou Mistral, Weave enregistre automatiquement l’utilisation des jetons et calcule le coût de chaque appel. Les coûts s’affichent dans l’arborescence de trace et dans le tableau des appels de l’interface Weights & Biases. Ils sont également accessibles par programmation dans `call.summary["weave"]["costs"]` lorsque vous interrogez les appels avec le paramètre `include_costs` défini sur `true`.

Le suivi automatique des coûts nécessite que deux conditions soient réunies :

* Le fournisseur de LLM fait partie des intégrations prises en charge.
* La réponse de l’API inclut l’utilisation des jetons (la plupart des fournisseurs la renvoient par défaut).

Si l’une de ces conditions n’est pas remplie, utilisez plutôt le suivi personnalisé des coûts.

L’exemple suivant montre comment récupérer par programmation les données de coûts automatiques :

```python lines theme={"system"}
import weave
from openai import OpenAI

weave.init("your-team/project-name")
client = OpenAI()

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": "What is 2 + 2?"}],
)

import time
time.sleep(2)

# Récupérer l’instance actuelle du client Weave
weave_client = weave.get_client()
# Accéder aux appels de l’instance et à leurs coûts
calls = list(weave_client.get_calls(include_costs=True, limit=1))
call = calls[0]

# Accéder à la synthèse de l’appel et récupérer les champs de coûts disponibles
costs = call.summary.get("weave", {}).get("costs", {})
if not costs:
    print("No costs found in summary.weave.costs")
for model, cost in costs.items():
    print(f"Model: {model}")
    print(f"  Input cost:  ${cost['prompt_tokens_total_cost']:.6f}")
    print(f"  Output cost: ${cost['completion_tokens_total_cost']:.6f}")
```

<h2 id="add-a-custom-cost">
  Ajouter un coût personnalisé
</h2>

Utilisez le suivi personnalisé des coûts lorsque le suivi automatique des coûts n'est pas disponible, par exemple pour des modèles affinés, des modèles auto-hébergés ou des fournisseurs avec lesquels Weave ne propose pas d'intégration. Les sections suivantes expliquent comment ajouter, interroger, purger et agréger des coûts personnalisés.

Ajoutez un coût personnalisé à l'aide de la méthode [`add_cost`](/fr/products/wandb/weave/reference/python-sdk/trace/weave_client#method-add-cost).
Les trois champs requis sont `llm_id`, `prompt_token_cost` et `completion_token_cost`.
`llm_id` est le nom du LLM (par exemple, `gpt-4o`). `prompt_token_cost` et `completion_token_cost` correspondent au coût par jeton du LLM. Si les prix du LLM sont exprimés par million de jetons, convertissez la valeur.
Vous pouvez également attribuer une valeur datetime à `effective_date` pour que le coût prenne effet à une date donnée. Par défaut, il s'agit de la date du jour.

```python lines theme={"system"}
import weave
from datetime import datetime

client = weave.init("your-team/project-name")

client.add_cost(
    llm_id="your_model_name",
    prompt_token_cost=0.01,
    completion_token_cost=0.02
)

client.add_cost(
    llm_id="your_model_name",
    prompt_token_cost=10,
    completion_token_cost=20,
    effective_date=datetime(2025, 4, 22),
)
```

<h3 id="query-custom-costs">
  Interroger les coûts personnalisés
</h3>

Après avoir ajouté des coûts personnalisés, vous pouvez les récupérer pour vérifier leurs valeurs ou retrouver l’ID de coût nécessaire à d’autres opérations, comme la purge.

Interrogez les coûts avec la méthode [`query_costs`](/fr/products/wandb/weave/reference/python-sdk/trace/weave_client#method-query-costs).
Vous pouvez interroger les coûts de plusieurs façons : en transmettant un seul ID de coût ou une liste de noms de modèles LLM.

```python lines theme={"system"}
import weave

client = weave.init("your-team/project-name")

costs = client.query_costs(llm_ids=["your_model_name"])

cost = client.query_costs(costs[0].id)
```

<h3 id="purge-a-custom-cost">
  Purger un coût personnalisé
</h3>

Pour purger un coût personnalisé, utilisez la méthode [`purge_costs`](/fr/products/wandb/weave/reference/python-sdk/trace/weave_client#method-purge-costs). Transmettez-lui une liste d’ID de coûts : Weave purge alors les coûts correspondants.

```python lines theme={"system"}
import weave

client = weave.init("your-team/project-name")

costs = client.query_costs(llm_ids=["your_model_name"])
client.purge_costs([cost.id for cost in costs])
```

<h3 id="calculate-custom-costs-for-a-project">
  Calculer les coûts personnalisés d’un projet
</h3>

Pour connaître les dépenses totales d’un projet, agrégez les coûts par appel renvoyés par Weave. Pour calculer les coûts d’un projet, utilisez `get_calls()` avec `include_costs=True`.

```python lines theme={"system"}
import weave

weave.init("your-team/project-name")

@weave.op()
def get_costs_for_project(project_name: str):
    total_cost = 0
    requests = 0

    client = weave.init(project_name)
    calls = list(
        client.get_calls(filter={"trace_roots_only": True}, include_costs=True)
    )

    for call in calls:
        if call.summary["weave"] is not None and call.summary["weave"].get("costs", None) is not None:
            for k, cost in call.summary["weave"]["costs"].items():
                requests += cost["requests"]
                total_cost += cost["prompt_tokens_total_cost"]
                total_cost += cost["completion_tokens_total_cost"]

    return {
        "total_cost": total_cost,
        "requests": requests,
        "calls": len(calls),
    }

get_costs_for_project("my_custom_cost_model")
```

<h3 id="set-up-a-custom-model-with-custom-costs">
  Configurer un modèle personnalisé avec des coûts personnalisés
</h3>

Pour un guide pas à pas complet combinant un modèle personnalisé et le suivi personnalisé des coûts, essayez le cookbook sur la [configuration des coûts avec un modèle personnalisé](/fr/products/wandb/weave/cookbooks/custom_model_cost).

<Card title="Essayer dans Colab" href="https://colab.research.google.com/github/wandb/weave/blob/master/docs/./notebooks/custom_model_cost.ipynb" icon="code" />