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. 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 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?"
}
]
)
Facultatif : patching explicite
import weave
weave.init('emoji-bot')
weave.integrations.patch_openai() # Activer le tracing OpenAI
from openai import OpenAI
client = OpenAI()
response = client.chat.completions.create(
model="gpt-4",
messages=[
{"role": "user", "content": "Make me a emoji"}
]
)
UserDetail typé à partir d’un message utilisateur :
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)
Prise en charge de l’asynchrone
AsyncOpenAI bénéficient de la même visibilité que les applications synchrones.
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
# Appel de la fonction asynchrone
result = await call_openai()
Prise en charge du streaming
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="")
Tracing des appels de fonction
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)
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)
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)
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.
Tracing des fonctions personnalisées
@weave.op. Cela crée une trace parente pour la fonction, dans laquelle les appels OpenAI sous-jacents sont imbriqués.
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?")
- Afficher les traces dans l’interface Weave : 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 ce qui se passe dans votre application LLM.
Pour plus d’informations sur ces sujets, voir le guide d’évaluation et le guide de suivi.
