SDK OpenAI Agents - Weights & Biases Documentation

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.

Python
TypeScript

Le SDK Python OpenAI Agents est un framework léger pour créer des flux de travail multi-agents.

Installation

Installez les dépendances requises à l’aide de pip :

pip install weave openai-agents

Pour commencer

Pour utiliser le SDK OpenAI Agents avec Weave :

Initialisez Weave avec le nom de votre projet.
Ajoutez le processeur de tracing Weave à vos agents.
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.

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

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

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() :

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 :

import { addTraceProcessor } from "@openai/agents";
import { createOpenAIAgentsTracingProcessor } from "weave";

...

const processor = createOpenAIAgentsTracingProcessor();
addTraceProcessor(processor);

​Installation

​Pour commencer

​Voir les traces

​Installation

​Premiers pas

​Instrumentation manuelle

Installation

Pour commencer

Voir les traces

Installation

Premiers pas

Instrumentation manuelle