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

# OpenAI

> Intégrer OpenAI avec Weave pour le traçage, l’évaluation et la surveillance

<a target="_blank" href="https://colab.research.google.com/github/wandb/examples/blob/master/weave/docs/quickstart_openai.ipynb" aria-label="Ouvrir dans Google Colab">
  <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Ouvrir dans Colab" />
</a>

Ce guide explique comment intégrer les bibliothèques Python et TypeScript d’OpenAI à Weave afin de tracer, d’évaluer et de surveiller votre application LLM. Il s’adresse aux développeurs qui utilisent déjà les SDK d’OpenAI et souhaitent gagner en visibilité sur leurs appels, en développement comme en production.

<Note>
  Testez les modèles OpenAI dans Weave sans aucune configuration grâce au [LLM Playground](/fr/products/wandb/weave/guides/tools/playground).
</Note>

<h2 id="tracing">
  Traçage
</h2>

Stocker les traces des applications LLM dans une base de données centralisée est utile aussi bien pendant le développement qu’en production. Utilisez ces traces pour le débogage et pour constituer un jeu de données d’exemples difficiles sur lesquels évaluer votre application au fil de vos améliorations.

Weave peut capturer automatiquement les traces de la [bibliothèque Python `openai`](https://developers.openai.com/api/docs/libraries).

Pour commencer la capture, appelez `weave.init("[PROJECT_NAME]")` avec le nom de projet de votre choix. Weave patche automatiquement OpenAI, quel que soit le moment où vous l’importez : tous les appels OpenAI ultérieurs sont donc tracés.

Si vous ne spécifiez pas d’équipe CoreWeave Forge lors de l’appel à `weave.init()`, Weave utilise votre entity par défaut. Pour trouver ou modifier votre entity par défaut, reportez-vous à la section [Paramètres utilisateur](/fr/products/wandb/platform/app/settings-page/user-settings#default-team) de la documentation Weights & Biases Models.

<h3 id="automatic-patching">
  Patching automatique
</h3>

Weave patche automatiquement OpenAI, que vous l’importiez avant ou après `weave.init()`. L’exemple suivant présente la configuration minimale requise pour commencer à tracer les appels :

<CodeGroup>
  ```python Python lines {4} theme={"system"}
  from openai import OpenAI
  import weave

  weave.init('emoji-bot')  # OpenAI est automatiquement patché !

  client = OpenAI()
  response = client.chat.completions.create(
    model="gpt-4",
    messages=[
      {
        "role": "system",
        "content": "You are AGI. You will be provided with a message, and your task is to respond using emojis only."
      },
      {
        "role": "user",
        "content": "How are you?"
      }
    ]
  )
  ```

  ```typescript twoslash TypeScript theme={"system"}
  // @noErrors
  import { OpenAI } from 'openai';
  import { wrapOpenAI } from '@wandb/weave';

  const openai = wrapOpenAI(new OpenAI());

  // Tous les appels à OpenAI sont désormais tracés
  openai.chat.completions.create(
    {
      model: "gpt-4",
      messages: [
        {
          role: "system",
          content: "You are AGI. You will be provided with a message, and your task is to respond using emojis only."
        },
        {
          role: "user",
          content: "How are you?"
        }
      ]
    }
  );
  ```
</CodeGroup>

<h3 id="optional-explicit-patching">
  Facultatif : patching explicite
</h3>

Pour contrôler précisément le moment où le patching prend effet, appliquez explicitement un patch à OpenAI plutôt que de vous fier au comportement automatique :

```python lines {3,4} theme={"system"}
import weave

weave.init('emoji-bot')
weave.integrations.patch_openai()  # Activer le traçage OpenAI

from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
  model="gpt-4",
  messages=[
    {"role": "user", "content": "Make me a emoji"}
  ]
)
```

[Voir une trace en direct](https://forge.coreweave.com/wandb/capecape/emoji-bot/weave/calls/01928a78-6d8a-7e20-9b8c-0cbc8318a0c8)

<Tip>
  Weave capture également les outils d’appel de fonctions d’[OpenAI Functions](https://platform.openai.com/docs/guides/function-calling) et d’[OpenAI Assistants](https://platform.openai.com/docs/assistants/overview).
</Tip>

<h2 id="structured-outputs">
  Sorties structurées
</h2>

Weave prend en charge le traçage des sorties structurées d’OpenAI, utiles lorsque vous devez garantir que les réponses de votre LLM respectent un format précis. L’exemple suivant trace un appel qui extrait un objet typé `UserDetail` d’un message utilisateur :

<CodeGroup>
  ```python Python theme={"system"}
  from openai import OpenAI
  from pydantic import BaseModel
  import weave

  class UserDetail(BaseModel):
      name: str
      age: int

  client = OpenAI()
  weave.init('extract-user-details')

  completion = client.beta.chat.completions.parse(
      model="gpt-4o-2024-08-06",
      messages=[
          {"role": "system", "content": "Extract the user details from the message."},
          {"role": "user", "content": "My name is David and I am 30 years old."},
      ],
      response_format=UserDetail,
  )

  user_detail = completion.choices[0].message.parsed
  print(user_detail)
  ```
</CodeGroup>

<h2 id="async-support">
  Prise en charge asynchrone
</h2>

Weave prend en charge le traçage des appels OpenAI asynchrones : les applications qui utilisent `AsyncOpenAI` bénéficient ainsi de la même visibilité que les applications synchrones.

<CodeGroup>
  ```python Python theme={"system"}
  from openai import AsyncOpenAI
  import weave

  client = AsyncOpenAI()
  weave.init('async-emoji-bot')

  async def call_openai():
      response = await client.chat.completions.create(
          model="gpt-4",
          messages=[
              {
                  "role": "system", 
                  "content": "You are AGI. You will be provided with a message, and your task is to respond using emojis only."
              },
              {
                  "role": "user",
                  "content": "How are you?"
              }
          ]
      )
      return response

  # Appeler la fonction asynchrone
  result = await call_openai()
  ```
</CodeGroup>

<h2 id="streaming-support">
  Prise en charge du streaming
</h2>

Weave prend en charge le traçage des réponses en streaming d’OpenAI. La trace capturée reflète l’intégralité de la complétion diffusée en streaming, ce qui vous permet d’examiner la sortie finale en regard des paramètres de la requête.

<CodeGroup>
  ```python Python theme={"system"}
  from openai import OpenAI
  import weave

  client = OpenAI()
  weave.init('streaming-emoji-bot')

  response = client.chat.completions.create(
      model="gpt-4",
      messages=[
          {
              "role": "system", 
              "content": "You are AGI. You will be provided with a message, and your task is to respond using emojis only."
          },
          {
              "role": "user",
              "content": "How are you?"
          }
      ],
      stream=True
  )

  for chunk in response:
      print(chunk.choices[0].delta.content or "", end="")
  ```
</CodeGroup>

<h2 id="tracing-function-calls">
  Traçage des appels de fonction
</h2>

Weave trace les appels de fonction effectués par OpenAI lorsque vous utilisez des outils, ce qui vous permet de comprendre comment le modèle a appelé chaque outil et avec quels arguments.

<CodeGroup>
  ```python Python theme={"system"}
  from openai import OpenAI
  import weave

  client = OpenAI()
  weave.init('function-calling-bot')

  tools = [
      {
          "type": "function",
          "function": {
              "name": "get_weather",
              "description": "Get the weather in a given location",
              "parameters": {
                  "type": "object",
                  "properties": {
                      "location": {
                          "type": "string",
                          "description": "The location to get the weather for"
                      },
                      "unit": {
                          "type": "string",
                          "enum": ["celsius", "fahrenheit"],
                          "description": "The unit to return the temperature in"
                      }
                  },
                  "required": ["location"]
              }
          }
      }
  ]

  response = client.chat.completions.create(
      model="gpt-4",
      messages=[
          {
              "role": "user",
              "content": "What's the weather like in New York?"
          }
      ],
      tools=tools
  )

  print(response.choices[0].message.tool_calls)
  ```
</CodeGroup>

<h2 id="batch-api">
  API Batch
</h2>

Weave prend en charge l’API Batch d’OpenAI, qui vous permet de traiter plusieurs requêtes de manière asynchrone, tandis que Weave continue de capturer chaque requête dans vos traces.

<CodeGroup>
  ```python Python theme={"system"}
  from openai import OpenAI
  import weave

  client = OpenAI()
  weave.init('batch-processing')

  # Créer un fichier de lot
  batch_input = [
      {
          "custom_id": "request-1",
          "method": "POST",
          "url": "/v1/chat/completions",
          "body": {
              "model": "gpt-4",
              "messages": [{"role": "user", "content": "Hello, how are you?"}]
          }
      },
      {
          "custom_id": "request-2", 
          "method": "POST",
          "url": "/v1/chat/completions",
          "body": {
              "model": "gpt-4",
              "messages": [{"role": "user", "content": "What's the weather like?"}]
          }
      }
  ]

  # Soumettre le lot
  batch = client.batches.create(
      input_file_id="your-file-id",
      endpoint="/v1/chat/completions",
      completion_window="24h"
  )

  # Récupérer les résultats du lot
  completed_batch = client.batches.retrieve(batch.id)
  ```
</CodeGroup>

<h2 id="assistants-api">
  API Assistants
</h2>

Weave prend en charge l’API Assistants d’OpenAI, ce qui vous permet de tracer les applications d’IA conversationnelle construites autour d’assistants, de threads et de runs.

<CodeGroup>
  ```python Python theme={"system"}
  from openai import OpenAI
  import weave

  client = OpenAI()
  weave.init('assistant-bot')

  # Créer un assistant
  assistant = client.beta.assistants.create(
      name="Math Assistant",
      instructions="You are a personal math tutor. Answer questions about math.",
      model="gpt-4"
  )

  # Créer un thread
  thread = client.beta.threads.create()

  # Ajouter un message au thread
  message = client.beta.threads.messages.create(
      thread_id=thread.id,
      role="user",
      content="What is 2+2?"
  )

  # Exécuter l’assistant
  run = client.beta.threads.runs.create(
      thread_id=thread.id,
      assistant_id=assistant.id
  )

  # Obtenir la réponse de l’assistant
  messages = client.beta.threads.messages.list(thread_id=thread.id)
  ```
</CodeGroup>

<h2 id="cost-tracking">
  Suivi des coûts
</h2>

Weave suit automatiquement le coût de vos appels d’API OpenAI afin que vous puissiez surveiller vos dépenses en parallèle des performances. Vous pouvez consulter la répartition des coûts dans l’interface de Weights & Biases.

<Note>
  Le suivi des coûts est disponible pour tous les modèles OpenAI. Weave calcule les coûts en se basant sur la tarification publiée par OpenAI.
</Note>

<h2 id="tracing-custom-functions">
  Traçage de fonctions personnalisées
</h2>

Pour regrouper les appels OpenAI au sein de la logique de votre propre application, tracez les fonctions personnalisées qui utilisent OpenAI en leur appliquant le décorateur `@weave.op`. Vous obtenez ainsi une trace parente pour la fonction, dans laquelle sont imbriqués les appels OpenAI sous-jacents.

<CodeGroup>
  ```python Python theme={"system"}
  from openai import OpenAI
  import weave

  client = OpenAI()
  weave.init('custom-function-bot')

  @weave.op
  def generate_response(prompt: str) -> str:
      response = client.chat.completions.create(
          model="gpt-4",
          messages=[
              {
                  "role": "user",
                  "content": prompt
              }
          ]
      )
      return response.choices[0].message.content

  # Cet appel de fonction sera tracé
  result = generate_response("Hello, how are you?")
  ```
</CodeGroup>

<h2 id="next-steps">
  Étapes suivantes
</h2>

Maintenant que le traçage est configuré pour OpenAI, les appels de votre application sont visibles dans Weave. Vous pouvez désormais :

* **Afficher les traces dans l’interface Weights & Biases** : accédez à votre projet Weave pour consulter les traces de vos appels OpenAI.
* **Créer des évaluations** : utilisez vos traces pour constituer des jeux de données d’évaluation.
* **Surveiller les performances** : suivez la latence, les coûts et d’autres métriques.
* **Déboguer les problèmes** : utilisez les traces pour comprendre le comportement de votre application LLM.

Pour en savoir plus sur ces sujets, consultez le [guide d’évaluation](/fr/products/wandb/weave/guides/evaluation/scorers) et le [guide de surveillance](../tracking).


## Related topics

- [API OpenAI](/fr/products/wandb/integrations/openai-api.md)