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

# PydanticAI

> Tracer les appels d’agent et d’outil PydanticAI dans Weave avec OpenTelemetry

Vous pouvez tracer les appels d’agent et d’outil [PydanticAI](https://ai.pydantic.dev/) dans Weave à l’aide d’[OpenTelemetry (OTEL)](https://opentelemetry.io/). PydanticAI est un framework d’agents Python développé par l’équipe Pydantic pour créer simplement, et avec un typage sûr, des applications d’IA générative prêtes pour la production. Il s’appuie sur OTEL pour tracer tous les appels d’agent et d’outil.

<Tip>
  Pour plus d’informations sur le traçage OTEL dans Weave, consultez [Envoyer des traces OTEL à Weave](/fr/products/wandb/weave/guides/tracking/otel).
</Tip>

Ce guide s’adresse aux développeurs qui créent des agents PydanticAI et souhaitent observer l’exécution de leurs agents et outils dans Weave. Il explique comment tracer les appels d’agent et d’outil PydanticAI avec OTEL, puis visualiser ces traces dans Weave. Vous apprendrez à installer les dépendances requises, à configurer un traceur OTEL pour envoyer des données vers Weave et à instrumenter vos agents et outils PydanticAI. Vous verrez également comment activer le traçage par défaut pour tous les agents de votre application.

<h2 id="prerequisites">
  Prérequis
</h2>

Avant de pouvoir envoyer des traces vers Weave, vous devez installer les dépendances OTEL et configurer un exportateur OTEL. Installez les dépendances OTEL requises :

```bash theme={"system"}
pip install opentelemetry-sdk opentelemetry-exporter-otlp-proto-http
```

Ensuite, [configurez le traçage OTEL dans Weave](#configure-otel-tracing-in-weave).

<h3 id="configure-otel-tracing-in-weave">
  Configurer le traçage OTEL dans Weave
</h3>

Pour envoyer des traces de PydanticAI vers Weave, configurez OTEL avec un `TracerProvider` et un `OTLPSpanExporter`. Configurez l’exportateur avec le [point de terminaison et les en-têtes HTTP appropriés pour l’authentification et l’identification du projet](#required-configuration).

Stockez les variables d’environnement sensibles, comme votre clé API et les informations de votre projet, dans un fichier d’environnement (par exemple, `.env`), puis chargez-les à l’aide de `os.environ`. Vos identifiants d’authentification restent ainsi protégés et hors de votre base de code.

<h3 id="required-configuration">
  Configuration requise
</h3>

* **Point de terminaison :** `https://trace.wandb.ai/otel/v1/traces`
* **En-têtes :**
  * `Authorization` : authentification Basic avec votre clé API W\&B.
  * `project_id` : votre entity W\&B et le nom de votre projet (par exemple, `myteam/myproject`).

<h3 id="example-setup">
  Exemple de configuration
</h3>

L’extrait de code suivant montre comment configurer un exportateur de spans OTLP et un fournisseur de traceurs afin d’envoyer vers Weave les traces OTEL d’une application PydanticAI.

```python lines theme={"system"}
import base64
import os
from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
from opentelemetry.sdk import trace as trace_sdk
from opentelemetry.sdk.trace.export import SimpleSpanProcessor

# Charger les valeurs sensibles depuis les variables d’environnement
WANDB_BASE_URL = "https://trace.wandb.ai"
PROJECT_ID = os.environ.get("WANDB_PROJECT_ID")  # Votre entity/nom de projet W&B, par ex. "myteam/myproject"
WANDB_API_KEY = os.environ.get("WANDB_API_KEY")  # Votre clé API W&B

WEAVE_OTLP_ENDPOINT = f"{WANDB_BASE_URL}/otel/v1/traces"
AUTH = base64.b64encode(f"api:{WANDB_API_KEY}".encode()).decode()

OTEL_EXPORTER_OTLP_HEADERS = {
    "Authorization": f"Basic {AUTH}",
    "project_id": PROJECT_ID,
}

# Créer l’exportateur de spans OTLP avec le point de terminaison et les en-têtes
exporter = OTLPSpanExporter(
    endpoint=WEAVE_OTLP_ENDPOINT,
    headers=OTEL_EXPORTER_OTLP_HEADERS,
)

# Créer un fournisseur de traceurs et y ajouter l’exportateur
tracer_provider = trace_sdk.TracerProvider()
tracer_provider.add_span_processor(SimpleSpanProcessor(exporter))
```

Vous disposez maintenant d’un `tracer_provider` que vous pouvez transmettre aux agents PydanticAI afin d’acheminer leurs traces OTEL vers Weave.

<h2 id="trace-pydanticai-agents-with-otel">
  Tracer les agents PydanticAI avec OTEL
</h2>

Pour tracer vos agents PydanticAI et envoyer les données de trace vers Weave, transmettez au constructeur `Agent` un objet `InstrumentationSettings` configuré avec votre fournisseur de traceurs. Tous les appels d’agent et d’outil sont ainsi tracés conformément à votre configuration OTEL.

L’exemple suivant montre comment créer un agent de base avec le traçage activé. L’étape essentielle consiste à définir l’argument `instrument` lors de l’initialisation de l’agent :

```python lines theme={"system"}
from pydantic_ai import Agent
from pydantic_ai.models.instrumented import InstrumentationSettings

# Créer un agent PydanticAI avec traçage OTEL
agent = Agent(
    "openai:gpt-4o",
    instrument=InstrumentationSettings(tracer_provider=tracer_provider),
)

result = agent.run_sync("What is the capital of France?")
print(result.output)
```

Tous les appels à l’agent sont tracés et envoyés vers Weave.

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/pydanticai_agent_trace.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=f2f1eb9fc9deea12e26eddb5a730f7ec" alt="Visualisation de la trace d’un agent PydanticAI de base" width="2910" height="1594" data-path="products/wandb/weave/_media/pydanticai_agent_trace.png" />
</Frame>

<h2 id="trace-pydanticai-tools-with-otel">
  Tracer les outils PydanticAI avec OTEL
</h2>

Weave peut tracer toutes les opérations PydanticAI instrumentées avec OTEL, y compris les appels d’agent et les appels d’outil. Ainsi, lorsque votre agent invoque un outil (par exemple, une fonction décorée avec `@agent.tool_plain`), l’ensemble de l’interaction est capturé et visualisé dans Weave, notamment les entrées et sorties de l’outil ainsi que le raisonnement du modèle.

L’exemple suivant montre comment créer un agent doté d’un prompt système et d’un outil. Le traçage est activé automatiquement pour l’agent comme pour l’outil :

```python lines theme={"system"}
from pydantic_ai import Agent
from pydantic_ai.models.instrumented import InstrumentationSettings

# Créer un agent PydanticAI avec un prompt système et le traçage OTEL activé
agent = Agent(
    "openai:gpt-4o",
    system_prompt=(
        "You are a helpful assistant that can multiply numbers. "
        "When asked to multiply numbers, use the multiply tool."
    ),
    instrument=InstrumentationSettings(tracer_provider=tracer_provider),
)

# Définir un outil
@agent.tool_plain
def multiply(a: int, b: int) -> int:
    """Multiply two numbers."""
    return a * b

# Demander à l’agent d’utiliser l’outil
result = agent.run_sync("What is 7 multiplied by 8?")
print(result.output)
```

<Frame>
  <img src="https://mintcdn.com/coreweave-dbfa0e8d/3Dv_sw2eg8feUJlx/products/wandb/weave/_media/pydanticai_tool_call.png?fit=max&auto=format&n=3Dv_sw2eg8feUJlx&q=85&s=56bcdd0ce8a0fb0c00ef790632dda6e8" alt="Visualisation de la trace d’un appel d’outil" width="2912" height="1592" data-path="products/wandb/weave/_media/pydanticai_tool_call.png" />
</Frame>

L’appel de l’agent et l’appel d’outil sont tous deux tracés dans Weave, ce qui vous permet d’examiner l’intégralité du raisonnement et du chemin d’exécution de votre application.

<h2 id="instrument-all-agents-by-default">
  Instrumenter tous les agents par défaut
</h2>

Pour appliquer le traçage OTEL à tous les agents PydanticAI de votre application, utilisez la méthode `Agent.instrument_all()`. Cette méthode définit une instance `InstrumentationSettings` par défaut pour tout agent qui ne spécifie pas explicitement le paramètre `instrument`.

```python lines theme={"system"}
from pydantic_ai import Agent
from pydantic_ai.models.instrumented import InstrumentationSettings

# Configurer l’instrumentation par défaut pour tous les agents
Agent.instrument_all(InstrumentationSettings(tracer_provider=tracer_provider))

# Désormais, tout nouvel agent utilise cette instrumentation par défaut
agent1 = Agent("openai:gpt-4o")
agent2 = Agent("openai:gpt-4o", system_prompt="Be helpful.")

result = agent1.run_sync("What is the capital of France?")
print(result.output)
```

Cette approche est utile pour les applications de grande taille, où vous souhaitez un traçage cohérent sur l’ensemble des agents sans avoir à répéter la configuration. Pour en savoir plus, consultez la [documentation OTEL de PydanticAI](https://ai.pydantic.dev/logfire/#using-logfire).

<h2 id="learn-more">
  En savoir plus
</h2>

* [Documentation Weave : envoyer des traces OTEL à Weave](/fr/products/wandb/weave/guides/tracking/otel)
* [Documentation officielle d’OTEL](https://opentelemetry.io/)
* [Documentation officielle de PydanticAI](https://ai.pydantic.dev/)
* [Dépôt GitHub de PydanticAI](https://github.com/pydantic/pydantic-ai)