Intégrez OpenAI avec Weave pour le tracing, l’évaluation et le monitoring
Ce guide vous montre comment intégrer les bibliothèques Python et TypeScript d’OpenAI avec 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 avoir une meilleure visibilité sur leurs appels pendant le développement et en production.
Vous souhaitez tester des modèles OpenAI sur Weave sans aucune configuration préalable ? Essayez le LLM Playground.
Il est utile de stocker les traces des applications LLM dans une base de données centrale, aussi bien pendant le développement qu’en production. Utilisez ces traces pour le débogage, ainsi que pour constituer un jeu de données d’exemples difficiles servant à l’évaluation au fur et à mesure que vous améliorez votre application.Weave peut capturer automatiquement les traces de la bibliothèque Python openai.Pour commencer à capturer des traces, 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, afin que tous les appels OpenAI suivants soient tracés.Si vous ne spécifiez pas d’équipe W&B lorsque vous appelez weave.init(), Weave utilise votre entité par défaut. Pour trouver ou mettre à jour votre entité par défaut, consultez Paramètres utilisateur dans la documentation W&B Models.
Weave patche automatiquement OpenAI, que vous l’importiez avant ou après weave.init(). L’exemple suivant montre la configuration minimale requise pour commencer à tracer les appels :
from openai import OpenAIimport weaveweave.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?" } ])
import { OpenAI } from 'openai';import { wrapOpenAI } from '@wandb/weave';constopenai =wrapOpenAI(newOpenAI());// Tous les appels à OpenAI seront désormais tracésopenai.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?" } ] });
Pour contrôler plus finement le moment où le patching prend effet, patchez OpenAI explicitement plutôt que de vous appuyer sur le comportement automatique :
import weaveweave.init('emoji-bot')weave.integrations.patch_openai() # Activer le tracing OpenAIfrom openai import OpenAIclient = OpenAI()response = client.chat.completions.create( model="gpt-4", messages=[ {"role": "user", "content": "Make me a emoji"} ])
Weave prend en charge le tracing des sorties structurées OpenAI, ce qui est utile lorsque vous devez garantir que les réponses de votre LLM respectent un format spécifique. L’exemple suivant trace un appel qui extrait un objet UserDetail typé à partir d’un message utilisateur :
from openai import OpenAIfrom pydantic import BaseModelimport weaveclass UserDetail(BaseModel): name: str age: intclient = 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.parsedprint(user_detail)
Weave prend également en charge le tracing des appels OpenAI asynchrones, afin que les applications qui utilisent AsyncOpenAI bénéficient de la même visibilité que les applications synchrones.
from openai import AsyncOpenAIimport weaveclient = 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# Appel de la fonction asynchroneresult = await call_openai()
Weave prend en charge le tracing des réponses en streaming d’OpenAI. La trace capturée reflète l’intégralité de la complétion diffusée en streaming, afin que vous puissiez examiner la sortie finale avec les paramètres de la requête.
from openai import OpenAIimport weaveclient = 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="")
Weave effectue le tracing des appels de fonction effectués par OpenAI lorsque vous utilisez des outils, ce qui vous aide à comprendre comment le modèle a invoqué chaque outil et avec quels arguments.
from openai import OpenAIimport weaveclient = 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)
Weave prend en charge la Batch API d’OpenAI, qui vous permet de traiter plusieurs requêtes de manière asynchrone tout en continuant à capturer chaque requête dans vos traces.
from openai import OpenAIimport weaveclient = OpenAI()weave.init('batch-processing')# Créer un fichier de lotbatch_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 lotbatch = client.batches.create( input_file_id="your-file-id", endpoint="/v1/chat/completions", completion_window="24h")# Récupérer les résultats du lotcompleted_batch = client.batches.retrieve(batch.id)
Weave prend en charge l’API Assistants d’OpenAI, ce qui vous permet de tracer des applications d’IA conversationnelle basées sur des assistants, des threads et des runs.
from openai import OpenAIimport weaveclient = OpenAI()weave.init('assistant-bot')# Créer un assistantassistant = client.beta.assistants.create( name="Math Assistant", instructions="You are a personal math tutor. Answer questions about math.", model="gpt-4")# Créer un threadthread = client.beta.threads.create()# Ajouter un message au threadmessage = client.beta.threads.messages.create( thread_id=thread.id, role="user", content="What is 2+2?")# Exécuter l’assistantrun = client.beta.threads.runs.create( thread_id=thread.id, assistant_id=assistant.id)# Obtenir la réponse de l’assistantmessages = client.beta.threads.messages.list(thread_id=thread.id)
Weave suit automatiquement le coût de vos appels à l’API OpenAI afin que vous puissiez surveiller les dépenses parallèlement aux performances. Vous pouvez consulter le détail des coûts dans l’interface Weave.
Le suivi des coûts est disponible pour tous les modèles OpenAI et est calculé d’après la tarification publiée par OpenAI.
Pour regrouper les appels à OpenAI dans votre propre logique applicative, tracez les fonctions personnalisées qui utilisent OpenAI en appliquant le décorateur @weave.op. Cela crée une trace parente pour la fonction, dans laquelle les appels OpenAI sous-jacents sont imbriqués.
from openai import OpenAIimport weaveclient = OpenAI()weave.init('custom-function-bot')@weave.opdef 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?")
