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

# Suivre les coûts

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

Weave suit les coûts des appels LLM de deux façons :

* **Suivi automatique des coûts** : pour les [intégrations prises en charge](/fr/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 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 auxquels Weave ne s’intègre pas automatiquement, configurez Weave pour 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>

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

Lorsque vous appelez `weave.init()` et utilisez une [intégration LLM prise en charge](/fr/weave/guides/integrations) comme OpenAI, Anthropic, Cohere ou Mistral, Weave enregistre automatiquement la consommation de jetons et calcule le coût de chaque appel. Les coûts apparaissent dans l’arborescence de trace et dans le tableau des appels de l’interface Weave. Ils sont également disponibles par code dans `call.summary["weave"]["costs"]` lorsque vous exécutez une requête sur les appels avec le paramètre `include_costs` défini sur `true`.

Le suivi automatique des coûts nécessite deux conditions :

* Le fournisseur LLM doit être une intégration prise en charge.
* La réponse de l’API doit inclure 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 des coûts personnalisé.

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

```python lines theme={null}
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}")
```

<div id="add-a-custom-cost">
  ## Ajout d’un coût personnalisé
</div>

Utilisez le suivi personnalisé des coûts lorsque le suivi automatique des coûts n’est pas disponible, par exemple avec des modèles fine-tunés, des modèles auto-hébergés ou des fournisseurs auxquels Weave ne s’intègre pas. 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/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 ex. `gpt-4o`). `prompt_token_cost` et `completion_token_cost` correspondent au coût par jeton du LLM. Si le prix du LLM est indiqué par million de jetons, convertissez la valeur.
Vous pouvez également définir `effective_date` sur une valeur datetime afin que le coût prenne effet à une date précise. Par défaut, la date du jour est utilisée.

```python lines theme={null}
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),
)
```

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

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

Vous pouvez interroger les coûts à l’aide de la méthode [`query_costs`](/fr/weave/reference/python-sdk/trace/weave_client#method-query-costs).
Il existe plusieurs façons d’interroger les coûts : vous pouvez fournir un ID de coût unique ou une liste de noms de modèles LLM.

```python lines theme={null}
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)
```

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

Purgez un coût personnalisé avec la méthode [`purge_costs`](/fr/weave/reference/python-sdk/trace/weave_client#method-purge-costs). Transmettez une liste d’ID de coût, et Weave purge les coûts correspondant à ces ID.

```python lines theme={null}
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])
```

<div id="calculate-custom-costs-for-a-project">
  ### Calcul des coûts personnalisés d’un projet
</div>

Pour comprendre la dépense totale d’un projet, agrégez les coûts par appel renvoyés par Weave. Calculez les coûts d’un projet à l’aide de `get_calls()` avec `include_costs=True`.

```python lines theme={null}
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")
```

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

Pour un guide pas à pas de bout en bout combinant un modèle personnalisé et un suivi personnalisé des coûts, essayez le cookbook sur la [configuration des coûts d’un modèle personnalisé](/fr/weave/cookbooks/custom_model_cost).

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