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

> Tracez les appels du SDK d’OpenAI dans Agent Lens avec le SDK CoreWeave Forge.

Le SDK CoreWeave Forge trace automatiquement les appels que vous effectuez avec le SDK d’OpenAI pour Python et Node.js. Une fois le traçage initialisé, chaque appel effectué au sein d’une conversation est enregistré dans Agent Lens sous la forme d’un span LLM, avec ses messages, ses appels d’outils, ses paramètres de requête et son utilisation des jetons, y compris les jetons mis en cache et les jetons de raisonnement. Vous n’avez rien à modifier dans votre façon d’appeler le SDK d’OpenAI.

L’intégration trace les complétions de chat (y compris en streaming), le parsing des sorties structurées, l’API Responses (y compris en streaming) et la génération d’images.

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

* Un compte CoreWeave Forge et une [clé API](https://forge.coreweave.com/settings#apikeys) définie dans la variable d’environnement `WANDB_API_KEY`.
* Une [clé API OpenAI](https://platform.openai.com/api-keys) définie dans la variable d’environnement `OPENAI_API_KEY`.
* Pour Python : Python 3.10 ou version ultérieure et `openai` 1.99.9 ou version ultérieure.
* Pour TypeScript : Node.js 18.19 ou version ultérieure (ou 20.6 ou version ultérieure) et `openai` 4.0.0 ou version ultérieure.

<h2 id="install-packages">
  Installer les paquets
</h2>

<CodeGroup>
  ```bash Python theme={"system"}
  pip install "coreweave[openai]"
  ```

  ```bash TypeScript theme={"system"}
  npm install @coreweave/forge-sdk openai
  ```
</CodeGroup>

<h2 id="trace-openai-conversations">
  Tracer les conversations OpenAI
</h2>

Appelez `tracing.init()` avec les noms de votre équipe et de votre projet Forge. En Python, `tracing.init()` patche le SDK d’OpenAI, que vous l’importiez avant ou après l’appel. En TypeScript, démarrez Node avec l’option d’instrumentation indiquée dans l’onglet TypeScript.

Agent Lens n’affiche que les appels exécutés au sein d’une conversation. Un appel effectué en dehors d’une conversation n’a pas d’ID de conversation et n’apparaît donc pas dans Agent Lens. Créez une conversation pour chaque session d’agent et démarrez un tour de conversation pour chaque message utilisateur. Tous les tours partagent l’ID de la conversation : Agent Lens les regroupe donc en une seule conversation, et chaque appel devient un span LLM du tour dans lequel il s’exécute.

<Tabs>
  <Tab title="Python">
    ```python lines theme={"system"}
    from openai import OpenAI
    from coreweave.forge.agentlens import tracing

    tracing.init("[YOUR-TEAM]/[YOUR-PROJECT]")
    client = OpenAI()

    questions = [
        "What is inference latency?",
        "How does batching affect it?",
        "Summarize what we discussed in one sentence.",
    ]

    history = []
    with tracing.Conversation(agent_name="support-agent") as conversation:
        for question in questions:
            with conversation.start_turn(user_message=question):
                history.append({"role": "user", "content": question})
                response = client.responses.create(model="gpt-5-mini", input=history)
                history.append({"role": "assistant", "content": response.output_text})
                print(response.output_text)

    tracing.shutdown()
    ```
  </Tab>

  <Tab title="TypeScript">
    Encapsulez chaque exécution d’agent dans `tracing.runIsolated()` afin que sa conversation et ses tours de conversation restent séparés des autres exécutions simultanées.

    ```typescript lines title="app.mjs" theme={"system"}
    import OpenAI from 'openai';
    import {tracing} from '@coreweave/forge-sdk/agentlens';

    await tracing.init('[YOUR-TEAM]/[YOUR-PROJECT]');
    const openai = new OpenAI();

    const questions = [
      'What is inference latency?',
      'How does batching affect it?',
      'Summarize what we discussed in one sentence.',
    ];

    await tracing.runIsolated(async () => {
      const conversation = tracing.startConversation({agentName: 'support-agent'});
      const history = [];
      try {
        for (const question of questions) {
          const turn = conversation.startTurn({userMessage: question});
          try {
            history.push({role: 'user', content: question});
            const response = await openai.responses.create({model: 'gpt-5-mini', input: history});
            history.push({role: 'assistant', content: response.output_text});
            console.log(response.output_text);
          } finally {
            turn.end();
          }
        }
      } finally {
        conversation.end();
      }
    });

    await tracing.shutdown();
    ```

    Exécutez le script avec l’option d’instrumentation. Celle-ci charge l’instrumentation Forge avant votre code, de sorte que le SDK d’OpenAI est déjà patché lorsque votre code l’importe :

    ```bash theme={"system"}
    node --import=@coreweave/forge-sdk/instrument app.mjs
    ```

    Si vous ne pouvez pas utiliser cette option, par exemple parce qu’un bundler regroupe vos dépendances dans un seul fichier, encapsulez plutôt le client :

    ```typescript theme={"system"}
    import {integrations} from '@coreweave/forge-sdk/agentlens';

    const openai = integrations.wrapOpenAI(new OpenAI());
    ```

    Si vous exécutez le script sans cette option, `tracing.init()` affiche un avertissement à ce sujet, une seule fois. Vous pouvez l’ignorer si vous encapsulez vos clients.
  </Tab>
</Tabs>

Pour ajouter ultérieurement des tours de conversation à une conversation existante, par exemple dans une application web qui traite un tour par requête, transmettez le même `conversation_id` (Python) ou `conversationId` (TypeScript) chaque fois que vous créez la conversation.

Pour en savoir plus sur les conversations, les tours de conversation et les autres types de spans, consultez [Tracer vos agents](/fr/products/agent-lens/tracing/instrument).

<h2 id="turn-off-automatic-patching">
  Désactiver le patching automatique
</h2>

En Python, passez `autopatch_integrations=False` à `tracing.init()`. Vous pouvez ensuite appliquer et retirer vous-même le patch du SDK d’OpenAI avec `tracing.integrations.patch_openai()` et `tracing.integrations.unpatch_openai()`.

En TypeScript, exécutez votre code sans l’option `--import=@coreweave/forge-sdk/instrument` et encapsulez avec `integrations.wrapOpenAI()` uniquement les clients que vous souhaitez tracer.

<h2 id="view-your-traces">
  Afficher vos traces
</h2>

Dans [CoreWeave Forge](https://forge.coreweave.com), sélectionnez Agent Lens dans le menu des produits, choisissez votre projet dans le sélecteur de projet en haut du menu latéral, puis sélectionnez **Conversations**. Pour plus d'informations, voir [Afficher l'activité des agents](/fr/products/agent-lens/conversations/view-activity).