> ## 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. # SDK OpenAI Agents > Utilisez W&B Weave avec le SDK OpenAI Agents pour suivre et surveiller vos applications basées sur des agents Vous pouvez utiliser W\&B Weave avec le SDK OpenAI Agents pour tracer et surveiller vos applications basées sur des agents. Ce guide vous montre comment installer l’intégration, initialiser Weave dans le code de votre agent et consulter les traces obtenues dans le tableau de bord Weave afin de déboguer et d’évaluer des flux de travail multi-agents. Le [SDK Python OpenAI Agents](https://github.com/openai/openai-agents-python) est un framework léger pour créer des flux de travail multi-agents. ## Installation Installez les dépendances requises à l’aide de `pip` : ```bash theme={null} pip install weave openai-agents ``` ## Pour commencer Pour utiliser le SDK OpenAI Agents avec Weave : 1. Initialisez Weave avec le nom de votre projet. 2. Ajoutez le processeur de tracing Weave à vos agents. 3. Créez et exécutez vos agents comme d’habitude. L’exemple de code suivant crée un agent OpenAI et l’intègre à Weave pour assurer la traçabilité. L’exemple initialise un projet Weave et configure `WeaveTracingProcessor` pour capturer les traces d’exécution. Un modèle de données `Weather` représente des informations météorologiques. La fonction `get_weather`, décorée pour être utilisée comme outil par l’agent, renvoie un exemple de bulletin météo. Un agent nommé `Hello world` utilise des instructions de base et l’accès à l’outil météo. La fonction `main` exécute l’agent de manière asynchrone avec un exemple d’entrée (`What's the weather in Tokyo?`) et affiche la réponse finale. ```python lines theme={null} from pydantic import BaseModel from agents import Agent, Runner, function_tool import agents import weave import asyncio weave.init("openai-agents") class Weather(BaseModel): city: str temperature_range: str conditions: str @function_tool def get_weather(city: str) -> Weather: return Weather(city=city, temperature_range="14-20C", conditions="Sunny with wind.") agent = Agent( name="Hello world", instructions="You are a helpful agent.", tools=[get_weather] ) async def main(): result = await Runner.run(agent, input="What's the weather in Tokyo?") print(result.final_output) if __name__ == "__main__": asyncio.run(main()) ``` ## Voir les traces Lorsque vous exécutez l’exemple de code précédent, Weave génère un lien vers le tableau de bord Weave. Ouvrez ce lien pour examiner les traces du run de votre agent. Le [SDK Node OpenAI Agents](https://github.com/openai/openai-node) est un framework léger pour créer des flux de travail multi-agents. ## Installation Installez les dépendances requises à l’aide de `npm`. L’intégration TypeScript de Weave nécessite `@openai/agents` version `0.4.15` ou ultérieure : ```bash theme={null} npm install weave @openai/agents zod ``` ## Premiers pas Dans la plupart des environnements Node.js, vous n’avez pas besoin d’instrumentation manuelle. Weave instrumente automatiquement `@openai/agents` lorsque le module est chargé. L’instrumentation automatique fonctionne en enregistrant un hook de chargement de module : * **Projets CommonJS :** aucune configuration supplémentaire n’est nécessaire. * **Projets ESM :** démarrez Node avec l’indicateur `--import=weave/instrument` afin que l’instrumentation soit chargée avant les autres modules. Si vous avez besoin d’aide pour configurer votre projet ou déterminer quel type vous utilisez, consultez le [guide d’intégration de services tiers du SDK TypeScript](/fr/weave/guides/integrations/js). L’exemple de code suivant crée un agent OpenAI et l’intègre à Weave pour assurer la traçabilité. Remplacez `your-team-name/your-project-name` dans l’initialisation du projet Weave par votre entité et votre projet. L’exemple définit un outil `get_weather` qui renvoie un exemple de bulletin météo, puis configure un agent nommé `Hello world` avec des instructions simples et un accès à l’outil météo. La fonction `main` exécute l’agent avec une entrée d’exemple (`What's the weather in Tokyo?`) et consigne la réponse finale. ```typescript twoslash lines theme={null} // @noErrors import * as weave from "weave"; import { Agent, run, tool } from "@openai/agents"; import { z } from "zod"; const getWeather = tool({ name: "get_weather", description: "Get the current weather for a given city.", parameters: z.object({ city: z.string().describe("The name of the city"), }), async execute({ city }) { return `${city}: 14-20C, Sunny with wind.`; }, }); async function main() { // Mettez à jour avec les informations de votre projet. await weave.init("your-team-name/your-project-name"); const agent = new Agent({ name: "Hello world", instructions: "You are a helpful agent.", tools: [getWeather], }); const result = await run(agent, [ { role: "user", content: "What's the weather in Tokyo?" }, ]); console.log(result.finalOutput); } main(); ``` En CommonJS, l’instruction `import * as weave from "weave"` doit apparaître avant `import { Agent, run, tool } from "@openai/agents"` pour que l’instrumentation automatique fonctionne. Si votre code ne peut pas respecter cet ordre, utilisez la technique d’instrumentation manuelle ci-dessous. ### Instrumentation manuelle L’instrumentation manuelle n’est nécessaire que lorsque le hook du chargeur de modules ne peut pas s’exécuter, par exemple dans les cas suivants : * Les bundlers qui regroupent les dépendances dans un seul fichier. * Les environnements où il n’est pas possible de transmettre des flags à la CLI Node. * Les schémas de chargement dynamique des modules qui contournent le hook du chargeur. Dans ces cas, vous pouvez enregistrer explicitement l’instrumentation à l’aide de `instrumentOpenAIAgents()` : ```typescript twoslash lines theme={null} // @noErrors import * as weave from "weave"; await weave.init("openai-agents"); await weave.instrumentOpenAIAgents(); ``` Pour avoir un contrôle complet sur le processeur de Tracing, par exemple pour une configuration personnalisée du processeur ou un enregistrement conditionnel, créez-le et enregistrez-le manuellement : ```typescript twoslash lines theme={null} // @noErrors import { addTraceProcessor } from "@openai/agents"; import { createOpenAIAgentsTracingProcessor } from "weave"; ... const processor = createOpenAIAgentsTracingProcessor(); addTraceProcessor(processor); ```